diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6c39dcfa..d06aa871 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -25,6 +25,29 @@ jobs:
       - name: Check formatting
         run: cargo fmt --all -- --check
 
+  # The fuzz crate is a standalone workspace excluded from the root build, so a
+  # normal `cargo build` never compiles it — API drift in wfl could silently
+  # break every fuzz target. This job type-checks the targets against the current
+  # API on stable (libFuzzer/nightly is only needed to actually *run* them).
+  fuzz-check:
+    name: Fuzz targets compile
+    runs-on: ubuntu-latest
+    needs: fmt
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Cache Cargo registry and target directory
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: fuzz
+          shared-key: fuzz-check-cache
+      # `--locked` enforces the committed fuzz/Cargo.lock, so dependency drift
+      # fails the job instead of silently regenerating the lockfile.
+      - name: Type-check fuzz targets against the current API
+        run: cargo check --locked --manifest-path fuzz/Cargo.toml
+
   clippy-and-test:
     name: Build, Test, Clippy
     runs-on: ubuntu-latest
@@ -70,18 +93,20 @@ jobs:
           fi
           echo "panic=abort correctly rejected by the compile_error gate"
 
-      # Run tests (integration tests now have access to release binary)
+      # Run tests across the WHOLE workspace (root package + wflpkg + wfl-lsp),
+      # so the CI aggregate is a true full-workspace baseline. Previously this
+      # was `cargo test` (root package only), which silently skipped wflpkg's
+      # tests. (integration tests have access to the release binary)
       - name: Run Tests
-        run: cargo test --verbose
+        run: cargo test --workspace --verbose
 
-      # Build LSP to catch Send/Sync regressions
+      # Build the LSP binary explicitly as a focused Send/Sync build gate.
+      # (`cargo test --workspace` above already compiles and runs wfl-lsp's
+      # tests, so a separate `cargo test -p wfl-lsp` step would only duplicate
+      # them — it was removed.)
       - name: Build LSP
         run: cargo build -p wfl-lsp --verbose
 
-      # Run LSP tests
-      - name: Run LSP Tests
-        run: cargo test -p wfl-lsp --verbose
-
       # Run Clippy for code quality
       - name: Run Clippy
         run: cargo clippy --all-targets -- -D warnings
@@ -455,11 +480,12 @@ jobs:
             exit 1
           }
 
-  # Version bumping only happens after ALL checks pass
+  # Version bumping only happens after ALL checks pass — including fuzz-check,
+  # so API drift that breaks the fuzz targets blocks the post-merge version bump.
   bump-version:
     name: Bump Version
     runs-on: ubuntu-latest
-    needs: [fmt, clippy-and-test, integration-tests, database-tests, run-wfl-programs]
+    needs: [fmt, fuzz-check, clippy-and-test, integration-tests, database-tests, run-wfl-programs]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     permissions:
       contents: write
diff --git a/Cargo.toml b/Cargo.toml
index 86fecaa0..e335682c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,6 +28,11 @@ members = [
     "wfl-lsp",
     "crates/wflpkg"
 ]
+# `fuzz/` is a standalone cargo-fuzz workspace (nightly + libFuzzer only); keep
+# it out of the stable-toolchain root build/test.
+exclude = [
+    "fuzz"
+]
 
 [package.metadata.deb]
 assets = [
diff --git a/Dev diary/2026-07-13-issue-610-phase-1-containment.md b/Dev diary/2026-07-13-issue-610-phase-1-containment.md
new file mode 100644
index 00000000..5b6bf11d
--- /dev/null
+++ b/Dev diary/2026-07-13-issue-610-phase-1-containment.md	
@@ -0,0 +1,259 @@
+# Dev Diary — 2026-07-13: Issue #610 Phase 1 — Baseline & containment (remaining tasks)
+
+**Tracker:** [#610 — WFL Production Readiness: 8/10 by January 1, 2027](https://github.com/WebFirstLanguage/wfl/issues/610)
+**Phase 1 target window:** July 12 – August 15, 2026.
+
+This entry records the five Phase 1 tasks executed after the issue inventory
+(`…-phase-1-inventory.md`) and scorecard baseline (`…-phase-1-scorecard-baseline.md`):
+
+1. Finish and integrate the shared ExecutionBudget
+2. Convert every known correctness defect into an end-to-end regression test
+3. Establish fuzz targets for lexer, parser, pattern engine, and module loading
+4. Record baseline metrics
+5. Define supported platforms and support boundaries
+
+All work was verified against a `cargo build --release` binary on Linux; the
+branch is rebased onto **WFL 26.7.37** (current `main`), whose source is
+identical to 26.7.36 apart from the version bump and #613's docs, so the repro
+observations carry over unchanged.
+
+---
+
+## 1. Shared ExecutionBudget — finished & integrated (verified)
+
+The shared budget landed in **#609** (`src/exec/budget.rs`, `src/exec/mod.rs`).
+Phase 1's job here was to confirm it is *finished and integrated*, i.e. that a
+single object covers every dimension the mandatory gate enumerates and that it
+is wired through the whole pipeline.
+
+**Enforcement surface (every gate dimension has a public method):**
+
+| Gate dimension | `ExecutionBudget` method |
+|---|---|
+| Deadline / cancellation | `charge_operation`, `check_deadline`, `cancel`, `check_cancelled` |
+| Operation ceiling | `charge_operation` (optional `max_operations`) |
+| Recursion / import / execute-file depth | `check_call_depth`, `check_import_depth`, `check_execute_file_depth` |
+| Pattern steps / states | `check_pattern_steps`, `check_pattern_states` |
+| Source / request-body / response bytes | `check_source_bytes`, `check_request_body_bytes`, `check_response_bytes` |
+| Pending HTTP requests | `max_pending_requests` |
+| WebSocket queue / connections | `ws_queue_bound`, `try_acquire_ws_connection`, `max_ws_connections` |
+
+**Wired through the pipeline** (reference counts of `budget` usages):
+lexer (parsing input), parser, analyzer, type checker, interpreter (evaluation +
+`respond` + module/include + `execute file`), and the pattern VM (matching). The
+budget is `Send + Sync` (atomics only) so an `Arc<ExecutionBudget>` crosses into
+the multi-threaded web transport without any `Rc`/`RefCell` rewrite.
+
+**Tests:** `tests/execution_budget_test.rs` (32 tests) covers config parsing of
+every `.wflcfg` budget key plus end-to-end enforcement (recursion → clean
+catchable error instead of SIGABRT; oversized source refused before running).
+
+**Verdict:** the mandatory gate *"Shared runtime execution budget covers parsing,
+evaluation, pattern matching, web handling, and module loading"* is **met**. The
+adjacent gate — *adversarial* tests for each limit — is explicitly **Phase 3**
+and is not claimed here.
+
+## 2. Known correctness defects → regression tests (PARTIAL — #578 tail still open)
+
+New suite `tests/phase1_correctness_regression_test.rs`. **Stated plainly: the
+Phase 1 task *"convert every known correctness defect into an end-to-end
+regression test"* is NOT complete.** Every inventoried correctness *issue* has at
+least one guard, but **#578 is an umbrella** (~26 checkboxes) and only its
+reproducible confirmed functional/silent-wrong-result bugs are encoded — its
+remaining sub-items (weak inference edges, ergonomics, missing forms) have **no
+regression test yet** and are tracked on the issue. So this is **partial**
+coverage: a representative #578 sample plus per-issue guards, with exhaustive
+per-item #578 classification left open. It is not a redefinition of "every
+defect" as "every issue". Two halves:
+
+- **Fixed defects → passing guards.** New binary-level guards for **#569**
+  (action-call result is `Text`, not `Nothing`), **#571** (precedence, both
+  `divided by` and `/` division, `modulo`, `is between`), and **#590** (a
+  CLI-level end-to-end guard for the self-recursive indexed-result case, added on
+  review — complementing the in-process `recursive_action_return_type_test.rs`).
+  Defects already covered elsewhere (#582/#557/#566/#567/#583/#588 in
+  `github_issues_batch_test.rs`, #580 in `include_of_form_resolution_test.rs`)
+  are indexed in the file's module doc rather than duplicated. **#573 is fixed**
+  (binary read/write + MIME shipped in #574; guarded by `web_server_binary_test.rs`
+  + `binary_io_test.rs` + `binary_file_and_mime_test.wfl`; the issue is open only
+  pending a close click).
+- **Open defects → `#[ignore]`d desired-behaviour tests** that reproduce the bug
+  today (they fail under `--ignored`) and flip green when the fix lands:
+  - **#592** — bare zero-arg included action fatal at top level **and** in an
+    action body (parameterized).
+  - **#578** (reproducible confirmed bugs) — `list files … with pattern` returns
+    0; `one or more` quantifier matches per-char (16 vs 4 words); `repeat N times`
+    is a parse error; `Number plus Text` silently concatenates; no text→number
+    conversion; `format_date` echoes friendly patterns; and `with`-form action
+    calls silently concatenate.
+
+CI stays green (open defects are `#[ignore]`d, not failing).
+
+Re-verification against the release binary corrected the inventory in several
+places: #578's *`X ends with Y` misparse*, its *`add` to `List<Any>` drops in
+`--test` mode*, and its *`double of 5 minus 1` → Nothing* inference items **no
+longer reproduce** on the current build (fixed), so they are not encoded as open
+defects; #573 is **fixed** (above), not the open limitation an earlier draft
+listed.
+
+## 3. Fuzz targets — three of four surfaces established; module loading still open
+
+New standalone cargo-fuzz workspace under `fuzz/` (kept out of the stable root
+build via its own `[workspace]` and root `exclude = ["fuzz"]`):
+
+| Target | Surface |
+|---|---|
+| `fuzz_lexer` | `lex_wfl_with_positions_checked` |
+| `fuzz_parser` | lex → `Parser::parse` |
+| `fuzz_pattern` | `pattern\0haystack` **pair** → `create pattern` parse → `CompiledPattern::compile` → `find_all(haystack)` (ReDoS surface: the fuzzer controls both the pattern and the input it runs against) |
+| `fuzz_frontend` | compiler **frontend** on arbitrary source: **checked** lex → parse → include/load-module detection → `Analyzer::analyze` → `TypeChecker::check_types` |
+
+Each target's invariant: no arbitrary input may panic, overflow the stack, or
+hang. Tracked seed inputs live in `fuzz/seeds/<target>/`; the live corpus and
+artifacts are gitignored (the corpus dir is created from the seeds on first run —
+see `fuzz/README.md`). The standalone `fuzz/Cargo.lock` **is** committed for
+reproducible builds.
+
+Targets **type-check cleanly on stable** (`cargo check --manifest-path
+fuzz/Cargo.toml`), and a new `fuzz-check` CI job runs exactly that on every PR so
+API drift can't silently break the excluded fuzz crate. The *sustained run* (with
+corpus retention) is deliberately **Phase 3** work; no run duration is claimed at
+baseline (see metrics below).
+
+**Module-loading fuzzing is NOT done (open Phase 1 item).** Phase 1 lists four
+required surfaces: lexer, parser, pattern engine, **and module loading**. The
+first three are covered. `fuzz_frontend` fuzzes the static frontend that a
+module's *content* passes through, but it deliberately does **not** invoke the
+interpreter's `LoadModuleStatement` / `IncludeStatement` paths — so filesystem
+path resolution/canonicalization, bounded reads, cross-file circular/import-depth
+enforcement, parent-scope construction, and module execution are **uncovered**.
+Fuzzing the real loader means driving the async interpreter against on-disk
+modules, and doing that *safely* is the blocker: executing fuzzer-generated WFL
+would also exercise subprocess spawning, networking, the web server, and
+filesystem writes. A sandboxed module-loading harness (benign module bodies +
+fuzzed include-graph structure, or an execution-disabled load path) is tracked as
+remaining Phase 1 work. The renamed target (`fuzz_frontend`, formerly the
+misleadingly-named `fuzz_module_loading`) no longer claims to fuzz module
+loading.
+
+## 4. Baseline metrics (2026-07-13; rebased onto WFL 26.7.37, Linux)
+
+**Methodology (corrected after the round-2 review).** The head-SHA CI run on
+`f627b4e` was **green**, but its `cargo test` command tested the **root package
+only** — it did **not** run `wflpkg`, so it was never a full-workspace baseline.
+Observed component numbers on that run (scope-labeled):
+
+| Scope | Command (on `f627b4e`) | passed | failed | ignored | result suites |
+|---|---|---:|---:|---:|---:|
+| root package | `cargo test` | 1206 | 0 | 24 | 76 |
+| `wfl-lsp` | `cargo test -p wfl-lsp` | 69 | 0 | — | — |
+| `wflpkg` | *(not run by CI)* | 204† | 0 | — | — |
+| **workspace total** | (sum) | **≈1479** | **0** | **24+** | — |
+
+† `wflpkg`'s 204 tests were not executed by CI on `f627b4e`; the count is from the
+package, not that CI run. This is exactly why the earlier single "≈1479 aggregate"
+was **derived, not measured**.
+
+**Fix applied here:** `ci.yml`'s "Run Tests" step now runs `cargo test
+--workspace` (was `cargo test`), so CI executes the **whole workspace** — root +
+`wflpkg` + `wfl-lsp` — in one lane and reports a true aggregate.
+
+**Authoritative full-workspace run — MEASURED (no longer pending).** CI run
+[**29240959575**](https://github.com/WebFirstLanguage/wfl/actions/runs/29240959575)
+ran `cargo test --workspace` on this branch's head and passed with **1480 passed
+/ 0 failed / 25 ignored across 95 result suites**. That is the observed
+full-workspace baseline, recorded below. (It matches the earlier derived estimate
+exactly — but it is now a *measured* run with a workflow link, not an estimate.
+The `f627b4e` component table above is retained only to explain why the interim
+figure had to be derived.) This change's contribution to the suite is the new
+`phase1_correctness_regression_test`: **3 passing** guards (#569, #571, #590) and
+**9 `#[ignore]`d** reproducers (2×#592, 7×#578).
+
+| Metric | Baseline | Source / notes |
+|---|---|---|
+| Rust test count (workspace) | **1480 passed / 0 failed / 25 ignored** | **measured** — CI run [29240959575](https://github.com/WebFirstLanguage/wfl/actions/runs/29240959575), `cargo test --workspace` on this head |
+| Result suites (workspace) | **95** | measured on the same run (root + `wfl-lsp` + `wflpkg` test binaries) |
+| Skipped Rust tests (`#[ignore]`, workspace) | **25** | measured on the same run |
+| Skipped end-to-end programs (`CI-SKIP`) | **32** of 163 `TestPrograms/*.wfl` | see skip justification below |
+| Compiler / Clippy warnings | **0 (CI gate: `cargo clippy --all-targets -- -D warnings`)** | the one pre-existing `deprecated` rustc warning in `src/logging.rs` is **fixed in this change** (`parse` → `parse_borrowed::<2>`) |
+| Line coverage | **not instrumented** | no coverage tool wired (tarpaulin/llvm-cov absent). This leaves the Phase 1 *"record baseline coverage"* task **not fully done** — instrumenting a line-coverage baseline is one of the three explicitly-open Phase 1 items (see exit-gate) |
+| Fuzz sustained-run duration | **0 s** (targets established + a `fuzz-check` compile job on PRs; not yet run for duration) | sustained run + corpus retention is Phase 3 |
+| Known crashes / hangs | **none reproducible** | the 2 open High defects (#592, #578) reproduce as wrong-result / parse-error / silent-concat, not crashes or hangs; #578's listed nested-`for each` crash did **not** reproduce on the current build; recursion overflow is now a clean `ExecutionBudget` error, not SIGABRT |
+
+**Skip justification.** Of the 32 `CI-SKIP` programs, 15 start a web server and
+need an HTTP client to drive them. The `run_web_tests` scripts exist to drive
+these, **but no CI workflow currently invokes them**, so those paths are skipped
+in CI's `TestPrograms` runner and lack automated CI coverage today (tracked;
+wiring `run_web_tests` into CI is a Testing follow-up). The remainder are
+`#555`-tracked unimplemented features (session/CSRF, direct-index) or
+`keyword_reference` docs examples with pre-existing parse errors (the
+docs-examples-in-CI gate). Every skip carries a first-line reason.
+
+## 5. Supported platforms & support boundaries
+
+New reference `Docs/reference/supported-platforms.md` defines a three-tier model
+grounded in what CI actually exercises:
+
+- **Tier 1 (supported, CI-tested):** Linux `x86_64` (glibc) and Windows
+  `x86_64` — both run the integration + `TestPrograms` matrix on every PR. The
+  doc includes a **per-platform PR CI coverage table** because coverage is *not*
+  symmetric: the full `cargo test` unit/LSP/clippy/DB suite runs on **Linux
+  only**; Windows PR CI runs the integration + `TestPrograms` lanes. The MSI +
+  installer smoke test is **nightly/post-merge**, not a PR gate.
+- **Tier 2 (best-effort, not in CI):** macOS (x86_64/Apple Silicon), musl/other
+  Linux, other 64-bit Unix.
+- **Unsupported:** 32-bit targets (the interpreter assumes a 64-bit address
+  space and runs on a 1 GiB call-stack thread).
+
+It also pins the toolchain (stable channel; MSRV 1.88 **declared but not
+gate-tested** — CI runs stable; edition 2024), runtime requirements (Tokio, FS,
+optional network, the `ExecutionBudget` ceilings), and the boundary of
+"supported" (no untrusted-code sandbox; docs-in-CI still an open gate;
+aspirational syntax excluded). Linked from `Docs/README.md` and `SECURITY.md`;
+the stale `SECURITY.md` version-support row was refreshed to `26.7.x`, its footer
+version to `26.7.37`, and its "no cryptographic functions" / `max_nesting_depth`
+recursion claims corrected in the same change (docs-honesty).
+
+---
+
+## Phase 1 exit-gate read
+
+> **Exit gate:** *No known production-readiness risk is untracked.*
+
+- No open **Critical** issue. The 2 open **High** items are both **correctness**
+  defects (#592, #578), tracked with reproductions **and** regression tests.
+  Separately, Dependabot **alert #49** (`rustls-webpki`, high severity) is present in
+  the dependency graph, but its vulnerable code path is **not reachable** in WFL:
+  the only TLS setup is `warp::serve(routes).tls().cert_path(…).key_path(…)`
+  (`src/interpreter/mod.rs:6441`) with client auth off and **no** CRL /
+  `RevocationOptions` configured, and the advisory (GHSA-82j2-j2ch-gfr8) only
+  triggers on opt-in revocation + attacker CRL bytes. Disposition *"vulnerable code
+  not used"* — **not** a reachable High WFL defect; #600 is the separate SNI /
+  multi-cert enhancement (post-production). The literal *no-open-high-severity-
+  security* policy gate may remain administratively open until alert #49 is formally
+  triaged. See the inventory diary's #600 row.
+- ExecutionBudget is finished, integrated, and test-covered.
+- Every inventoried correctness **issue** has at least one guard, but the
+  *"convert every known correctness defect"* task is **PARTIAL** — only #578's
+  reproducible confirmed bugs are encoded; exhaustive per-item #578
+  classification is still open (see §2).
+- Fuzz targets cover **three of the four** required surfaces (lexer, parser,
+  pattern engine). **Module-loading fuzzing is not done** — see §3; it is an
+  explicitly open Phase 1 item.
+- Baseline metrics are **measured** (test count/skips/warnings/fuzz-duration/
+  crashes): CI run 29240959575 (`cargo test --workspace`) reports **1480 passed /
+  0 failed / 25 ignored across 95 suites** (§4) — but **line coverage is not
+  instrumented**, so the Phase 1 *"record baseline coverage"* task is not fully
+  done. Supported platforms and boundaries are defined.
+
+**Phase 1 is therefore not fully complete.** The **three** explicitly open Phase
+1 items (matching the three unchecked Phase 1 boxes on #610), carried forward and
+tracked, are: (1) a **module-loading fuzz target** (safe async harness); (2)
+exhaustive per-item **#578 classification** — this is Phase 1 work (part of
+*"convert every known correctness defect…"*; *fixing* #578 is Phase 2); and (3) a
+**line-coverage baseline** (no coverage tool is instrumented yet). (The
+`--workspace` CI aggregate is now recorded — run 29240959575 — so that
+earlier-pending item is closed.) Larger hand-offs to Phase 2/3 (also tracked):
+the parser/analyzer/type-checker/runtime **consistency suite**, **docs examples
+into CI**, the **sustained fuzz run** + corpus retention, and per-limit
+**adversarial tests**.
diff --git a/Dev diary/2026-07-13-issue-610-phase-1-inventory.md b/Dev diary/2026-07-13-issue-610-phase-1-inventory.md
index 907212da..d9c596d2 100644
--- a/Dev diary/2026-07-13-issue-610-phase-1-inventory.md	
+++ b/Dev diary/2026-07-13-issue-610-phase-1-inventory.md	
@@ -24,8 +24,25 @@ demonstrably behaves correctly today.
 
 ## Inventory result
 
-**Total open at start:** 17 (16 tracked issues + the #610 tracker itself).
-**Closed as verified-fixed:** 10. **Remaining open after triage:** 6 tracked + #610.
+**Total open on GitHub at start:** 17 (16 tracked issues + the #610 tracker itself).
+
+**Reconciliation of the 16 tracked issues** — stated explicitly because "open"
+was previously conflated between two senses (*open on GitHub* vs. *genuinely
+unresolved*):
+
+| Bucket | Count | Issues |
+|---|---|---|
+| Verified-fixed **and** closed on GitHub | 10 | the *Closed* table below |
+| Verified-fixed but still **open on GitHub**, pending a close click | 1 | #573 |
+| **Genuinely unresolved** | 5 | #592, #578, #555, #600, #612 |
+
+Arithmetic: `10 + 1 + 5 = 16` tracked `+ #610 = 17`, matching the start count. So
+**6** tracked issues are still *open on GitHub* (the 5 unresolved **plus** #573),
+but only **5** are *genuinely unresolved*. #573 is verified-fixed — PR #574
+shipped binary read/write + MIME with byte-round-trip tests **before** this
+inventory, and the issue is open on GitHub only pending a close click (it was
+originally recorded here as an open "Medium" limitation in error). See the #573
+row below.
 
 ### Closed — verified fixed against 26.7.36
 
@@ -49,8 +66,8 @@ demonstrably behaves correctly today.
 | #592 | Zero-arg include-exposed action by bare name is fatal | **High** | Fatal (`exit 3`, `Variable 'greet' is not defined`) on valid natural multi-file API; the third call form #580/#581's fix did not cover. Repro still fails on 26.7.36. |
 | #578 | Remaining #571 rough edges (glob, pattern-VM, text→number, inference) | **High** | Confirmed functional bugs (wrong result/crash, not doc drift). Verified `list files … with pattern "*.txt"` still returns `0` on 26.7.36. |
 | #555 | Aspirational skipped tests + broken keyword_reference docs examples | **Medium** | Core websockets landed (#593), but session/CSRF/cookie middleware, direct-index syntax, and 10 docs examples remain; 3 `CI-SKIP` TestPrograms still present. Docs-examples-in-CI is a mandatory release gate. Feature parts are effectively post-production. |
-| #573 | Web server cannot serve binary content (fonts, images) | **Medium** | Real limitation (file read + HTTP body are text/UTF-8 only); blocks self-hosting static assets. Not a regression in existing behavior. |
-| #600 | Native TLS: SNI / multiple certificates on one `:443` | **Post-production-readiness** | Single-cert HTTPS works; multi-cert/SNI is a multi-tenant deployment enhancement, not a release-gate blocker. |
+| ~~#573~~ | Web server cannot serve binary content (fonts, images) | **Fixed (correction)** | **Reclassified: this was recorded open in error.** PR #574 shipped binary read (`read binary from …`), binary write, lossless byte round-trip, and MIME helpers *before* this inventory, guarded by `web_server_binary_test.rs`, `binary_io_test.rs`, and `binary_file_and_mime_test.wfl`. The issue's own latest verification (2026-07-06) recommends closing; it is open on GitHub only pending a close click. |
+| #600 | Native TLS ergonomics: SNI / multiple certificates on one `:443` | **Post-production-readiness** (SNI) · Dependabot alert #49 = *vulnerable code not used* | **Correction (source-level re-review).** An earlier revision reclassified this **High (security)**, treating the *presence* of `rustls-webpki` (alert #49, [GHSA-82j2-j2ch-gfr8](https://github.com/advisories/GHSA-82j2-j2ch-gfr8)) in the dependency graph as WFL exploitability. That overreached. The advisory's panic requires opt-in `RevocationOptions` **and** attacker-controlled CRL bytes; default rustls configs are unaffected. WFL's only TLS setup is `warp::serve(routes).tls().cert_path(…).key_path(…)` (`src/interpreter/mod.rs:6441`); warp 0.3.7 defaults client auth to `TlsClientAuth::Off` / `with_no_client_auth()`, and WFL configures **no** CRL / `RevocationOptions` anywhere (verified by grep) — so the vulnerable path is **not reachable**. Disposition: record/dismiss alert #49 as *"vulnerable code not used."* #600 itself is the **SNI / multi-cert enhancement** (post-production); it is **not** a reachable High WFL security defect, and its TLS rewrite is not established as required remediation on this evidence. The literal *no-open-High-severity-security* policy gate may remain administratively open until #49 is formally triaged. SNI priority is tracked on #600 independently. |
 | #612 | Make PR #609 resource-budget policies overrideable via `.wflcfg` | **Low** | Explicitly filed "low priority"; safe conservative defaults already ship. Config-surface polish. |
 
 ### Severity legend (aligned to #610's gates)
@@ -58,7 +75,10 @@ demonstrably behaves correctly today.
 - **Critical** — blocks a mandatory release gate: critical correctness/security,
   data loss, or uncontrolled resource exhaustion.
 - **High** — correctness defect on valid/supported programs (incl. fatal
-  false-positives) or a confirmed functional bug; must be fixed before RC.
+  false-positives), a confirmed functional bug, **or a *reachable* high-severity
+  security advisory** — the vulnerable code path must actually be exercised by
+  WFL's usage; the mere *presence* of a vulnerable dependency does **not** qualify
+  (see the #600 row); must be fixed before RC.
 - **Medium** — false diagnostics that don't change runtime results, or real but
   non-blocking feature limitations touching a gate.
 - **Low** — polish / configurability with safe current defaults.
@@ -67,12 +87,18 @@ demonstrably behaves correctly today.
 ## Phase 1 exit-gate read
 
 The exit gate for Phase 1 is *"No known production-readiness risk is untracked."*
-After this pass **no open issue is Critical**, and the two open High-severity
-correctness items (#592, #578) are tracked with reproductions. The remaining
-Phase 1 tasks (record scorecard baseline, integrate the shared ExecutionBudget —
-note #609 already merged — regression tests, fuzz targets, baseline metrics,
-supported-platform definition) are separate checkboxes and out of scope for this
-inventory entry.
+After this pass **no open issue is Critical**, and the two open High-severity items
+are both **correctness** defects (#592, #578), tracked with reproductions.
+Separately, Dependabot **alert #49** (`rustls-webpki`, high severity) is present in
+the dependency graph but its vulnerable code path is **not reachable** in WFL's
+usage (see the #600 row) — disposition *"vulnerable code not used."* It is therefore
+**not** classified as a reachable High WFL defect, and #600's TLS rewrite is not
+established as its required remediation; the literal *no-open-high-severity-security*
+policy gate may remain administratively open until the alert is formally
+triaged/dismissed on the Security tab. The remaining Phase 1 tasks (record scorecard
+baseline, integrate the shared ExecutionBudget — note #609 already merged —
+regression tests, fuzz targets, baseline metrics, supported-platform definition) are
+separate checkboxes and out of scope for this inventory entry.
 
 ## Compatibility / resource impact
 
diff --git a/Docs/README.md b/Docs/README.md
index d65d976f..8ff21e22 100644
--- a/Docs/README.md
+++ b/Docs/README.md
@@ -221,6 +221,7 @@ Guidelines for quality, security, performance, and collaboration — aligned wit
 - **[Operator Reference](reference/operator-reference.md)** - All operators
 - **[Built-in Functions](reference/builtin-functions-reference.md)** - Complete function list
 - **[Error Codes](reference/error-codes.md)** - Understanding errors
+- **[Supported Platforms & Support Boundaries](reference/supported-platforms.md)** - Support tiers, platform matrix, toolchain/runtime requirements, and what "supported" covers
 
 ### Development
 
diff --git a/Docs/reference/supported-platforms.md b/Docs/reference/supported-platforms.md
new file mode 100644
index 00000000..df38980f
--- /dev/null
+++ b/Docs/reference/supported-platforms.md
@@ -0,0 +1,140 @@
+# Supported Platforms & Support Boundaries
+
+This document defines the platforms WFL supports, what "supported" means, and
+the boundaries of that support. It is the reference for the **Maintenance** and
+**Operations** dimensions of the production-readiness plan
+([issue #610](https://github.com/WebFirstLanguage/wfl/issues/610)) and for the
+mandatory release gate *"Release artifacts, checksums, installation, upgrade,
+rollback, supported-platform, and known-limitations documentation are
+published."*
+
+> **Status:** WFL is currently **alpha** software (see [`SECURITY.md`](../../SECURITY.md)).
+> The support tiers below describe what the project tests and stands behind
+> *today*; they tighten as WFL approaches its 8/10 production-readiness gate.
+
+## Support tiers
+
+WFL uses three tiers. A platform's tier is defined by **what CI actually
+exercises**, not by aspiration.
+
+| Tier | Meaning | What you can rely on |
+|---|---|---|
+| **Tier 1 — Supported** | Built **and** tested on every PR in CI. | A release binary is built and the end-to-end `TestPrograms` + Rust integration tests (`cargo test --test '*'`) run on **every** Tier-1 platform; regressions block merges. Coverage is **not identical** across Tier-1 platforms — see *Per-platform PR CI coverage* below for the exact lanes each one runs. |
+| **Tier 2 — Best-effort** | Expected to build from source; **not** covered by CI. | The code targets it and contributors run it, but breakage is possible between releases and is fixed on a best-effort basis. |
+| **Unsupported** | Not built, not tested, not a goal for the 8/10 release. | May work, may not. No guarantees, no gate coverage. |
+
+## Platform matrix
+
+| Platform | Architecture | Tier | Evidence / notes |
+|---|---|---|---|
+| **Linux (glibc)** | `x86_64` | **Tier 1** | `ci.yml` builds + tests on `ubuntu-latest`: unit/integration tests, Clippy (`-D warnings`), database tests (PostgreSQL + MariaDB), and the `TestPrograms` runner. |
+| **Windows** | `x86_64` (`x86_64-pc-windows-msvc`) | **Tier 1** | `ci.yml` runs the integration + `TestPrograms` matrix on `windows-latest`. The MSI installer (`cargo-wix`) and its smoke test run in `nightly.yml` **after** merge, not on PRs. |
+| **macOS** | `x86_64`, `aarch64` (Apple Silicon) | **Tier 2** | Builds from source ([`installation.md`](../02-getting-started/installation.md) documents the flow) but is **not** in CI. Supported best-effort until a macOS CI lane is added. |
+| **Linux (musl / non-glibc)** | any | **Tier 2** | No CI lane; static-musl builds are expected to work but unverified. |
+| **Linux / other Unix** | `aarch64`, others | **Tier 2** | Pure-Rust with a Tokio runtime; expected to build where the toolchain and dependencies do. Unverified. |
+| **32-bit targets** | `i686`, `armv7`, … | **Unsupported** | Not built or tested. The interpreter runs on a large (1 GiB) call stack thread and assumes 64-bit address space. |
+
+**Promotion policy.** A Tier 2 platform is promoted to Tier 1 only when a CI lane
+builds it and runs the integration + `TestPrograms` suites green — a
+before-the-release-gate requirement, not a documentation change.
+
+### Per-platform PR CI coverage (what actually runs today)
+
+Tier-1 coverage is **not symmetric**. This table lists exactly what each Tier-1
+platform runs on a pull request, per `.github/workflows/ci.yml`:
+
+| Lane | Linux (`ubuntu-latest`) | Windows (`windows-latest`) |
+|---|---|---|
+| `cargo fmt --check` | ✅ | ➖ (Linux only) |
+| Full `cargo test` (unit + integration) | ✅ | ➖ (Linux only) |
+| LSP build + tests | ✅ | ➖ (Linux only) |
+| Clippy `-D warnings` | ✅ | ➖ (Linux only) |
+| Database tests (PostgreSQL + MariaDB) | ✅ | ➖ (Linux only) |
+| Rust integration tests (`cargo test --test '*'`) | ✅ | ✅ |
+| `TestPrograms` end-to-end runner | ✅ | ✅ |
+| Release **artifact publish** (checksums, installers) | ➖ | ➖ (nightly/post-merge only) |
+| Documentation-example execution | ➖ (not wired into CI yet — mandatory gate still open) | ➖ |
+
+Known gaps that are **not** yet gated on any PR: the full unit/LSP/clippy/DB
+suite runs on Linux only; installer testing is nightly and post-merge; release
+artifacts are not published from PR CI; documentation examples are not executed
+in CI; and the declared MSRV is not verified (see below). These are tracked
+Phase 1→3 items, not guarantees.
+
+## Toolchain requirements
+
+| Requirement | Value | Source of truth |
+|---|---|---|
+| Rust channel | **stable** | All CI jobs use `dtolnay/rust-toolchain@stable`. |
+| Minimum supported Rust version (MSRV) | **1.88** (declared) | `Cargo.toml` `rust-version = "1.88"`. The codebase uses `let`-chains (stabilized in 1.88), so older toolchains fail fast via `cargo`'s check. Note: CI builds on **stable**, so the 1.88 floor is *declared but not gate-tested* — an MSRV lane is a tracked follow-up. |
+| Rust edition | **2024** | `Cargo.toml` `edition = "2024"`. |
+| Build profiles | `debug`, `release` | Integration tests and `TestPrograms` require a `cargo build --release` binary. |
+| Disallowed | `panic = "abort"` | CI asserts the release binary rejects `panic=abort` (`ci.yml`), so panics stay unwindable/catchable. |
+
+## Runtime requirements
+
+- **Async runtime:** Tokio (`tokio` "full"). WFL's interpreter is async and
+  drives the runtime on a dedicated large-stack thread.
+- **Filesystem:** required for source loading, `include from` / `load module`
+  module resolution, and filesystem stdlib operations.
+- **Network:** required only for programs that use HTTP (`reqwest`), the web
+  server (`warp`), or databases (`sqlx`: SQLite/MySQL/PostgreSQL). No network is
+  needed to run a plain script.
+- **Resource ceilings:** every run is governed by the shared
+  [`ExecutionBudget`](../../src/exec/budget.rs) (recursion/import depth, pattern
+  steps/states, source/body/response bytes, HTTP/WebSocket queues and
+  connections, and optional operation/wall-clock ceilings). Defaults are
+  documented in [`configuration-reference.md`](configuration-reference.md).
+
+## What "supported" covers — and what it does not
+
+On a **Tier 1** platform, the project commits to WFL being *predictable,
+testable, documented, and operable* for **supported language behaviour**:
+
+- Supported language constructs behave consistently across the parser, analyzer,
+  type checker, and interpreter.
+- The documented CLI, `.wflcfg` configuration, and standard-library surface work
+  as described. (Automated execution of documentation examples in CI is a
+  mandatory release gate that is **not yet met** — examples are validated
+  locally via `scripts/validate_docs_examples.py` today.)
+- Release artifacts are produced by the nightly/release workflows (not from PR
+  CI) and installable via the documented paths; verifiable checksums are a
+  tracked Operations follow-up.
+
+Support **does not** extend to:
+
+- **Untrusted-code sandboxing.** WFL runs the programs you give it; the
+  `ExecutionBudget` bounds resource *exhaustion*, but WFL is **not** a sandbox
+  for hostile code. See [`SECURITY.md`](../../SECURITY.md) → *Known Security
+  Limitations*.
+- **Aspirational / unimplemented syntax.** Anything marked planned/future in the
+  docs is explicitly outside the supported surface until implemented.
+- **Tier 2 / Unsupported platforms**, per the matrix above.
+- **End-of-life versions**, per the version-support matrix in
+  [`SECURITY.md`](../../SECURITY.md) → *Supported Versions*.
+
+## Versioning, compatibility & lifecycle
+
+- **Versioning:** calendar-based `YY.MM.BUILD` (e.g. `26.7.36`). The major
+  component stays `< 256` for Windows MSI compatibility.
+- **Security-update lifecycle:** the current minor line receives prioritized
+  fixes; older lines get critical-only or no updates. The authoritative matrix
+  lives in [`SECURITY.md`](../../SECURITY.md).
+- **Compatibility & breaking changes:** backward compatibility for supported
+  language behaviour is protected by [`GOVERNANCE.md`](../../GOVERNANCE.md)
+  (§3.1/§3.2 stability policy; §2.2 breaking-change authority). Breaking a
+  supported program requires the documented deprecation path.
+
+## Reporting a platform problem
+
+- **Build/runtime bug on a Tier 1 platform:** file a normal issue with the
+  platform, architecture, Rust version (`rustc --version`), and a minimal
+  reproduction.
+- **Security issue:** do **not** open a public issue — follow
+  [`SECURITY.md`](../../SECURITY.md) (private advisory or email).
+
+---
+
+*Maintained as part of the production-readiness effort (issue #610, Phase 1).
+Update the platform matrix whenever a CI lane is added or removed, and keep the
+tiers in sync with `.github/workflows/`.*
diff --git a/SECURITY.md b/SECURITY.md
index 5d0b9fba..4453efdc 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -10,12 +10,14 @@ We provide security updates for the following versions of WFL:
 
 | Version Pattern | Supported          | Notes |
 | --------------- | ------------------ | ----- |
-| 26.6.x (Current)| ✅ Yes             | Active development, security fixes prioritized |
-| 26.5.x         | ⚠️ Limited         | Critical security issues only |
-| 26.4.x and older| ❌ No            | No security updates provided |
+| 26.7.x (Current)| ✅ Yes             | Active development, security fixes prioritized |
+| 26.6.x         | ⚠️ Limited         | Critical security issues only |
+| 26.5.x and older| ❌ No            | No security updates provided |
 
 **Version Scheme**: WFL uses calendar-based versioning (YY.MM.BUILD). Security patches are released as point releases within the current month.
 
+**Supported Platforms**: See [Docs/reference/supported-platforms.md](Docs/reference/supported-platforms.md) for the platform support tiers (what CI builds and tests), the toolchain/runtime requirements, and the boundaries of "supported" behaviour.
+
 ## 🔒 Reporting Security Vulnerabilities
 
 We take security vulnerabilities seriously and appreciate responsible disclosure from the security community.
@@ -140,10 +142,11 @@ WFL interprets and executes user-provided code. Consider these security implicat
 
 ```ini
 # Example secure .wflcfg
-timeout_seconds = 30          # Reasonable timeout
+timeout_seconds = 30          # Reasonable wall-clock timeout (ExecutionBudget)
 logging_enabled = true        # Enable for audit trails
 debug_report_enabled = false  # Disable in production-like environments
-max_nesting_depth = 5         # Prevent deep recursion attacks
+max_call_depth = 1000         # Runtime recursion/stack ceiling (ExecutionBudget)
+max_nesting_depth = 5         # Linter: max block nesting for readability (style, not a runtime guard)
 ```
 
 ## 🔍 Known Security Limitations
@@ -151,10 +154,10 @@ max_nesting_depth = 5         # Prevent deep recursion attacks
 As alpha software, WFL has the following known limitations:
 
 1. **Execution Sandboxing**: No built-in sandboxing for untrusted code execution
-2. **Resource Limits**: Limited built-in protection against resource exhaustion
+2. **Resource Limits**: A shared `ExecutionBudget` now enforces ceilings (recursion/import depth, pattern steps/states, source/body/response bytes, HTTP/WebSocket capacity, and optional operation/time limits). Adversarial per-limit boundary testing is still in progress (tracked as Phase 3 of #610).
 3. **Input Sanitization**: Basic input validation - additional sanitization may be needed
 4. **Audit Logging**: Security-focused audit logging still in development
-5. **Cryptographic Operations**: No built-in cryptographic functions (rely on external tools)
+5. **Cryptographic Operations**: WFL ships a crypto standard library (WFLHASH plus SHA-256/HMAC and password KDFs — argon2, bcrypt, scrypt, PBKDF2). **WFLHASH is a custom, experimental primitive** and must not be used where a standardized, independently audited hash is required.
 
 ## 📚 Security Resources
 
@@ -196,6 +199,6 @@ We appreciate the security research community and will acknowledge responsible d
 ---
 
 **Last Updated**: July 2026
-**Version**: 26.6.5
+**Version**: 26.7.37
 
 © 2026 Logbie LLC. This security policy is subject to updates as WFL evolves from alpha to stable release.
\ No newline at end of file
diff --git a/fuzz/.gitignore b/fuzz/.gitignore
new file mode 100644
index 00000000..df274b35
--- /dev/null
+++ b/fuzz/.gitignore
@@ -0,0 +1,7 @@
+target
+corpus
+artifacts
+coverage
+# Cargo.lock IS committed for the fuzz crate: it is an application (binaries),
+# so a pinned lockfile makes fuzz builds reproducible and lets the CI
+# fuzz-compile check catch dependency/API drift deterministically.
diff --git a/fuzz/Cargo.lock b/fuzz/Cargo.lock
new file mode 100644
index 00000000..86d3a4ab
--- /dev/null
+++ b/fuzz/Cargo.lock
@@ -0,0 +1,3441 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+
+[[package]]
+name = "argon2"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072"
+dependencies = [
+ "base64ct",
+ "blake2",
+ "cpufeatures",
+ "password-hash",
+]
+
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
+name = "bcrypt"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e65938ed058ef47d92cf8b346cc76ef48984572ade631927e9937b5ffc7662c7"
+dependencies = [
+ "base64 0.22.1",
+ "blowfish",
+ "getrandom 0.2.17",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "beef"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "blowfish"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e412e2cd0f2b2d93e02543ceae7917b3c70331573df19ee046bcbc35e45e87d7"
+dependencies = [
+ "byteorder",
+ "cipher",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
+
+[[package]]
+name = "cc"
+version = "1.2.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e17dd265a7d0f31ef544e1b20e03add05d3b45b491b633b10d67145d2acc1a38"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "clipboard-win"
+version = "4.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7191c27c2357d9b7ef96baac1773290d4ca63b24205b82a3fd8a0637afcf0362"
+dependencies = [
+ "error-code",
+ "str-buf",
+ "winapi",
+]
+
+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "803d13fb3b09d88be9f4dbc29062c66b19bf7170867ceb746d2a8689bf6c7a26"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dotenvy"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
+
+[[package]]
+name = "either"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "endian-type"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "error-code"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64f18991e7bf11e7ffee451b5318b5c1a73c52d0d0ada6e5a3017c8c1ced6a21"
+dependencies = [
+ "libc",
+ "str-buf",
+]
+
+[[package]]
+name = "etcetera"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "136d1b5283a1ab77bd9257427ffd09d8667ced0570b6f938942bc7568ed5b943"
+dependencies = [
+ "cfg-if",
+ "home",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "fd-lock"
+version = "3.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef033ed5e9bad94e55838ca0ca906db0e043f517adda0c8b79c7a8c66c93c1b5"
+dependencies = [
+ "cfg-if",
+ "rustix 0.38.44",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
+dependencies = [
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "flume"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "spin",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-intrusive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
+dependencies = [
+ "futures-core",
+ "lock_api",
+ "parking_lot",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "h2"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http 0.2.12",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "hashlink"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+dependencies = [
+ "hashbrown 0.15.5",
+]
+
+[[package]]
+name = "headers"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06683b93020a07e3dbcf5f8c0f6d40080d725bea7936fc01ad345c01b97dc270"
+dependencies = [
+ "base64 0.21.7",
+ "bytes",
+ "headers-core",
+ "http 0.2.12",
+ "httpdate",
+ "mime",
+ "sha1",
+]
+
+[[package]]
+name = "headers-core"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429"
+dependencies = [
+ "http 0.2.12",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "home"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6970f50e31d6fc17d3fa27329444bfa74e196cf62e95052a3f6fee181dba6425"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http 0.2.12",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hyper"
+version = "0.14.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http 0.2.12",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2 0.5.10",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+dependencies = [
+ "bytes",
+ "hyper",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "jobserver"
+version = "0.1.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
+dependencies = [
+ "getrandom 0.4.3",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53b44bfcdb3f8d5837a46dae1ca9660a837176eee74a28b229bc626816589102"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+dependencies = [
+ "spin",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libredox"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c943259e342f1e06ff2da7a83eabdfe7f92ce10262688dbf1895ff0b3e6e4652"
+dependencies = [
+ "bitflags 2.13.0",
+ "libc",
+ "plain",
+ "redox_syscall 0.9.0",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+
+[[package]]
+name = "logos"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff472f899b4ec2d99161c51f60ff7075eeb3097069a36050d8037a6325eb8154"
+dependencies = [
+ "logos-derive",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "192a3a2b90b0c05b27a0b2c43eecdb7c415e29243acc3f89cc8247a5b693045c"
+dependencies = [
+ "beef",
+ "fnv",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex-syntax",
+ "rustc_version",
+ "syn",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "605d9697bcd5ef3a42d38efc51541aa3d6a4a25f7ab6d1ed0da5ac632a26b470"
+dependencies = [
+ "logos-codegen",
+]
+
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "multer"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01acbdc23469fd8fe07ab135923371d5f5a422fbf9c522158677c8eb15bc51c2"
+dependencies = [
+ "bytes",
+ "encoding_rs",
+ "futures-util",
+ "http 0.2.12",
+ "httparse",
+ "log",
+ "memchr",
+ "mime",
+ "spin",
+ "version_check",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "nibble_vec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "nix"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
+dependencies = [
+ "bitflags 1.3.2",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "num-bigint-dig"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7"
+dependencies = [
+ "lazy_static",
+ "libm",
+ "num-integer",
+ "num-iter",
+ "num-traits",
+ "rand 0.8.7",
+ "serde",
+ "smallvec",
+ "zeroize",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c92800bd69a1eac91786bcfe9da64a897eb72911b8dc3095decbd07429e8048b"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "openssl"
+version = "0.10.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77823a27f0babb03091cb9ed9ef80af3b39dbc82f97e8fa530374b7dafd87a45"
+dependencies = [
+ "bitflags 2.13.0",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b47e7e6bb2c38cd930d25a23b40fa52e068c10e85f3e03a7f5ba5aaca5713695"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.5.18",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "password-hash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
+dependencies = [
+ "base64ct",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest",
+ "hmac",
+ "password-hash",
+ "sha2",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pkcs1"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
+dependencies = [
+ "der",
+ "pkcs8",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "radix_trie"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+dependencies = [
+ "endian-type",
+ "nibble_vec",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.13.0",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5102a6aaa05aa011a238e178e6bca86d2cb56fc9f586d37cb80f5bca6e07759"
+dependencies = [
+ "bitflags 2.13.0",
+]
+
+[[package]]
+name = "regex"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a0e75113e14dc5acb068cd0786884f214f1312650a3d36d269f5c4f3cdee8a2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f388202e4b80542a0921078cc23b6333bcf1409c1e3f86404cae4766a6131db"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "reqwest"
+version = "0.11.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
+dependencies = [
+ "base64 0.21.7",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http 0.2.12",
+ "http-body",
+ "hyper",
+ "hyper-tls",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "mime_guess",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pemfile 1.0.4",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "system-configuration",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "winreg",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rpassword"
+version = "7.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2da316a15f47e3d053de9cb2c439650bd8fa4aaeb9365f2e5f27f492ff73c196"
+dependencies = [
+ "libc",
+ "rtoolbox",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rsa"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d"
+dependencies = [
+ "const-oid",
+ "digest",
+ "num-bigint-dig",
+ "num-integer",
+ "num-traits",
+ "pkcs1",
+ "pkcs8",
+ "rand_core 0.6.4",
+ "signature",
+ "spki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rtoolbox"
+version = "0.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50a0e551c1e27e1731aba276dbeaeac73f53c7cd34d1bda485d02bd1e0f36844"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags 2.13.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.13.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
+dependencies = [
+ "log",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b92b125634d9b795e7beca796cc790df15a7fb38323bf3196fda83292d06b1f"
+dependencies = [
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki 0.103.13",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "764899a24af3980067ee14bc143654f297b22eaebfe3c7b6b211920a5a59b046"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "rustyline"
+version = "12.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "994eca4bca05c87e86e15d90fc7a91d1be64b4482b38cb2d27474568fe7c9db9"
+dependencies = [
+ "bitflags 2.13.0",
+ "cfg-if",
+ "clipboard-win",
+ "fd-lock",
+ "home",
+ "libc",
+ "log",
+ "memchr",
+ "nix",
+ "radix_trie",
+ "scopeguard",
+ "unicode-segmentation",
+ "unicode-width",
+ "utf8parse",
+ "winapi",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "password-hash",
+ "pbkdf2",
+ "salsa20",
+ "sha2",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.13.0",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.150"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
+[[package]]
+name = "simplelog"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16257adbfaef1ee58b1363bdc0664c9b8e1e30aed86049635fb5f147d065a9c0"
+dependencies = [
+ "log",
+ "termcolor",
+ "time",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "sqlx"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fefb893899429669dcdd979aff487bd78f4064e5e7907e4269081e0ef7d97dc"
+dependencies = [
+ "sqlx-core",
+ "sqlx-macros",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+]
+
+[[package]]
+name = "sqlx-core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "chrono",
+ "crc",
+ "crossbeam-queue",
+ "either",
+ "event-listener",
+ "futures-core",
+ "futures-intrusive",
+ "futures-io",
+ "futures-util",
+ "hashbrown 0.15.5",
+ "hashlink",
+ "indexmap",
+ "log",
+ "memchr",
+ "once_cell",
+ "percent-encoding",
+ "rustls 0.23.41",
+ "serde",
+ "serde_json",
+ "sha2",
+ "smallvec",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "url",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
+name = "sqlx-macros"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2d452988ccaacfbf5e0bdbc348fb91d7c8af5bee192173ac3636b5fb6e6715d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "sqlx-core",
+ "sqlx-macros-core",
+ "syn",
+]
+
+[[package]]
+name = "sqlx-macros-core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19a9c1841124ac5a61741f96e1d9e2ec77424bf323962dd894bdb93f37d5219b"
+dependencies = [
+ "dotenvy",
+ "either",
+ "heck",
+ "hex",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "sha2",
+ "sqlx-core",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+ "syn",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "sqlx-mysql"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
+dependencies = [
+ "atoi",
+ "base64 0.22.1",
+ "bitflags 2.13.0",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "crc",
+ "digest",
+ "dotenvy",
+ "either",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "generic-array",
+ "hex",
+ "hkdf",
+ "hmac",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "percent-encoding",
+ "rand 0.8.7",
+ "rsa",
+ "serde",
+ "sha1",
+ "sha2",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror 2.0.18",
+ "tracing",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-postgres"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
+dependencies = [
+ "atoi",
+ "base64 0.22.1",
+ "bitflags 2.13.0",
+ "byteorder",
+ "chrono",
+ "crc",
+ "dotenvy",
+ "etcetera",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "hex",
+ "hkdf",
+ "hmac",
+ "home",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "rand 0.8.7",
+ "serde",
+ "serde_json",
+ "sha2",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror 2.0.18",
+ "tracing",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-sqlite"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2d12fe70b2c1b4401038055f90f151b78208de1f9f89a7dbfd41587a10c3eea"
+dependencies = [
+ "atoi",
+ "chrono",
+ "flume",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-intrusive",
+ "futures-util",
+ "libsqlite3-sys",
+ "log",
+ "percent-encoding",
+ "serde",
+ "serde_urlencoded",
+ "sqlx-core",
+ "thiserror 2.0.18",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "str-buf"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e08d8363704e6c71fc928674353e6b7c23dcea9d82d7012c8faf2a3a025f8d0"
+
+[[package]]
+name = "stringprep"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+ "unicode-properties",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "tar"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.3",
+ "once_cell",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "time"
+version = "0.3.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18dfaaeddcb932337b5e7866ee7d0ce9b76d2fd092997146f187ec09b4558a50"
+dependencies = [
+ "deranged",
+ "libc",
+ "num-conv",
+ "num_threads",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
+
+[[package]]
+name = "time-macros"
+version = "0.2.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c431b87111666e491a90baa837f914fb45cd5dc3c268591b0220ff5057f2085f"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb4ebadaa0af04fab11ae01eb5f9fdb5f9c5b875506e210e71c07873528baa7f"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.52.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2 0.6.4",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
+dependencies = [
+ "rustls 0.22.4",
+ "rustls-pki-types",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
+dependencies = [
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http 1.4.2",
+ "httparse",
+ "log",
+ "rand 0.8.7",
+ "sha1",
+ "thiserror 1.0.69",
+ "url",
+ "utf-8",
+]
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-properties"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uuid"
+version = "1.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea5fab0d6c3c01ae70085a09cb03d4c7a1d6314e2b3e075392783396d724ca0a"
+dependencies = [
+ "getrandom 0.4.3",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "warp"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4378d202ff965b011c64817db11d5829506d3404edeadb61f190d111da3f231c"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "headers",
+ "http 0.2.12",
+ "hyper",
+ "log",
+ "mime",
+ "mime_guess",
+ "multer",
+ "percent-encoding",
+ "pin-project",
+ "rustls-pemfile 2.2.0",
+ "scoped-tls",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "tokio",
+ "tokio-rustls",
+ "tokio-tungstenite",
+ "tokio-util",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62df1340f32221cb9c54d6a27b030e3dba64361d4a95bed55f9aacb44da291d"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8622dcb61c0bcc9fffa6938bed81210af2da9a7e4a1a834b2e37a59b6dfb6141"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.8",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf85cb06032201fa7c6f829d7db5a7e5aa45bcc0655327713065f6f0576731bf"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "wfl"
+version = "26.7.37"
+dependencies = [
+ "argon2",
+ "bcrypt",
+ "bytes",
+ "chrono",
+ "codespan-reporting",
+ "futures-util",
+ "glob",
+ "hkdf",
+ "hmac",
+ "log",
+ "logos",
+ "num-bigint-dig",
+ "once_cell",
+ "pbkdf2",
+ "rand 0.9.5",
+ "regex",
+ "reqwest",
+ "rustls-pemfile 2.2.0",
+ "rustyline",
+ "scrypt",
+ "serde_json",
+ "sha2",
+ "simplelog",
+ "sqlx",
+ "subtle",
+ "time",
+ "tokio",
+ "uuid",
+ "warp",
+ "wflpkg",
+ "zeroize",
+]
+
+[[package]]
+name = "wfl-fuzz"
+version = "0.0.0"
+dependencies = [
+ "libfuzzer-sys",
+ "wfl",
+]
+
+[[package]]
+name = "wflpkg"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "flate2",
+ "reqwest",
+ "rpassword",
+ "rustyline",
+ "serde",
+ "serde_json",
+ "sha2",
+ "tar",
+ "tokio",
+ "zeroize",
+]
+
+[[package]]
+name = "whoami"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d"
+dependencies = [
+ "libredox",
+ "wasite",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "writeable"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix 1.1.4",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7cbbc0a705a0fd05cc3676525980d2bf5a9bc4adac6d6475209a7887cf59d19"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2e817b7b52d0c7358d3246da9d69935ebb18116b2b102b4230dac079b4862f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd2f034a4bebf216c9e4b7083603e024cf930873fd67830cfb083c9fa33129d9"
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
new file mode 100644
index 00000000..1ea85554
--- /dev/null
+++ b/fuzz/Cargo.toml
@@ -0,0 +1,52 @@
+# WFL fuzz targets (cargo-fuzz / libFuzzer).
+#
+# This is a SEPARATE workspace (note the empty `[workspace]` table below) so the
+# stable-toolchain `cargo build` / `cargo test` at the repo root never tries to
+# build it — libFuzzer targets require a nightly toolchain and the sanitizer
+# runtime. See fuzz/README.md for how to run them.
+[package]
+name = "wfl-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2024"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+
+[dependencies.wfl]
+path = ".."
+
+# Keep the fuzz crate out of the parent workspace.
+[workspace]
+
+# libFuzzer targets: no libtest harness, no doctests, no benches.
+[[bin]]
+name = "fuzz_lexer"
+path = "fuzz_targets/fuzz_lexer.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "fuzz_parser"
+path = "fuzz_targets/fuzz_parser.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "fuzz_pattern"
+path = "fuzz_targets/fuzz_pattern.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "fuzz_frontend"
+path = "fuzz_targets/fuzz_frontend.rs"
+test = false
+doc = false
+bench = false
diff --git a/fuzz/README.md b/fuzz/README.md
new file mode 100644
index 00000000..7c476bae
--- /dev/null
+++ b/fuzz/README.md
@@ -0,0 +1,122 @@
+# WFL fuzz targets
+
+Coverage-guided fuzz targets for WFL's untrusted-input surfaces, built with
+[`cargo-fuzz`](https://github.com/rust-fuzz/cargo-fuzz) / libFuzzer. Established
+under Phase 1 of the production-readiness plan
+([issue #610](https://github.com/WebFirstLanguage/wfl/issues/610)) to satisfy the
+mandatory gate *"Fuzz targets complete the agreed sustained run without an
+unresolved crash or hang."*
+
+## Targets
+
+| Target | Surface under test | Entry points |
+|---|---|---|
+| `fuzz_lexer` | Tokenization | `lexer::lex_wfl_with_positions_checked` |
+| `fuzz_parser` | Recursive-descent parser (with error recovery) | `lexer::lex_wfl_with_positions` → `Parser::parse` |
+| `fuzz_pattern` | Pattern grammar + compiler + VM (ReDoS surface) | `pattern\0haystack` pair → `create pattern` parse → `CompiledPattern::compile` → `find_all(haystack)` |
+| `fuzz_frontend` | Compiler **frontend** on arbitrary source: checked lex → parse → include/load-module detection → analyze → type check | `lex_wfl_with_positions_checked` → `Parser::parse` → `program_has_includes`/`program_has_load_module` → `Analyzer::analyze` → `TypeChecker::check_types` |
+
+Each target's invariant is the same: **no arbitrary input may panic, overflow
+the stack, or hang.** Controlled `Err`/diagnostic results are expected outcomes,
+not failures.
+
+### Not yet covered: module *loading* (open Phase 1 follow-up)
+
+> **Naming note:** an earlier revision named the frontend target
+> `fuzz_module_loading`; it was **renamed to `fuzz_frontend`** because it does
+> not actually fuzz module loading. If you are cross-referencing older PR text
+> that says `fuzz_module_loading`, it means `fuzz_frontend`.
+
+Phase 1 ([#610](https://github.com/WebFirstLanguage/wfl/issues/610)) lists a
+**module-loading** fuzz surface. There is no such target yet. `fuzz_frontend`
+fuzzes the static pipeline a module's *content* passes through, but it does
+**not** invoke the interpreter's `LoadModuleStatement` / `IncludeStatement`
+paths, so it never reaches filesystem path resolution/canonicalization, bounded
+reads, cross-file circular/import-depth enforcement, parent-scope construction,
+or module execution.
+
+Fuzzing the *real* loader means driving the async interpreter against on-disk
+modules. Doing that **safely** is the hard part: executing fuzzer-generated WFL
+would also exercise subprocess spawning, networking, the web server, and
+filesystem writes, so a naive interpreter-in-libFuzzer harness is unsafe. A
+proper module-loading target needs a sandboxed harness (benign module bodies +
+fuzzed include-graph structure/paths, or an execution-disabled load path). This
+is tracked as remaining Phase 1 work — the module-loading fuzz item is **not**
+complete.
+
+## Why this is a separate workspace
+
+`fuzz/Cargo.toml` declares its own empty `[workspace]` and the repo root lists
+`fuzz` under `[workspace] exclude`, so the stable-toolchain `cargo build` /
+`cargo test` / `cargo clippy` at the root never descend into it. libFuzzer
+targets need a **nightly** toolchain and the sanitizer runtime; keeping them out
+of the default build means the mandatory CI checks stay on stable.
+
+You can still *type-check* the targets on stable to catch API drift. `--locked`
+enforces the committed `fuzz/Cargo.lock` (fails on dependency drift instead of
+regenerating it):
+
+```bash
+cargo check --locked --manifest-path fuzz/Cargo.toml
+```
+
+## Running
+
+Requires a nightly toolchain and `cargo-fuzz`. **Run all commands below from the
+repository root** — `cargo fuzz` locates the `fuzz/` workspace automatically, and
+the seeding commands use repo-root-relative `fuzz/…` paths:
+
+```bash
+rustup toolchain install nightly
+cargo install cargo-fuzz
+
+# List targets
+cargo +nightly fuzz list
+
+# The live corpus dir (fuzz/corpus/<target>) is gitignored and does NOT exist on
+# a fresh clone, so seed it from the tracked seeds first. `cargo fuzz run` then
+# uses fuzz/corpus/<target> as the writable corpus by default.
+for t in fuzz_lexer fuzz_parser fuzz_pattern fuzz_frontend; do
+  mkdir -p "fuzz/corpus/$t"
+  cp -n fuzz/seeds/$t/* "fuzz/corpus/$t/" 2>/dev/null || true
+done
+
+# Run one target (writable corpus defaults to fuzz/corpus/<target>).
+# -timeout=10 flags any single input that takes >10s as a hang.
+cargo +nightly fuzz run fuzz_parser -- -timeout=10 -max_len=65536
+
+# Time-boxed run (the shape a CI/nightly job uses); bounds total time + input.
+cargo +nightly fuzz run fuzz_parser -- -max_total_time=300 -timeout=10 -max_len=65536
+```
+
+Crashes/hangs are written to `fuzz/artifacts/<target>/`; reproduce with:
+
+```bash
+cargo +nightly fuzz run fuzz_parser fuzz/artifacts/fuzz_parser/crash-<hash>
+```
+
+## Layout
+
+```text
+fuzz/
+  Cargo.toml            # standalone cargo-fuzz workspace
+  fuzz_targets/*.rs     # one libFuzzer target per surface
+  seeds/<target>/       # tracked seed inputs (committed)
+  corpus/<target>/      # live/evolving corpus (gitignored)
+  artifacts/<target>/   # crash reproducers (gitignored)
+```
+
+## Baseline & follow-up
+
+- **Baseline (Phase 1):** three of the four required surfaces (lexer, parser,
+  pattern engine) plus the compiler frontend are established and type-checked; no
+  sustained run recorded yet. The agreed sustained run and corpus retention are
+  **Phase 3** work (issue #610, *"Establish continuous or scheduled fuzzing with
+  corpus retention"*). Record the duration and any findings in the score history
+  when that run completes.
+- **Open Phase 1 item — module-loading fuzzing:** not done (see *"Not yet
+  covered"* above). Filesystem- and Tokio-backed module *resolution*
+  (`resolve_module_path`, cross-file circular-include detection, import-depth) and
+  module execution need a *sandboxed* async harness — full interpreter execution
+  of fuzzer WFL is unsafe. Until that lands, the module-loading fuzz surface
+  remains uncovered and the Phase 1 fuzz-target task is only partially complete.
diff --git a/fuzz/fuzz_targets/fuzz_frontend.rs b/fuzz/fuzz_targets/fuzz_frontend.rs
new file mode 100644
index 00000000..8078d155
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_frontend.rs
@@ -0,0 +1,55 @@
+#![no_main]
+//! Fuzz target: the compiler **frontend** (lexer → parser → analyzer → type
+//! checker) on arbitrary source.
+//!
+//! This drives the static pipeline every program — including the *content* of a
+//! module — passes through before execution:
+//!   1. **checked** lexing (`lex_wfl_with_positions_checked`),
+//!   2. parse,
+//!   3. include/load-module detection predicates (`program_has_includes` /
+//!      `program_has_load_module`),
+//!   4. include-aware semantic analysis **and** type checking via
+//!      `TypeChecker::check_types` — which runs `Analyzer::analyze` internally
+//!      (its `analyzer_already_run` starts false), so a single call exercises
+//!      both stages. Calling `Analyzer::analyze` separately as well would just
+//!      double-analyze and halve fuzz throughput, so it is not done.
+//!
+//! Invariant: no arbitrary input may panic, overflow the stack, or hang the
+//! frontend. Controlled `Err`/diagnostic results are expected.
+//!
+//! ## This is NOT a module-loading fuzz target
+//!
+//! It does **not** invoke the interpreter's `LoadModuleStatement` /
+//! `IncludeStatement` paths, so it never reaches filesystem path
+//! resolution/canonicalization, bounded reads, cross-file circular/import-depth
+//! enforcement, parent-scope construction, or module execution. Fuzzing the real
+//! loader requires driving the async interpreter against on-disk modules — and
+//! doing that *safely* is non-trivial, because executing fuzzer-generated WFL
+//! would also exercise subprocess spawning, networking, the web server, and
+//! filesystem writes. That is tracked as follow-up in `fuzz/README.md`; the
+//! Phase 1 "module loading" fuzz surface is therefore **not** covered here.
+use libfuzzer_sys::fuzz_target;
+use wfl::analyzer;
+use wfl::lexer::lex_wfl_with_positions_checked;
+use wfl::parser::Parser;
+use wfl::typechecker::TypeChecker;
+
+fuzz_target!(|data: &[u8]| {
+    let Ok(source) = std::str::from_utf8(data) else {
+        return;
+    };
+    let Ok(tokens) = lex_wfl_with_positions_checked(source) else {
+        return;
+    };
+    let mut parser = Parser::new(&tokens);
+    let Ok(program) = parser.parse() else {
+        return;
+    };
+    let _ = analyzer::program_has_includes(&program);
+    let _ = analyzer::program_has_load_module(&program);
+    // `check_types` runs the analyzer internally (analyzer_already_run == false),
+    // so this single call exercises both semantic analysis and type checking
+    // without double-analyzing.
+    let mut type_checker = TypeChecker::new();
+    let _ = type_checker.check_types(&program);
+});
diff --git a/fuzz/fuzz_targets/fuzz_lexer.rs b/fuzz/fuzz_targets/fuzz_lexer.rs
new file mode 100644
index 00000000..af62d441
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_lexer.rs
@@ -0,0 +1,14 @@
+#![no_main]
+//! Fuzz target: the lexer.
+//!
+//! `lex_wfl_with_positions_checked` is WFL's untrusted-input tokenization entry
+//! point. It must never panic or hang on arbitrary source text — a controlled
+//! `Err(BudgetExceeded)` (when a budget is installed) or a token vector are the
+//! only acceptable outcomes.
+use libfuzzer_sys::fuzz_target;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok(source) = std::str::from_utf8(data) {
+        let _ = wfl::lexer::lex_wfl_with_positions_checked(source);
+    }
+});
diff --git a/fuzz/fuzz_targets/fuzz_parser.rs b/fuzz/fuzz_targets/fuzz_parser.rs
new file mode 100644
index 00000000..720c4a90
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_parser.rs
@@ -0,0 +1,17 @@
+#![no_main]
+//! Fuzz target: the recursive-descent parser.
+//!
+//! Lexes arbitrary source, then drives `Parser::parse`. The parser has error
+//! recovery, so a `Vec<ParseError>` is an expected outcome; the invariant under
+//! test is that no input panics, overflows the stack, or hangs the parser.
+use libfuzzer_sys::fuzz_target;
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok(source) = std::str::from_utf8(data) {
+        let tokens = lex_wfl_with_positions(source);
+        let mut parser = Parser::new(&tokens);
+        let _ = parser.parse();
+    }
+});
diff --git a/fuzz/fuzz_targets/fuzz_pattern.rs b/fuzz/fuzz_targets/fuzz_pattern.rs
new file mode 100644
index 00000000..faf4a6cb
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_pattern.rs
@@ -0,0 +1,54 @@
+#![no_main]
+//! Fuzz target: the pattern engine (parser grammar + compiler + VM).
+//!
+//! The input is split into a **pattern/haystack pair** at the first NUL byte, so
+//! the fuzzer controls both sides independently — the pattern *and* the text it
+//! runs against. This is what surfaces ReDoS-style blowups, which depend on the
+//! interaction between a pathological pattern and a crafted input, not on either
+//! alone. (With no NUL, the whole input is the pattern and a default haystack is
+//! used.)
+//!
+//! The pattern bytes are wrapped as the body of a `create pattern` block so the
+//! whole pattern pipeline sees untrusted input end-to-end:
+//!   1. the parser's pattern grammar (`parse_pattern_tokens`),
+//!   2. the pattern compiler (`CompiledPattern::compile`),
+//!   3. the pattern VM (`find_all`) against the fuzzed haystack.
+//!
+//! The interesting failure modes are a panic in compilation or a pathological
+//! match blowup (caught by libFuzzer's timeout). The pattern VM's own step/state
+//! ceilings should keep matching bounded even without an interpreter-level
+//! budget installed — a hang here is a finding.
+use libfuzzer_sys::fuzz_target;
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+use wfl::parser::ast::Statement;
+use wfl::pattern::CompiledPattern;
+
+const DEFAULT_HAYSTACK: &str = "the quick brown fox 123 !@# aAbBcC   \t\n done";
+
+fuzz_target!(|data: &[u8]| {
+    // Split "pattern\0haystack"; fall back to a default haystack if no NUL.
+    let (pattern_bytes, haystack): (&[u8], String) = match data.iter().position(|&b| b == 0) {
+        Some(i) => (
+            &data[..i],
+            String::from_utf8_lossy(&data[i + 1..]).into_owned(),
+        ),
+        None => (data, DEFAULT_HAYSTACK.to_string()),
+    };
+    let Ok(body) = std::str::from_utf8(pattern_bytes) else {
+        return;
+    };
+    let source = format!("create pattern fuzzpat:\n{body}\nend pattern\n");
+    let tokens = lex_wfl_with_positions(&source);
+    let mut parser = Parser::new(&tokens);
+    let Ok(program) = parser.parse() else {
+        return;
+    };
+    for statement in &program.statements {
+        if let Statement::PatternDefinition { pattern, .. } = statement {
+            if let Ok(compiled) = CompiledPattern::compile(pattern) {
+                let _ = compiled.find_all(&haystack);
+            }
+        }
+    }
+});
diff --git a/fuzz/seeds/fuzz_frontend/seed_include.wfl b/fuzz/seeds/fuzz_frontend/seed_include.wfl
new file mode 100644
index 00000000..4537bd6f
--- /dev/null
+++ b/fuzz/seeds/fuzz_frontend/seed_include.wfl
@@ -0,0 +1,3 @@
+include from "mod.wfl"
+store x as greet of "a"
+display x
diff --git a/fuzz/seeds/fuzz_frontend/seed_loadmod.wfl b/fuzz/seeds/fuzz_frontend/seed_loadmod.wfl
new file mode 100644
index 00000000..386a56c8
--- /dev/null
+++ b/fuzz/seeds/fuzz_frontend/seed_loadmod.wfl
@@ -0,0 +1,2 @@
+load module "helpers"
+display something
diff --git a/fuzz/seeds/fuzz_lexer/seed_check.wfl b/fuzz/seeds/fuzz_lexer/seed_check.wfl
new file mode 100644
index 00000000..2bea5da3
--- /dev/null
+++ b/fuzz/seeds/fuzz_lexer/seed_check.wfl
@@ -0,0 +1,3 @@
+check if x is greater than 5:
+    display "big"
+end check
diff --git a/fuzz/seeds/fuzz_lexer/seed_store.wfl b/fuzz/seeds/fuzz_lexer/seed_store.wfl
new file mode 100644
index 00000000..cb900a2e
--- /dev/null
+++ b/fuzz/seeds/fuzz_lexer/seed_store.wfl
@@ -0,0 +1,2 @@
+store x as 5
+display x
diff --git a/fuzz/seeds/fuzz_parser/seed_action.wfl b/fuzz/seeds/fuzz_parser/seed_action.wfl
new file mode 100644
index 00000000..f563efa8
--- /dev/null
+++ b/fuzz/seeds/fuzz_parser/seed_action.wfl
@@ -0,0 +1,4 @@
+define action called f with parameters n:
+    return n times 2
+end action
+display f of 21
diff --git a/fuzz/seeds/fuzz_parser/seed_count.wfl b/fuzz/seeds/fuzz_parser/seed_count.wfl
new file mode 100644
index 00000000..16c78ac3
--- /dev/null
+++ b/fuzz/seeds/fuzz_parser/seed_count.wfl
@@ -0,0 +1,3 @@
+count from 1 to 10:
+    display count
+end count
diff --git a/fuzz/seeds/fuzz_pattern/seed_digits.txt b/fuzz/seeds/fuzz_pattern/seed_digits.txt
new file mode 100644
index 00000000..cc102ff5
--- /dev/null
+++ b/fuzz/seeds/fuzz_pattern/seed_digits.txt
@@ -0,0 +1 @@
+digit then digit then digit
diff --git a/fuzz/seeds/fuzz_pattern/seed_mixed.txt b/fuzz/seeds/fuzz_pattern/seed_mixed.txt
new file mode 100644
index 00000000..502b01c1
--- /dev/null
+++ b/fuzz/seeds/fuzz_pattern/seed_mixed.txt
@@ -0,0 +1 @@
+optional "x" then one or more letter or digit
diff --git a/fuzz/seeds/fuzz_pattern/seed_word.txt b/fuzz/seeds/fuzz_pattern/seed_word.txt
new file mode 100644
index 00000000..759b5b0b
--- /dev/null
+++ b/fuzz/seeds/fuzz_pattern/seed_word.txt
@@ -0,0 +1 @@
+one or more letter
diff --git a/scripts/bump_version.py b/scripts/bump_version.py
index 2f958cbc..4e95dd56 100755
--- a/scripts/bump_version.py
+++ b/scripts/bump_version.py
@@ -113,6 +113,31 @@ def update_cargo_toml(version):
     MODIFIED_FILES.append(CARGO_TOML)
     return True
 
+def _extract_wfl_lock_version(lock_path):
+    """Return the pinned `wfl` package version from a Cargo.lock file.
+
+    Shared by `update_cargo_lock` (root) and `update_fuzz_cargo_lock` (the
+    standalone fuzz workspace) so the `[[package]] name = "wfl"` parse can't
+    drift out of sync between them. Exits (SystemExit) if the file can't be read
+    or the `wfl` entry is absent, so a malformed/missing lock fails the bump.
+    """
+    try:
+        with open(lock_path, "r") as f:
+            content = f.read()
+    except OSError as e:
+        print(f"Error reading {lock_path}: {e}")
+        sys.exit(1)
+
+    match = re.search(
+        r'\[\[package\]\]\s*name = "wfl"\s*version = "([^"]+)"',
+        content,
+        re.DOTALL,
+    )
+    if not match:
+        print(f"Error: Could not find WFL package version in {lock_path}")
+        sys.exit(1)
+    return match.group(1)
+
 def update_cargo_lock():
     """Update Cargo.lock to match Cargo.toml version by running cargo update.
 
@@ -181,34 +206,91 @@ def update_cargo_lock():
         print(f"Error: {CARGO_LOCK} not found after cargo update")
         sys.exit(1)
 
-    try:
-        # Extract version from Cargo.lock using cross-platform Python approach
-        with open(CARGO_LOCK, "r") as f:
-            cargo_lock_content = f.read()
-
-        # Find WFL package version specifically (equivalent to grep -A1 'name = "wfl"')
-        wfl_package_match = re.search(r'\[\[package\]\]\s*name = "wfl"\s*version = "([^"]+)"', cargo_lock_content, re.DOTALL)
-        if not wfl_package_match:
-            print("Error: Could not find WFL package version in Cargo.lock")
-            sys.exit(1)
+    actual_version = _extract_wfl_lock_version(CARGO_LOCK)
+    print(f"Cargo.lock version: {actual_version}")
 
-        actual_version = wfl_package_match.group(1)
-        print(f"Cargo.lock version: {actual_version}")
+    # Verify versions match
+    if expected_version != actual_version:
+        print("Error: Version mismatch!")
+        print(f"  Cargo.toml version: {expected_version}")
+        print(f"  Cargo.lock version: {actual_version}")
+        print("Cargo.lock was not properly synchronized")
+        sys.exit(1)
 
-        # Verify versions match
-        if expected_version != actual_version:
-            print(f"Error: Version mismatch!")
-            print(f"  Cargo.toml version: {expected_version}")
-            print(f"  Cargo.lock version: {actual_version}")
-            print("Cargo.lock was not properly synchronized")
-            sys.exit(1)
+    print(f"✓ Version synchronization verified: {expected_version}")
+    MODIFIED_FILES.append(CARGO_LOCK)
 
-        print(f"✓ Version synchronization verified: {expected_version}")
-        MODIFIED_FILES.append(CARGO_LOCK)
+def update_fuzz_cargo_lock(expected_version):
+    """Sync + validate the standalone fuzz workspace's Cargo.lock after a bump.
 
-    except Exception as e:
-        print(f"Error validating Cargo.lock: {e}")
+    `fuzz/` is a SEPARATE cargo workspace (excluded from the root workspace) that
+    path-depends on the root `wfl` package, so `fuzz/Cargo.lock` pins the root
+    version too. `update_cargo_lock()` only refreshes the ROOT lock; if we don't
+    also refresh and STAGE `fuzz/Cargo.lock`, the committed fuzz lock goes stale
+    on every bump and the next `cargo check --locked --manifest-path
+    fuzz/Cargo.toml` (the `fuzz-check` CI gate) fails — and the bump commit is
+    `[skip ci]`, so nothing self-corrects. We also run that same locked check
+    here so a broken lock can never be committed/tagged.
+
+    Raises SystemExit on any error to ensure CI failure.
+    """
+    FUZZ_MANIFEST = os.path.join("fuzz", "Cargo.toml")
+    FUZZ_LOCK = os.path.join("fuzz", "Cargo.lock")
+
+    if not (os.path.exists(FUZZ_MANIFEST) and os.path.exists(FUZZ_LOCK)):
+        print(f"Note: {FUZZ_LOCK} not present; skipping fuzz lock sync.")
+        return
+
+    print("Syncing fuzz/Cargo.lock to match the new root version...")
+
+    # Refresh only the `wfl` entry (a path dep) so the fuzz lock records the new
+    # version without churning unrelated dependencies.
+    try:
+        subprocess.run(
+            ["cargo", "update", "--package", "wfl", "--manifest-path", FUZZ_MANIFEST],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"Error running cargo update for fuzz/Cargo.lock: {e}")
+        print(f"stdout: {e.stdout}")
+        print(f"stderr: {e.stderr}")
         sys.exit(1)
+    except FileNotFoundError:
+        print("Error: cargo command not found. Make sure Rust/Cargo is installed.")
+        sys.exit(1)
+
+    # Verify the fuzz lock now records the expected version for `wfl`.
+    fuzz_version = _extract_wfl_lock_version(FUZZ_LOCK)
+    if fuzz_version != expected_version:
+        print("Error: fuzz/Cargo.lock version mismatch!")
+        print(f"  expected: {expected_version}")
+        print(f"  fuzz/Cargo.lock: {fuzz_version}")
+        sys.exit(1)
+
+    print(f"✓ fuzz/Cargo.lock synchronized: {expected_version}")
+
+    # Prove the staged lock passes the SAME `--locked` gate the next PR's
+    # `fuzz-check` job runs, so a stale/inconsistent lock can never be
+    # committed or tagged by the [skip ci] bump.
+    try:
+        subprocess.run(
+            ["cargo", "check", "--locked", "--manifest-path", FUZZ_MANIFEST],
+            check=True,
+        )
+        print("✓ cargo check --locked --manifest-path fuzz/Cargo.toml passed")
+    except subprocess.CalledProcessError:
+        print(
+            "Error: locked fuzz check failed after bump; "
+            "refusing to stage a broken fuzz/Cargo.lock"
+        )
+        sys.exit(1)
+    except FileNotFoundError:
+        print("Error: cargo command not found. Make sure Rust/Cargo is installed.")
+        sys.exit(1)
+
+    MODIFIED_FILES.append(FUZZ_LOCK)
 
 def update_wix_toml(version):
     """Update version in wix.toml."""
@@ -313,6 +395,10 @@ def main():
         update_cargo_toml(version)
         # Update Cargo.lock after Cargo.toml to ensure version synchronization
         update_cargo_lock()
+        # The standalone fuzz workspace path-depends on root `wfl`, so its lock
+        # pins the root version too. Keep it in sync + staged, or the [skip ci]
+        # bump silently breaks the next `--locked` fuzz-check (see the function).
+        update_fuzz_cargo_lock(version)
         update_vscode_extensions(version)
         update_wix_toml(version)
         print(f"Updated all version references to {version}")
diff --git a/src/logging.rs b/src/logging.rs
index 6fa2bc32..77732130 100644
--- a/src/logging.rs
+++ b/src/logging.rs
@@ -16,8 +16,13 @@ use time::format_description::FormatItem;
 static LOGGER_INITIALIZED: AtomicBool = AtomicBool::new(false);
 static EXEC_LOGGER_INITIALIZED: AtomicBool = AtomicBool::new(false);
 static START_TIME: Lazy<Instant> = Lazy::new(Instant::now);
-static TIME_FORMAT: Lazy<Vec<FormatItem>> =
-    Lazy::new(|| time::format_description::parse("[hour]:[minute]:[second].[subsecond]").unwrap());
+static TIME_FORMAT: Lazy<Vec<FormatItem>> = Lazy::new(|| {
+    // `parse` is deprecated in favor of the version-explicit `parse_borrowed`.
+    // Version 2 is behaviorally identical for this format string (only
+    // components plus literal `:`/`.` separators — no characters whose escaping
+    // differs between format-description versions).
+    time::format_description::parse_borrowed::<2>("[hour]:[minute]:[second].[subsecond]").unwrap()
+});
 static INDENTATION_LEVEL: AtomicUsize = AtomicUsize::new(0);
 thread_local! {
     static EXECUTION_LOG_FILE: RefCell<Option<PathBuf>> = const { RefCell::new(None) };
diff --git a/tests/phase1_correctness_regression_test.rs b/tests/phase1_correctness_regression_test.rs
new file mode 100644
index 00000000..70a1689a
--- /dev/null
+++ b/tests/phase1_correctness_regression_test.rs
@@ -0,0 +1,534 @@
+//! Phase 1 (issue #610) — "convert every known correctness defect into an
+//! end-to-end regression test".
+//!
+//! This file is the auditable index of the known correctness defects surfaced
+//! during the Phase 1 issue inventory. It has two halves:
+//!
+//! * **Fixed defects** — a `#[test]` that asserts the *correct* behaviour, so a
+//!   regression re-opening the defect turns the suite red. Defects already
+//!   covered by a dedicated file are indexed below rather than duplicated; the
+//!   new guards here drive the `wfl` binary end-to-end.
+//! * **Open defects** — a `#[ignore]`d `#[test]` that asserts the *desired*
+//!   behaviour (the fix's acceptance criterion). It is skipped in CI today so
+//!   the tree stays green, and is flipped to a passing guard by removing
+//!   `#[ignore]` the moment the fix lands. Running `cargo test -- --ignored`
+//!   reproduces every open defect **encoded in this file** on demand (each
+//!   currently fails).
+//!
+//! ## The "convert every known correctness defect" task is PARTIAL, not complete
+//!
+//! Stated plainly so the record can't be read as complete: this suite does
+//! **not** finish that Phase 1 task. **#578 is an umbrella** of ~26 checkboxes;
+//! only its reproducible confirmed functional/silent-wrong-result bugs are
+//! encoded below. Its remaining sub-items (weak inference edges, ergonomics,
+//! missing forms) have **no regression test yet** and are tracked on the issue.
+//! So the "every known correctness defect" gate is **incomplete** — exhaustive
+//! per-item #578 classification remains open Phase 1 work. This is *partial*
+//! coverage; it is **not** a redefinition of "every defect" as "every issue".
+//!
+//! ## Coverage map for the Phase 1 inventory (16 tracked issues + the #610 tracker)
+//!
+//! | Issue | Class | Status | Regression test |
+//! |---|---|---|---|
+//! | #582 | Critical (fixed) | ✅ | `github_issues_batch_test.rs::parameter_shadows_same_named_global` |
+//! | #557 | High (fixed) | ✅ | `github_issues_batch_test.rs` (date-unit include vars) |
+//! | #566 | High (fixed) | ✅ | `github_issues_batch_test.rs` + `route_test.rs` |
+//! | #571 | High (fixed) | ✅ | this file: `issue_571_*` (drives the binary) |
+//! | #580 | High (fixed) | ✅ | `include_of_form_resolution_test.rs` |
+//! | #567 | Medium (fixed) | ✅ | `github_issues_batch_test.rs` (Any/Unknown add/split) |
+//! | #569 | Medium (fixed) | ✅ | this file: `issue_569_*` (drives the binary) |
+//! | #583 | Medium (fixed) | ✅ | `github_issues_batch_test.rs::bracket_string_stays_text` |
+//! | #588 | Medium (fixed) | ✅ | `github_issues_batch_test.rs` (`store x as <call>` Unknown) |
+//! | #590 | Medium (fixed) | ✅ | `recursive_action_return_type_test.rs` (in-process type-checker guard) **+** this file: `issue_590_*` (CLI-level end-to-end guard) |
+//! | #592 | **High (open)** | ⏳ | this file: `issue_592_*` (`#[ignore]`, top-level + action-body) |
+//! | #578 | **High (open, umbrella)** | ⏳ | this file: `issue_578_*` (`#[ignore]`) — see note below |
+//! | #573 | Medium (**fixed**) | ✅ | Binary read (`read binary from …`), binary write, lossless byte round-trip, and MIME helpers shipped in #574; guarded by `web_server_binary_test.rs`, `binary_io_test.rs`, and `binary_file_and_mime_test.wfl`. The issue's own latest verification recommends closing; it is open only pending the close click. |
+//! | #555 | Medium (open) | ⏳ | `TestPrograms/` `CI-SKIP` corpus (docs-in-CI gate) |
+//! | #600 | Post-prod (SNI) | — | Native TLS SNI / multi-cert enhancement. Dependabot alert #49 (`rustls-webpki` DoS) is *present* in the dep graph but **not reachable** — WFL uses `warp …tls().cert_path().key_path()` with client auth off and no CRL/`RevocationOptions` (GHSA-82j2-j2ch-gfr8 needs opt-in revocation + attacker CRL). Disposition "vulnerable code not used"; not a reachable High WFL defect. |
+//! | #612 | Low | — | PR #609 safe defaults already shipped |
+//!
+//! ### Note on #578 (umbrella issue)
+//!
+//! #578 is not a single defect: it collects ~26 checkbox items of varying
+//! severity (confirmed functional bugs, footguns, inference gaps, missing
+//! forms, ergonomics). The `issue_578_*` tests below cover the **reproducible
+//! confirmed functional/silent-wrong-result bugs** re-verified against the
+//! release build — they are a representative, not exhaustive, sample. Two
+//! caveats found while verifying:
+//!
+//! * #578's *nested-`for each` over a growing list crashes* item **did not
+//!   reproduce** on the current build (the nested loops complete and exit 0), so
+//!   it is not encoded as a crash guard — that is why the baseline records "no
+//!   *reproducible* crashes/hangs", not "no bugs".
+//! * #578's *`X ends with Y` misparse* item is also **no longer reproducible**
+//!   (fixed alongside #566).
+//!
+//! Full per-item classification of the remaining #578 checkboxes is **open
+//! Phase 1 work** — it is part of the Phase 1 task *"convert every known
+//! correctness defect into an end-to-end regression test"* and is tracked on the
+//! issue. (*Fixing* those #578 defects is Phase 2; only their classification /
+//! regression coverage belongs to Phase 1.)
+//!
+//! Every "fixed" verdict was measured against a fresh `cargo build --release`
+//! binary, not inferred from commit history.
+
+use std::fs;
+use std::io::Read;
+use std::process::{Command, Stdio};
+use std::time::{Duration, Instant};
+use tempfile::{NamedTempFile, TempDir};
+
+/// Absolute path to the `wfl` binary Cargo built for this test run. It matches
+/// the profile the test itself is compiled with: the **debug** binary under a
+/// plain `cargo test` / `cargo test --workspace` (what CI's test job runs), or
+/// the **release** binary under `cargo test --release`. Either way
+/// `CARGO_BIN_EXE_wfl` points at the freshly-built one, so there is no
+/// stale-binary risk. (These regression programs are tiny, so the debug/release
+/// distinction doesn't affect their outcome.)
+fn wfl_exe() -> &'static str {
+    env!("CARGO_BIN_EXE_wfl")
+}
+
+/// Hard wall-clock cap for a single program run. A regression that loops or
+/// hangs is killed here instead of consuming the whole job timeout.
+const RUN_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Write `files` (relative `name`, `content`) into a fresh temp dir, run the
+/// `entry` program with the temp dir as the working directory (so relative
+/// `include from` / `list files in` paths resolve inside it), and return the
+/// captured output — **stdout, a newline separator, then stderr** (both captured in
+/// full, but *not* interleaved by time) — and the process exit code (`None` if the run
+/// was killed on timeout). Pipes are drained on background threads so a chatty program
+/// cannot dead-lock on a full pipe buffer, and the child is killed if it exceeds
+/// [`RUN_TIMEOUT`]. Output is drained as raw bytes and decoded with
+/// [`String::from_utf8_lossy`], so non-UTF-8 bytes become `U+FFFD` rather than
+/// aborting the read (which `read_to_string` would, silently truncating capture).
+fn run_files(files: &[(&str, &str)], entry: &str) -> (String, Option<i32>) {
+    let dir = TempDir::new().expect("tempdir");
+    for (name, content) in files {
+        let path = dir.path().join(name);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).expect("mkdir");
+        }
+        fs::write(&path, content).expect("write file");
+    }
+    let entry_path = dir.path().join(entry);
+
+    // Hermeticity: pin `WFL_GLOBAL_CONFIG_PATH` to an empty temp file so the child
+    // never picks up a machine-global `/etc/wfl/wfl.cfg` (or its legacy
+    // `/etc/wfl/.wflcfg` fallback), which could silently change timeouts/limits and
+    // make this suite flaky outside CI. The file must *exist* and be empty: a
+    // missing path makes the loader fall back to the legacy `/etc/wfl/.wflcfg`
+    // (see `src/config.rs`), so a nonexistent path would NOT isolate it. It lives
+    // outside `dir`, so directory-listing reproducers can't observe it. Kept in
+    // scope until after the child exits so it isn't deleted mid-run.
+    let global_cfg = NamedTempFile::new().expect("empty global-config tempfile");
+    let mut child = Command::new(wfl_exe())
+        .arg(&entry_path)
+        .current_dir(dir.path())
+        .env("WFL_GLOBAL_CONFIG_PATH", global_cfg.path())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .expect("failed to spawn WFL");
+
+    let mut out_pipe = child.stdout.take().expect("stdout");
+    let mut err_pipe = child.stderr.take().expect("stderr");
+    let out_thread = std::thread::spawn(move || {
+        let mut buf = Vec::new();
+        let _ = out_pipe.read_to_end(&mut buf);
+        String::from_utf8_lossy(&buf).into_owned()
+    });
+    let err_thread = std::thread::spawn(move || {
+        let mut buf = Vec::new();
+        let _ = err_pipe.read_to_end(&mut buf);
+        String::from_utf8_lossy(&buf).into_owned()
+    });
+
+    let start = Instant::now();
+    let mut killed = false;
+    let status = loop {
+        match child.try_wait().expect("try_wait") {
+            Some(status) => break status,
+            None => {
+                if start.elapsed() > RUN_TIMEOUT {
+                    let _ = child.kill();
+                    killed = true;
+                    break child.wait().expect("wait after kill");
+                }
+                std::thread::sleep(Duration::from_millis(25));
+            }
+        }
+    };
+
+    let stdout = out_thread.join().unwrap_or_default();
+    let stderr = err_thread.join().unwrap_or_default();
+    drop(dir);
+    // Separate the two streams with a newline so a `contains(...)`/exact-line
+    // assertion can't false-match a substring that straddles the boundary
+    // (end of stdout + start of stderr).
+    let combined = format!("{stdout}\n{stderr}");
+    (combined, if killed { None } else { status.code() })
+}
+
+/// Convenience for single-file programs.
+fn run_src(src: &str) -> (String, Option<i32>) {
+    run_files(&[("main.wfl", src)], "main.wfl")
+}
+
+// ===========================================================================
+// FIXED DEFECTS — assert correct behaviour (must stay green)
+// ===========================================================================
+
+// --- #569 ------------------------------------------------------------------
+// The type checker must infer a user-defined action's return type from its
+// `return` expression, so a `call` result used where `Text` is required does
+// NOT emit a spurious `error[ERROR]: … Expected Text but found Nothing`.
+// https://github.com/WebFirstLanguage/wfl/issues/569
+
+#[test]
+fn issue_569_action_call_result_is_text_not_nothing() {
+    // `touppercase of <text>` is a strictly Text-typed position; before the fix
+    // the action-call result typed as `Nothing` and the type checker screamed.
+    let (out, code) = run_src(
+        "define action called h with parameters name:\n\
+        \x20   store greeting as \"hello \"\n\
+        \x20   return greeting with name\n\
+         end action\n\
+         store c as call h with \"world\"\n\
+         store upper as touppercase of c\n\
+         display upper\n",
+    );
+    assert!(out.contains("HELLO WORLD"), "program must run: {out}");
+    assert!(
+        !out.contains("found Nothing"),
+        "action-call result must not be typed Nothing (#569): {out}"
+    );
+    assert!(
+        !out.contains("Expected Text but found"),
+        "no spurious Text-mismatch on an action-call result (#569): {out}"
+    );
+    assert_eq!(code, Some(0), "program should exit 0: {out}");
+}
+
+// --- #571 ------------------------------------------------------------------
+// Natural-language arithmetic must bind tighter than comparison, both `divided
+// by` and the `/` symbol lex as division, `modulo` works, and `is between` is a
+// real range check. These are silent-wrong-result footguns, so they get a value
+// assertion. (Broad `/` coverage also lives in the natural-language
+// TestProgram; this is the focused binary-level guard.)
+// https://github.com/WebFirstLanguage/wfl/issues/571
+
+#[test]
+fn issue_571_precedence_division_modulo_between() {
+    let (out, code) = run_src(
+        "store a as 2 plus 3 times 4\n\
+         display \"A=\" with a\n\
+         store b as 10 divided by 4\n\
+         display \"B=\" with b\n\
+         store c as 10 / 4\n\
+         display \"C=\" with c\n\
+         store m as 17 modulo 5\n\
+         display \"M=\" with m\n\
+         check if 5 is between 1 and 10:\n\
+        \x20   display \"BETWEEN=yes\"\n\
+         end check\n",
+    );
+    // `times` binds tighter than `plus`: 2 + (3 * 4) = 14, not (2 + 3) * 4 = 20.
+    assert!(out.contains("A=14"), "operator precedence (#571): {out}");
+    assert!(
+        out.contains("B=2.5"),
+        "`divided by` must be division (#571): {out}"
+    );
+    assert!(
+        out.contains("C=2.5"),
+        "the `/` symbol must lex as division (#571): {out}"
+    );
+    assert!(out.contains("M=2"), "`modulo` must work (#571): {out}");
+    assert!(
+        out.contains("BETWEEN=yes"),
+        "`is between` must be a range check (#571): {out}"
+    );
+    assert_eq!(code, Some(0), "program should exit 0: {out}");
+}
+
+// --- #590 ------------------------------------------------------------------
+// A self-recursive action whose result is indexed must not be typed `Nothing`
+// (which produced a false `Cannot index into Nothing` and could poison runtime).
+// `recursive_action_return_type_test.rs` guards the type-checker in-process;
+// this is the CLI-level end-to-end guard the review asked for — it drives the
+// binary and asserts the program runs and prints, with no Nothing diagnostic.
+// https://github.com/WebFirstLanguage/wfl/issues/590
+
+#[test]
+fn issue_590_self_recursive_indexed_result_runs_cli() {
+    let (out, code) = run_src(
+        "define action called other with parameters n:\n\
+        \x20   create map m:\n\
+        \x20       \"val\" is n\n\
+        \x20   end map\n\
+        \x20   return m\n\
+         end action\n\n\
+         define action called p_unary with parameters n:\n\
+        \x20   check if n is greater than 0:\n\
+        \x20       store r as p_unary of (n minus 1)\n\
+        \x20       return other of (r[\"val\"])\n\
+        \x20   end check\n\
+        \x20   return other of n\n\
+         end action\n\n\
+         display \"VAL=\" with (p_unary of 3)[\"val\"]\n",
+    );
+    assert!(
+        !out.contains("Cannot index into Nothing"),
+        "self-recursive indexed result must not be typed Nothing (#590): {out}"
+    );
+    assert!(
+        !out.contains("found Nothing"),
+        "no spurious Nothing diagnostic on the recursive result (#590): {out}"
+    );
+    assert_eq!(code, Some(0), "program should exit 0 (#590): {out}");
+    // The base case returns `other of 0` → map {"val": 0}; indexing "val" prints 0.
+    // Assert the exact labeled marker so unrelated output (other numbers,
+    // timestamps, diagnostics) can't accidentally satisfy the guard.
+    assert!(
+        out.contains("VAL=0"),
+        "program must run and print its labeled value VAL=0 (#590): {out}"
+    );
+}
+
+// ===========================================================================
+// OPEN DEFECTS — assert desired behaviour, `#[ignore]`d until the fix lands.
+// Remove `#[ignore]` (and update the linked issue) when the fix lands.
+// Run all of them with:
+//   cargo test --test phase1_correctness_regression_test -- --ignored
+// ===========================================================================
+
+// --- #592 ------------------------------------------------------------------
+// A zero-argument include-exposed action referenced by its BARE name (no `of`,
+// no `call`) is fatal — both at top level AND inside an action body — with
+// `Variable '…' is not defined` (exit 3), while `call greet` and the `of` form
+// work. Desired: it resolves like the other call forms in BOTH contexts.
+// Parameterized so a fix that only covers one context cannot make this green.
+// https://github.com/WebFirstLanguage/wfl/issues/592
+//
+// CURRENT (26.7.37): fatal `error[ANALYZE-SEMANTIC]: Variable 'greet' is not
+// defined`, exit 3, in both contexts.
+const MOD_GREET: &str =
+    "define action called greet:\n    return \"hello from greet\"\nend action\n";
+
+fn assert_greet_resolves(main_src: &str, context: &str) {
+    let (out, code) = run_files(
+        &[("mod.wfl", MOD_GREET), ("main.wfl", main_src)],
+        "main.wfl",
+    );
+    assert!(
+        out.contains("hello from greet"),
+        "bare zero-arg included action must resolve ({context}, #592): {out}"
+    );
+    // Match only the *fatal* diagnostic form (`Variable 'greet' is not defined`,
+    // the `error[ANALYZE-SEMANTIC]` #592 emits), not the bare substring
+    // "is not defined" — a benign "This action is not defined in this file …"
+    // note must not false-fail this once the fix lands.
+    assert!(
+        !out.contains("Variable 'greet' is not defined"),
+        "must not be a fatal undefined-variable error ({context}, #592): {out}"
+    );
+    assert_eq!(
+        code,
+        Some(0),
+        "program should exit 0 ({context}, #592): {out}"
+    );
+}
+
+#[test]
+#[ignore = "open defect #592: bare zero-arg included action is fatal at top level"]
+fn issue_592_bare_zero_arg_included_action_top_level() {
+    assert_greet_resolves(
+        "include from \"mod.wfl\"\nstore x as greet\ndisplay x\n",
+        "top level",
+    );
+}
+
+#[test]
+#[ignore = "open defect #592: bare zero-arg included action is fatal inside an action body"]
+fn issue_592_bare_zero_arg_included_action_in_action_body() {
+    assert_greet_resolves(
+        // Invoke run_it with an explicit `call` (not a bare `display run_it`),
+        // so the test stays focused on the included-action name resolution
+        // inside run_it's body (`store x as greet`) and does not depend on
+        // top-level bare-call semantics.
+        "include from \"mod.wfl\"\n\
+         define action called run_it:\n    store x as greet\n    return x\nend action\n\
+         store result as call run_it\n\
+         display result\n",
+        "action body",
+    );
+}
+
+// --- #578 (reproducible confirmed functional bugs from the umbrella issue) --
+// https://github.com/WebFirstLanguage/wfl/issues/578
+
+// `list files in <dir> with pattern <glob>` drops every match and returns 0.
+// CURRENT (26.7.37): COUNT=0 even when matching files exist.
+#[test]
+#[ignore = "open defect #578: `list files … with pattern` glob path returns 0"]
+fn issue_578_list_files_with_pattern_matches() {
+    let (out, code) = run_files(
+        &[
+            ("input/a.txt", "a\n"),
+            ("input/b.txt", "b\n"),
+            ("input/c.log", "c\n"),
+            (
+                "main.wfl",
+                "store files as list files in \"input\" with pattern \"*.txt\"\n\
+                 display \"COUNT=\" with length of files\n",
+            ),
+        ],
+        "main.wfl",
+    );
+    assert!(
+        out.contains("COUNT=2"),
+        "glob filter must return the two .txt files (#578): {out}"
+    );
+    assert_eq!(code, Some(0), "program should exit 0 (#578): {out}");
+}
+
+// A `one or more letter` quantifier is ignored: `pattern_find_all` advances one
+// character at a time, so a four-word sentence yields 16 single-letter matches
+// instead of 4 word matches.
+// CURRENT (26.7.37): NMATCHES=16.
+#[test]
+#[ignore = "open defect #578: pattern-VM ignores the `one or more` quantifier"]
+fn issue_578_pattern_one_or_more_quantifier() {
+    let (out, code) = run_src(
+        "create pattern word:\n    one or more letter\nend pattern\n\
+         store results as pattern_find_all of \"the quick brown fox\" and word\n\
+         display \"NMATCHES=\" with length of results\n",
+    );
+    assert!(
+        out.contains("NMATCHES=4"),
+        "`one or more letter` must match 4 whole words, not per-char (#578): {out}"
+    );
+    // Guard against a false pass where the program errors out before printing.
+    assert_eq!(code, Some(0), "program should exit 0 (#578): {out}");
+}
+
+// `repeat N times:` is not accepted (it collides with the `times` multiply
+// operator), even though it is the most natural counted loop.
+// CURRENT (26.7.37): parse error at the numeric literal.
+#[test]
+#[ignore = "open defect #578: `repeat N times` counted loop is unsupported"]
+fn issue_578_repeat_n_times() {
+    let (out, code) = run_src("repeat 3 times:\n    display \"hi\"\nend repeat\n");
+    // Count lines that are exactly `hi` (not substring `matches("hi")`, which a
+    // diagnostic containing "this"/"which" could inflate).
+    let hi_count = out.lines().filter(|line| line.trim() == "hi").count();
+    assert_eq!(
+        hi_count, 3,
+        "`repeat 3 times` must run its body 3 times (#578): {out}"
+    );
+    assert_eq!(code, Some(0), "program should exit 0 (#578): {out}");
+}
+
+// `Number plus Text` must be a compile-time type error (the docs promise it),
+// not a silent string concatenation.
+// CURRENT (26.7.37): prints `25Alice` and exits 0.
+#[test]
+#[ignore = "open defect #578: `Number plus Text` silently concatenates instead of erroring"]
+fn issue_578_number_plus_text_is_a_type_error() {
+    let (out, code) = run_src("store age as 25\nstore name as \"Alice\"\ndisplay age plus name\n");
+    assert!(
+        !out.contains("25Alice"),
+        "`Number plus Text` must not silently concatenate (#578): {out}"
+    );
+    // "Rejected" must be policy-agnostic: WFL type errors are *non-fatal* — the
+    // type checker prints a "Type checking warnings:" diagnostic and execution
+    // still exits 0 (only ExecutionBudget breaches are fatal; see src/main.rs).
+    // So accept EITHER a non-zero exit (if a future fix makes it fatal, e.g. a
+    // Severity::Error semantic diagnostic → exit 3) OR an explicit type-checker
+    // diagnostic on a *completed* run. `code == None` (timeout kill) fails both
+    // branches, so a future hang can't pass as green.
+    assert!(
+        matches!(code, Some(c) if c != 0)
+            || (code == Some(0) && out.contains("Type checking warnings:")),
+        "`Number plus Text` must be rejected — a non-zero exit OR an explicit type-checker \
+         diagnostic (WFL type errors are non-fatal), not a silent concat or a hang/timeout (#578): {out}"
+    );
+}
+
+// There is no text→number conversion, yet the type checker's own hint tells the
+// user to "convert to number". `convert <text> to number` does not parse.
+// CURRENT (26.7.37): parse error at `to`.
+#[test]
+#[ignore = "open defect #578: no text→number conversion builtin/syntax"]
+fn issue_578_text_to_number_conversion() {
+    let (out, code) =
+        run_src("store t as \"42\"\nstore n as convert t to number\ndisplay n plus 1\n");
+    assert!(
+        out.contains("43"),
+        "`convert t to number` then +1 must be 43 (#578): {out}"
+    );
+    assert_eq!(code, Some(0), "program should exit 0 (#578): {out}");
+}
+
+// `format_date`/`format_datetime` ignore friendly (`YYYY-MM-DD`) patterns and
+// pass them straight to chrono strftime, so only `%Y-%m-%d` works while the
+// documented friendly form returns the literal pattern string. Silently wrong
+// (exit 0). `current time formatted as "yyyy-MM-dd"` *does* translate, so the
+// two paths are inconsistent.
+// CURRENT (26.7.37): `format_date of d and "YYYY-MM-DD"` returns "YYYY-MM-DD".
+#[test]
+#[ignore = "open defect #578: format_date/format_datetime ignore friendly patterns"]
+fn issue_578_format_date_friendly_pattern() {
+    let (out, code) = run_src(
+        "store d as create_date of 2025 and 8 and 9\n\
+         display \"R=\" with format_date of d and \"YYYY-MM-DD\"\n",
+    );
+    assert!(
+        out.contains("R=2025-08-09"),
+        "friendly `YYYY-MM-DD` pattern must format the date, not echo the literal (#578): {out}"
+    );
+    assert!(
+        !out.contains("R=YYYY-MM-DD"),
+        "the literal pattern string must not be returned verbatim (#578): {out}"
+    );
+    assert_eq!(code, Some(0), "program should exit 0 (#578): {out}");
+}
+
+// A `with`-form action call (`store r as double with 21`) silently builds the
+// string `action double21` and exits 0 instead of calling `double` (the correct
+// form is `double of 21`). A common mistake that passes without any error/warning.
+// CURRENT (26.7.37): prints `action double21`, exit 0.
+//
+// (Re-verified with the release binary; the other #578 items the round-2 review
+// named — `add` to a `List<Any>` dropping in `--test` mode, and residual
+// return-type inference `double of 5 minus 1` → Nothing — did NOT reproduce on
+// the current build, so they are not encoded as open defects here.)
+#[test]
+#[ignore = "open defect #578: `with`-form action call silently concatenates instead of calling"]
+fn issue_578_with_form_action_call_is_not_a_silent_concat() {
+    let (out, code) = run_src(
+        "define action called double with parameters n:\n\
+        \x20   return n times 2\n\
+         end action\n\
+         store r as double with 21\n\
+         display r\n",
+    );
+    assert!(
+        !out.contains("action double21") && !out.contains("double21"),
+        "`double with 21` must not silently concatenate to a string (#578): {out}"
+    );
+    // Desired: it either calls `double` (→ prints exactly `42` AND exits 0) or is
+    // rejected with an explicit non-zero exit; today it silently concatenates and
+    // exits 0, which this guard fails on. Both branches require the run to have
+    // *completed*: the success branch pins `code == Some(0)` so "prints 42 then
+    // hangs" (`code == None`) can't pass, and the failure branch uses
+    // `matches!(code, Some(c) if c != 0)` (not `code != Some(0)`) so a timeout kill
+    // (`code == None`) does not count as "rejected". The exact-line match
+    // (`line.trim() == "42"`) avoids a stray `42` inside diagnostics passing.
+    assert!(
+        (code == Some(0) && out.lines().any(|line| line.trim() == "42"))
+            || matches!(code, Some(c) if c != 0),
+        "`with`-form call must call the action (→ prints `42`, exit 0) or fail with a non-zero exit, not silently concat or hang (#578): {out}"
+    );
+}