diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1244f65a..516e3402 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -112,6 +112,57 @@ jobs:
       - name: Run All Integration Tests
         run: cargo test --test '*' --verbose
 
+  # Database integration tests against live PostgreSQL and MariaDB servers.
+  # SQLite database tests need no services and already run everywhere via
+  # `cargo test`; this job exercises the env-gated PostgreSQL/MariaDB paths.
+  database-tests:
+    name: Database Tests (PostgreSQL + MariaDB)
+    runs-on: ubuntu-latest
+    needs: fmt
+    timeout-minutes: 15
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: wfl
+          POSTGRES_PASSWORD: wfl
+          POSTGRES_DB: wfl_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U wfl"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      mariadb:
+        image: mariadb:11
+        env:
+          MARIADB_USER: wfl
+          MARIADB_PASSWORD: wfl
+          MARIADB_DATABASE: wfl_test
+          MARIADB_ROOT_PASSWORD: root
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd "healthcheck.sh --connect --innodb_initialized"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    env:
+      WFL_TEST_POSTGRES_URL: postgres://wfl:wfl@localhost:5432/wfl_test
+      WFL_TEST_MYSQL_URL: mysql://wfl:wfl@localhost:3306/wfl_test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Cargo registry and target directory
+        uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: database-tests
+
+      - name: Run Database Tests
+        run: cargo test --test database_test --verbose
+
   # Run WFL test programs to verify the interpreter works correctly
   run-wfl-programs:
     name: Run WFL Programs
@@ -414,7 +465,7 @@ jobs:
   bump-version:
     name: Bump Version
     runs-on: ubuntu-latest
-    needs: [fmt, clippy-and-test, integration-tests, run-wfl-programs]
+    needs: [fmt, 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/CHANGELOG.md b/CHANGELOG.md
index ba08c6db..380a2680 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,26 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Request objects from `wait for request` now carry `method`, `path`, `client_ip`, `body` and `headers` properties (in addition to the existing standalone variables)
 - Errors in executed files (missing file, parse errors, runtime errors) are catchable in the parent with `try`/`when`, including `when file not found`
 - Nesting depth guard (4 levels) protects against a file that executes itself
+- Built-in database support for SQLite, PostgreSQL, and MariaDB/MySQL backed by sqlx connection pooling:
+  - `open database at "<url>" as db` (alias: `connect to database at ... as ...`) routed by URL scheme (`sqlite://`, `sqlite::memory:`, `postgres://`, `postgresql://`, `mysql://`, `mariadb://`)
+  - `store rows as query db with "<sql>" [and parameters [...]]` returns a list of row objects keyed by column name
+  - `store result as execute db with "<sql>" [and parameters [...]]` returns `{affected_rows, last_insert_id}` (`last_insert_id` is `nothing` on PostgreSQL — use `RETURNING`)
+  - `close database db`
+  - Parameters always bind through the database driver (never string interpolation), so SQL injection via values is not possible; placeholders are driver-native (`?` for SQLite/MariaDB, `$1` for PostgreSQL)
+  - Type-aware decoding: integers/floats/decimals → number, `NULL` → `nothing`, `BOOLEAN` → boolean, `BLOB`/`BYTEA` → binary, `DATE`/`TIME`/`TIMESTAMP` → date/time/datetime
+  - Database errors are catchable with `try`/`when error`
+  - Note: `store <name> as query <handle> with ...` and `store <name> as execute <handle> with ...` are now reserved statement shapes; a multi-word variable whose name starts with the word `query`, followed by a `with` concatenation, would previously have parsed as an expression
+- Web route parameter helpers in the standard library:
+  - `path_params of <path> and "<template>"` extracts `:name` segment captures (plus trailing `*name` wildcards) as an object, or returns `nothing` on no match; captures are percent-decoded and query strings are ignored
+  - `path_matches of <path> and "<template>"` returns a boolean for routing conditionals
+- CI job running the database test suite against live PostgreSQL 16 and MariaDB 11 service containers (`WFL_TEST_POSTGRES_URL` / `WFL_TEST_MYSQL_URL` gate the backend-specific tests)
+- New documentation: `Docs/04-advanced-features/databases.md`; route-parameters section in `Docs/04-advanced-features/web-servers.md`
+
+### Fixed
+- `respond to ... with <content> and status <code> and content_type <type>` previously parsed the status as the boolean expression `<code> and content_type`, which failed at runtime and left the HTTP request unanswered; status/content_type values now parse as primary expressions
+- `header "<Name>" of <request>` is now case-insensitive; warp normalizes header names to lowercase, so canonically-spelled names like `User-Agent` always returned nothing on real requests. Absent headers now compare equal to `nothing`
+- The static analyzer now marks variables inside list literals (e.g. `parameters [user_name]`) as used
+- `scripts/run_web_tests.sh` exited before running any test due to `set -e` combined with `((var++))` arithmetic increments
 
 ## [25.9.1] - 2025-09-20
 
diff --git a/Cargo.lock b/Cargo.lock
index ac0f0e35..e19acb52 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2437,6 +2437,7 @@ checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6"
 dependencies = [
  "base64 0.22.1",
  "bytes",
+ "chrono",
  "crc",
  "crossbeam-queue",
  "either",
@@ -2514,6 +2515,7 @@ dependencies = [
  "bitflags 2.10.0",
  "byteorder",
  "bytes",
+ "chrono",
  "crc",
  "digest",
  "dotenvy",
@@ -2555,6 +2557,7 @@ dependencies = [
  "base64 0.22.1",
  "bitflags 2.10.0",
  "byteorder",
+ "chrono",
  "crc",
  "dotenvy",
  "etcetera",
@@ -2589,6 +2592,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2d12fe70b2c1b4401038055f90f151b78208de1f9f89a7dbfd41587a10c3eea"
 dependencies = [
  "atoi",
+ "chrono",
  "flume",
  "futures-channel",
  "futures-core",
diff --git a/Cargo.toml b/Cargo.toml
index b2b55fba..7993a03c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -48,7 +48,7 @@ log = "0.4.20"
 rustyline = "12.0.0"
 tokio = { version = "1.35.1", features = ["full"] }
 reqwest = { version = "0.11.24", features = ["json"] }
-sqlx = { version = "0.8.1", features = ["runtime-tokio-rustls", "sqlite", "mysql", "postgres"] }
+sqlx = { version = "0.8.1", features = ["runtime-tokio-rustls", "sqlite", "mysql", "postgres", "chrono"] }
 serde_json = "1.0.114"
 warp = "0.3.7"
 uuid = { version = "1.6.1", features = ["v4"] }
diff --git a/Dev diary/2026-06-12-database-bindings-and-route-parameters.md b/Dev diary/2026-06-12-database-bindings-and-route-parameters.md
new file mode 100644
index 00000000..8e936165
--- /dev/null
+++ b/Dev diary/2026-06-12-database-bindings-and-route-parameters.md	
@@ -0,0 +1,97 @@
+# Database Bindings, Route Parameters, and Web Server Fixes
+
+**Date:** 2026-06-12
+
+## What Changed
+
+### Database support (SQLite, PostgreSQL, MariaDB)
+
+The sqlx dependency that has been sitting in Cargo.toml is now exposed to WFL
+programs:
+
+```wfl
+open database at "sqlite://app.db" as db
+store inserted as execute db with "INSERT INTO users (name) VALUES (?)" and parameters ["Alice"]
+store users as query db with "SELECT * FROM users"
+close database db
+```
+
+- Backends route by URL scheme: `sqlite://` / `sqlite::memory:`,
+  `postgres://` / `postgresql://`, `mysql://` / `mariadb://` (MariaDB uses
+  the MySQL driver).
+- Runtime lives in `src/interpreter/database.rs` as an explicit `DbPool` enum
+  (deliberately not sqlx `Any`, which has lossy type mapping). Pools hang off
+  `IoClient` behind string handles, exactly like file handles.
+- Rows decode to lists of objects keyed by column name; SQL `NULL` maps to
+  the runtime value of the `nothing` literal (`Value::Null`).
+- Parameters always go through driver-level `.bind()` — SQL injection via
+  values is structurally impossible. Placeholders are driver-native (`?` vs
+  `$1`); we do not rewrite SQL text.
+- No new lexer keywords: `connect` and `query` are contextual with strict
+  lookahead, so existing programs (including variables named `query`) parse
+  unchanged.
+
+### Route parameters for the web server
+
+New stdlib helpers in `src/stdlib/web.rs`:
+
+```wfl
+store params as path_params of path and "/users/:id"
+check if params is nothing:
+    respond to req with "Not Found" and status 404
+otherwise:
+    respond to req with params["id"]
+end check
+```
+
+`:name` captures one segment (percent-decoded), trailing `*name` captures the
+rest, `path_matches` gives a boolean. Implemented as a split-segment matcher —
+the pattern VM would have been overkill.
+
+### Web server fixes (FRAMEWORK_FINAL_REPORT follow-up)
+
+Investigating the archived framework report's blockers against live servers
+turned up two real bugs, both now fixed with regression tests:
+
+1. **respond status clause swallowed the rest of the line.**
+   `respond to req with "x" and status 404 and content_type "text/plain"`
+   parsed the status as the boolean expression `404 and content_type`, which
+   failed at runtime (undefined variable) and left the request unanswered —
+   every 404 path in the comprehensive demo was silently broken. Status and
+   content_type values now parse as primary expressions.
+2. **Header access never matched on real requests.** warp lowercases header
+   names, but the lookup was exact-match, so `header "User-Agent" of req`
+   always returned nothing. Lookup is now case-insensitive, and absent
+   headers compare equal to `nothing`.
+
+The report's headline claim ("`wait for request comes in on ...` does not
+parse") no longer reproduces; parser regression tests in
+`tests/main_loop_parser_test.rs` lock in the try/catch-inside-main-loop
+shapes.
+
+## Why
+
+Strategic direction: close primitive-level gaps in the runtime (database
+access first) and let higher-level framework features live as WFL packages
+later, rather than building a Laravel-style framework into the core.
+
+## Testing
+
+- TDD throughout — every feature/fix started from a failing test.
+- `tests/database_parser_test.rs`, `tests/database_test.rs` (SQLite suites run
+  everywhere; PostgreSQL/MariaDB suites gate on `WFL_TEST_POSTGRES_URL` /
+  `WFL_TEST_MYSQL_URL` and were verified against live PostgreSQL 16 and
+  MariaDB 10.11/11 servers).
+- `tests/route_params_test.rs`, `tests/respond_statement_parser_test.rs`,
+  `tests/header_access_runtime_test.rs` (real warp server round-trips).
+- E2E: `TestPrograms/database_sqlite_test.wfl` (runs in the standard program
+  suites) and `TestPrograms/web_route_params_test.wfl` (driven by
+  `scripts/run_web_tests.sh|ps1` with curl assertions).
+- CI: new `database-tests` job with postgres:16 and mariadb:11 service
+  containers.
+
+## Docs
+
+`Docs/04-advanced-features/databases.md` (new, all examples parse-validated;
+the complete example runs), route-parameters section in `web-servers.md`,
+keyword reference notes for the reserved statement shapes, CHANGELOG.
diff --git a/Docs/04-advanced-features/databases.md b/Docs/04-advanced-features/databases.md
new file mode 100644
index 00000000..1ce2a105
--- /dev/null
+++ b/Docs/04-advanced-features/databases.md
@@ -0,0 +1,196 @@
+# Databases
+
+WFL has built-in database support powered by connection pooling. Three
+backends are supported out of the box:
+
+| Backend | Connection URL schemes | Placeholders |
+|---------|------------------------|--------------|
+| SQLite | `sqlite://path/to/file.db`, `sqlite::memory:` | `?` |
+| PostgreSQL | `postgres://...`, `postgresql://...` | `$1`, `$2`, ... |
+| MariaDB / MySQL | `mariadb://...`, `mysql://...` | `?` |
+
+## Opening a Connection
+
+Use `open database` (or the equivalent `connect to database`) with a
+connection URL, and give the connection a name with `as`:
+
+```wfl
+open database at "sqlite://app.db" as db
+```
+
+```wfl
+connect to database at "postgres://user:password@localhost:5432/mydb" as db
+```
+
+Notes:
+
+- SQLite files are created automatically if they do not exist.
+- `sqlite::memory:` opens a temporary in-memory database that disappears when
+  the connection closes.
+- `mariadb://` URLs are accepted as an alias for `mysql://` — MariaDB speaks
+  the MySQL protocol.
+- Connection failures (bad URL, unreachable server, wrong credentials) raise
+  catchable errors.
+
+## Querying Rows
+
+`query` runs a statement that returns rows (typically `SELECT`). The result is
+a list of objects, one per row, keyed by column name:
+
+```wfl
+open database at "sqlite://app.db" as db
+store users as query db with "SELECT id, name, age FROM users"
+
+for each user in users:
+    display user["name"] with " is " with user["age"]
+end for
+
+close database db
+```
+
+## Parameterized Queries
+
+Pass values with `and parameters [...]` — never by splicing them into the SQL
+text. Parameters are bound by the database driver, so a bound value can never
+change the meaning of the SQL statement. Binding protects values only: never
+build the SQL text itself — including table or column names — from untrusted
+input:
+
+```wfl
+store min_age as 21
+store adults as query db with "SELECT * FROM users WHERE age > ?" and parameters [min_age]
+```
+
+Multiple parameters are separated with `and` (or commas) and bind in order:
+
+```wfl
+store found_users as query db with "SELECT * FROM users WHERE age > ? AND name = ?" and parameters [21 and "Alice"]
+```
+
+On PostgreSQL, use numbered placeholders instead:
+
+```wfl
+store adults as query db with "SELECT * FROM users WHERE age > $1" and parameters [min_age]
+```
+
+## Executing Statements
+
+`execute` runs statements that do not return rows — `INSERT`, `UPDATE`,
+`DELETE`, and DDL like `CREATE TABLE`. The result is an object with
+`affected_rows` and `last_insert_id`:
+
+```wfl
+store created as execute db with "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)"
+store inserted as execute db with "INSERT INTO users (name, age) VALUES (?, ?)" and parameters ["Alice" and 30]
+
+display "Inserted " with inserted["affected_rows"] with " row(s)"
+display "New id: " with inserted["last_insert_id"]
+```
+
+Backend notes for `last_insert_id`:
+
+- **SQLite**: the last inserted rowid.
+- **MariaDB/MySQL**: the last `AUTO_INCREMENT` id.
+- **PostgreSQL**: always `nothing` — use a `RETURNING` clause with `query`
+  instead:
+
+```wfl
+store rows as query db with "INSERT INTO users (name) VALUES ($1) RETURNING id" and parameters ["Carol"]
+store row as rows[0]
+store new_id as row["id"]
+```
+
+## Waiting Explicitly
+
+Database statements run asynchronously inside WFL's runtime; you can make the
+wait explicit with `wait for`:
+
+```wfl
+wait for store users as query db with "SELECT * FROM users"
+```
+
+## Type Mapping
+
+Column values convert to WFL values automatically:
+
+| SQL type | WFL value |
+|----------|-----------|
+| `INTEGER`, `BIGINT`, `SERIAL`, ... | number |
+| `REAL`, `FLOAT`, `DOUBLE`, `NUMERIC`, `DECIMAL` | number |
+| `TEXT`, `VARCHAR`, `CHAR`, ... | text |
+| `BOOLEAN` (and MySQL `TINYINT(1)`) | boolean |
+| `BLOB`, `BYTEA`, `VARBINARY` | binary data |
+| `DATE` | date |
+| `TIME` | time |
+| `TIMESTAMP`, `DATETIME` | datetime |
+| SQL `NULL` | nothing |
+
+`NULL` values compare equal to the `nothing` literal:
+
+```wfl
+store rows as query db with "SELECT age FROM users WHERE name = ?" and parameters ["Ghost"]
+store row as rows[0]
+check if row["age"] is nothing:
+    display "age not recorded"
+end check
+```
+
+Bind parameters convert the other way: whole numbers bind as integers,
+fractional numbers as floats, plus text, booleans, binary data, dates, times,
+datetimes, and `nothing` (binds as SQL `NULL`).
+
+## Error Handling
+
+Database errors — bad SQL, constraint violations, connection problems, or use
+of a closed handle — raise runtime errors that `try` blocks can catch:
+
+```wfl
+try:
+    store rows as query db with "SELECT * FROM missing_table"
+when error:
+    display "query failed: " with error
+end try
+```
+
+## Closing Connections
+
+Close a connection when you are done with it:
+
+```wfl
+close database db
+```
+
+Querying a closed (or never-opened) handle raises a catchable error. Pools
+left open when a program ends are cleaned up with the runtime.
+
+## Complete Example
+
+```wfl
+open database at "sqlite://todo.db" as db
+
+store created as execute db with "CREATE TABLE IF NOT EXISTS tasks (id INTEGER PRIMARY KEY, title TEXT, done BOOLEAN)"
+
+store added as execute db with "INSERT INTO tasks (title, done) VALUES (?, ?)" and parameters ["Write docs" and no]
+display "Created task #" with added["last_insert_id"]
+
+store open_tasks as query db with "SELECT id, title FROM tasks WHERE done = ?" and parameters [no]
+store task_count as length of open_tasks
+display task_count with " open task(s)"
+
+for each task in open_tasks:
+    display "- [" with task["id"] with "] " with task["title"]
+end for
+
+store finished as execute db with "UPDATE tasks SET done = ? WHERE title = ?" and parameters [yes and "Write docs"]
+display "Completed " with finished["affected_rows"] with " task(s)"
+
+close database db
+```
+
+## Testing
+
+- SQLite needs no external services; `sqlite::memory:` is ideal for tests.
+- The repository's CI runs the full suite against live PostgreSQL 16 and
+  MariaDB 11 containers. Locally, set `WFL_TEST_POSTGRES_URL` and/or
+  `WFL_TEST_MYSQL_URL` and run `cargo test --test database_test` to exercise
+  those backends; the tests skip quietly when the variables are unset.
diff --git a/Docs/04-advanced-features/interoperability.md b/Docs/04-advanced-features/interoperability.md
index e118fae6..cbd3d122 100644
--- a/Docs/04-advanced-features/interoperability.md
+++ b/Docs/04-advanced-features/interoperability.md
@@ -62,6 +62,24 @@ WFL web servers work with standard HTTP:
 
 Any HTTP client can communicate with WFL servers!
 
+### 5. **Database Integration**
+
+WFL has built-in database support for SQLite, PostgreSQL, and MariaDB/MySQL:
+
+```wfl
+// Connect to database
+connect to database at "postgres://localhost/mydb" as db
+
+// Query
+wait for store users as query db with "SELECT * FROM users"
+
+// Close
+close database db
+```
+
+See the [Databases guide](databases.md) for the complete reference, including
+parameterized queries, type mapping, and per-backend notes.
+
 ## Planned Interoperability
 
 ### JavaScript Integration (Planned)
@@ -105,27 +123,6 @@ display json
 // Output: {"name": "Alice", "age": 28}
 ```
 
-### Database Integration (Planned)
-
-**Future syntax (conceptual):**
-
-```wfl
-// Connect to database
-connect to database at "postgresql://localhost/mydb" as db
-
-// Query
-wait for store users as query db with "SELECT * FROM users"
-
-// Close
-close database db
-```
-
-**Current workaround:** Use subprocess to call database CLIs
-
-```wfl
-wait for execute command "psql -c 'SELECT * FROM users'" as query_output
-```
-
 ### HTML/CSS Integration (Planned)
 
 **Future syntax (conceptual):**
diff --git a/Docs/04-advanced-features/web-servers.md b/Docs/04-advanced-features/web-servers.md
index 27a2a900..eddc6aa5 100644
--- a/Docs/04-advanced-features/web-servers.md
+++ b/Docs/04-advanced-features/web-servers.md
@@ -264,6 +264,58 @@ otherwise:
 end check
 ```
 
+### Route Parameters
+
+Extract values from path segments with `path_params`. The template marks
+captured segments with `:name`; the result is an object of captures, or
+`nothing` when the path does not match:
+
+```wfl
+store params as path_params of path and "/users/:id"
+check if params is nothing:
+    respond to req with "Not Found" and status 404
+otherwise:
+    store user_id as params["id"]
+    store user_text as "User " with user_id
+    respond to req with user_text
+end check
+```
+
+Template rules:
+
+- `:name` captures exactly one path segment (`/users/:id` matches `/users/42`
+  but not `/users` or `/users/42/extra`).
+- A trailing `*name` captures the rest of the path
+  (`/static/*filepath` matches `/static/css/main.css` with
+  `filepath` = `"css/main.css"`).
+- Other segments must match literally.
+- Captures are percent-decoded (`/users/John%20Doe` captures `"John Doe"`),
+  and any query string on the path is ignored.
+
+Multiple parameters work as expected:
+
+```wfl
+store params as path_params of path and "/users/:user_id/posts/:post_id"
+check if params is not nothing:
+    store post_text as "Post " with params["post_id"] with " by user " with params["user_id"]
+    respond to req with post_text
+end check
+```
+
+Use `path_matches` when you only need a yes/no answer:
+
+```wfl
+check if path_matches of path and "/users/:id":
+    respond to req with "looks like a user page"
+end check
+```
+
+**Security note:** captured values come straight from the request (after
+percent-decoding) and can contain anything, including `..` or path separators.
+If you use a capture to build a filesystem path — common with `*filepath`
+templates — validate it first: reject values containing `..` and confirm the
+final path stays inside the directory you intend to serve.
+
 ## Serving Static Files
 
 Serve files from a directory:
diff --git a/Docs/reference/keyword-reference.md b/Docs/reference/keyword-reference.md
index 26a6dc0f..160d5162 100644
--- a/Docs/reference/keyword-reference.md
+++ b/Docs/reference/keyword-reference.md
@@ -337,6 +337,19 @@ store list as "shopping_list"
 create list called items
 ```
 
+**Example: `query` and `connect` (database statement shapes)**
+```wfl
+// ✅ 'query' works as a plain variable
+store query as "SELECT 1"
+store copy as query
+
+// ❌ 'query <handle> with ...' after 'store ... as' is a database query
+store rows as query db with "SELECT * FROM users"
+
+// ❌ 'connect to database at ... as ...' is a statement
+connect to database at "sqlite://app.db" as db
+```
+
 ---
 
 ## Common Scenarios
diff --git a/Docs/reference/reserved-keywords.md b/Docs/reference/reserved-keywords.md
index cd1af9d5..2ec88868 100644
--- a/Docs/reference/reserved-keywords.md
+++ b/Docs/reference/reserved-keywords.md
@@ -420,6 +420,21 @@ store filename as "data.txt"  // Clear purpose
 store max_users as 100       // Descriptive
 ```
 
+### Rule 5: Reserved Statement Shapes (Database)
+
+The database statements reserve a few phrase shapes built from contextual
+words rather than new keywords:
+
+- `connect to database at ... as ...` — `connect` stays usable as an ordinary
+  identifier everywhere else; only this exact phrase is a statement.
+- `store <name> as query <handle> with <sql> ...` — a value expression
+  beginning with `query <identifier>` directly followed by `with` is parsed as
+  a database query. A plain variable named `query` still works
+  (`store copy as query`), but avoid multi-word variable names whose first
+  word is `query`.
+- `store <name> as execute <handle> with <sql> ...` — same shape with the
+  `execute` keyword.
+
 ---
 
 ## Common Pitfalls
@@ -546,7 +561,7 @@ Complete reference table of all 178 keywords.
 | `create` | Contextual | Declaration | ✅ | `create resource` |
 | `current` | Other | Web/Network | ❌ | `current time` |
 | `data` | Other | Data & Types | ❌ | `process data` |
-| `database` | Other | Data & Types | ❌ | `connect database` |
+| `database` | Other | Data & Types | ❌ | `open database at "sqlite://app.db" as db` |
 | `date` | Other | Data & Types | ❌ | `current date` |
 | `defaults` | Contextual | Declaration | ✅ | `property defaults` |
 | `define` | Structural | Declaration | ❌ | `define action` |
diff --git a/TestPrograms/database_sqlite_test.wfl b/TestPrograms/database_sqlite_test.wfl
new file mode 100644
index 00000000..04dd753c
--- /dev/null
+++ b/TestPrograms/database_sqlite_test.wfl
@@ -0,0 +1,121 @@
+// End-to-end database test using SQLite (no external services required)
+// Exercises: open database, execute (DDL/INSERT/UPDATE/DELETE with bound
+// parameters), query (SELECT with bound parameters), NULL handling, and
+// close database.
+
+display "=== Database SQLite E2E Test ==="
+
+check if file exists at "wfl_e2e_database_test.db":
+    delete file at "wfl_e2e_database_test.db"
+end check
+
+store failures as 0
+
+open database at "sqlite://wfl_e2e_database_test.db" as db
+
+// 1. Create a table
+store created as execute db with "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)"
+display "Created users table"
+
+// 2. Insert rows with bound parameters
+store insert1 as execute db with "INSERT INTO users (name, age) VALUES (?, ?)" and parameters ["Alice" and 30]
+store insert2 as execute db with "INSERT INTO users (name, age) VALUES (?, ?)" and parameters ["Bob" and 25]
+
+check if insert1["affected_rows"] is equal to 1:
+    display "✓ Insert affected 1 row"
+otherwise:
+    display "✗ FAILED: insert affected_rows wrong"
+    add 1 to failures
+end check
+
+check if insert2["last_insert_id"] is equal to 2:
+    display "✓ last_insert_id is 2"
+otherwise:
+    display "✗ FAILED: last_insert_id wrong"
+    add 1 to failures
+end check
+
+// 3. Query with a bound parameter
+store adults as query db with "SELECT id, name, age FROM users WHERE age > ? ORDER BY id" and parameters [26]
+store adult_count as length of adults
+check if adult_count is equal to 1:
+    display "✓ Parameterized SELECT returned 1 row"
+otherwise:
+    display "✗ FAILED: expected 1 row, got " with adult_count
+    add 1 to failures
+end check
+
+store first_adult as adults[0]
+check if first_adult["name"] is equal to "Alice":
+    display "✓ Row field access works: " with first_adult["name"]
+otherwise:
+    display "✗ FAILED: wrong name in row"
+    add 1 to failures
+end check
+
+// 4. SQL injection attempt stays inert as a bound value
+store evil as "x'; DROP TABLE users;--"
+store evil_insert as execute db with "INSERT INTO users (name, age) VALUES (?, ?)" and parameters [evil and 99]
+store user_rows as query db with "SELECT count(*) AS n FROM users"
+store row0 as user_rows[0]
+check if row0["n"] is equal to 3:
+    display "✓ Bound parameters resist injection"
+otherwise:
+    display "✗ FAILED: users table damaged or wrong count"
+    add 1 to failures
+end check
+
+// 5. UPDATE reports affected rows
+store updated as execute db with "UPDATE users SET age = age + 1"
+check if updated["affected_rows"] is equal to 3:
+    display "✓ UPDATE affected 3 rows"
+otherwise:
+    display "✗ FAILED: update affected_rows wrong"
+    add 1 to failures
+end check
+
+// 6. NULL maps to nothing
+store null_insert as execute db with "INSERT INTO users (name, age) VALUES (?, NULL)" and parameters ["Ghost"]
+store ghost_rows as query db with "SELECT age FROM users WHERE name = ?" and parameters ["Ghost"]
+store ghost as ghost_rows[0]
+check if ghost["age"] is nothing:
+    display "✓ SQL NULL maps to nothing"
+otherwise:
+    display "✗ FAILED: NULL did not map to nothing"
+    add 1 to failures
+end check
+
+// 7. DELETE and verify
+store deleted as execute db with "DELETE FROM users WHERE name = ?" and parameters ["Ghost"]
+check if deleted["affected_rows"] is equal to 1:
+    display "✓ DELETE affected 1 row"
+otherwise:
+    display "✗ FAILED: delete affected_rows wrong"
+    add 1 to failures
+end check
+
+// 8. Errors are catchable
+store error_caught as "no"
+try:
+    store broken as query db with "SELEKT * FROM nowhere"
+when error:
+    change error_caught to "yes"
+end try
+check if error_caught is equal to "yes":
+    display "✓ Malformed SQL raises a catchable error"
+otherwise:
+    display "✗ FAILED: malformed SQL did not raise an error"
+    add 1 to failures
+end check
+
+close database db
+delete file at "wfl_e2e_database_test.db"
+display "Database closed and file cleaned up"
+
+check if failures is equal to 0:
+    display "=== All database tests passed ==="
+otherwise:
+    display "=== DATABASE TESTS FAILED: " with failures with " failure(s) ==="
+    // Force a nonzero exit so CI catches the failure
+    open database at "invalid://intentional-failure" as crash
+end check
diff --git a/TestPrograms/web_route_params_test.wfl b/TestPrograms/web_route_params_test.wfl
new file mode 100644
index 00000000..cc3d33fe
--- /dev/null
+++ b/TestPrograms/web_route_params_test.wfl
@@ -0,0 +1,41 @@
+// CI-SKIP: starts server and waits for requests
+// Route parameter extraction E2E test, driven by scripts/run_web_tests.sh.
+// Also regression-covers the issues from Docs/Archive/FRAMEWORK_FINAL_REPORT.md:
+// try/catch inside the main request loop, request property mutation across
+// requests (request_count), and header access.
+
+display "=== Route Params Web Server Test ==="
+listen on port 8096 as route_server
+store request_count as 0
+display "Server listening on port 8096"
+
+main loop:
+    try:
+        wait for request comes in on route_server as req
+        change request_count to request_count plus 1
+        // `path` is defined automatically when a request arrives
+        store request_path as path
+
+        store user_params as path_params of request_path and "/users/:id"
+        check if user_params is nothing:
+            check if request_path is equal to "/":
+                store ready_text as "Route server ready - request " with request_count
+                respond to req with ready_text and content_type "text/plain"
+            otherwise:
+                check if request_path is equal to "/agent":
+                    store agent as header "User-Agent" of req
+                    store agent_text as "Agent: " with agent
+                    respond to req with agent_text and content_type "text/plain"
+                otherwise:
+                    respond to req with "Not Found" and status 404 and content_type "text/plain"
+                end check
+            end check
+        otherwise:
+            store user_id as user_params["id"]
+            store user_text as "User " with user_id
+            respond to req with user_text and content_type "text/plain"
+        end check
+    when error:
+        display "request handling failed"
+    end try
+end loop
diff --git a/google_index.html b/google_index.html
index a9f0504d..02f7628b 100644
--- a/google_index.html
+++ b/google_index.html
@@ -1,59 +1 @@
-<!doctype html><html itemscope="" itemtype="http://schema.org/WebPage" lang="en"><head><meta content="Search the world's information, including webpages, images, videos and more. Google has many special features to help you find exactly what you're looking for." name="description"><meta content="noodp, " name="robots"><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="/images/branding/googleg/1x/googleg_standard_color_128dp.png" itemprop="image"><title>Google</title><script nonce="sfyt5WF_CGhQeUHFmV4qfg">(function(){var _g={kEI:'7YXOaPzJMfW5qtsPt4Ti2Q4',kEXPI:'0,202854,2,83,4037106,85211,9707,344796,290044,5242164,170,5991723,339,26776219,4043709,25228681,51190,5,72793,14280,14115,62507,2663,3431,3319,23879,9139,4599,328,6225,64165,15048,8211,3286,4134,30380,28333,10904,43309,352,4100,14780,5870,1908,5799,7,5773,16796,4849,3305,1,3,2658,4719,11805,6251,28,7,1,1293,2126,2115,748,1,5970,4649,2361,9747,5683,3605,17764,7,1,2729,16551,14882,988,4804,202,1016,1,9635,1032,2293,3803,340,9743,2646,98,5,4,1,320,779,65,4256,670,91,2297,1722,8175,732,682,4349,9592,476,3733,1497,590,1,2,1379,32,104,1120,1924,311,1057,1553,748,538,2114,2,1347,5,2,680,128,3371,5,1554,113,653,2,7,818,2363,4874,4,154,4,1532,2,817,9,1852,1,2,882,2,300,1930,3911,1,1,581,610,3012,28,767,27,2192,1086,358,2158,18,2,2806,824,310,126,110,5,1914,602,3121,3874,21,11,78,7,633,6,5,2646,312,2,548,745,614,5,987,2249,5,7,1138,2,541,96,191,3571,660,506,140,325,218,18,255,548,125,119,1,1,4,10,1039,253,288,361,1504,3,1307,322,310,307,28,3,2,2,2,1036,1200,1,2,11,2,432,377,1,8,1,236,9,117,441,252,423,164,215,135,297,77,2,1018,200,9,27,8,1489,3,2,2,2,642,3,912,360,4,645,2,119,2,602,983,40,4,622,201,1,333,5,8,2,151,248,10,52,10,275,81,8,358,1250,737,219,618,303,4,134,1933,1804,264,26,100,3,204,273,320,43,1,2,48,433,2,7,2,845,1436,439,11,545,863,3,3,351,15,999,35,83,5,95,320,3,9,1,128,306,387,1,269,1,11,1,67,64,499,203,29,127,36,501,1442,305,149,2,19,223,294,73,481,31,428,283,300,1022,333,10,142,732,1227,284,2,110,264,17,122,2,635,401,251,10,5,83,320,6,456,114,313,662,100,239,260,129,172,68,426,86,650,323,227,287,195,1572,2042,369,232,1,2,978,1,2,141,1,2,353,21124208,1717,7635,5,2992,4,2700,260,3,8491,2,1562,3,996,1446,3,8640,158,1033,655,1981,504,130,1829,3617384,2421194,11629,2620970,386367,1078330,1008832',kBL:'WPRo',kOPI:89978449};(function(){var a;((a=window.google)==null?0:a.stvsc)?google.kEI=_g.kEI:window.google=_g;}).call(this);})();(function(){google.sn='webhp';google.kHL='en';})();(function(){
-var g=this||self;function k(){return window.google&&window.google.kOPI||null};var l,m=[];function n(a){for(var b;a&&(!a.getAttribute||!(b=a.getAttribute("eid")));)a=a.parentNode;return b||l}function p(a){for(var b=null;a&&(!a.getAttribute||!(b=a.getAttribute("leid")));)a=a.parentNode;return b}function q(a){/^http:/i.test(a)&&window.location.protocol==="https:"&&(google.ml&&google.ml(Error("a"),!1,{src:a,glmm:1}),a="");return a}
-function r(a,b,d,c,h){var e="";b.search("&ei=")===-1&&(e="&ei="+n(c),b.search("&lei=")===-1&&(c=p(c))&&(e+="&lei="+c));var f=b.search("&cshid=")===-1&&a!=="slh";c="&zx="+Date.now().toString();g._cshid&&f&&(c+="&cshid="+g._cshid);(d=d())&&(c+="&opi="+d);return"/"+(h||"gen_204")+"?atyp=i&ct="+String(a)+"&cad="+(b+e+c)};l=google.kEI;google.getEI=n;google.getLEI=p;google.ml=function(){return null};google.log=function(a,b,d,c,h,e){e=e===void 0?k:e;d||(d=r(a,b,e,c,h));if(d=q(d)){a=new Image;var f=m.length;m[f]=a;a.onerror=a.onload=a.onabort=function(){delete m[f]};a.src=d}};google.logUrl=function(a,b){b=b===void 0?k:b;return r("",a,b)};}).call(this);(function(){google.y={};google.sy={};function e(a,b,c){if(a)var d=a.id;else{do d=Math.random();while(c[d])}c[d]=[a,b]}var f;(f=google).x||(f.x=function(a,b){e(a,b,google.y)});var g;(g=google).sx||(g.sx=function(a,b){e(a,b,google.sy)});google.lm=[];var h;(h=google).plm||(h.plm=function(a){google.lm.push.apply(google.lm,a)});google.lq=[];var k;(k=google).load||(k.load=function(a,b,c){google.lq.push([[a],b,c])});var l;(l=google).loadAll||(l.loadAll=function(a,b){google.lq.push([a,b])});google.bx=!1;var m;(m=google).lx||(m.lx=function(){});var n=[],p;(p=google).fce||(p.fce=function(a,b,c,d){n.push([a,b,c,d])});google.qce=n;google.adl=[];}).call(this);google.f={};(function(){
-document.documentElement.addEventListener("submit",function(b){var a;if(a=b.target){var c=a.getAttribute("data-submitfalse");a=c==="1"||c==="q"&&!a.elements.q.value?!0:!1}else a=!1;a&&(b.preventDefault(),b.stopPropagation())},!0);document.documentElement.addEventListener("click",function(b){var a;a:{for(a=b.target;a&&a!==document.documentElement;a=a.parentElement)if(a.tagName==="A"){a=a.getAttribute("data-nohref")==="1";break a}a=!1}a&&b.preventDefault()},!0);}).call(this);</script><style>#gb{font:13px/27px Arial,sans-serif;height:30px}#gbz,#gbg{position:absolute;white-space:nowrap;top:0;height:30px;z-index:1000}#gbz{left:0;padding-left:4px}#gbg{right:0;padding-right:5px}#gbs{background:transparent;position:absolute;top:-999px;visibility:hidden;z-index:998;right:0}.gbto #gbs{background:#fff}#gbx3,#gbx4{background-color:#2d2d2d;background-image:none;_background-image:none;background-position:0 -138px;background-repeat:repeat-x;border-bottom:1px solid #000;font-size:24px;height:29px;_height:30px;opacity:1;filter:alpha(opacity=100);position:absolute;top:0;width:100%;z-index:990}#gbx3{left:0}#gbx4{right:0}#gbb{position:relative}#gbbw{left:0;position:absolute;top:30px;width:100%}.gbtcb{position:absolute;visibility:hidden}#gbz .gbtcb{right:0}#gbg .gbtcb{left:0}.gbxx{display:none !important}.gbxo{opacity:0 !important;filter:alpha(opacity=0) !important}.gbm{position:absolute;z-index:999;top:-999px;visibility:hidden;text-align:left;border:1px solid #bebebe;background:#fff;-moz-box-shadow:-1px 1px 1px rgba(0,0,0,.2);-webkit-box-shadow:0 2px 4px rgba(0,0,0,.2);box-shadow:0 2px 4px rgba(0,0,0,.2)}.gbrtl .gbm{-moz-box-shadow:1px 1px 1px rgba(0,0,0,.2)}.gbto .gbm,.gbto #gbs{top:29px;visibility:visible}#gbz .gbm{left:0}#gbg .gbm{right:0}.gbxms{background-color:#ccc;display:block;position:absolute;z-index:1;top:-1px;left:-2px;right:-2px;bottom:-2px;opacity:.4;-moz-border-radius:3px;filter:progid:DXImageTransform.Microsoft.Blur(pixelradius=5);*opacity:1;*top:-2px;*left:-5px;*right:5px;*bottom:4px;-ms-filter:"progid:DXImageTransform.Microsoft.Blur(pixelradius=5)";opacity:1\0/;top:-4px\0/;left:-6px\0/;right:5px\0/;bottom:4px\0/}.gbma{position:relative;top:-1px;border-style:solid dashed dashed;border-color:transparent;border-top-color:#c0c0c0;display:-moz-inline-box;display:inline-block;font-size:0;height:0;line-height:0;width:0;border-width:3px 3px 0;padding-top:1px;left:4px}#gbztms1,#gbi4m1,#gbi4s,#gbi4t{zoom:1}.gbtc,.gbmc,.gbmcc{display:block;list-style:none;margin:0;padding:0}.gbmc{background:#fff;padding:10px 0;position:relative;z-index:2;zoom:1}.gbt{position:relative;display:-moz-inline-box;display:inline-block;line-height:27px;padding:0;vertical-align:top}.gbt{*display:inline}.gbto{box-shadow:0 2px 4px rgba(0,0,0,.2);-moz-box-shadow:0 2px 4px rgba(0,0,0,.2);-webkit-box-shadow:0 2px 4px rgba(0,0,0,.2)}.gbzt,.gbgt{cursor:pointer;display:block;text-decoration:none !important}span#gbg6,span#gbg4{cursor:default}.gbts{border-left:1px solid transparent;border-right:1px solid transparent;display:block;*display:inline-block;padding:0 5px;position:relative;z-index:1000}.gbts{*display:inline}.gbzt .gbts{display:inline;zoom:1}.gbto .gbts{background:#fff;border-color:#bebebe;color:#36c;padding-bottom:1px;padding-top:2px}.gbz0l .gbts{color:#fff;font-weight:bold}.gbtsa{padding-right:9px}#gbz .gbzt,#gbz .gbgt,#gbg .gbgt{color:#ccc!important}.gbtb2{display:block;border-top:2px solid transparent}.gbto .gbzt .gbtb2,.gbto .gbgt .gbtb2{border-top-width:0}.gbtb .gbts{background:url(https://ssl.gstatic.com/gb/images/b_8d5afc09.png);_background:url(https://ssl.gstatic.com/gb/images/b8_3615d64d.png);background-position:-27px -22px;border:0;font-size:0;padding:29px 0 0;*padding:27px 0 0;width:1px}.gbzt:hover,.gbzt:focus,.gbgt-hvr,.gbgt:focus{background-color:#4c4c4c;background-image:none;_background-image:none;background-position:0 -102px;background-repeat:repeat-x;outline:none;text-decoration:none !important}.gbpdjs .gbto .gbm{min-width:99%}.gbz0l .gbtb2{border-top-color:#dd4b39!important}#gbi4s,#gbi4s1{font-weight:bold}#gbg6.gbgt-hvr,#gbg6.gbgt:focus{background-color:transparent;background-image:none}.gbg4a{font-size:0;line-height:0}.gbg4a .gbts{padding:27px 5px 0;*padding:25px 5px 0}.gbto .gbg4a .gbts{padding:29px 5px 1px;*padding:27px 5px 1px}#gbi4i,#gbi4id{left:5px;border:0;height:24px;position:absolute;top:1px;width:24px}.gbto #gbi4i,.gbto #gbi4id{top:3px}.gbi4p{display:block;width:24px}#gbi4id{background-position:-44px -101px}#gbmpid{background-position:0 0}#gbmpi,#gbmpid{border:none;display:inline-block;height:48px;width:48px}#gbmpiw{display:inline-block;line-height:9px;padding-left:20px;margin-top:10px;position:relative}#gbmpi,#gbmpid,#gbmpiw{*display:inline}#gbg5{font-size:0}#gbgs5{padding:5px !important}.gbto #gbgs5{padding:7px 5px 6px !important}#gbi5{background:url(https://ssl.gstatic.com/gb/images/b_8d5afc09.png);_background:url(https://ssl.gstatic.com/gb/images/b8_3615d64d.png);background-position:0 0;display:block;font-size:0;height:17px;width:16px}.gbto #gbi5{background-position:-6px -22px}.gbn .gbmt,.gbn .gbmt:visited,.gbnd .gbmt,.gbnd .gbmt:visited{color:#dd8e27 !important}.gbf .gbmt,.gbf .gbmt:visited{color:#900 !important}.gbmt,.gbml1,.gbmlb,.gbmt:visited,.gbml1:visited,.gbmlb:visited{color:#36c !important;text-decoration:none !important}.gbmt,.gbmt:visited{display:block}.gbml1,.gbmlb,.gbml1:visited,.gbmlb:visited{display:inline-block;margin:0 10px}.gbml1,.gbmlb,.gbml1:visited,.gbmlb:visited{*display:inline}.gbml1,.gbml1:visited{padding:0 10px}.gbml1-hvr,.gbml1:focus{outline:none;text-decoration:underline !important}#gbpm .gbml1{display:inline;margin:0;padding:0;white-space:nowrap}.gbmlb,.gbmlb:visited{line-height:27px}.gbmlb-hvr,.gbmlb:focus{outline:none;text-decoration:underline !important}.gbmlbw{color:#ccc;margin:0 10px}.gbmt{padding:0 20px}.gbmt:hover,.gbmt:focus{background:#eee;cursor:pointer;outline:0 solid black;text-decoration:none !important}.gbm0l,.gbm0l:visited{color:#000 !important;font-weight:bold}.gbmh{border-top:1px solid #bebebe;font-size:0;margin:10px 0}#gbd4 .gbmc{background:#f5f5f5;padding-top:0}#gbd4 .gbsbic::-webkit-scrollbar-track:vertical{background-color:#f5f5f5;margin-top:2px}#gbmpdv{background:#fff;border-bottom:1px solid #bebebe;-moz-box-shadow:0 2px 4px rgba(0,0,0,.12);-o-box-shadow:0 2px 4px rgba(0,0,0,.12);-webkit-box-shadow:0 2px 4px rgba(0,0,0,.12);box-shadow:0 2px 4px rgba(0,0,0,.12);position:relative;z-index:1}#gbd4 .gbmh{margin:0}.gbmtc{padding:0;margin:0;line-height:27px}.GBMCC:last-child:after,#GBMPAL:last-child:after{content:'\0A\0A';white-space:pre;position:absolute}#gbmps{*zoom:1}#gbd4 .gbpc,#gbmpas .gbmt{line-height:17px}#gbd4 .gbpgs .gbmtc{line-height:27px}#gbd4 .gbmtc{border-bottom:1px solid #bebebe}#gbd4 .gbpc{display:inline-block;margin:16px 0 10px;padding-right:50px;vertical-align:top}#gbd4 .gbpc{*display:inline}.gbpc .gbps,.gbpc .gbps2{display:block;margin:0 20px}#gbmplp.gbps{margin:0 10px}.gbpc .gbps{color:#000;font-weight:bold}.gbpc .gbpd{margin-bottom:5px}.gbpd .gbmt,.gbpd .gbps{color:#666 !important}.gbpd .gbmt{opacity:.4;filter:alpha(opacity=40)}.gbps2{color:#666;display:block}.gbp0{display:none}.gbp0 .gbps2{font-weight:bold}#gbd4 .gbmcc{margin-top:5px}.gbpmc{background:#fef9db}.gbpmc .gbpmtc{padding:10px 20px}#gbpm{border:0;*border-collapse:collapse;border-spacing:0;margin:0;white-space:normal}#gbpm .gbpmtc{border-top:none;color:#000 !important;font:11px Arial,sans-serif}#gbpms{*white-space:nowrap}.gbpms2{font-weight:bold;white-space:nowrap}#gbmpal{*border-collapse:collapse;border-spacing:0;border:0;margin:0;white-space:nowrap;width:100%}.gbmpala,.gbmpalb{font:13px Arial,sans-serif;line-height:27px;padding:10px 20px 0;white-space:nowrap}.gbmpala{padding-left:0;text-align:left}.gbmpalb{padding-right:0;text-align:right}#gbmpasb .gbps{color:#000}#gbmpal .gbqfbb{margin:0 20px}.gbp0 .gbps{*display:inline}a.gbiba{margin:8px 20px 10px}.gbmpiaw{display:inline-block;padding-right:10px;margin-bottom:6px;margin-top:10px}.gbxv{visibility:hidden}.gbmpiaa{display:block;margin-top:10px}.gbmpia{border:none;display:block;height:48px;width:48px}.gbmpnw{display:inline-block;height:auto;margin:10px 0;vertical-align:top}
-.gbqfb,.gbqfba,.gbqfbb{-moz-border-radius:2px;-webkit-border-radius:2px;border-radius:2px;cursor:default !important;display:inline-block;font-weight:bold;height:29px;line-height:29px;min-width:54px;*min-width:70px;padding:0 8px;text-align:center;text-decoration:none !important;-moz-user-select:none;-webkit-user-select:none}.gbqfb:focus,.gbqfba:focus,.gbqfbb:focus{border:1px solid #4d90fe;-moz-box-shadow:inset 0 0 0 1px rgba(255, 255, 255, 0.5);-webkit-box-shadow:inset 0 0 0 1px rgba(255, 255, 255, 0.5);box-shadow:inset 0 0 0 1px rgba(255, 255, 255, 0.5);outline:none}.gbqfb-hvr:focus,.gbqfba-hvr:focus,.gbqfbb-hvr:focus{-webkit-box-shadow:inset 0 0 0 1px #fff,0 1px 1px rgba(0,0,0,.1);-moz-box-shadow:inset 0 0 0 1px #fff,0 1px 1px rgba(0,0,0,.1);box-shadow:inset 0 0 0 1px #fff,0 1px 1px rgba(0,0,0,.1)}.gbqfb-no-focus:focus{border:1px solid #3079ed;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none}.gbqfb-hvr,.gbqfba-hvr,.gbqfbb-hvr{-webkit-box-shadow:0 1px 1px rgba(0,0,0,.1);-moz-box-shadow:0 1px 1px rgba(0,0,0,.1);box-shadow:0 1px 1px rgba(0,0,0,.1)}.gbqfb::-moz-focus-inner,.gbqfba::-moz-focus-inner,.gbqfbb::-moz-focus-inner{border:0}.gbqfba,.gbqfbb{border:1px solid #dcdcdc;border-color:rgba(0,0,0,.1);color:#444 !important;font-size:11px}.gbqfb{background-color:#4d90fe;background-image:-webkit-gradient(linear,left top,left bottom,from(#4d90fe),to(#4787ed));background-image:-webkit-linear-gradient(top,#4d90fe,#4787ed);background-image:-moz-linear-gradient(top,#4d90fe,#4787ed);background-image:-ms-linear-gradient(top,#4d90fe,#4787ed);background-image:-o-linear-gradient(top,#4d90fe,#4787ed);background-image:linear-gradient(top,#4d90fe,#4787ed);filter:progid:DXImageTransform.Microsoft.gradient(startColorStr='#4d90fe',EndColorStr='#4787ed');border:1px solid #3079ed;color:#fff!important;margin:0 0}.gbqfb-hvr{border-color:#2f5bb7}.gbqfb-hvr:focus{border-color:#2f5bb7}.gbqfb-hvr,.gbqfb-hvr:focus{background-color:#357ae8;background-image:-webkit-gradient(linear,left top,left bottom,from(#4d90fe),to(#357ae8));background-image:-webkit-linear-gradient(top,#4d90fe,#357ae8);background-image:-moz-linear-gradient(top,#4d90fe,#357ae8);background-image:-ms-linear-gradient(top,#4d90fe,#357ae8);background-image:-o-linear-gradient(top,#4d90fe,#357ae8);background-image:linear-gradient(top,#4d90fe,#357ae8)}.gbqfb:active{background-color:inherit;-webkit-box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.3);-moz-box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.3);box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.3)}.gbqfba{background-color:#f5f5f5;background-image:-webkit-gradient(linear,left top,left bottom,from(#f5f5f5),to(#f1f1f1));background-image:-webkit-linear-gradient(top,#f5f5f5,#f1f1f1);background-image:-moz-linear-gradient(top,#f5f5f5,#f1f1f1);background-image:-ms-linear-gradient(top,#f5f5f5,#f1f1f1);background-image:-o-linear-gradient(top,#f5f5f5,#f1f1f1);background-image:linear-gradient(top,#f5f5f5,#f1f1f1);filter:progid:DXImageTransform.Microsoft.gradient(startColorStr='#f5f5f5',EndColorStr='#f1f1f1')}.gbqfba-hvr,.gbqfba-hvr:active{background-color:#f8f8f8;background-image:-webkit-gradient(linear,left top,left bottom,from(#f8f8f8),to(#f1f1f1));background-image:-webkit-linear-gradient(top,#f8f8f8,#f1f1f1);background-image:-moz-linear-gradient(top,#f8f8f8,#f1f1f1);background-image:-ms-linear-gradient(top,#f8f8f8,#f1f1f1);background-image:-o-linear-gradient(top,#f8f8f8,#f1f1f1);background-image:linear-gradient(top,#f8f8f8,#f1f1f1);filter:progid:DXImageTransform.Microsoft.gradient(startColorStr='#f8f8f8',EndColorStr='#f1f1f1')}.gbqfbb{background-color:#fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#fff),to(#fbfbfb));background-image:-webkit-linear-gradient(top,#fff,#fbfbfb);background-image:-moz-linear-gradient(top,#fff,#fbfbfb);background-image:-ms-linear-gradient(top,#fff,#fbfbfb);background-image:-o-linear-gradient(top,#fff,#fbfbfb);background-image:linear-gradient(top,#fff,#fbfbfb);filter:progid:DXImageTransform.Microsoft.gradient(startColorStr='#ffffff',EndColorStr='#fbfbfb')}.gbqfbb-hvr,.gbqfbb-hvr:active{background-color:#fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#fff),to(#f8f8f8));background-image:-webkit-linear-gradient(top,#fff,#f8f8f8);background-image:-moz-linear-gradient(top,#fff,#f8f8f8);background-image:-ms-linear-gradient(top,#fff,#f8f8f8);background-image:-o-linear-gradient(top,#fff,#f8f8f8);background-image:linear-gradient(top,#fff,#f8f8f8);filter:progid:DXImageTransform.Microsoft.gradient(startColorStr='#ffffff',EndColorStr='#f8f8f8')}.gbqfba-hvr,.gbqfba-hvr:active,.gbqfbb-hvr,.gbqfbb-hvr:active{border-color:#c6c6c6;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.1);-moz-box-shadow:0 1px 1px rgba(0,0,0,.1);box-shadow:0 1px 1px rgba(0,0,0,.1);color:#222 !important}.gbqfba:active,.gbqfbb:active{-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,.1);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,.1);box-shadow:inset 0 1px 2px rgba(0,0,0,.1)}
-.gbprcd{padding:0;width:258px;white-space:normal}.gbprcb{display:inline-block;height:27px;padding:0 15px;text-decoration:none}#gbprc .gbprcbc{background-color:;background-image:none;border-color:;color:!important}#gbprc .gbprcbc:hover{color:!important}#gbprc .gbprcbc:active,#gbprc .gbprcbc:focus{color:!important}.gbprct{color:#666;line-height:17px;margin:0;margin-bottom:20px}.gbprci{color:#333;font-size:16px;line-height:20px;margin:0;margin-bottom:16px}#gbprc .gbmc{padding:26px;padding-bottom:22px;border:1px solid #bebebe}#gbprc .gbm{border:0}#gbprc .gbprcx,#gbprc .gbprcx.gbgt-hvr,#gbprc .gbprcx:focus,#gbprc .gbprcx:active{right:12px;background:url(//ssl.gstatic.com/s2/oz/images/stars/x.png);display:block;height:9px;opacity:.8;filter:alpha(opacity=80);position:absolute;top:12px;width:9px}#gbprc .gbprcx.gbgt-hvr,#gbprc .gbprcx:focus,#gbprc .gbprcx:active{opacity:1;filter:alpha(opacity=100)}.gbgs .gbmab,.gbgs .gbmab{left:10px;margin:40px 0 0}.gbgs .gbmac,.gbgs .gbmac{left:10px;margin:41px 0 0}.gbemi .gbgs .gbmab,.gbem .gbgs .gbmab{left:10px;margin:40px 0 0}.gbemi .gbgs .gbmac,.gbem .gbgs .gbmac{left:10px;margin:41px 0 0}.gbesi .gbgs .gbmab,.gbes .gbgs .gbmab{left:10px;margin:40px 0 0}.gbesi .gbgs .gbmac,.gbes .gbgs .gbmac{left:10px;margin:41px 0 0}#gbprca .gbmab{z-index:999}#gbprca .gbmac{border-bottom-color:#fff;z-index:999}#gbprcs{position:absolute;background:transparent;top:-999px;z-index:-1;visibility:hidden;margin-top:1px;margin-left:1px}
-#gb #gbprc{right:-28px;top:15px;z-index:997}#gbprca{left:-63px;position:relative;top:-22px}.gbmab,.gbmac{left:5px;border-style:dashed dashed solid;border-color:transparent;border-bottom-color:#bebebe;border-width:0 10px 10px;display:-moz-inline-box;display:inline-block;font-size:0;height:0;line-height:0;position:absolute;top:0;width:0;z-index:1000}.gbmab,.gbmac{visibility:hidden}.gbmac{border-bottom-color:#fff}.gbto .gbmab,.gbto .gbmac{visibility:visible}#gbqfqw,#gbqfb{vertical-align:top}#gbqfbw{right:0;margin:0 15px;position:absolute;top:0}.gbqfb{background-color:#4d90fe;background-image:-webkit-gradient(linear,left top,left bottom,from(#4d90fe),to(#4787ed));background-image:-webkit-linear-gradient(top,#4d90fe,#4787ed);background-image:-moz-linear-gradient(top,#4d90fe,#4787ed);background-image:-ms-linear-gradient(top,#4d90fe,#4787ed);background-image:-o-linear-gradient(top,#4d90fe,#4787ed);background-image:linear-gradient(top,#4d90fe,#4787ed);filter:progid:DXImageTransform.Microsoft.gradient(startColorStr='#4d90fe',EndColorStr='#4787ed');border:1px solid #3079ed;-moz-border-radius:2px;-webkit-border-radius:2px;border-radius:2px;-moz-user-select:none;-webkit-user-select:none;color:#fff;cursor:default;font-size:11px;font-weight:bold;height:29px;min-width:54px;*min-width:70px;text-align:center;padding:0 8px}.gbqfb-hvr{border:1px solid #2f5bb7;background-color:#357ae8;background-image:-webkit-gradient(linear,left top,left bottom,from(#4d90fe),to(#357ae8));background-image:-webkit-linear-gradient(top,#4d90fe,#357ae8);background-image:-moz-linear-gradient(top,#4d90fe,#357ae8);background-image:-ms-linear-gradient(top,#4d90fe,#357ae8);background-image:-o-linear-gradient(top,#4d90fe,#357ae8);background-image:linear-gradient(top,#4d90fe,#357ae8);-webkit-box-shadow:0 1px 1px rgba(0,0,0,.1);-moz-box-shadow:0 1px 1px rgba(0,0,0,.1);box-shadow:0 1px 1px rgba(0,0,0,.1)}.gbqfb:focus{-moz-box-shadow:inset 0 0 0 1px #fff;-webkit-box-shadow:inset 0 0 0 1px #fff;box-shadow:inset 0 0 0 1px #fff;outline:none}.gbqfb::-moz-focus-inner{border:0}.gbqfb-hvr:focus{-moz-box-shadow:inset 0 0 0 1px #fff,0 1px 1px rgba(0,0,0,.1);-webkit-box-shadow:inset 0 0 0 1px #fff,0 1px 1px rgba(0,0,0,.1);box-shadow:inset 0 0 0 1px #fff,0 1px 1px rgba(0,0,0,.1)}.gbqfb:active{-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,.3);-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,.3);box-shadow:inset 0 1px 2px rgba(0,0,0,.3)}
-#gbmpas{max-height:220px}#gbmm{max-height:530px}.gbsb{-webkit-box-sizing:border-box;display:block;position:relative;*zoom:1}.gbsbic{overflow:auto}.gbsbis .gbsbt,.gbsbis .gbsbb{-webkit-mask-box-image:-webkit-gradient(linear,left top,right top,color-stop(0,rgba(0,0,0,.1)),color-stop(.5,rgba(0,0,0,.8)),color-stop(1,rgba(0,0,0,.1)));left:0;margin-right:0;opacity:0;position:absolute;width:100%}.gbsb .gbsbt:after,.gbsb .gbsbb:after{content:"";display:block;height:0;left:0;position:absolute;width:100%}.gbsbis .gbsbt{background:-webkit-gradient(linear,left top,left bottom,from(rgba(0,0,0,.2)),to(rgba(0,0,0,0)));background-image:-webkit-linear-gradient(top,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:-moz-linear-gradient(top,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:-ms-linear-gradient(top,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:-o-linear-gradient(top,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:linear-gradient(top,rgba(0,0,0,.2),rgba(0,0,0,0));height:6px;top:0}.gbsb .gbsbt:after{border-top:1px solid #ebebeb;border-color:rgba(0,0,0,.3);top:0}.gbsb .gbsbb{-webkit-mask-box-image:-webkit-gradient(linear,left top,right top,color-stop(0,rgba(0,0,0,.1)),color-stop(.5,rgba(0,0,0,.8)),color-stop(1,rgba(0,0,0,.1)));background:-webkit-gradient(linear,left bottom,left top,from(rgba(0,0,0,.2)),to(rgba(0,0,0,0)));background-image:-webkit-linear-gradient(bottom,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:-moz-linear-gradient(bottom,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:-ms-linear-gradient(bottom,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:-o-linear-gradient(bottom,rgba(0,0,0,.2),rgba(0,0,0,0));background-image:linear-gradient(bottom,rgba(0,0,0,.2),rgba(0,0,0,0));bottom:0;height:4px}.gbsb .gbsbb:after{border-bottom:1px solid #ebebeb;border-color:rgba(0,0,0,.3);bottom:0}
-</style><style>body,td,a,p,.h{font-family:sans-serif}body{margin:0;overflow-y:scroll}#gog{padding:3px 8px 0}td{line-height:.8em}.gac_m td{line-height:17px}form{margin-bottom:20px}.h{color:#1967d2}em{font-weight:bold;font-style:normal}.lst{height:25px;width:496px}.gsfi,.lst{font:18px sans-serif}.gsfs{font:17px sans-serif}.ds{display:inline-box;display:inline-block;margin:3px 0 4px;margin-left:4px}input{font-family:inherit}body{background:#fff;color:#1f1f1f}a{color:#681da8;text-decoration:none}a:hover,a:active{text-decoration:underline}.fl a{color:#1967d2}a:visited{color:#681da8}.sblc{padding-top:5px}.sblc a{display:block;margin:2px 0;margin-left:13px;font-size:11px}.lsbb{background:#ecedee;border:solid 1px;border-color:#dadce0 #70757a #70757a #dadce0;height:30px}.lsbb{display:block}#WqQANb a{display:inline-block;margin:0 12px}.lsb{background:url(/images/nav_logo229.png) 0 -261px repeat-x;color:#1f1f1f;border:none;cursor:pointer;height:30px;margin:0;outline:0;font:15px sans-serif;vertical-align:top}.lsb:active{background:#dadce0}.lst:focus{outline:none}</style><script nonce="sfyt5WF_CGhQeUHFmV4qfg">(function(){window.google.erd={jsr:1,bv:2292,de:true,dpf:'YB8GzTh7vGxaqLlv-dLfDr11r6HxQ31dv7t0viqg8-4'};
-var g=this||self;var k,l=(k=g.mei)!=null?k:1,m,p=(m=g.diel)!=null?m:0,q,r=(q=g.sdo)!=null?q:!0,t=0,u,w=google.erd,x=w.jsr;google.ml=function(a,b,d,n,e){e=e===void 0?2:e;b&&(u=a&&a.message);d===void 0&&(d={});d.cad="ple_"+google.ple+".aple_"+google.aple;if(google.dl)return google.dl(a,e,d,!0),null;b=d;if(x<0){window.console&&console.error(a,b);if(x===-2)throw a;b=!1}else b=!a||!a.message||a.message==="Error loading script"||t>=l&&!n?!1:!0;if(!b)return null;t++;d=d||{};b=encodeURIComponent;var c="/gen_204?atyp=i&ei="+b(google.kEI);google.kEXPI&&(c+="&jexpid="+b(google.kEXPI));c+="&srcpg="+b(google.sn)+"&jsr="+b(w.jsr)+
-"&bver="+b(w.bv);w.dpf&&(c+="&dpf="+b(w.dpf));var f=a.lineNumber;f!==void 0&&(c+="&line="+f);var h=a.fileName;h&&(h.indexOf("-extension:/")>0&&(e=3),c+="&script="+b(h),f&&h===window.location.href&&(f=document.documentElement.outerHTML.split("\n")[f],c+="&cad="+b(f?f.substring(0,300):"No script found.")));google.ple&&google.ple===1&&(e=2);c+="&jsel="+e;for(var v in d)c+="&",c+=b(v),c+="=",c+=b(d[v]);c=c+"&emsg="+b(a.name+": "+a.message);c=c+"&jsst="+b(a.stack||"N/A");c.length>=12288&&(c=c.substring(0,12288));a=c;n||google.log(0,"",a);return a};window.onerror=function(a,b,d,n,e){u!==a&&(a=e instanceof Error?e:Error(a),d===void 0||"lineNumber"in a||(a.lineNumber=d),b===void 0||"fileName"in a||(a.fileName=b),google.ml(a,!1,void 0,!1,a.name==="SyntaxError"||a.message.substring(0,11)==="SyntaxError"||a.message.indexOf("Script error")!==-1?3:p));u=null;r&&t>=l&&(window.onerror=null)};})();(function(){try{/*
-
- Copyright The Closure Library Authors.
- SPDX-License-Identifier: Apache-2.0
-*/
-var e=this||self;var aa=function(a,b,c,d){d=d||{};d._sn=["cfg",b,c].join(".");window.gbar.logger.ml(a,d)};var f=window.gbar=window.gbar||{},h=window.gbar.i=window.gbar.i||{},da;function _tvn(a,b){a=parseInt(a,10);return isNaN(a)?b:a}function _tvf(a,b){a=parseFloat(a);return isNaN(a)?b:a}function _tvv(a){return!!a}function n(a,b,c){(c||f)[a]=b}f.bv={n:_tvn("2",0),r:"",f:".66.",e:"",m:_tvn("1",1)};
-function ea(a,b,c){var d="on"+b;if(a.addEventListener)a.addEventListener(b,c,!1);else if(a.attachEvent)a.attachEvent(d,c);else{var g=a[d];a[d]=function(){var k=g.apply(this,arguments),m=c.apply(this,arguments);return k==void 0?m:m==void 0?k:m&&k}}}var fa=function(a){return function(){return f.bv.m==a}},ha=fa(1),ia=fa(2);n("sb",ha);n("kn",ia);h.a=_tvv;h.b=_tvf;h.c=_tvn;h.i=aa;var q=window.gbar.i.i;var r=function(){},u=function(){},la=function(a){var b=new Image,c=ja;b.onerror=b.onload=b.onabort=function(){try{delete ka[c]}catch(d){}};ka[c]=b;b.src=a;ja=c+1},ka=[],ja=0;n("logger",{il:u,ml:r,log:la});var v=window.gbar.logger;var w={},x={createScript:function(a){return a}};x=self.trustedTypes&&self.trustedTypes.createPolicy?self.trustedTypes.createPolicy("ogb#inline",x):x;
-var ma={},y=[],na=h.b("0.1",.1),oa=h.a("1",!0),pa=function(a,b){y.push([a,b])},qa=function(a,b){w[a]=b},ra=function(a){return a in w},z={},A=function(a,b){z[a]||(z[a]=[]);z[a].push(b)},B=function(a){A("m",a)},C=function(a,b){var c=document.createElement("script");c.src=x.createScript(a);c.async=oa;Math.random()<na&&(c.onerror=function(){c.onerror=null;r(Error("Bundle load failed: name="+(b||"UNK")+" url="+a))});(document.getElementById("xjsc")||
-document.getElementsByTagName("body")[0]||document.getElementsByTagName("head")[0]).appendChild(c)},F=function(a){for(var b,c=0;(b=y[c])&&b[0]!=a;++c);!b||b[1].l||b[1].s||(b[1].s=!0,D(2,a),b[1].url&&C(b[1].url,a),b[1].libs&&E&&E(b[1].libs))},sa=function(a){A("gc",a)},G=null,ta=function(a){G=a},D=function(a,b,c){if(G){a={t:a,b:b};if(c)for(var d in c)a[d]=c[d];try{G(a)}catch(g){}}};n("mdc",w);n("mdi",ma);n("bnc",y);n("qGC",sa);n("qm",B);n("qd",z);n("lb",F);n("mcf",qa);n("bcf",pa);n("aq",A);
-n("mdd","");n("has",ra);n("trh",ta);n("tev",D);if(h.a("m;/_/scs/abc-static/_/js/k=gapi.gapi.en.GJa4oir6WlA.O/d=1/rs=AHpOoo-oT18V72om9ubISB9Na8GvbQT5cg/m=__features__")){var H=function(a,b){return ua?a||b:b},I=h.a("1"),va=h.a(""),wa=h.a(""),ua=h.a(""),J=window.gapi=H(window.gapi,{}),K=function(a,b){var c=function(){f.dgl(a,b)};I?B(c):(A("gl",c),F("gl"))},xa={},ya=function(a){a=a.split(":");for(var b;(b=a.pop())&&xa[b];);return!b},E=function(a){function b(){for(var c=a.split(":"),d,g=0;d=c[g];++g)xa[d]=1;for(c=0;d=y[c];++c)d=d[1],(g=d.libs)&&!d.l&&d.i&&ya(g)&&
-d.i()}f.dgl(a,b)},L=window.___jsl=H(window.___jsl,{});L.h=H(L.h,"m;/_/scs/abc-static/_/js/k=gapi.gapi.en.GJa4oir6WlA.O/d=1/rs=AHpOoo-oT18V72om9ubISB9Na8GvbQT5cg/m=__features__");L.ms=H(L.ms,"https://apis.google.com");L.m=H(L.m,"");L.l=H(L.l,[]);L.dpo=H(L.dpo,"");I||y.push(["gl",{url:"//ssl.gstatic.com/gb/js/abc/glm_e7bb39a7e1a24581ff4f8d199678b1b9.js"}]);var za="gl",Aa={pu:va,sh:"",si:wa,hl:"en"};w[za]=Aa;ua?J.load||n("load",K,J):n("load",K,J);n("dgl",K);n("agl",ya);h.o=I};var Ba=h.b("0.1",.001),Ca=0;
-function _mlToken(a,b){try{if(Ca<1){Ca++;var c=a;b=b||{};var d=encodeURIComponent,g=["//www.google.com/gen_204?atyp=i&zx=",(new Date).getTime(),"&jexpid=",d("28834"),"&srcpg=",d("prop=1"),"&jsr=",Math.round(1/Ba),"&ogev=",d("7YXOaLaWMsmQmtkP0OqT0Ao"),"&ogf=",f.bv.f,"&ogrp=",d(""),"&ogv=",d("807030966.0"),"&oggv="+d("es_plusone_gc_20250803.0_p0"),"&ogd=",d("com"),"&ogc=",d("USA"),"&ogl=",d("en")];b._sn&&(b._sn=
-"og."+b._sn);for(var k in b)g.push("&"),g.push(d(k)),g.push("="),g.push(d(b[k]));g.push("&emsg=");g.push(d(c.name+":"+c.message));var m=g.join("");Ga(m)&&(m=m.substr(0,2E3));var p=m;var l=window.gbar.logger._aem(a,p);la(l)}}catch(t){}}var Ga=function(a){return a.length>=2E3},Ja=function(a,b){return b};function Ka(a){r=a;n("_itl",Ga,v);n("_aem",Ja,v);n("ml",r,v);a="er";var b={};w[a]=b}h.a("")?Ka(function(a){throw a;}):h.a("1")&&Math.random()<Ba&&Ka(_mlToken);var _E="left",La=h.a(""),Ma=h.a(""),N=function(a,b){var c=a.className;M(a,b)||(a.className+=(c!=""?" ":"")+b)},O=function(a,b){var c=a.className;b=new RegExp("\\s?\\b"+b+"\\b");c&&c.match(b)&&(a.className=c.replace(b,""))},M=function(a,b){b=new RegExp("\\b"+b+"\\b");a=a.className;return!(!a||!a.match(b))},Na=function(a,b){M(a,b)?O(a,b):N(a,b)},Oa=function(a,b){a[b]=function(c){var d=arguments;f.qm(function(){a[b].apply(this,d)})}},Pa=function(a){a=
-[Ma?"":"https://www.gstatic.com","/og/_/js/d=1/k=","og.og.en_US.9O1gdzro4c8.es5.O","/rt=j/m=",a,"/rs=","AA2YrTukHuYZi36_oVAflIh7xLNam8TLrw"];La&&a.push("?host=www.gstatic.com&bust=og.og.en_US.F5mK2tSzogM.es5.DU");a=a.join("");C(a)};n("ca",N);n("cr",O);n("cc",M);h.k=N;h.l=O;h.m=M;h.n=Na;h.p=Pa;h.q=Oa;var Qa=["gb_71","gb_155"],Ra;function Sa(a){Ra=a}function Ta(a){var b=Ra&&!a.href.match(/.*\/accounts\/ClearSID[?]/)&&encodeURIComponent(Ra());b&&(a.href=a.href.replace(/([?&]continue=)[^&]*/,"$1"+b))}function Ua(a){window.gApplication&&(a.href=window.gApplication.getTabUrl(a.href))}function Va(a){try{var b=(document.forms[0].q||"").value;b&&(a.href=a.href.replace(/([?&])q=[^&]*|$/,function(c,d){return(d||"&")+"q="+encodeURIComponent(b)}))}catch(c){q(c,"sb","pq")}}
-var Wa=function(){for(var a=[],b,c=0;b=Qa[c];++c)(b=document.getElementById(b))&&a.push(b);return a},Xa=function(){var a=Wa();return a.length>0?a[0]:null},Ya=function(){return document.getElementById("gb_70")},P={},Q={},Za={},R={},S=void 0,db=function(a,b){try{var c=document.getElementById("gb");N(c,"gbpdjs");T();$a(document.getElementById("gb"))&&N(c,"gbrtl");if(b&&b.getAttribute){var d=b.getAttribute("aria-owns");if(d.length){var g=document.getElementById(d);if(g){var k=b.parentNode;if(S==d)S=void 0,
-O(k,"gbto");else{if(S){var m=document.getElementById(S);if(m&&m.getAttribute){var p=m.getAttribute("aria-owner");if(p.length){var l=document.getElementById(p);l&&l.parentNode&&O(l.parentNode,"gbto")}}}ab(g)&&bb(g);S=d;N(k,"gbto")}}}}B(function(){f.tg(a,b,!0)});cb(a)}catch(t){q(t,"sb","tg")}},eb=function(a){B(function(){f.close(a)})},fb=function(a){B(function(){f.rdd(a)})},$a=function(a){var b,c=document.defaultView;c&&c.getComputedStyle?(a=c.getComputedStyle(a,""))&&(b=a.direction):b=a.currentStyle?
-a.currentStyle.direction:a.style.direction;return b=="rtl"},hb=function(a,b,c){if(a)try{var d=document.getElementById("gbd5");if(d){var g=d.firstChild,k=g.firstChild,m=document.createElement("li");m.className=b+" gbmtc";m.id=c;a.className="gbmt";m.appendChild(a);if(k.hasChildNodes()){c=[["gbkc"],["gbf","gbe","gbn"],["gbkp"],["gbnd"]];d=0;var p=k.childNodes.length;g=!1;for(var l=-1,t,Da=0;t=c[Da];Da++){for(var ba=void 0,Ea=0;ba=t[Ea];Ea++){for(;d<p&&M(k.childNodes[d],ba);)d++;if(ba==b){k.insertBefore(m,
-k.childNodes[d]||null);g=!0;break}}if(g){if(d+1<k.childNodes.length){var Fa=k.childNodes[d+1];M(Fa.firstChild,"gbmh")||gb(Fa,t)||(l=d+1)}else if(d-1>=0){var Ha=k.childNodes[d-1];M(Ha.firstChild,"gbmh")||gb(Ha,t)||(l=d)}break}d>0&&d+1<p&&d++}if(l>=0){var ca=document.createElement("li"),Ia=document.createElement("div");ca.className="gbmtc";Ia.className="gbmt gbmh";ca.appendChild(Ia);k.insertBefore(ca,k.childNodes[l])}f.addHover&&f.addHover(a)}else k.appendChild(m)}}catch(vb){q(vb,"sb","al")}},gb=function(a,
-b){for(var c=b.length,d=0;d<c;d++)if(M(a,b[d]))return!0;return!1},ib=function(a,b,c){hb(a,b,c)},jb=function(a,b){hb(a,"gbe",b)},kb=function(){B(function(){f.pcm&&f.pcm()})},lb=function(){B(function(){f.pca&&f.pca()})},mb=function(a,b,c,d,g,k,m,p,l,t){B(function(){f.paa&&f.paa(a,b,c,d,g,k,m,p,l,t)})},nb=function(a,b){P[a]||(P[a]=[]);P[a].push(b)},ob=function(a,b){Q[a]||(Q[a]=[]);Q[a].push(b)},pb=function(a,b){Za[a]=b},qb=function(a,b){R[a]||(R[a]=[]);R[a].push(b)},cb=function(a){a.preventDefault&&
-a.preventDefault();a.returnValue=!1;a.cancelBubble=!0},rb=null,bb=function(a,b){T();if(a){sb(a,"Opening&hellip;");U(a,!0);b=typeof b!="undefined"?b:1E4;var c=function(){tb(a)};rb=window.setTimeout(c,b)}},ub=function(a){T();a&&(U(a,!1),sb(a,""))},tb=function(a){try{T();var b=a||document.getElementById(S);b&&(sb(b,"This service is currently unavailable.%1$sPlease try again later.","%1$s"),U(b,!0))}catch(c){q(c,"sb","sdhe")}},sb=function(a,b,c){if(a&&b){var d=ab(a);if(d){if(c){d.textContent="";b=b.split(c);for(var g=0;c=
-b[g];g++){var k=document.createElement("div");k.innerHTML=c;d.appendChild(k)}}else d.innerHTML=b;U(a,!0)}}},U=function(a,b){(b=b!==void 0?b:!0)?N(a,"gbmsgo"):O(a,"gbmsgo")},ab=function(a){for(var b,c=0;b=a.childNodes[c];c++)if(M(b,"gbmsg"))return b},T=function(){rb&&window.clearTimeout(rb)},wb=function(a){var b="inner"+a;a="offset"+a;return window[b]?window[b]:document.documentElement&&document.documentElement[a]?document.documentElement[a]:0},xb=function(){return!1},yb=function(){return!!S};
-n("so",Xa);n("sos",Wa);n("si",Ya);n("tg",db);n("close",eb);n("rdd",fb);n("addLink",ib);n("addExtraLink",jb);n("pcm",kb);n("pca",lb);n("paa",mb);n("ddld",bb);n("ddrd",ub);n("dderr",tb);n("rtl",$a);n("op",yb);n("bh",P);n("abh",nb);n("dh",Q);n("adh",ob);n("ch",R);n("ach",qb);n("eh",Za);n("aeh",pb);da=h.a("")?Ua:Va;n("qs",da);n("setContinueCb",Sa);n("pc",Ta);n("bsy",xb);h.d=cb;h.j=wb;var zb="base",Ab={};w[zb]=Ab;y.push(["m",{url:"//ssl.gstatic.com/gb/js/sem_6cd3a6e9ccc06796f61d5a581bd33cce.js"}]);f.sg={c:"1"};n("wg",{rg:{}});var Bb="wg",Cb={tiw:h.c("15000",0),tie:h.c("30000",0)};w[Bb]=Cb;var Db="wm",Eb={thi:h.c("10000",0),thp:h.c("180000",0),tho:h.c("5000",0),tet:h.b("0.5",0)};w[Db]=Eb;if(h.a("1")){var Fb=h.a("");y.push(["gc",{auto:Fb,url:"//ssl.gstatic.com/gb/js/abc/gci_91f30755d6a6b787dcc2a4062e6e9824.js",libs:"googleapis.client:gapi.iframes"}]);var Gb="gc",Hb={version:"gci_91f30755d6a6b787dcc2a4062e6e9824.js",index:"",lang:"en"};w[Gb]=Hb;var Ib=function(a){window.googleapis&&window.iframes?a&&a():(a&&sa(a),F("gc"))};n("lGC",Ib);h.a("1")&&n("lPWF",Ib)};window.__PVT="";function Jb(){}u=Jb;n("il",u,v);var Kb="il",Lb={};w[Kb]=Lb;var Mb=function(a,b,c,d,g,k,m,p,l,t){B(function(){f.paa(a,b,c,d,g,k,m,p,l,t)})},Nb=function(){B(function(){f.prm()})},Ob=function(a){B(function(){f.spn(a)})},Pb=function(a){B(function(){f.sps(a)})},Qb=function(a){B(function(){f.spp(a)})},Rb={"27":"https://lh3.googleusercontent.com/ogw/default-user=s24","27":"https://lh3.googleusercontent.com/ogw/default-user=s24","27":"https://lh3.googleusercontent.com/ogw/default-user=s24"},Sb=function(a){return(a=Rb[a])||"https://lh3.googleusercontent.com/ogw/default-user=s24"},
-Tb=function(){B(function(){f.spd()})};n("spn",Ob);n("spp",Qb);n("sps",Pb);n("spd",Tb);n("paa",Mb);n("prm",Nb);nb("gbd4",Nb);
-if(h.a("")){var Ub="prf",Vb={d:h.a(""),e:"",sanw:h.a(""),p:"https://lh3.googleusercontent.com/ogw/default-user=s96",cp:"1",xp:h.a("1"),mg:"%1$s (delegated)",md:"%1$s (default)",mh:"220",s:"1",pp:Sb,ppl:h.a(""),ppa:h.a(""),
-ppm:"Google+ page"};w[Ub]=Vb};var V,Wb,W,Xb,X=0,Yb=function(a,b,c){if(a.indexOf)return a.indexOf(b,c);if(Array.indexOf)return Array.indexOf(a,b,c);for(c=c==null?0:c<0?Math.max(0,a.length+c):c;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1},Y=function(a,b){return Yb(a,X)==-1?(q(Error(X+"_"+b),"up","caa"),!1):!0},$b=function(a,b){Y([1,2],"r")&&(V[a]=V[a]||[],V[a].push(b),X==2&&window.setTimeout(function(){b(Zb(a))},0))},ac=function(a,b,c){if(Y([1],"nap")&&c){for(var d=0;d<c.length;d++)Wb[c[d]]=!0;f.up.spl(a,b,"nap",c)}},bc=
-function(a,b,c){if(Y([1],"aop")&&c){if(W)for(var d in W)W[d]=W[d]&&Yb(c,d)!=-1;else for(W={},d=0;d<c.length;d++)W[c[d]]=!0;f.up.spl(a,b,"aop",c)}},cc=function(){try{if(X=2,!Xb){Xb=!0;for(var a in V)for(var b=V[a],c=0;c<b.length;c++)try{b[c](Zb(a))}catch(d){q(d,"up","tp")}}}catch(d){q(d,"up","mtp")}},Zb=function(a){if(Y([2],"ssp")){var b=!Wb[a];W&&(b=b&&!!W[a]);return b}};Xb=!1;V={};Wb={};W=null;X=1;
-var dc=function(a){var b=!1;try{b=a.cookie&&a.cookie.match("PREF")}catch(c){}return!b},ec=function(){try{return!!e.localStorage&&typeof e.localStorage=="object"}catch(a){return!1}},fc=function(a){return a&&a.style&&a.style.behavior&&typeof a.load!="undefined"},hc=function(a,b,c,d){try{dc(document)||(d||(b="og-up-"+b),ec()?e.localStorage.setItem(b,c):fc(a)&&(a.setAttribute(b,c),a.save(a.id)))}catch(g){g.code!=DOMException.QUOTA_EXCEEDED_ERR&&q(g,"up","spd")}},ic=function(a,b,c){try{if(dc(document))return"";
-c||(b="og-up-"+b);if(ec())return e.localStorage.getItem(b);if(fc(a))return a.load(a.id),a.getAttribute(b)}catch(d){d.code!=DOMException.QUOTA_EXCEEDED_ERR&&q(d,"up","gpd")}return""},jc=function(a,b,c){a.addEventListener?a.addEventListener(b,c,!1):a.attachEvent&&a.attachEvent("on"+b,c)},kc=function(a){for(var b,c=0;b=a[c];c++){var d=f.up;b=b in d&&d[b];if(!b)return!1}return!0},lc=function(a,b){try{if(dc(a))return-1;var c=a.cookie.match(/OGPC=([^;]*)/);if(c&&c[1]){var d=c[1].match(new RegExp("\\b"+
-b+"-([0-9]+):"));if(d&&d[1])return parseInt(d[1],10)}}catch(g){g.code!=DOMException.QUOTA_EXCEEDED_ERR&&q(g,"up","gcc")}return-1};n("up",{r:$b,nap:ac,aop:bc,tp:cc,ssp:Zb,spd:hc,gpd:ic,aeh:jc,aal:kc,gcc:lc});var Z=function(a,b){a[b]=function(c){var d=arguments;f.qm(function(){a[b].apply(this,d)})}};Z(f.up,"sl");Z(f.up,"si");Z(f.up,"spl");Z(f.up,"dpc");Z(f.up,"iic");f.mcf("up",{sp:h.b("0.01",1),tld:"com",prid:"1"});function mc(){function a(){for(var l;(l=k[m++])&&l[0]!="m"&&!l[1].auto;);l&&(D(2,l[0]),l[1].url&&C(l[1].url,l[0]),l[1].libs&&E&&E(l[1].libs));m<k.length&&setTimeout(a,0)}function b(){g-- >0?setTimeout(b,0):a()}var c=h.a("1"),d=h.a(""),g=3,k=y,m=0,p=window.gbarOnReady;if(p)try{p()}catch(l){q(l,"ml","or")}d?n("ldb",a):c?ea(window,"load",b):b()}n("rdl",mc);}catch(e){window.gbar&&gbar.logger&&gbar.logger.ml(e,{"_sn":"cfg.init"});}})();
-(function(){try{var b=window.gbar.i.i;var c=window.gbar;var f=function(d){try{var a=document.getElementById("gbom");a&&d.appendChild(a.cloneNode(!0))}catch(e){b(e,"omas","aomc")}};c.aomc=f;}catch(e){window.gbar&&gbar.logger&&gbar.logger.ml(e,{"_sn":"cfg.init"});}})();
-(function(){try{var a=window.gbar;a.mcf("pm",{p:"19046229,o_E,7,,"});}catch(e){window.gbar&&gbar.logger&&gbar.logger.ml(e,{"_sn":"cfg.init"});}})();
-(function(){try{var a=window.gbar;a.mcf("mm",{s:"1"});}catch(e){window.gbar&&gbar.logger&&gbar.logger.ml(e,{"_sn":"cfg.init"});}})();
-(function(){try{var d=window.gbar.i.i;var e=window.gbar;var f=e.i;var g=f.c("1",0),h=/\bgbmt\b/,k=function(a){try{var b=document.getElementById("gb_"+g),c=document.getElementById("gb_"+a);b&&f.l(b,h.test(b.className)?"gbm0l":"gbz0l");c&&f.k(c,h.test(c.className)?"gbm0l":"gbz0l")}catch(l){d(l,"sj","ssp")}g=a},m=e.qs,n=function(a){var b=a.href;var c=window.location.href.match(/.*?:\/\/[^\/]*/)[0];c=new RegExp("^"+c+"/search\\?");(b=c.test(b))&&!/(^|\\?|&)ei=/.test(a.href)&&(b=window.google)&&b.kEXPI&&(a.href+="&ei="+b.kEI)},p=function(a){m(a);
-n(a)},q=function(){if(window.google&&window.google.sn){var a=/.*hp$/;return a.test(window.google.sn)?"":"1"}return"-1"};e.rp=q;e.slp=k;e.qs=p;e.qsi=n;}catch(e){window.gbar&&gbar.logger&&gbar.logger.ml(e,{"_sn":"cfg.init"});}})();
-(function(){try{/*
-
- Copyright The Closure Library Authors.
- SPDX-License-Identifier: Apache-2.0
-*/
-var a=this||self;var b=window.gbar;var c=b.i;for(var d=c.a,e=c.c,f={cty:"USA",cv:"807030966",dbg:d(""),ecv:"0",ei:e("7YXOaLaWMsmQmtkP0OqT0Ao"),ele:d("1"),esr:e("0.1"),evts:["mousedown","touchstart","touchmove","wheel","keydown"],gbl:"es_plusone_gc_20250803.0_p0",hd:"com",hl:"en",irp:d(""),pid:e("1"),
-snid:e("28834"),to:e("300000"),u:e(""),vf:".66."},g=["bndcfg"],h=a,k;g.length&&(k=g.shift());)g.length||f===void 0?h=h[k]&&h[k]!==Object.prototype[k]?h[k]:h[k]={}:h[k]=f;}catch(e){window.gbar&&gbar.logger&&gbar.logger.ml(e,{"_sn":"cfg.init"});}})();
-(function(){try{window.gbar.rdl();}catch(e){window.gbar&&gbar.logger&&gbar.logger.ml(e,{"_sn":"cfg.init"});}})();
-</script></head><body bgcolor="#fff"><script nonce="sfyt5WF_CGhQeUHFmV4qfg">(function(){var src='/images/nav_logo229.png';var iesg=false;document.body.onload = function(){window.n && window.n();if (document.images){new Image().src=src;}
-if (!iesg){document.f&&document.f.q.focus();document.gbqf&&document.gbqf.q.focus();}
-}
-})();</script><div id="mngb"><div id=gb><script nonce='sfyt5WF_CGhQeUHFmV4qfg'>window.gbar&&gbar.eli&&gbar.eli()</script><div id=gbw><div id=gbz><span class=gbtcb></span><ol id=gbzc class=gbtc><li class=gbt><a class="gbzt gbz0l gbp1" id=gb_1 href="https://www.google.com/webhp?tab=ww"><span class=gbtb2></span><span class=gbts>Search</span></a></li><li class=gbt><a class=gbzt id=gb_2 href="https://www.google.com/imghp?hl=en&tab=wi"><span class=gbtb2></span><span class=gbts>Images</span></a></li><li class=gbt><a class=gbzt id=gb_8 href="https://maps.google.com/maps?hl=en&tab=wl"><span class=gbtb2></span><span class=gbts>Maps</span></a></li><li class=gbt><a class=gbzt id=gb_78 href="https://play.google.com/?hl=en&tab=w8"><span class=gbtb2></span><span class=gbts>Play</span></a></li><li class=gbt><a class=gbzt id=gb_36 href="https://www.youtube.com/?tab=w1"><span class=gbtb2></span><span class=gbts>YouTube</span></a></li><li class=gbt><a class=gbzt id=gb_426 href="https://news.google.com/?tab=wn"><span class=gbtb2></span><span class=gbts>News</span></a></li><li class=gbt><a class=gbzt id=gb_23 href="https://mail.google.com/mail/?tab=wm"><span class=gbtb2></span><span class=gbts>Gmail</span></a></li><li class=gbt><a class=gbzt id=gb_49 href="https://drive.google.com/?tab=wo"><span class=gbtb2></span><span class=gbts>Drive</span></a></li><li class=gbt><a class=gbgt id=gbztm href="https://www.google.com/intl/en/about/products?tab=wh"  aria-haspopup=true aria-owns=gbd><span class=gbtb2></span><span id=gbztms class="gbts gbtsa"><span id=gbztms1>More</span><span class=gbma></span></span></a><script nonce='sfyt5WF_CGhQeUHFmV4qfg'>document.getElementById('gbztm').addEventListener('click', function clickHandler() { gbar.tg(event,this); });</script><div class=gbm id=gbd aria-owner=gbztm><div id=gbmmb class="gbmc gbsb gbsbis"><ol id=gbmm class="gbmcc gbsbic"><li class=gbmtc><a class=gbmt id=gb_24 href="https://calendar.google.com/calendar?tab=wc">Calendar</a></li><li class=gbmtc><a class=gbmt id=gb_51 href="https://translate.google.com/?hl=en&tab=wT">Translate</a></li><li class=gbmtc><a class=gbmt id=gb_17 href="http://www.google.com/mobile/?hl=en&tab=wD">Mobile</a></li><li class=gbmtc><a class=gbmt id=gb_10 href="https://books.google.com/?hl=en&tab=wp">Books</a></li><li class=gbmtc><a class=gbmt id=gb_6 href="https://www.google.com/shopping?hl=en&source=og&tab=wf">Shopping</a></li><li class=gbmtc><a class=gbmt id=gb_30 href="https://www.blogger.com/?tab=wj">Blogger</a></li><li class=gbmtc><a class=gbmt id=gb_27 href="https://www.google.com/finance?tab=we">Finance</a></li><li class=gbmtc><a class=gbmt id=gb_31 href="https://photos.google.com/?tab=wq&pageId=none">Photos</a></li><li class=gbmtc><a class=gbmt id=gb_25 href="https://docs.google.com/document/?usp=docs_alc">Docs</a></li><li class=gbmtc><div class="gbmt gbmh"></div></li><li class=gbmtc><a  href="https://www.google.com/intl/en/about/products?tab=wh" class=gbmt>Even more &raquo;</a><script nonce='sfyt5WF_CGhQeUHFmV4qfg'>document.querySelector('li > a.gbmt').addEventListener('click', function clickHandler() { gbar.logger.il(1,{t:66});; });</script></li></ol><div class=gbsbt></div><div class=gbsbb></div></div></div></li></ol></div><div id=gbg><h2 class=gbxx>Account Options</h2><span class=gbtcb></span><ol class=gbtc><li class=gbt><a target=_top href="https://accounts.google.com/ServiceLogin?hl=en&passive=true&continue=https://www.google.com/&ec=GAZAAQ" onclick="gbar.logger.il(9,{l:'i'})" id=gb_70 class=gbgt><span class=gbtb2></span><span id=gbgs4 class=gbts><span id=gbi4s1>Sign in</span></span></a></li><li class="gbt gbtb"><span class=gbts></span></li><li class=gbt><a class=gbgt id=gbg5 href="http://www.google.com/preferences?hl=en" title="Options" aria-haspopup=true aria-owns=gbd5><span class=gbtb2></span><span id=gbgs5 class=gbts><span id=gbi5></span></span></a><script nonce='sfyt5WF_CGhQeUHFmV4qfg'>document.getElementById('gbg5').addEventListener('click', function clickHandler() { gbar.tg(event,this); });</script><div class=gbm id=gbd5 aria-owner=gbg5><div class=gbmc><ol id=gbom class=gbmcc><li class="gbkc gbmtc"><a  class=gbmt href="/preferences?hl=en">Search settings</a></li><li class=gbmtc><div class="gbmt gbmh"></div></li><li class="gbkp gbmtc"><a class=gbmt href="http://www.google.com/history/optout?hl=en">Web History</a></li></ol></div></div></li></ol></div></div><div id=gbx3></div><div id=gbx4></div><script nonce='sfyt5WF_CGhQeUHFmV4qfg'>window.gbar&&gbar.elp&&gbar.elp()</script></div></div><center><br clear="all" id="lgpd"><div id="XjhHGf"><img alt="Google" height="92" src="/images/branding/googlelogo/1x/googlelogo_white_background_color_272x92dp.png" style="padding:28px 0 14px" width="272" id="hplogo"><br><br></div><form action="/search" name="f"><table cellpadding="0" cellspacing="0"><tr valign="top"><td width="25%">&nbsp;</td><td align="center" nowrap=""><input name="ie" value="ISO-8859-1" type="hidden"><input value="en" name="hl" type="hidden"><input name="source" type="hidden" value="hp"><input name="biw" type="hidden"><input name="bih" type="hidden"><div class="ds" style="height:32px;margin:4px 0"><input class="lst" style="margin:0;padding:5px 8px 0 6px;vertical-align:top;color:#1f1f1f" autocomplete="off" value="" title="Google Search" maxlength="2048" name="q" size="57"></div><br style="line-height:0"><span class="ds"><span class="lsbb"><input class="lsb" value="Google Search" name="btnG" type="submit"></span></span><span class="ds"><span class="lsbb"><input class="lsb" id="tsuid_7YXOaPzJMfW5qtsPt4Ti2Q4_1" value="I'm Feeling Lucky" name="btnI" type="submit"><script nonce="sfyt5WF_CGhQeUHFmV4qfg">(function(){var id='tsuid_7YXOaPzJMfW5qtsPt4Ti2Q4_1';document.getElementById(id).onclick = function(){if (this.form.q.value){this.checked = 1;if (this.form.iflsig)this.form.iflsig.disabled = false;}
-else top.location='/doodles/';};})();</script><input value="AOw8s4IAAAAAaM6T_fdBqhw-uXJHj7hfVOUyorLXS-7C" name="iflsig" type="hidden"></span></span></td><td class="fl sblc" align="left" nowrap="" width="25%"><a href="/advanced_search?hl=en&amp;authuser=0">Advanced search</a></td></tr></table><input id="gbv" name="gbv" type="hidden" value="1"><script nonce="sfyt5WF_CGhQeUHFmV4qfg">(function(){var a,b="1";if(document&&document.getElementById)if(typeof XMLHttpRequest!="undefined")b="2";else if(typeof ActiveXObject!="undefined"){var c,d,e=["MSXML2.XMLHTTP.6.0","MSXML2.XMLHTTP.3.0","MSXML2.XMLHTTP","Microsoft.XMLHTTP"];for(c=0;d=e[c++];)try{new ActiveXObject(d),b="2"}catch(h){}}a=b;if(a=="2"&&location.search.indexOf("&gbv=2")==-1){var f=google.gbvu,g=document.getElementById("gbv");g&&(g.value=a);f&&window.setTimeout(function(){location.href=f},0)};}).call(this);</script></form><div style="font-size:83%;min-height:3.5em"><br></div><span id="footer"><div style="font-size:10pt"><div style="margin:19px auto;text-align:center" id="WqQANb"><a href="/intl/en/ads/">Advertising</a><a href="/services/">Business Solutions</a><a href="/intl/en/about.html">About Google</a></div></div><p style="font-size:8pt;color:#636363">&copy; 2025 - <a href="/intl/en/policies/privacy/">Privacy</a> - <a href="/intl/en/policies/terms/">Terms</a></p></span></center><script nonce="sfyt5WF_CGhQeUHFmV4qfg">(function(){window.google.cdo={height:757,width:1440};(function(){var a=window.innerWidth,b=window.innerHeight;if(!a||!b){var c=window.document,d=c.compatMode=="CSS1Compat"?c.documentElement:c.body;a=d.clientWidth;b=d.clientHeight}if(a&&b&&(a!=google.cdo.width||b!=google.cdo.height)){var e=google,f=e.log,g="/client_204?&atyp=i&biw="+a+"&bih="+b+"&ei="+google.kEI,h="",k=window.google&&window.google.kOPI||null;k&&(h+="&opi="+k);f.call(e,"","",g+h)};}).call(this);})();(function(){google.xjs={basecomb:'/xjs/_/js/k\x3dxjs.hp.en.VzG020BebR0.es5.O/ck\x3dxjs.hp.4NQidDHtR5M.L.X.O/am\x3dAAIAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAABBQCAAAAAAAAAAAAAAAAACAAAAwKAE4AAAAAACAAECAAAAAAIAYAAAAAAAJAAACAAEAABAfEcAAAAgEIsAAAAAXg/d\x3d1/ed\x3d1/dg\x3d0/ujg\x3d1/rs\x3dACT90oFxzidmH55s4XaAV5fCAzj6D820Xg',basecss:'/xjs/_/ss/k\x3dxjs.hp.4NQidDHtR5M.L.X.O/am\x3dAAIAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAABBACAAAAAAAAAAAAAAAAACAAAAwKAAAAAAAAACAAECAAAAAAIAYAAAAAAAJAAACAAEAAAAAAAAAAAAEA/rs\x3dACT90oHNH5LfCjMHRo9wL8BvYCP8nohUvA',basejs:'/xjs/_/js/k\x3dxjs.hp.en.VzG020BebR0.es5.O/am\x3dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAACAAAAAAAE4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAfEcAAAAgAIsAAAAAXg/dg\x3d0/rs\x3dACT90oE9frsyg-mBLRqEI2nvT-DDWn0AYw',excm:[]};})();(function(){var u='/xjs/_/js/k\x3dxjs.hp.en.VzG020BebR0.es5.O/am\x3dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAACAAAAAAAE4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAfEcAAAAgAIsAAAAAXg/d\x3d1/ed\x3d1/dg\x3d3/rs\x3dACT90oE9frsyg-mBLRqEI2nvT-DDWn0AYw/m\x3dsb_he,d';var st=1;var amd=1000;var mmd=0;var pop=true;var povp=false;var fp='';
-var e=this||self;function f(){var a=google.ia&&google.ia.r.B2Jtyd;return a&&[1,5,6].indexOf(a.m)>=0&&a.cbfd&&a.cbvi?a:void 0};function g(a){var b=document.createElement("link");b.as="script";b.href=a;b.rel="preload";document.body.appendChild(b)}function k(){var a=[u];google.dp||(a.forEach(g),google.dp=!0)};google.ps=google.ps||[];function l(){var a=u,b=function(){};google.lx=google.stvsc?b:function(){m(a);google.lx=b};google.bx||google.lx()}function n(a,b){b&&(a.src=b);fp&&google.caft&&google.caft(function(){a.fetchPriority=fp});var h=a.onload;a.onload=function(d){h&&h(d);google.ps=google.ps.filter(function(c){return a!==c})};google.ps.push(a);document.body.appendChild(a)}google.as=n;function m(a){google.tick&&google.tick("load","xjsls");var b=document.createElement("script");b.onerror=function(){google.ple=1};b.onload=function(){google.ple=0};google.xjsus=void 0;n(b,a);google.aple=-1;google.dp=!0};function p(){for(var a=document.getElementsByTagName("img"),b=0,h=a.length;b<h;b++){var d=a[b],c;if(c=d.hasAttribute("data-lzy_")&&Number(d.getAttribute("data-atf"))&1)c=d.getAttribute("jscontroller"),c=!((c==="UBXHI"||c==="R3fhkb"||c==="TSZEqd")&&d.hasAttribute("data-src"));if(c)return!0}return!1};var q,r,t,w,x,y,z,A,B;function C(){google.xjsu=u;e._F_jsUrl=u;x=function(){l()};q=!1;r=(st===1||st===3)&&!!google.caft&&!p();t=f();w=(st===2||st===3)&&!!t&&!p();y=pop;z=povp;A=y&&document.prerendering||z&&document.hidden;B=z?"visibilitychange":"prerenderingchange"}function D(){q||r||w||A||(x(),q=!0)}
-setTimeout(function(){google.tick&&google.tick("load","xjspls");C();if(r||w||A){if(r){var a=function(){r=!1;D()};google.caft(a);setTimeout(a,amd)}w&&(a=function(){w=!1;D()},t.cbvi.push(a),setTimeout(a,mmd));if(A){var b=function(){(z?document.hidden:document.prerendering)||(A=!1,D(),document.removeEventListener(B,b))};document.addEventListener(B,b,{passive:!0})}q||k()}else x()},0);})();window._ = window._ || {};window._DumpException = _._DumpException = function(e){throw e;};window._s = window._s || {};_s._DumpException = _._DumpException;window._qs = window._qs || {};_qs._DumpException = _._DumpException;(function(){var t=[512,0,512,0,0,0,0,128,512,25265152,2,8388608,0,2048,168563650,9091073,131088,2052,2105600,6144,603979776,3145728,66,1171216,270532608,556,385024];window._F_toggles = window._xjs_toggles = t;})();window._F_installCss = window._F_installCss || function(css){};(function(){google.jl={bfl:0,dw:false,eli:false,ine:false,ubm:false,uwp:true,vs:false};})();(function(){var pmc='{\x22d\x22:{},\x22sb_he\x22:{\x22client\x22:\x22heirloom-hp\x22,\x22dh\x22:true,\x22ds\x22:\x22\x22,\x22host\x22:\x22google.com\x22,\x22jsonp\x22:true,\x22msgs\x22:{\x22cibl\x22:\x22Clear Search\x22,\x22dym\x22:\x22Did you mean:\x22,\x22lcky\x22:\x22I\\u0026#39;m Feeling Lucky\x22,\x22lml\x22:\x22Learn more\x22,\x22psrc\x22:\x22This search was removed from your \\u003Ca href\x3d\\\x22/history\\\x22\\u003EWeb History\\u003C/a\\u003E\x22,\x22psrl\x22:\x22Remove\x22,\x22sbit\x22:\x22Search by image\x22,\x22srch\x22:\x22Google Search\x22},\x22ovr\x22:{},\x22pq\x22:\x22\x22,\x22rfs\x22:[],\x22stok\x22:\x22gzxEOeUsq-xa3QxE-MGqO_J71PM\x22}}';google.pmc=JSON.parse(pmc);})();</script></body></html>
\ No newline at end of file
+Host not in allowlist: google.com. Add this host to your network egress settings to allow access.
\ No newline at end of file
diff --git a/scripts/run_integration_tests.ps1 b/scripts/run_integration_tests.ps1
index 64eec9c4..2d546646 100644
--- a/scripts/run_integration_tests.ps1
+++ b/scripts/run_integration_tests.ps1
@@ -106,9 +106,10 @@ Write-Host "[INFO] Running WFL test programs..." -ForegroundColor Blue
 # Tests that require special handling (web servers, interactive tests)
 # These are tested separately with dedicated scripts
 $SkipTests = @(
-    "simple_web_test.wfl",      # Web server - needs HTTP client
-    "web_server_test.wfl",      # Web server - needs HTTP client
-    "websocket_test.wfl"        # WebSocket - needs WS client
+    "simple_web_test.wfl",        # Web server - needs HTTP client
+    "web_server_test.wfl",        # Web server - needs HTTP client
+    "websocket_test.wfl",         # WebSocket - needs WS client
+    "web_route_params_test.wfl"   # Web server - tested via run_web_tests.ps1
 )
 
 # Timeout for each test (seconds)
diff --git a/scripts/run_integration_tests.sh b/scripts/run_integration_tests.sh
index 4b199cbe..bf2257a1 100644
--- a/scripts/run_integration_tests.sh
+++ b/scripts/run_integration_tests.sh
@@ -80,9 +80,10 @@ run_integration_tests() {
 # Tests that require special handling (web servers, interactive tests)
 # These are tested separately with dedicated scripts
 SKIP_TESTS=(
-    "simple_web_test.wfl"      # Web server - needs HTTP client
-    "web_server_test.wfl"      # Web server - needs HTTP client
-    "websocket_test.wfl"       # WebSocket - needs WS client
+    "simple_web_test.wfl"          # Web server - needs HTTP client
+    "web_server_test.wfl"          # Web server - needs HTTP client
+    "websocket_test.wfl"           # WebSocket - needs WS client
+    "web_route_params_test.wfl"    # Web server - tested via run_web_tests.sh
 )
 
 # Timeout for each test (seconds)
diff --git a/scripts/run_web_tests.ps1 b/scripts/run_web_tests.ps1
index 48b75e54..088a876b 100644
--- a/scripts/run_web_tests.ps1
+++ b/scripts/run_web_tests.ps1
@@ -125,6 +125,79 @@ if (Test-Path "TestPrograms\web_server_test.wfl") {
     }
 }
 
+# Test 3: web_route_params_test.wfl (route parameter extraction)
+if (Test-Path "TestPrograms\web_route_params_test.wfl") {
+    $totalTests++
+    Write-Host ""
+    Write-Host "[INFO] Testing: web_route_params_test.wfl on port 8096" -ForegroundColor Blue
+
+    $routeProcess = Start-Process -FilePath ".\$BinaryPath" -ArgumentList "TestPrograms\web_route_params_test.wfl" -NoNewWindow -PassThru -RedirectStandardOutput "NUL" -RedirectStandardError "NUL"
+
+    try {
+        $serverReady = $false
+        $retries = 0
+        $maxRetries = $Timeout * 2
+
+        while (-not $serverReady -and $retries -lt $maxRetries) {
+            Start-Sleep -Milliseconds 500
+            $retries++
+            try {
+                $rootResponse = Invoke-WebRequest -Uri "http://localhost:8096/" -TimeoutSec 2 -UseBasicParsing -ErrorAction Stop
+                if ($rootResponse.Content -like "*Route server ready*") {
+                    $serverReady = $true
+                }
+            } catch {
+                # Intentionally empty - server not ready yet, continue polling
+            }
+        }
+
+        $routeOk = $true
+        if (-not $serverReady) {
+            Write-Host "[ERROR] TIMEOUT: Route params server did not start within ${Timeout}s" -ForegroundColor Red
+            $routeOk = $false
+        } else {
+            # Route parameter extraction: /users/:id
+            $userResponse = Invoke-WebRequest -Uri "http://localhost:8096/users/42" -TimeoutSec 2 -UseBasicParsing
+            if ($userResponse.Content -like "*User 42*") {
+                Write-Host "[SUCCESS] PASS: /users/42 -> '$($userResponse.Content)'" -ForegroundColor Green
+            } else {
+                Write-Host "[ERROR] FAIL: /users/42 returned '$($userResponse.Content)'" -ForegroundColor Red
+                $routeOk = $false
+            }
+
+            # Non-matching route returns 404
+            try {
+                Invoke-WebRequest -Uri "http://localhost:8096/missing" -TimeoutSec 2 -UseBasicParsing -ErrorAction Stop | Out-Null
+                Write-Host "[ERROR] FAIL: unknown route did not return 404" -ForegroundColor Red
+                $routeOk = $false
+            } catch {
+                if ($_.Exception.Response -and [int]$_.Exception.Response.StatusCode -eq 404) {
+                    Write-Host "[SUCCESS] PASS: unknown route returns 404" -ForegroundColor Green
+                } else {
+                    Write-Host "[ERROR] FAIL: unknown route error was not a 404" -ForegroundColor Red
+                    $routeOk = $false
+                }
+            }
+
+            # Header access regression
+            $agentResponse = Invoke-WebRequest -Uri "http://localhost:8096/agent" -TimeoutSec 2 -UseBasicParsing -UserAgent "wfl-route-test"
+            if ($agentResponse.Content -like "*wfl-route-test*") {
+                Write-Host "[SUCCESS] PASS: header access echoes User-Agent" -ForegroundColor Green
+            } else {
+                Write-Host "[ERROR] FAIL: /agent returned '$($agentResponse.Content)'" -ForegroundColor Red
+                $routeOk = $false
+            }
+        }
+
+        if ($routeOk) { $passedTests++ }
+    } finally {
+        if (-not $routeProcess.HasExited) {
+            $routeProcess.Kill()
+            Write-Host "[INFO] Server process terminated" -ForegroundColor Gray
+        }
+    }
+}
+
 # Summary
 Write-Host ""
 Write-Host "[INFO] ============================" -ForegroundColor Blue
diff --git a/scripts/run_web_tests.sh b/scripts/run_web_tests.sh
index 588edbf9..cbc00120 100644
--- a/scripts/run_web_tests.sh
+++ b/scripts/run_web_tests.sh
@@ -98,7 +98,7 @@ test_wfl_webserver() {
 
     while [ "$server_ready" = false ] && [ $retries -lt $max_retries ]; do
         sleep 0.5
-        ((retries++))
+        retries=$((retries + 1))
 
         # Try to connect using curl
         if response=$(curl -s --max-time 2 "http://localhost:$port/" 2>/dev/null); then
@@ -132,24 +132,104 @@ passed_tests=0
 
 # Test 1: simple_web_test.wfl
 if [ -f "TestPrograms/simple_web_test.wfl" ]; then
-    ((total_tests++))
+    total_tests=$((total_tests + 1))
     if test_wfl_webserver "TestPrograms/simple_web_test.wfl" 8095 "Hello from WFL" "$TIMEOUT"; then
-        ((passed_tests++))
+        passed_tests=$((passed_tests + 1))
     fi
 fi
 
 # Test 2: web_server_test.wfl (if exists)
 if [ -f "TestPrograms/web_server_test.wfl" ]; then
-    ((total_tests++))
+    total_tests=$((total_tests + 1))
     # Read the file to find the port
     port=$(grep -oP 'port\s+\K\d+' "TestPrograms/web_server_test.wfl" 2>/dev/null || echo "")
     if [ -n "$port" ]; then
         if test_wfl_webserver "TestPrograms/web_server_test.wfl" "$port" "" "$TIMEOUT"; then
-            ((passed_tests++))
+            passed_tests=$((passed_tests + 1))
         fi
     else
         echo -e "${YELLOW}[SKIP]${NC} web_server_test.wfl - could not determine port"
-        ((total_tests--))
+        total_tests=$((total_tests - 1))
+    fi
+fi
+
+# Test 3: web_route_params_test.wfl (route parameter extraction)
+if [ -f "TestPrograms/web_route_params_test.wfl" ]; then
+    total_tests=$((total_tests + 1))
+    echo ""
+    echo -e "${BLUE}[INFO]${NC} Testing: web_route_params_test.wfl on port 8096"
+
+    "./$BINARY_PATH" "TestPrograms/web_route_params_test.wfl" > /dev/null 2>&1 &
+    route_pid=$!
+
+    route_ready=false
+    retries=0
+    max_retries=$((TIMEOUT * 2))
+    while [ "$route_ready" = false ] && [ $retries -lt $max_retries ]; do
+        sleep 0.5
+        retries=$((retries + 1))
+        if curl -s --max-time 2 "http://localhost:8096/" 2>/dev/null | grep -q "Route server ready"; then
+            route_ready=true
+        fi
+    done
+
+    route_ok=true
+    if [ "$route_ready" = false ]; then
+        echo -e "${RED}[ERROR]${NC} TIMEOUT: Route params server did not start within ${TIMEOUT}s"
+        route_ok=false
+    else
+        # Route parameter extraction: /users/:id
+        user_resp=$(curl -s --max-time 2 "http://localhost:8096/users/42")
+        if [[ "$user_resp" == *"User 42"* ]]; then
+            echo -e "${GREEN}[SUCCESS]${NC} PASS: /users/42 -> '$user_resp'"
+        else
+            echo -e "${RED}[ERROR]${NC} FAIL: /users/42 returned '$user_resp' (expected 'User 42')"
+            route_ok=false
+        fi
+
+        # Percent-decoded captures
+        enc_resp=$(curl -s --max-time 2 "http://localhost:8096/users/John%20Doe")
+        if [[ "$enc_resp" == *"User John Doe"* ]]; then
+            echo -e "${GREEN}[SUCCESS]${NC} PASS: percent-decoded capture"
+        else
+            echo -e "${RED}[ERROR]${NC} FAIL: /users/John%20Doe returned '$enc_resp'"
+            route_ok=false
+        fi
+
+        # Non-matching route returns 404
+        notfound_code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 2 "http://localhost:8096/missing")
+        if [ "$notfound_code" = "404" ]; then
+            echo -e "${GREEN}[SUCCESS]${NC} PASS: unknown route returns 404"
+        else
+            echo -e "${RED}[ERROR]${NC} FAIL: unknown route returned HTTP $notfound_code (expected 404)"
+            route_ok=false
+        fi
+
+        # Header access regression (FRAMEWORK_FINAL_REPORT)
+        agent_resp=$(curl -s --max-time 2 -A "wfl-route-test" "http://localhost:8096/agent")
+        if [[ "$agent_resp" == *"wfl-route-test"* ]]; then
+            echo -e "${GREEN}[SUCCESS]${NC} PASS: header access echoes User-Agent"
+        else
+            echo -e "${RED}[ERROR]${NC} FAIL: /agent returned '$agent_resp'"
+            route_ok=false
+        fi
+
+        # Request counter increments across requests (property mutation regression)
+        counter_resp=$(curl -s --max-time 2 "http://localhost:8096/")
+        if [[ "$counter_resp" == *"Route server ready - request"* ]]; then
+            echo -e "${GREEN}[SUCCESS]${NC} PASS: request counter response '$counter_resp'"
+        else
+            echo -e "${RED}[ERROR]${NC} FAIL: counter route returned '$counter_resp'"
+            route_ok=false
+        fi
+    fi
+
+    if kill -0 $route_pid 2>/dev/null; then
+        kill $route_pid 2>/dev/null || true
+    fi
+
+    if [ "$route_ok" = true ]; then
+        passed_tests=$((passed_tests + 1))
     fi
 fi
 
diff --git a/src/analyzer/mod.rs b/src/analyzer/mod.rs
index 3eb92bb4..e98c7515 100644
--- a/src/analyzer/mod.rs
+++ b/src/analyzer/mod.rs
@@ -747,42 +747,17 @@ impl Analyzer {
             Statement::ReturnStatement { value: None, .. } => {}
             Statement::WaitForStatement {
                 inner,
-                line,
-                column,
+                line: _line,
+                column: _column,
             } => {
                 let outer_scope = std::mem::take(&mut self.current_scope);
                 self.current_scope = Scope::with_parent(outer_scope);
 
-                match &**inner {
-                    Statement::ReadFileStatement { variable_name, .. } => {
-                        let symbol = Symbol {
-                            name: variable_name.clone(),
-                            kind: SymbolKind::Variable { mutable: true },
-                            symbol_type: Some(Type::Text), // File content is always text
-                            line: *line,
-                            column: *column,
-                        };
-
-                        if let Err(error) = self.current_scope.define(symbol) {
-                            self.errors.push(error);
-                        }
-                    }
-                    Statement::OpenFileStatement { variable_name, .. } => {
-                        let symbol = Symbol {
-                            name: variable_name.clone(),
-                            kind: SymbolKind::Variable { mutable: true },
-                            symbol_type: None, // File handle type
-                            line: *line,
-                            column: *column,
-                        };
-
-                        if let Err(error) = self.current_scope.define(symbol) {
-                            self.errors.push(error);
-                        }
-                    }
-                    _ => {}
-                }
-
+                // The inner statement's own analysis defines any variables it
+                // introduces (file handles, read content, database handles,
+                // query results); pre-defining them here would make
+                // Scope::define report a duplicate. The wait-scope merge
+                // below hoists them into the parent scope.
                 self.analyze_statement(inner);
 
                 let wait_scope = std::mem::take(&mut self.current_scope);
@@ -886,6 +861,56 @@ impl Analyzer {
                     self.errors.push(error);
                 }
             }
+            Statement::OpenDatabaseStatement {
+                url,
+                variable_name,
+                line,
+                column,
+            } => {
+                self.analyze_expression(url);
+
+                let symbol = Symbol {
+                    name: variable_name.clone(),
+                    kind: SymbolKind::Variable { mutable: true },
+                    symbol_type: None, // Database handle type
+                    line: *line,
+                    column: *column,
+                };
+
+                if let Err(error) = self.current_scope.define(symbol) {
+                    self.errors.push(error);
+                }
+            }
+            Statement::DatabaseQueryStatement {
+                db,
+                sql,
+                parameters,
+                variable_name,
+                line,
+                column,
+                ..
+            } => {
+                self.analyze_expression(db);
+                self.analyze_expression(sql);
+                if let Some(params) = parameters {
+                    self.analyze_expression(params);
+                }
+
+                let symbol = Symbol {
+                    name: variable_name.clone(),
+                    kind: SymbolKind::Variable { mutable: true },
+                    symbol_type: None, // Query result type
+                    line: *line,
+                    column: *column,
+                };
+
+                if let Err(error) = self.current_scope.define(symbol) {
+                    self.errors.push(error);
+                }
+            }
+            Statement::CloseDatabaseStatement { db, .. } => {
+                self.analyze_expression(db);
+            }
             Statement::HttpGetStatement { variable_name, .. } => {
                 let symbol = Symbol {
                     name: variable_name.clone(),
diff --git a/src/analyzer/static_analyzer.rs b/src/analyzer/static_analyzer.rs
index 6b46ee23..0dfedb6b 100644
--- a/src/analyzer/static_analyzer.rs
+++ b/src/analyzer/static_analyzer.rs
@@ -590,6 +590,29 @@ impl Analyzer {
             Statement::CloseFileStatement { file, .. } => {
                 self.mark_used_in_expression(file, usages);
             }
+            Statement::OpenDatabaseStatement {
+                url, variable_name, ..
+            } => {
+                self.mark_used_in_expression(url, usages);
+                if let Some(usage) = usages.get_mut(variable_name) {
+                    usage.used = true;
+                }
+            }
+            Statement::DatabaseQueryStatement {
+                db,
+                sql,
+                parameters,
+                ..
+            } => {
+                self.mark_used_in_expression(db, usages);
+                self.mark_used_in_expression(sql, usages);
+                if let Some(params) = parameters {
+                    self.mark_used_in_expression(params, usages);
+                }
+            }
+            Statement::CloseDatabaseStatement { db, .. } => {
+                self.mark_used_in_expression(db, usages);
+            }
             Statement::ExecuteFileStatement {
                 path,
                 request,
@@ -662,6 +685,11 @@ impl Analyzer {
                     usage.used = true;
                 }
             }
+            Expression::Literal(crate::parser::ast::Literal::List(elements), ..) => {
+                for element in elements {
+                    self.mark_used_in_expression(element, usages);
+                }
+            }
             Expression::BinaryOperation { left, right, .. } => {
                 self.mark_used_in_expression(left, usages);
                 self.mark_used_in_expression(right, usages);
diff --git a/src/builtins.rs b/src/builtins.rs
index c5e5c1c8..82c1071e 100644
--- a/src/builtins.rs
+++ b/src/builtins.rs
@@ -44,6 +44,9 @@ const BUILTIN_FUNCTIONS: &[&str] = &[
     "parse_query_string",
     "parse_cookies",
     "parse_form_urlencoded",
+    // Web routing helpers (implemented in stdlib/web.rs)
+    "path_params",
+    "path_matches",
     // Math functions (implemented in stdlib/math.rs)
     "min",
     "max",
@@ -264,6 +267,10 @@ pub fn get_function_arity(name: &str) -> usize {
         // Single argument functions
         "parse_query_string" | "parse_cookies" | "parse_form_urlencoded" => 1,
 
+        // === WEB ROUTING HELPERS ===
+        // Two argument functions: (path, template)
+        "path_params" | "path_matches" => 2,
+
         // === TEXT FUNCTIONS ===
         // Single argument functions
         "length" | "touppercase" | "to_uppercase" | "tolowercase" | "to_lowercase" | "trim"
diff --git a/src/interpreter/database.rs b/src/interpreter/database.rs
new file mode 100644
index 00000000..b84f78ea
--- /dev/null
+++ b/src/interpreter/database.rs
@@ -0,0 +1,448 @@
+//! Database connectivity for WFL programs, backed by sqlx.
+//!
+//! Supports PostgreSQL (`postgres://`/`postgresql://`), MariaDB/MySQL
+//! (`mariadb://`/`mysql://`), and SQLite (`sqlite://path`, `sqlite::memory:`).
+//! Connections are pooled and addressed from WFL code through string handles
+//! ("db1", "db2", ...) managed by the interpreter's IoClient, mirroring file
+//! handles.
+//!
+//! All SQL runs through runtime `sqlx::query` with explicit `.bind()` calls —
+//! parameter values are never interpolated into SQL text. Placeholders are
+//! driver-native: `?` for SQLite/MariaDB, `$1` for PostgreSQL.
+
+use super::value::Value;
+use sqlx::mysql::{MySqlPoolOptions, MySqlRow};
+use sqlx::postgres::{PgPoolOptions, PgRow};
+use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions, SqliteRow};
+use sqlx::{Column, Row, TypeInfo, ValueRef};
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+const MAX_POOL_CONNECTIONS: u32 = 5;
+
+/// A connection pool to one of the supported database backends.
+#[derive(Clone)]
+pub enum DbPool {
+    Postgres(sqlx::PgPool),
+    /// Also serves MariaDB, which speaks the MySQL protocol.
+    MySql(sqlx::MySqlPool),
+    Sqlite(sqlx::SqlitePool),
+}
+
+/// An owned, Send-safe SQL bind parameter converted from a WFL `Value`.
+#[derive(Debug, Clone)]
+pub enum SqlParam {
+    Int(i64),
+    Float(f64),
+    Text(String),
+    Bool(bool),
+    Binary(Vec<u8>),
+    Date(chrono::NaiveDate),
+    Time(chrono::NaiveTime),
+    DateTime(chrono::NaiveDateTime),
+    Null,
+}
+
+/// Convert a WFL value into a bindable SQL parameter.
+pub fn value_to_sql_param(value: &Value) -> Result<SqlParam, String> {
+    match value {
+        // Whole numbers bind as integers so strict backends (PostgreSQL)
+        // accept them in integer columns. Magnitudes beyond i64 range would
+        // saturate in the cast, so they fall through to float binding.
+        Value::Number(n)
+            if n.fract() == 0.0
+                && n.is_finite()
+                && *n >= i64::MIN as f64
+                && *n <= i64::MAX as f64 =>
+        {
+            Ok(SqlParam::Int(*n as i64))
+        }
+        Value::Number(n) => Ok(SqlParam::Float(*n)),
+        Value::Text(t) => Ok(SqlParam::Text(t.to_string())),
+        Value::Bool(b) => Ok(SqlParam::Bool(*b)),
+        Value::Binary(b) => Ok(SqlParam::Binary(b.to_vec())),
+        Value::Date(d) => Ok(SqlParam::Date(**d)),
+        Value::Time(t) => Ok(SqlParam::Time(**t)),
+        Value::DateTime(dt) => Ok(SqlParam::DateTime(**dt)),
+        Value::Null | Value::Nothing => Ok(SqlParam::Null),
+        other => Err(format!(
+            "Cannot bind value of type {} as a query parameter",
+            other.type_name()
+        )),
+    }
+}
+
+/// Open a pooled connection, routed by the URL scheme.
+pub async fn connect(url: &str) -> Result<DbPool, String> {
+    if url.starts_with("sqlite:") {
+        let options = if url == "sqlite::memory:" || url == "sqlite://:memory:" {
+            SqliteConnectOptions::new().in_memory(true)
+        } else {
+            let path = url
+                .strip_prefix("sqlite://")
+                .or_else(|| url.strip_prefix("sqlite:"))
+                .unwrap_or(url);
+            SqliteConnectOptions::new()
+                .filename(path)
+                .create_if_missing(true)
+        };
+        // In-memory SQLite databases exist per connection, so the pool must
+        // not hand out more than one.
+        let max_connections = if url.contains(":memory:") {
+            1
+        } else {
+            MAX_POOL_CONNECTIONS
+        };
+        SqlitePoolOptions::new()
+            .max_connections(max_connections)
+            .connect_with(options)
+            .await
+            .map(DbPool::Sqlite)
+            .map_err(|e| format!("Failed to connect to SQLite database: {e}"))
+    } else if url.starts_with("postgres://") || url.starts_with("postgresql://") {
+        PgPoolOptions::new()
+            .max_connections(MAX_POOL_CONNECTIONS)
+            .connect(url)
+            .await
+            .map(DbPool::Postgres)
+            .map_err(|e| format!("Failed to connect to PostgreSQL database: {e}"))
+    } else if url.starts_with("mysql://") || url.starts_with("mariadb://") {
+        let url = url.replacen("mariadb://", "mysql://", 1);
+        MySqlPoolOptions::new()
+            .max_connections(MAX_POOL_CONNECTIONS)
+            .connect(&url)
+            .await
+            .map(DbPool::MySql)
+            .map_err(|e| format!("Failed to connect to MariaDB/MySQL database: {e}"))
+    } else {
+        Err(format!(
+            "Unsupported database URL '{url}'. Supported schemes: sqlite://, postgres://, postgresql://, mysql://, mariadb://"
+        ))
+    }
+}
+
+/// Run a row-returning statement; rows become a list of objects keyed by
+/// column name.
+pub async fn run_query(pool: &DbPool, sql: &str, params: &[SqlParam]) -> Result<Value, String> {
+    let rows: Vec<Value> = match pool {
+        DbPool::Sqlite(pool) => {
+            let mut query = sqlx::query(sql);
+            for param in params {
+                query = bind_sqlite(query, param);
+            }
+            let rows = query
+                .fetch_all(pool)
+                .await
+                .map_err(|e| format!("Query failed: {e}"))?;
+            rows.iter()
+                .map(sqlite_row_to_value)
+                .collect::<Result<_, _>>()?
+        }
+        DbPool::Postgres(pool) => {
+            let mut query = sqlx::query(sql);
+            for param in params {
+                query = bind_postgres(query, param);
+            }
+            let rows = query
+                .fetch_all(pool)
+                .await
+                .map_err(|e| format!("Query failed: {e}"))?;
+            rows.iter().map(pg_row_to_value).collect::<Result<_, _>>()?
+        }
+        DbPool::MySql(pool) => {
+            let mut query = sqlx::query(sql);
+            for param in params {
+                query = bind_mysql(query, param);
+            }
+            let rows = query
+                .fetch_all(pool)
+                .await
+                .map_err(|e| format!("Query failed: {e}"))?;
+            rows.iter()
+                .map(mysql_row_to_value)
+                .collect::<Result<_, _>>()?
+        }
+    };
+
+    Ok(Value::List(Rc::new(RefCell::new(rows))))
+}
+
+/// Run a non-returning statement; the result is an object with
+/// `affected_rows` and `last_insert_id` (nothing on PostgreSQL — use
+/// `RETURNING` there instead).
+pub async fn run_execute(pool: &DbPool, sql: &str, params: &[SqlParam]) -> Result<Value, String> {
+    let (affected_rows, last_insert_id): (u64, Option<i64>) = match pool {
+        DbPool::Sqlite(pool) => {
+            let mut query = sqlx::query(sql);
+            for param in params {
+                query = bind_sqlite(query, param);
+            }
+            let result = query
+                .execute(pool)
+                .await
+                .map_err(|e| format!("Execute failed: {e}"))?;
+            (result.rows_affected(), Some(result.last_insert_rowid()))
+        }
+        DbPool::Postgres(pool) => {
+            let mut query = sqlx::query(sql);
+            for param in params {
+                query = bind_postgres(query, param);
+            }
+            let result = query
+                .execute(pool)
+                .await
+                .map_err(|e| format!("Execute failed: {e}"))?;
+            (result.rows_affected(), None)
+        }
+        DbPool::MySql(pool) => {
+            let mut query = sqlx::query(sql);
+            for param in params {
+                query = bind_mysql(query, param);
+            }
+            let result = query
+                .execute(pool)
+                .await
+                .map_err(|e| format!("Execute failed: {e}"))?;
+            (result.rows_affected(), Some(result.last_insert_id() as i64))
+        }
+    };
+
+    let mut object = HashMap::new();
+    object.insert(
+        "affected_rows".to_string(),
+        Value::Number(affected_rows as f64),
+    );
+    object.insert(
+        "last_insert_id".to_string(),
+        match last_insert_id {
+            Some(id) => Value::Number(id as f64),
+            // Value::Null is the runtime value of WFL's `nothing` literal
+            None => Value::Null,
+        },
+    );
+
+    Ok(Value::Object(Rc::new(RefCell::new(object))))
+}
+
+/// Close the pool, ending all connections.
+pub async fn close(pool: DbPool) {
+    match pool {
+        DbPool::Postgres(pool) => pool.close().await,
+        DbPool::MySql(pool) => pool.close().await,
+        DbPool::Sqlite(pool) => pool.close().await,
+    }
+}
+
+macro_rules! bind_param {
+    ($fn_name:ident, $db:ty) => {
+        fn $fn_name<'q>(
+            query: sqlx::query::Query<'q, $db, <$db as sqlx::Database>::Arguments<'q>>,
+            param: &SqlParam,
+        ) -> sqlx::query::Query<'q, $db, <$db as sqlx::Database>::Arguments<'q>> {
+            match param {
+                SqlParam::Int(v) => query.bind(*v),
+                SqlParam::Float(v) => query.bind(*v),
+                SqlParam::Text(v) => query.bind(v.clone()),
+                SqlParam::Bool(v) => query.bind(*v),
+                SqlParam::Binary(v) => query.bind(v.clone()),
+                SqlParam::Date(v) => query.bind(*v),
+                SqlParam::Time(v) => query.bind(*v),
+                SqlParam::DateTime(v) => query.bind(*v),
+                SqlParam::Null => query.bind(Option::<String>::None),
+            }
+        }
+    };
+}
+
+bind_param!(bind_sqlite, sqlx::Sqlite);
+bind_param!(bind_postgres, sqlx::Postgres);
+bind_param!(bind_mysql, sqlx::MySql);
+
+fn sqlite_int(row: &SqliteRow, index: usize) -> Result<Value, sqlx::Error> {
+    row.try_get::<i64, _>(index)
+        .map(|v| Value::Number(v as f64))
+}
+
+fn pg_int(row: &PgRow, index: usize) -> Result<Value, sqlx::Error> {
+    // PostgreSQL decoding is strict about integer widths (INT2/INT4/INT8).
+    row.try_get::<i64, _>(index)
+        .map(|v| Value::Number(v as f64))
+        .or_else(|_| {
+            row.try_get::<i32, _>(index)
+                .map(|v| Value::Number(v as f64))
+        })
+        .or_else(|_| {
+            row.try_get::<i16, _>(index)
+                .map(|v| Value::Number(v as f64))
+        })
+}
+
+fn mysql_int(row: &MySqlRow, index: usize) -> Result<Value, sqlx::Error> {
+    // MySQL/MariaDB UNSIGNED columns decode as u64 only.
+    row.try_get::<i64, _>(index)
+        .map(|v| Value::Number(v as f64))
+        .or_else(|_| {
+            row.try_get::<u64, _>(index)
+                .map(|v| Value::Number(v as f64))
+        })
+        .or_else(|_| {
+            row.try_get::<i32, _>(index)
+                .map(|v| Value::Number(v as f64))
+        })
+        .or_else(|_| {
+            row.try_get::<i16, _>(index)
+                .map(|v| Value::Number(v as f64))
+        })
+}
+
+/// Decode a column by its reported type name into a WFL value. Shared
+/// decision tree; the integer decoder differs per driver.
+macro_rules! row_to_value {
+    ($fn_name:ident, $row:ty, $int_fn:path) => {
+        fn $fn_name(row: &$row) -> Result<Value, String> {
+            let mut object = HashMap::new();
+
+            for (index, column) in row.columns().iter().enumerate() {
+                let name = column.name().to_string();
+
+                let is_null = row
+                    .try_get_raw(index)
+                    .map(|raw| raw.is_null())
+                    .unwrap_or(true);
+                if is_null {
+                    // Value::Null is the runtime value of WFL's `nothing`
+                    // literal, so `is nothing` comparisons work on NULLs.
+                    object.insert(name, Value::Null);
+                    continue;
+                }
+
+                let type_name = column.type_info().name().to_uppercase();
+                let value = if type_name.contains("BOOL") {
+                    row.try_get::<bool, _>(index)
+                        .map(Value::Bool)
+                        .or_else(|_| row.try_get::<i64, _>(index).map(|v| Value::Bool(v != 0)))
+                        .map_err(|e| decode_error(&name, &type_name, e))?
+                } else if type_name.contains("INT") || type_name == "SERIAL" {
+                    $int_fn(row, index).map_err(|e| decode_error(&name, &type_name, e))?
+                } else if type_name.contains("REAL")
+                    || type_name.contains("FLOAT")
+                    || type_name.contains("DOUBLE")
+                {
+                    row.try_get::<f64, _>(index)
+                        .map(Value::Number)
+                        .map_err(|e| decode_error(&name, &type_name, e))?
+                } else if type_name.contains("NUMERIC") || type_name.contains("DECIMAL") {
+                    // PostgreSQL NUMERIC cannot decode as f64 directly; go
+                    // through the text representation.
+                    row.try_get::<f64, _>(index)
+                        .map(Value::Number)
+                        .or_else(|_| {
+                            row.try_get::<String, _>(index).map(|s| {
+                                s.parse::<f64>()
+                                    .map(Value::Number)
+                                    .unwrap_or_else(|_| Value::Text(Arc::from(s.as_str())))
+                            })
+                        })
+                        .map_err(|e| decode_error(&name, &type_name, e))?
+                } else if type_name.contains("BLOB")
+                    || type_name.contains("BYTEA")
+                    || type_name.contains("BINARY")
+                {
+                    row.try_get::<Vec<u8>, _>(index)
+                        .map(|v| Value::Binary(Arc::from(v.as_slice())))
+                        .map_err(|e| decode_error(&name, &type_name, e))?
+                } else if type_name.contains("TIMESTAMP") || type_name == "DATETIME" {
+                    row.try_get::<chrono::NaiveDateTime, _>(index)
+                        .map(|v| Value::DateTime(Rc::new(v)))
+                        .or_else(|_| {
+                            row.try_get::<chrono::DateTime<chrono::Utc>, _>(index)
+                                .map(|v| Value::DateTime(Rc::new(v.naive_utc())))
+                        })
+                        .map_err(|e| decode_error(&name, &type_name, e))?
+                } else if type_name == "DATE" {
+                    row.try_get::<chrono::NaiveDate, _>(index)
+                        .map(|v| Value::Date(Rc::new(v)))
+                        .map_err(|e| decode_error(&name, &type_name, e))?
+                } else if type_name == "TIME" {
+                    row.try_get::<chrono::NaiveTime, _>(index)
+                        .map(|v| Value::Time(Rc::new(v)))
+                        .map_err(|e| decode_error(&name, &type_name, e))?
+                } else {
+                    // TEXT, VARCHAR, CHAR, and anything unrecognized (e.g.
+                    // SQLite expression columns like count(*)): try text,
+                    // then numeric decodings.
+                    row.try_get::<String, _>(index)
+                        .map(|v| Value::Text(Arc::from(v.as_str())))
+                        .or_else(|_| $int_fn(row, index))
+                        .or_else(|_| row.try_get::<f64, _>(index).map(Value::Number))
+                        .or_else(|_| row.try_get::<bool, _>(index).map(Value::Bool))
+                        .unwrap_or(Value::Null)
+                };
+
+                object.insert(name, value);
+            }
+
+            Ok(Value::Object(Rc::new(RefCell::new(object))))
+        }
+    };
+}
+
+fn decode_error(column: &str, type_name: &str, error: sqlx::Error) -> String {
+    format!("Failed to decode column '{column}' ({type_name}): {error}")
+}
+
+row_to_value!(sqlite_row_to_value, SqliteRow, sqlite_int);
+row_to_value!(pg_row_to_value, PgRow, pg_int);
+row_to_value!(mysql_row_to_value, MySqlRow, mysql_int);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn whole_numbers_bind_as_integers() {
+        assert!(matches!(
+            value_to_sql_param(&Value::Number(42.0)),
+            Ok(SqlParam::Int(42))
+        ));
+        assert!(matches!(
+            value_to_sql_param(&Value::Number(-7.0)),
+            Ok(SqlParam::Int(-7))
+        ));
+    }
+
+    #[test]
+    fn fractional_numbers_bind_as_floats() {
+        assert!(matches!(
+            value_to_sql_param(&Value::Number(9.5)),
+            Ok(SqlParam::Float(f)) if f == 9.5
+        ));
+    }
+
+    #[test]
+    fn whole_numbers_beyond_i64_range_bind_as_floats() {
+        // 1e19 > i64::MAX; an unchecked cast would saturate silently.
+        assert!(matches!(
+            value_to_sql_param(&Value::Number(1e19)),
+            Ok(SqlParam::Float(f)) if f == 1e19
+        ));
+        assert!(matches!(
+            value_to_sql_param(&Value::Number(-1e19)),
+            Ok(SqlParam::Float(f)) if f == -1e19
+        ));
+    }
+
+    #[test]
+    fn nothing_binds_as_null() {
+        assert!(matches!(
+            value_to_sql_param(&Value::Null),
+            Ok(SqlParam::Null)
+        ));
+        assert!(matches!(
+            value_to_sql_param(&Value::Nothing),
+            Ok(SqlParam::Null)
+        ));
+    }
+}
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
index 09123183..347aa77e 100644
--- a/src/interpreter/mod.rs
+++ b/src/interpreter/mod.rs
@@ -3,6 +3,7 @@ mod assertion_helpers;
 pub mod bounded_buffer;
 pub mod command_sanitizer;
 pub mod control_flow;
+pub mod database;
 pub mod environment;
 pub mod error;
 pub(crate) mod io_capture;
@@ -178,6 +179,13 @@ fn stmt_type(stmt: &Statement) -> String {
         Statement::WriteContentStatement { .. } => "WriteContentStatement".to_string(),
         Statement::WriteBinaryStatement { .. } => "WriteBinaryStatement".to_string(),
         Statement::CloseFileStatement { .. } => "CloseFileStatement".to_string(),
+        Statement::OpenDatabaseStatement { variable_name, .. } => {
+            format!("OpenDatabaseStatement '{variable_name}'")
+        }
+        Statement::DatabaseQueryStatement { variable_name, .. } => {
+            format!("DatabaseQueryStatement '{variable_name}'")
+        }
+        Statement::CloseDatabaseStatement { .. } => "CloseDatabaseStatement".to_string(),
         Statement::CreateDirectoryStatement { .. } => "CreateDirectoryStatement".to_string(),
         Statement::CreateFileStatement { .. } => "CreateFileStatement".to_string(),
         Statement::DeleteFileStatement { .. } => "DeleteFileStatement".to_string(),
@@ -424,6 +432,8 @@ pub struct IoClient {
     next_file_id: Mutex<usize>,
     process_handles: Mutex<HashMap<String, ProcessHandle>>,
     next_process_id: Mutex<usize>,
+    db_handles: Mutex<HashMap<String, database::DbPool>>,
+    next_db_id: Mutex<usize>,
     config: Arc<WflConfig>,
 }
 
@@ -435,10 +445,49 @@ impl IoClient {
             next_file_id: Mutex::new(1),
             process_handles: Mutex::new(HashMap::new()),
             next_process_id: Mutex::new(1),
+            db_handles: Mutex::new(HashMap::new()),
+            next_db_id: Mutex::new(1),
             config,
         }
     }
 
+    /// Open a database connection pool and return its WFL handle ("db1", ...).
+    async fn open_database(&self, url: &str) -> Result<String, String> {
+        let pool = database::connect(url).await?;
+
+        let handle_id = {
+            let mut next_id = self.next_db_id.lock().await;
+            let id = format!("db{}", *next_id);
+            *next_id += 1;
+            id
+        };
+
+        self.db_handles.lock().await.insert(handle_id.clone(), pool);
+        Ok(handle_id)
+    }
+
+    /// Look up a database pool by handle; pools are cheap to clone (Arc inside).
+    async fn get_database(&self, handle_id: &str) -> Result<database::DbPool, String> {
+        self.db_handles
+            .lock()
+            .await
+            .get(handle_id)
+            .cloned()
+            .ok_or_else(|| format!("Invalid or closed database handle: {handle_id}"))
+    }
+
+    /// Close a database pool and drop its handle.
+    async fn close_database(&self, handle_id: &str) -> Result<(), String> {
+        let pool = self
+            .db_handles
+            .lock()
+            .await
+            .remove(handle_id)
+            .ok_or_else(|| format!("Invalid or closed database handle: {handle_id}"))?;
+        database::close(pool).await;
+        Ok(())
+    }
+
     #[allow(dead_code)]
     async fn http_get(&self, url: &str) -> Result<String, String> {
         match self.http_client.get(url).send().await {
@@ -1979,6 +2028,9 @@ impl Interpreter {
             Statement::WriteContentStatement { line, column, .. } => (*line, *column),
             Statement::WriteBinaryStatement { line, column, .. } => (*line, *column),
             Statement::CloseFileStatement { line, column, .. } => (*line, *column),
+            Statement::OpenDatabaseStatement { line, column, .. } => (*line, *column),
+            Statement::DatabaseQueryStatement { line, column, .. } => (*line, *column),
+            Statement::CloseDatabaseStatement { line, column, .. } => (*line, *column),
             Statement::CreateDirectoryStatement { line, column, .. } => (*line, *column),
             Statement::CreateFileStatement { line, column, .. } => (*line, *column),
             Statement::DeleteFileStatement { line, column, .. } => (*line, *column),
@@ -2736,6 +2788,146 @@ impl Interpreter {
                     Err(e) => Err(e),
                 }
             }
+            Statement::OpenDatabaseStatement {
+                url,
+                variable_name,
+                line,
+                column,
+            } => {
+                let url_value = self.evaluate_expression(url, Rc::clone(&env)).await?;
+                let url_str = match &url_value {
+                    Value::Text(s) => s.clone(),
+                    _ => {
+                        return Err(RuntimeError::new(
+                            format!("Expected text for database URL, got {url_value:?}"),
+                            *line,
+                            *column,
+                        ));
+                    }
+                };
+
+                match self.io_client.open_database(&url_str).await {
+                    Ok(handle) => {
+                        let define_result = env
+                            .borrow_mut()
+                            .define(variable_name, Value::Text(handle.as_str().into()));
+                        match define_result {
+                            Ok(_) => Ok((Value::Null, ControlFlow::None)),
+                            Err(msg) => {
+                                // Don't leave an unreachable pool behind when
+                                // the variable binding fails.
+                                let _ = self.io_client.close_database(&handle).await;
+                                Err(RuntimeError::new(msg, *line, *column))
+                            }
+                        }
+                    }
+                    Err(e) => Err(RuntimeError::new(e, *line, *column)),
+                }
+            }
+            Statement::DatabaseQueryStatement {
+                db,
+                sql,
+                parameters,
+                variable_name,
+                kind,
+                line,
+                column,
+            } => {
+                let db_value = self.evaluate_expression(db, Rc::clone(&env)).await?;
+                let handle = match &db_value {
+                    Value::Text(s) => s.clone(),
+                    _ => {
+                        return Err(RuntimeError::new(
+                            format!("Expected a database handle, got {db_value:?}"),
+                            *line,
+                            *column,
+                        ));
+                    }
+                };
+
+                let sql_value = self.evaluate_expression(sql, Rc::clone(&env)).await?;
+                let sql_str = match &sql_value {
+                    Value::Text(s) => s.clone(),
+                    _ => {
+                        return Err(RuntimeError::new(
+                            format!("Expected text for SQL statement, got {sql_value:?}"),
+                            *line,
+                            *column,
+                        ));
+                    }
+                };
+
+                let params = match parameters {
+                    Some(params_expr) => {
+                        let params_value = self
+                            .evaluate_expression(params_expr, Rc::clone(&env))
+                            .await?;
+                        match &params_value {
+                            Value::List(list) => {
+                                let mut sql_params = Vec::new();
+                                for value in list.borrow().iter() {
+                                    sql_params.push(
+                                        database::value_to_sql_param(value)
+                                            .map_err(|e| RuntimeError::new(e, *line, *column))?,
+                                    );
+                                }
+                                sql_params
+                            }
+                            _ => {
+                                return Err(RuntimeError::new(
+                                    format!(
+                                        "Expected a list of query parameters, got {params_value:?}"
+                                    ),
+                                    *line,
+                                    *column,
+                                ));
+                            }
+                        }
+                    }
+                    None => Vec::new(),
+                };
+
+                let pool = self
+                    .io_client
+                    .get_database(&handle)
+                    .await
+                    .map_err(|e| RuntimeError::new(e, *line, *column))?;
+
+                let result = match kind {
+                    crate::parser::ast::DatabaseQueryKind::Query => {
+                        database::run_query(&pool, &sql_str, &params).await
+                    }
+                    crate::parser::ast::DatabaseQueryKind::Execute => {
+                        database::run_execute(&pool, &sql_str, &params).await
+                    }
+                }
+                .map_err(|e| RuntimeError::new(e, *line, *column))?;
+
+                match env.borrow_mut().define(variable_name, result) {
+                    Ok(_) => Ok((Value::Null, ControlFlow::None)),
+                    Err(msg) => Err(RuntimeError::new(msg, *line, *column)),
+                }
+            }
+            Statement::CloseDatabaseStatement { db, line, column } => {
+                let db_value = self.evaluate_expression(db, Rc::clone(&env)).await?;
+                let handle = match &db_value {
+                    Value::Text(s) => s.clone(),
+                    _ => {
+                        return Err(RuntimeError::new(
+                            format!("Expected a database handle, got {db_value:?}"),
+                            *line,
+                            *column,
+                        ));
+                    }
+                };
+
+                self.io_client
+                    .close_database(&handle)
+                    .await
+                    .map_err(|e| RuntimeError::new(e, *line, *column))?;
+
+                Ok((Value::Null, ControlFlow::None))
+            }
             Statement::ReadFileStatement {
                 path,
                 variable_name,
@@ -7440,12 +7632,26 @@ impl Interpreter {
                     }
                 };
 
-                // Get the specific header from the headers object
+                // Get the specific header from the headers object. HTTP
+                // header names are case-insensitive (and warp normalizes
+                // them to lowercase), so fall back to a case-insensitive
+                // scan when the exact key is absent.
                 match &headers_val {
-                    Value::Object(headers_map) => match headers_map.borrow().get(header_name) {
-                        Some(header_value) => Ok(header_value.clone()),
-                        None => Ok(Value::Nothing),
-                    },
+                    Value::Object(headers_map) => {
+                        let map = headers_map.borrow();
+                        let header_value = map.get(header_name).cloned().or_else(|| {
+                            let lowered = header_name.to_lowercase();
+                            map.iter()
+                                .find(|(key, _)| key.to_lowercase() == lowered)
+                                .map(|(_, value)| value.clone())
+                        });
+                        match header_value {
+                            Some(header_value) => Ok(header_value),
+                            // Value::Null is the runtime value of WFL's
+                            // `nothing` literal
+                            None => Ok(Value::Null),
+                        }
+                    }
                     _ => {
                         return Err(RuntimeError::new(
                             format!(
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index db976440..4c6667eb 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -232,6 +232,26 @@ pub enum Statement {
         line: usize,
         column: usize,
     },
+    OpenDatabaseStatement {
+        url: Expression,
+        variable_name: String,
+        line: usize,
+        column: usize,
+    },
+    DatabaseQueryStatement {
+        db: Expression,
+        sql: Expression,
+        parameters: Option<Expression>,
+        variable_name: String,
+        kind: DatabaseQueryKind,
+        line: usize,
+        column: usize,
+    },
+    CloseDatabaseStatement {
+        db: Expression,
+        line: usize,
+        column: usize,
+    },
     CreateDirectoryStatement {
         path: Expression,
         line: usize,
@@ -939,6 +959,14 @@ pub enum FileOpenMode {
     WriteBinary,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DatabaseQueryKind {
+    /// SELECT-style statement returning rows as a list of objects
+    Query,
+    /// INSERT/UPDATE/DELETE/DDL returning {affected_rows, last_insert_id}
+    Execute,
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum ErrorType {
     General,
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 00af4f21..e798036b 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -12,9 +12,9 @@ use ast::*;
 pub use cursor::Cursor; // Re-export Cursor publicly for doctests
 use expr::ExprParser;
 use stmt::{
-    ActionParser, CollectionParser, ContainerParser, ControlFlowParser, ErrorHandlingParser,
-    IoParser, ModuleParser, PatternParser, ProcessParser, StmtParser, TestingParser,
-    VariableParser, WebParser,
+    ActionParser, CollectionParser, ContainerParser, ControlFlowParser, DatabaseParser,
+    ErrorHandlingParser, IoParser, ModuleParser, PatternParser, ProcessParser, StmtParser,
+    TestingParser, VariableParser, WebParser,
 };
 
 pub struct Parser<'a> {
@@ -512,10 +512,12 @@ impl<'a> StmtParser<'a> for Parser<'a> {
                     }
                 }
                 Token::KeywordClose => {
-                    // Check if it's "close server" or regular "close file"
+                    // Check if it's "close server", "close database", or regular "close file"
                     if let Some(next_token) = self.cursor.peek_next() {
                         if matches!(next_token.token, Token::KeywordServer) {
                             self.parse_close_server_statement()
+                        } else if matches!(next_token.token, Token::KeywordDatabase) {
+                            self.parse_close_database_statement()
                         } else {
                             self.parse_close_file_statement()
                         }
@@ -531,6 +533,19 @@ impl<'a> StmtParser<'a> for Parser<'a> {
                 Token::KeywordRegister => self.parse_register_signal_handler_statement(),
                 Token::KeywordStop => self.parse_stop_accepting_connections_statement(),
                 Token::KeywordGive | Token::KeywordReturn => self.parse_return_statement(),
+                Token::Identifier(id)
+                    if id == "connect"
+                        && self
+                            .cursor
+                            .peek_next()
+                            .is_some_and(|t| t.token == Token::KeywordTo)
+                        && self
+                            .cursor
+                            .peek_n(2)
+                            .is_some_and(|t| t.token == Token::KeywordDatabase) =>
+                {
+                    self.parse_connect_to_database_statement()
+                }
                 Token::Identifier(id) if id == "main" => {
                     // Check if next token is "loop"
                     if let Some(next_token) = self.cursor.peek_next() {
diff --git a/src/parser/stmt/database.rs b/src/parser/stmt/database.rs
new file mode 100644
index 00000000..4a264638
--- /dev/null
+++ b/src/parser/stmt/database.rs
@@ -0,0 +1,213 @@
+//! Database statement parsing
+//!
+//! Syntax:
+//! - `open database at "<url>" as <name>` (also `connect to database at ... as ...`)
+//! - `store <name> as query <db> with <sql> [and parameters <list>]`
+//! - `store <name> as execute <db> with <sql> [and parameters <list>]`
+//! - `close database <db>`
+
+use super::super::{ParseError, Parser, Statement};
+use crate::lexer::token::Token;
+use crate::parser::ast::DatabaseQueryKind;
+use crate::parser::expr::{ExprParser, PrimaryExprParser};
+
+pub(crate) trait DatabaseParser<'a>: ExprParser<'a> {
+    /// Parse `open database at <url> as <name>` with the `open` token already consumed
+    /// and the cursor positioned on `database`. Also used by `connect to database`,
+    /// which shares everything after the `database` keyword.
+    fn parse_open_database_statement(
+        &mut self,
+        line: usize,
+        column: usize,
+    ) -> Result<Statement, ParseError>;
+
+    /// Parse `connect to database at <url> as <name>` from the `connect` identifier.
+    fn parse_connect_to_database_statement(&mut self) -> Result<Statement, ParseError>;
+
+    /// Parse `close database <db>` from the `close` keyword.
+    fn parse_close_database_statement(&mut self) -> Result<Statement, ParseError>;
+
+    /// Detect whether the cursor is positioned on the value side of a database
+    /// query/execute form: `query|execute <handle> with ...`. The three-token
+    /// lookahead keeps ordinary variables named `query` parsing as expressions.
+    fn peek_database_query_kind(&self) -> Option<DatabaseQueryKind>;
+
+    /// Parse the value side of `store <name> as query/execute <db> with <sql>
+    /// [and parameters <list>]` with the cursor positioned on `query`/`execute`.
+    fn parse_database_query_value(
+        &mut self,
+        name: String,
+        kind: DatabaseQueryKind,
+        line: usize,
+        column: usize,
+    ) -> Result<Statement, ParseError>;
+}
+
+impl<'a> DatabaseParser<'a> for Parser<'a> {
+    fn peek_database_query_kind(&self) -> Option<DatabaseQueryKind> {
+        match self.cursor.peek().map(|t| &t.token) {
+            // The lexer merges adjacent identifiers, so `query db` arrives as the
+            // single token Identifier("query db"). A plain variable named `query`
+            // (no handle) deliberately does not match.
+            Some(Token::Identifier(id)) if id.starts_with("query ") => {
+                let with_ok = self
+                    .cursor
+                    .peek_next()
+                    .is_some_and(|t| t.token == Token::KeywordWith);
+                if with_ok {
+                    Some(DatabaseQueryKind::Query)
+                } else {
+                    None
+                }
+            }
+            Some(Token::KeywordExecute) => {
+                let handle_ok = matches!(
+                    self.cursor.peek_next().map(|t| &t.token),
+                    Some(Token::Identifier(_))
+                );
+                let with_ok = self
+                    .cursor
+                    .peek_n(2)
+                    .is_some_and(|t| t.token == Token::KeywordWith);
+                if handle_ok && with_ok {
+                    Some(DatabaseQueryKind::Execute)
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn parse_open_database_statement(
+        &mut self,
+        line: usize,
+        column: usize,
+    ) -> Result<Statement, ParseError> {
+        self.bump_sync(); // Consume "database"
+        self.expect_token(Token::KeywordAt, "Expected 'at' after 'database'")?;
+
+        let url = self.parse_primary_expression()?;
+
+        self.expect_token(Token::KeywordAs, "Expected 'as' after database URL")?;
+
+        let variable_name = if let Some(token) = self.cursor.peek() {
+            if let Token::Identifier(name) = &token.token {
+                self.bump_sync();
+                name.clone()
+            } else {
+                return Err(ParseError::from_token(
+                    format!("Expected identifier after 'as', found {:?}", token.token),
+                    token,
+                ));
+            }
+        } else {
+            return Err(self
+                .cursor
+                .error("Unexpected end of input after 'as'".to_string()));
+        };
+
+        Ok(Statement::OpenDatabaseStatement {
+            url,
+            variable_name,
+            line,
+            column,
+        })
+    }
+
+    fn parse_connect_to_database_statement(&mut self) -> Result<Statement, ParseError> {
+        let connect_token = self.bump_sync().unwrap(); // Consume "connect"
+        self.expect_token(Token::KeywordTo, "Expected 'to' after 'connect'")?;
+
+        if let Some(token) = self.cursor.peek() {
+            if token.token != Token::KeywordDatabase {
+                return Err(ParseError::from_token(
+                    format!(
+                        "Expected 'database' after 'connect to', found {:?}",
+                        token.token
+                    ),
+                    token,
+                ));
+            }
+        } else {
+            return Err(self
+                .cursor
+                .error("Unexpected end of input after 'connect to'".to_string()));
+        }
+
+        self.parse_open_database_statement(connect_token.line, connect_token.column)
+    }
+
+    fn parse_close_database_statement(&mut self) -> Result<Statement, ParseError> {
+        let close_token = self.bump_sync().unwrap(); // Consume "close"
+        self.bump_sync(); // Consume "database"
+
+        let db = self.parse_expression()?;
+
+        Ok(Statement::CloseDatabaseStatement {
+            db,
+            line: close_token.line,
+            column: close_token.column,
+        })
+    }
+
+    fn parse_database_query_value(
+        &mut self,
+        name: String,
+        kind: DatabaseQueryKind,
+        line: usize,
+        column: usize,
+    ) -> Result<Statement, ParseError> {
+        let db = match self.cursor.peek() {
+            Some(token) => match &token.token {
+                // Merged token form: Identifier("query <handle>")
+                Token::Identifier(id) if id.starts_with("query ") => {
+                    let handle = id["query ".len()..].to_string();
+                    let (handle_line, handle_column) = (token.line, token.column);
+                    self.bump_sync(); // Consume "query <handle>"
+                    super::super::Expression::Variable(handle, handle_line, handle_column)
+                }
+                Token::KeywordExecute => {
+                    self.bump_sync(); // Consume "execute"
+                    self.parse_primary_expression()?
+                }
+                _ => {
+                    return Err(ParseError::from_token(
+                        format!("Expected 'query' or 'execute', found {:?}", token.token),
+                        token,
+                    ));
+                }
+            },
+            None => {
+                return Err(self
+                    .cursor
+                    .error("Unexpected end of input in database statement".to_string()));
+            }
+        };
+
+        self.expect_token(Token::KeywordWith, "Expected 'with' after database handle")?;
+
+        let sql = self.parse_primary_expression()?;
+
+        // Optional "and parameters <expression>"
+        let parameters = if self.cursor.peek().map(|t| &t.token) == Some(&Token::KeywordAnd)
+            && self.cursor.peek_next().map(|t| &t.token) == Some(&Token::KeywordParameters)
+        {
+            self.bump_sync(); // Consume "and"
+            self.bump_sync(); // Consume "parameters"
+            Some(self.parse_primary_expression()?)
+        } else {
+            None
+        };
+
+        Ok(Statement::DatabaseQueryStatement {
+            db,
+            sql,
+            parameters,
+            variable_name: name,
+            kind,
+            line,
+            column,
+        })
+    }
+}
diff --git a/src/parser/stmt/io.rs b/src/parser/stmt/io.rs
index 05cb3a05..bdf101b7 100644
--- a/src/parser/stmt/io.rs
+++ b/src/parser/stmt/io.rs
@@ -1,6 +1,7 @@
 //! File I/O and filesystem statement parsing
 
 use super::super::{Expression, FileOpenMode, Literal, ParseError, Parser, Statement};
+use super::database::DatabaseParser;
 use crate::lexer::token::Token;
 use crate::parser::expr::{ExprParser, PrimaryExprParser};
 use std::sync::Arc;
@@ -221,13 +222,17 @@ impl<'a> IoParser<'a> for Parser<'a> {
     fn parse_open_file_statement(&mut self) -> Result<Statement, ParseError> {
         let open_token = self.bump_sync().unwrap(); // Consume "open"
 
-        // Check if the next token is "file" or "url"
+        // Check if the next token is "file", "url", or "database"
         if let Some(next_token) = self.cursor.peek() {
             match next_token.token {
                 Token::KeywordFile => {
                     // Existing file handling
                     self.bump_sync(); // Consume "file"
                 }
+                Token::KeywordDatabase => {
+                    // "open database at <url> as <name>"
+                    return self.parse_open_database_statement(open_token.line, open_token.column);
+                }
                 Token::KeywordUrl => {
                     // New URL handling
                     self.bump_sync(); // Consume "url"
@@ -335,7 +340,7 @@ impl<'a> IoParser<'a> for Parser<'a> {
                 _ => {
                     return Err(ParseError::from_token(
                         format!(
-                            "Expected 'file' or 'url' after 'open', found {:?}",
+                            "Expected 'file', 'url', or 'database' after 'open', found {:?}",
                             next_token.token
                         ),
                         next_token,
diff --git a/src/parser/stmt/mod.rs b/src/parser/stmt/mod.rs
index 06687ae0..82b17041 100644
--- a/src/parser/stmt/mod.rs
+++ b/src/parser/stmt/mod.rs
@@ -9,6 +9,7 @@ mod actions;
 mod collections;
 mod containers;
 mod control_flow;
+mod database;
 mod errors;
 mod io;
 mod module;
@@ -22,6 +23,7 @@ pub(crate) use actions::ActionParser;
 pub(crate) use collections::CollectionParser;
 pub(crate) use containers::ContainerParser;
 pub(crate) use control_flow::ControlFlowParser;
+pub(crate) use database::DatabaseParser;
 pub(crate) use errors::ErrorHandlingParser;
 pub(crate) use io::IoParser;
 pub(crate) use module::ModuleParser;
@@ -50,6 +52,7 @@ pub(crate) trait StmtParser<'a>:
     + ActionParser<'a>
     + ErrorHandlingParser<'a>
     + ControlFlowParser<'a>
+    + DatabaseParser<'a>
     + PatternParser<'a>
     + ContainerParser<'a>
     + ModuleParser<'a>
diff --git a/src/parser/stmt/variables.rs b/src/parser/stmt/variables.rs
index 97805ba6..3040ce1a 100644
--- a/src/parser/stmt/variables.rs
+++ b/src/parser/stmt/variables.rs
@@ -1,6 +1,7 @@
 //! Variable declaration and assignment statement parsing
 
 use super::super::{Expression, Literal, Operator, ParseError, Parser, Statement};
+use super::database::DatabaseParser;
 use crate::lexer::token::{Token, TokenWithPosition};
 use crate::parser::expr::ExprParser;
 
@@ -98,6 +99,13 @@ impl<'a> VariableParser<'a> for Parser<'a> {
 
         self.bump_sync(); // Consume the 'as' token
 
+        // Database forms: "store <name> as query <db> with <sql> [and parameters <list>]"
+        // and the same with "execute". The strict lookahead (handle expression directly
+        // followed by 'with') keeps plain variables named "query" parsing as expressions.
+        if let Some(kind) = self.peek_database_query_kind() {
+            return self.parse_database_query_value(name, kind, token_pos.line, token_pos.column);
+        }
+
         let value = self.parse_expression()?;
 
         Ok(Statement::VariableDeclaration {
diff --git a/src/parser/stmt/web.rs b/src/parser/stmt/web.rs
index d96749cb..e7dc321b 100644
--- a/src/parser/stmt/web.rs
+++ b/src/parser/stmt/web.rs
@@ -68,7 +68,10 @@ impl<'a> WebParser<'a> for Parser<'a> {
                     if next_token.token == Token::KeywordStatus {
                         self.bump_sync(); // Consume "and"
                         self.bump_sync(); // Consume "status"
-                        status = Some(self.parse_expression()?);
+                        // Primary expression only: a full expression would
+                        // swallow a following "and content_type ..." clause
+                        // as a boolean operation.
+                        status = Some(self.parse_primary_expression()?);
                         continue;
                     } else if let Token::Identifier(id) = &next_token.token
                         && (id == "content_type" || id == "content")
@@ -85,7 +88,9 @@ impl<'a> WebParser<'a> for Parser<'a> {
                             self.bump_sync(); // Consume "type"
                         }
 
-                        content_type = Some(self.parse_expression()?);
+                        // Primary expression only, so a following "and
+                        // status ..." clause stays available.
+                        content_type = Some(self.parse_primary_expression()?);
                         continue;
                     }
                 }
diff --git a/src/stdlib/mod.rs b/src/stdlib/mod.rs
index b9e2763d..d769c2c9 100644
--- a/src/stdlib/mod.rs
+++ b/src/stdlib/mod.rs
@@ -11,6 +11,7 @@ pub mod random;
 pub mod text;
 pub mod time;
 pub mod typechecker;
+pub mod web;
 
 use crate::interpreter::environment::Environment;
 
@@ -25,4 +26,5 @@ pub fn register_stdlib(env: &mut Environment) {
     list::register_list(env);
     pattern::register(env);
     time::register_time(env);
+    web::register_web(env);
 }
diff --git a/src/stdlib/text.rs b/src/stdlib/text.rs
index c9591d6b..eb7d62c8 100644
--- a/src/stdlib/text.rs
+++ b/src/stdlib/text.rs
@@ -13,7 +13,7 @@ use std::sync::Arc;
 /// Decode percent-encoded URL string
 /// Converts '+' to space and decodes %HH hex sequences
 /// Invalid sequences are left as-is
-fn percent_decode(s: &str) -> Cow<'_, str> {
+pub(crate) fn percent_decode(s: &str) -> Cow<'_, str> {
     let bytes = s.as_bytes();
 
     // Optimization: avoid string allocation and decoding overhead if the string
diff --git a/src/stdlib/typechecker.rs b/src/stdlib/typechecker.rs
index a047d180..8ab5650d 100644
--- a/src/stdlib/typechecker.rs
+++ b/src/stdlib/typechecker.rs
@@ -37,6 +37,9 @@ pub fn register_stdlib_types(analyzer: &mut Analyzer) {
     register_parse_cookies(analyzer);
     register_parse_form_urlencoded(analyzer);
 
+    register_path_params(analyzer);
+    register_path_matches(analyzer);
+
     register_generate_uuid(analyzer);
     register_generate_csrf_token(analyzer);
 
@@ -354,6 +357,22 @@ fn register_parse_form_urlencoded(analyzer: &mut Analyzer) {
     analyzer.register_builtin_function("parse_form_urlencoded", param_types, return_type);
 }
 
+fn register_path_params(analyzer: &mut Analyzer) {
+    let param_types = vec![Type::Text, Type::Text]; // Request path, route template
+    // Returns an object of text captures, or nothing on no match; the map
+    // typing lets `params["id"]` typecheck cleanly.
+    let return_type = Type::Map(Box::new(Type::Text), Box::new(Type::Text));
+
+    analyzer.register_builtin_function("path_params", param_types, return_type);
+}
+
+fn register_path_matches(analyzer: &mut Analyzer) {
+    let param_types = vec![Type::Text, Type::Text]; // Request path, route template
+    let return_type = Type::Boolean;
+
+    analyzer.register_builtin_function("path_matches", param_types, return_type);
+}
+
 fn register_generate_uuid(analyzer: &mut Analyzer) {
     let param_types = vec![]; // No arguments
     let return_type = Type::Text; // Returns UUID string
diff --git a/src/stdlib/web.rs b/src/stdlib/web.rs
new file mode 100644
index 00000000..64c91b11
--- /dev/null
+++ b/src/stdlib/web.rs
@@ -0,0 +1,154 @@
+use super::helpers::{check_arg_count, expect_text};
+use super::text::percent_decode;
+use crate::interpreter::environment::Environment;
+use crate::interpreter::error::RuntimeError;
+use crate::interpreter::value::Value;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+/// Match a request path against a route template like "/users/:id".
+///
+/// Template segments:
+/// - `:name` captures a single path segment (percent-decoded)
+/// - `*name` as the final segment captures the rest of the path (at least one segment)
+/// - anything else must match the path segment literally
+///
+/// The query string portion of `path` is ignored. Empty segments from leading,
+/// trailing, or doubled slashes are skipped on both sides.
+///
+/// Returns `Some(captures)` on a match (empty map for parameterless templates),
+/// `None` otherwise.
+///
+/// Security: captured values are percent-decoded but otherwise untrusted —
+/// they can contain `..`, `.`, or (after decoding) path separators. Callers
+/// must validate captures before using them in filesystem paths, e.g. reject
+/// segments containing `..` or verify the resolved path stays inside an
+/// allowed base directory.
+fn match_path_template(path: &str, template: &str) -> Option<HashMap<String, Value>> {
+    let path = path.split(['?', '#']).next().unwrap_or("");
+
+    let path_segments: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
+    let template_segments: Vec<&str> = template.split('/').filter(|s| !s.is_empty()).collect();
+
+    let mut captures = HashMap::new();
+
+    for (i, tmpl_seg) in template_segments.iter().enumerate() {
+        if let Some(name) = tmpl_seg.strip_prefix('*') {
+            if i != template_segments.len() - 1 {
+                // Wildcard is only meaningful as the final segment
+                return None;
+            }
+            if i >= path_segments.len() {
+                return None;
+            }
+            let rest = path_segments[i..]
+                .iter()
+                .map(|s| percent_decode(s).into_owned())
+                .collect::<Vec<_>>()
+                .join("/");
+            captures.insert(name.to_string(), Value::Text(Arc::from(rest.as_str())));
+            return Some(captures);
+        }
+
+        let path_seg = path_segments.get(i)?;
+
+        if let Some(name) = tmpl_seg.strip_prefix(':') {
+            let decoded = percent_decode(path_seg);
+            captures.insert(name.to_string(), Value::Text(Arc::from(decoded.as_ref())));
+        } else if tmpl_seg != path_seg {
+            return None;
+        }
+    }
+
+    if path_segments.len() != template_segments.len() {
+        return None;
+    }
+
+    Some(captures)
+}
+
+/// path_params(path, template) -> Object of captures, or nothing when the path
+/// does not match the template.
+/// Usage: path_params of "/users/42" and "/users/:id" -> {"id": "42"}
+pub fn native_path_params(args: Vec<Value>) -> Result<Value, RuntimeError> {
+    check_arg_count("path_params", &args, 2)?;
+    let path = expect_text(&args[0])?;
+    let template = expect_text(&args[1])?;
+
+    match match_path_template(&path, &template) {
+        Some(captures) => Ok(Value::Object(Rc::new(RefCell::new(captures)))),
+        // Value::Null is the runtime value of WFL's `nothing` literal, so
+        // `check if params is nothing` works on a failed match.
+        None => Ok(Value::Null),
+    }
+}
+
+/// path_matches(path, template) -> boolean
+/// Usage: path_matches of "/users/42" and "/users/:id" -> yes
+pub fn native_path_matches(args: Vec<Value>) -> Result<Value, RuntimeError> {
+    check_arg_count("path_matches", &args, 2)?;
+    let path = expect_text(&args[0])?;
+    let template = expect_text(&args[1])?;
+
+    Ok(Value::Bool(match_path_template(&path, &template).is_some()))
+}
+
+pub fn register_web(env: &mut Environment) {
+    env.define_native("path_params", native_path_params);
+    env.define_native("path_matches", native_path_matches);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn matches_exact_path() {
+        let captures = match_path_template("/about", "/about").unwrap();
+        assert!(captures.is_empty());
+    }
+
+    #[test]
+    fn captures_single_segment() {
+        let captures = match_path_template("/users/42", "/users/:id").unwrap();
+        assert!(matches!(captures.get("id"), Some(Value::Text(t)) if t.as_ref() == "42"));
+    }
+
+    #[test]
+    fn rejects_segment_count_mismatch() {
+        assert!(match_path_template("/users", "/users/:id").is_none());
+        assert!(match_path_template("/users/1/2", "/users/:id").is_none());
+    }
+
+    #[test]
+    fn ignores_query_string_and_fragment() {
+        let captures = match_path_template("/users/42?page=2#top", "/users/:id").unwrap();
+        assert!(matches!(captures.get("id"), Some(Value::Text(t)) if t.as_ref() == "42"));
+    }
+
+    #[test]
+    fn percent_decodes_captured_segments() {
+        let captures = match_path_template("/users/John%20Doe", "/users/:name").unwrap();
+        assert!(matches!(captures.get("name"), Some(Value::Text(t)) if t.as_ref() == "John Doe"));
+    }
+
+    #[test]
+    fn wildcard_captures_remaining_segments() {
+        let captures = match_path_template("/static/css/main.css", "/static/*filepath").unwrap();
+        assert!(
+            matches!(captures.get("filepath"), Some(Value::Text(t)) if t.as_ref() == "css/main.css")
+        );
+    }
+
+    #[test]
+    fn wildcard_requires_at_least_one_segment() {
+        assert!(match_path_template("/static", "/static/*filepath").is_none());
+    }
+
+    #[test]
+    fn wildcard_must_be_final_segment() {
+        assert!(match_path_template("/a/b/c", "/a/*rest/c").is_none());
+    }
+}
diff --git a/src/transpiler/javascript.rs b/src/transpiler/javascript.rs
index e659dcb6..5602035f 100644
--- a/src/transpiler/javascript.rs
+++ b/src/transpiler/javascript.rs
@@ -608,6 +608,18 @@ impl JavaScriptTranspiler {
                 Ok(format!("{}// File closed (no-op in JS)\n", self.indent()))
             }
 
+            Statement::OpenDatabaseStatement { line, column, .. }
+            | Statement::DatabaseQueryStatement { line, column, .. }
+            | Statement::CloseDatabaseStatement { line, column, .. } => {
+                // Silently dropping database operations would produce broken
+                // JS, so fail like the other interpreter-only statements.
+                Err(TranspileError {
+                    message: "Database statements are not supported in JavaScript transpilation. They require the WFL interpreter.".to_string(),
+                    line: *line,
+                    column: *column,
+                })
+            }
+
             Statement::WriteContentStatement {
                 content, target, ..
             } => {
diff --git a/src/typechecker/mod.rs b/src/typechecker/mod.rs
index c5f4d813..76b23952 100644
--- a/src/typechecker/mod.rs
+++ b/src/typechecker/mod.rs
@@ -935,6 +935,109 @@ impl TypeChecker {
                     );
                 }
             }
+            Statement::OpenDatabaseStatement {
+                url,
+                variable_name,
+                line: _line,
+                column: _column,
+            } => {
+                let url_type = self.infer_expression_type(url);
+                if url_type != Type::Text && url_type != Type::Unknown && url_type != Type::Error {
+                    self.type_error(
+                        "Database URL must be a text string".to_string(),
+                        Some(Type::Text),
+                        Some(url_type),
+                        *_line,
+                        *_column,
+                    );
+                }
+
+                if let Some(symbol) = self.analyzer.get_symbol_mut(variable_name) {
+                    symbol.symbol_type = Some(Type::Custom("Database".to_string()));
+                }
+            }
+            Statement::DatabaseQueryStatement {
+                db,
+                sql,
+                parameters,
+                variable_name,
+                kind,
+                line: _line,
+                column: _column,
+            } => {
+                let db_type = self.infer_expression_type(db);
+                if db_type != Type::Custom("Database".to_string())
+                    && db_type != Type::Unknown
+                    && db_type != Type::Error
+                {
+                    self.type_error(
+                        "Expected a Database connection".to_string(),
+                        Some(Type::Custom("Database".to_string())),
+                        Some(db_type),
+                        *_line,
+                        *_column,
+                    );
+                }
+
+                let sql_type = self.infer_expression_type(sql);
+                if sql_type != Type::Text && sql_type != Type::Unknown && sql_type != Type::Error {
+                    self.type_error(
+                        "SQL statement must be a text string".to_string(),
+                        Some(Type::Text),
+                        Some(sql_type),
+                        *_line,
+                        *_column,
+                    );
+                }
+
+                if let Some(params) = parameters {
+                    let params_type = self.infer_expression_type(params);
+                    if !matches!(params_type, Type::List(_))
+                        && params_type != Type::Unknown
+                        && params_type != Type::Error
+                    {
+                        self.type_error(
+                            "Query parameters must be a list".to_string(),
+                            Some(Type::List(Box::new(Type::Any))),
+                            Some(params_type),
+                            *_line,
+                            *_column,
+                        );
+                    }
+                }
+
+                // Rows are objects keyed by column name; execute results are
+                // {affected_rows, last_insert_id}. Typing them as text-keyed
+                // maps lets downstream indexing typecheck cleanly.
+                let row_type = Type::Map(Box::new(Type::Text), Box::new(Type::Any));
+                if let Some(symbol) = self.analyzer.get_symbol_mut(variable_name) {
+                    symbol.symbol_type = Some(match kind {
+                        crate::parser::ast::DatabaseQueryKind::Query => {
+                            Type::List(Box::new(row_type))
+                        }
+                        crate::parser::ast::DatabaseQueryKind::Execute => row_type,
+                    });
+                }
+            }
+            Statement::CloseDatabaseStatement {
+                db,
+                line: _line,
+                column: _column,
+            } => {
+                let db_type = self.infer_expression_type(db);
+                if db_type != Type::Custom("Database".to_string())
+                    && db_type != Type::Unknown
+                    && db_type != Type::Error
+                {
+                    self.type_error(
+                        "Expected a Database connection".to_string(),
+                        Some(Type::Custom("Database".to_string())),
+                        Some(db_type),
+                        *_line,
+                        *_column,
+                    );
+                }
+            }
             Statement::CreateDirectoryStatement {
                 path,
                 line: _line,
diff --git a/tests/database_analyzer_test.rs b/tests/database_analyzer_test.rs
new file mode 100644
index 00000000..b7d6cda2
--- /dev/null
+++ b/tests/database_analyzer_test.rs
@@ -0,0 +1,106 @@
+// Regression tests: statements inside `wait for` that define a variable
+// (open database / query / execute / open file) must not be double-defined
+// by the analyzer. Previously the WaitForStatement arm pre-defined the
+// variable and the inner statement's own analysis defined it again, so
+// `wait for store rows as query db with ...` reported
+// "Variable 'rows' has already been defined".
+
+use wfl::analyzer::Analyzer;
+use wfl::analyzer::static_analyzer::StaticAnalyzer;
+use wfl::diagnostics::Severity;
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+
+fn analyze_errors(code: &str) -> Vec<String> {
+    let tokens = lex_wfl_with_positions(code);
+    let mut parser = Parser::new(&tokens);
+    let program = parser
+        .parse()
+        .unwrap_or_else(|e| panic!("Failed to parse {code:?}: {e:?}"));
+
+    let mut analyzer = Analyzer::new();
+    analyzer
+        .analyze_static(&program, 0)
+        .into_iter()
+        .filter(|d| d.severity == Severity::Error)
+        .map(|d| d.message)
+        .collect()
+}
+
+#[test]
+fn test_wait_for_query_does_not_double_define() {
+    let errors = analyze_errors(
+        r#"
+open database at "sqlite::memory:" as db
+wait for store rows as query db with "SELECT 1 AS x"
+display rows
+close database db
+"#,
+    );
+    assert!(
+        errors.is_empty(),
+        "wait for query should not produce analyzer errors: {errors:?}"
+    );
+}
+
+#[test]
+fn test_wait_for_execute_does_not_double_define() {
+    let errors = analyze_errors(
+        r#"
+open database at "sqlite::memory:" as db
+wait for store result as execute db with "CREATE TABLE t (x INTEGER)"
+display result
+close database db
+"#,
+    );
+    assert!(
+        errors.is_empty(),
+        "wait for execute should not produce analyzer errors: {errors:?}"
+    );
+}
+
+#[test]
+fn test_wait_for_open_database_does_not_double_define() {
+    let errors = analyze_errors(
+        r#"
+wait for open database at "sqlite::memory:" as db
+close database db
+"#,
+    );
+    assert!(
+        errors.is_empty(),
+        "wait for open database should not produce analyzer errors: {errors:?}"
+    );
+}
+
+#[test]
+fn test_wait_for_open_file_does_not_double_define() {
+    // Pre-existing instance of the same bug, fixed together.
+    let errors = analyze_errors(
+        r#"
+wait for open file at "t.txt" for writing as fh
+close file fh
+"#,
+    );
+    assert!(
+        errors.is_empty(),
+        "wait for open file should not produce analyzer errors: {errors:?}"
+    );
+}
+
+#[test]
+fn test_duplicate_definition_still_detected() {
+    // Removing the pre-define must not stop real duplicates being caught.
+    let errors = analyze_errors(
+        r#"
+store rows as 1
+store rows as 2
+"#,
+    );
+    assert!(
+        errors
+            .iter()
+            .any(|message| message.contains("already been defined")),
+        "Real duplicate definitions must still error: {errors:?}"
+    );
+}
diff --git a/tests/database_parser_test.rs b/tests/database_parser_test.rs
new file mode 100644
index 00000000..76afe4a0
--- /dev/null
+++ b/tests/database_parser_test.rs
@@ -0,0 +1,209 @@
+// TDD parser tests for the database statement syntax.
+// Written before the parser implementation.
+
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+use wfl::parser::ast::{DatabaseQueryKind, Statement};
+
+fn parse(code: &str) -> Vec<Statement> {
+    let tokens = lex_wfl_with_positions(code);
+    let mut parser = Parser::new(&tokens);
+    parser
+        .parse()
+        .unwrap_or_else(|e| panic!("Failed to parse {code:?}: {e:?}"))
+        .statements
+}
+
+fn parse_single(code: &str) -> Statement {
+    let mut statements = parse(code);
+    assert_eq!(statements.len(), 1, "Expected one statement for {code:?}");
+    statements.remove(0)
+}
+
+#[test]
+fn test_open_database_statement() {
+    let stmt = parse_single(r#"open database at "sqlite://./app.db" as db"#);
+    match stmt {
+        Statement::OpenDatabaseStatement { variable_name, .. } => {
+            assert_eq!(variable_name, "db");
+        }
+        other => panic!("Expected OpenDatabaseStatement, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_connect_to_database_statement() {
+    let stmt = parse_single(r#"connect to database at "postgres://localhost/mydb" as db"#);
+    match stmt {
+        Statement::OpenDatabaseStatement { variable_name, .. } => {
+            assert_eq!(variable_name, "db");
+        }
+        other => panic!("Expected OpenDatabaseStatement, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_query_statement_without_parameters() {
+    let stmt = parse_single(r#"store users as query db with "SELECT * FROM users""#);
+    match stmt {
+        Statement::DatabaseQueryStatement {
+            variable_name,
+            parameters,
+            kind,
+            ..
+        } => {
+            assert_eq!(variable_name, "users");
+            assert!(parameters.is_none());
+            assert_eq!(kind, DatabaseQueryKind::Query);
+        }
+        other => panic!("Expected DatabaseQueryStatement, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_query_statement_with_parameters() {
+    let stmt = parse_single(
+        r#"store users as query db with "SELECT * FROM users WHERE age > ?" and parameters [21]"#,
+    );
+    match stmt {
+        Statement::DatabaseQueryStatement {
+            variable_name,
+            parameters,
+            kind,
+            ..
+        } => {
+            assert_eq!(variable_name, "users");
+            assert!(parameters.is_some());
+            assert_eq!(kind, DatabaseQueryKind::Query);
+        }
+        other => panic!("Expected DatabaseQueryStatement, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_execute_statement_without_parameters() {
+    let stmt = parse_single(r#"store result as execute db with "DELETE FROM users""#);
+    match stmt {
+        Statement::DatabaseQueryStatement {
+            variable_name,
+            parameters,
+            kind,
+            ..
+        } => {
+            assert_eq!(variable_name, "result");
+            assert!(parameters.is_none());
+            assert_eq!(kind, DatabaseQueryKind::Execute);
+        }
+        other => panic!("Expected DatabaseQueryStatement, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_execute_statement_with_parameters() {
+    let stmt = parse_single(
+        r#"store result as execute db with "INSERT INTO users (name) VALUES (?)" and parameters [user_name]"#,
+    );
+    match stmt {
+        Statement::DatabaseQueryStatement {
+            parameters, kind, ..
+        } => {
+            assert!(parameters.is_some());
+            assert_eq!(kind, DatabaseQueryKind::Execute);
+        }
+        other => panic!("Expected DatabaseQueryStatement, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_close_database_statement() {
+    let stmt = parse_single("close database db");
+    assert!(
+        matches!(stmt, Statement::CloseDatabaseStatement { .. }),
+        "Expected CloseDatabaseStatement, got {stmt:?}"
+    );
+}
+
+#[test]
+fn test_query_inside_wait_for() {
+    let stmt = parse_single(r#"wait for store users as query db with "SELECT * FROM users""#);
+    match stmt {
+        Statement::WaitForStatement { inner, .. } => {
+            assert!(
+                matches!(*inner, Statement::DatabaseQueryStatement { .. }),
+                "Expected DatabaseQueryStatement inside wait for, got {inner:?}"
+            );
+        }
+        other => panic!("Expected WaitForStatement, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_open_database_inside_wait_for() {
+    let stmt = parse_single(r#"wait for open database at "sqlite://./app.db" as db"#);
+    match stmt {
+        Statement::WaitForStatement { inner, .. } => {
+            assert!(matches!(*inner, Statement::OpenDatabaseStatement { .. }));
+        }
+        other => panic!("Expected WaitForStatement, got {other:?}"),
+    }
+}
+
+// === Backward compatibility characterization ===
+
+#[test]
+fn test_variable_named_query_still_works() {
+    // `query` is a plain identifier; storing and copying it must keep parsing
+    // as ordinary variable use.
+    let statements = parse(
+        r#"
+store query as "SELECT 1"
+store copy as query
+display copy
+"#,
+    );
+    assert_eq!(statements.len(), 3);
+    assert!(matches!(
+        &statements[1],
+        Statement::VariableDeclaration { name, .. } if name == "copy"
+    ));
+}
+
+#[test]
+fn test_variable_named_query_in_concatenation() {
+    // `store x as query with "..."` would be ambiguous with the DB form only if
+    // the db-handle position is missing; concatenation directly after `query`
+    // must keep working.
+    let stmt = parse_single(r#"store message as query with " suffix""#);
+    assert!(
+        matches!(&stmt, Statement::VariableDeclaration { name, .. } if name == "message"),
+        "Expected VariableDeclaration, got {stmt:?}"
+    );
+}
+
+#[test]
+fn test_open_file_statement_unchanged() {
+    let stmt = parse_single(r#"open file at "data.txt" for reading as f"#);
+    assert!(matches!(stmt, Statement::OpenFileStatement { .. }));
+}
+
+#[test]
+fn test_close_file_statement_unchanged() {
+    let stmt = parse_single("close file f");
+    assert!(matches!(stmt, Statement::CloseFileStatement { .. }));
+}
+
+#[test]
+fn test_execute_command_statement_unchanged() {
+    let stmt = parse_single(r#"wait for execute command "echo hi" as cmd_result"#);
+    fn contains_database_statement(stmt: &Statement) -> bool {
+        match stmt {
+            Statement::DatabaseQueryStatement { .. } => true,
+            Statement::WaitForStatement { inner, .. } => contains_database_statement(inner),
+            _ => false,
+        }
+    }
+    assert!(
+        !contains_database_statement(&stmt),
+        "execute command must not become a database statement: {stmt:?}"
+    );
+}
diff --git a/tests/database_test.rs b/tests/database_test.rs
new file mode 100644
index 00000000..21626350
--- /dev/null
+++ b/tests/database_test.rs
@@ -0,0 +1,397 @@
+// TDD tests for the database runtime (sqlx bindings).
+//
+// SQLite tests run everywhere with no external services. PostgreSQL and
+// MariaDB tests are gated on WFL_TEST_POSTGRES_URL / WFL_TEST_MYSQL_URL and
+// skip with a notice when unset (same pattern as WFLHASH_HEAVY_TESTS).
+
+use std::path::PathBuf;
+use wfl::interpreter::Interpreter;
+use wfl::interpreter::value::Value;
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+
+/// Run WFL code and return the interpreter for inspecting globals.
+async fn run_wfl(code: &str) -> Result<Interpreter, String> {
+    let tokens = lex_wfl_with_positions(code);
+    let mut parser = Parser::new(&tokens);
+    let ast = parser
+        .parse()
+        .map_err(|e| format!("Parse error: {:?}", e))?;
+
+    let mut interpreter = Interpreter::new();
+    interpreter
+        .interpret(&ast)
+        .await
+        .map_err(|e| format!("Runtime error: {:?}", e))?;
+    Ok(interpreter)
+}
+
+fn get_global(interpreter: &Interpreter, name: &str) -> Value {
+    interpreter
+        .global_env()
+        .borrow()
+        .get(name)
+        .unwrap_or_else(|| panic!("Variable '{name}' not found"))
+}
+
+fn expect_number(value: &Value) -> f64 {
+    match value {
+        Value::Number(n) => *n,
+        other => panic!("Expected number, got {other:?}"),
+    }
+}
+
+fn expect_text(value: &Value) -> String {
+    match value {
+        Value::Text(t) => t.to_string(),
+        other => panic!("Expected text, got {other:?}"),
+    }
+}
+
+fn expect_object_key(value: &Value, key: &str) -> Value {
+    match value {
+        Value::Object(obj) => obj
+            .borrow()
+            .get(key)
+            .cloned()
+            .unwrap_or_else(|| panic!("Object missing key '{key}'")),
+        other => panic!("Expected object, got {other:?}"),
+    }
+}
+
+fn expect_list(value: &Value) -> Vec<Value> {
+    match value {
+        Value::List(list) => list.borrow().clone(),
+        other => panic!("Expected list, got {other:?}"),
+    }
+}
+
+/// Unique temp-file SQLite URL per test (forward slashes for WFL strings).
+fn sqlite_url(test_name: &str) -> (String, PathBuf) {
+    let path = std::env::temp_dir().join(format!(
+        "wfl_db_test_{}_{}.db",
+        test_name,
+        std::process::id()
+    ));
+    let _ = std::fs::remove_file(&path);
+    let url = format!("sqlite://{}", path.display()).replace('\\', "/");
+    (url, path)
+}
+
+mod sqlite_tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_create_insert_select_roundtrip() {
+        let (url, path) = sqlite_url("roundtrip");
+        let code = format!(
+            r#"
+open database at "{url}" as db
+store created as execute db with "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)"
+store inserted as execute db with "INSERT INTO users (name, age) VALUES (?, ?)" and parameters ["Alice" and 30]
+store rows as query db with "SELECT id, name, age FROM users"
+close database db
+"#
+        );
+        let interpreter = run_wfl(&code).await.expect("program should run");
+
+        let inserted = get_global(&interpreter, "inserted");
+        assert_eq!(
+            expect_number(&expect_object_key(&inserted, "affected_rows")),
+            1.0
+        );
+        assert_eq!(
+            expect_number(&expect_object_key(&inserted, "last_insert_id")),
+            1.0
+        );
+
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        assert_eq!(rows.len(), 1);
+        assert_eq!(expect_text(&expect_object_key(&rows[0], "name")), "Alice");
+        assert_eq!(expect_number(&expect_object_key(&rows[0], "age")), 30.0);
+        assert_eq!(expect_number(&expect_object_key(&rows[0], "id")), 1.0);
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[tokio::test]
+    async fn test_in_memory_database() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+store created as execute db with "CREATE TABLE t (x INTEGER)"
+store inserted as execute db with "INSERT INTO t (x) VALUES (?)" and parameters [42]
+store rows as query db with "SELECT x FROM t"
+close database db
+"#;
+        let interpreter = run_wfl(code).await.expect("program should run");
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        assert_eq!(rows.len(), 1);
+        assert_eq!(expect_number(&expect_object_key(&rows[0], "x")), 42.0);
+    }
+
+    #[tokio::test]
+    async fn test_null_becomes_nothing() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+store created as execute db with "CREATE TABLE t (x INTEGER, y TEXT)"
+store inserted as execute db with "INSERT INTO t (x, y) VALUES (1, NULL)"
+store rows as query db with "SELECT x, y FROM t"
+close database db
+"#;
+        let interpreter = run_wfl(code).await.expect("program should run");
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        let y = expect_object_key(&rows[0], "y");
+        assert!(
+            matches!(y, Value::Null),
+            "SQL NULL should map to nothing, got {y:?}"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_bound_parameters_resist_injection() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+store created as execute db with "CREATE TABLE users (name TEXT)"
+store evil as "x'; DROP TABLE users;--"
+store inserted as execute db with "INSERT INTO users (name) VALUES (?)" and parameters [evil]
+store rows as query db with "SELECT name FROM users"
+store still_there as query db with "SELECT count(*) AS n FROM users"
+close database db
+"#;
+        let interpreter = run_wfl(code).await.expect("program should run");
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        assert_eq!(
+            expect_text(&expect_object_key(&rows[0], "name")),
+            "x'; DROP TABLE users;--",
+            "Bound parameter must be stored literally"
+        );
+        let still = expect_list(&get_global(&interpreter, "still_there"));
+        assert_eq!(expect_number(&expect_object_key(&still[0], "n")), 1.0);
+    }
+
+    #[tokio::test]
+    async fn test_update_affected_rows() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+store created as execute db with "CREATE TABLE t (x INTEGER)"
+store i1 as execute db with "INSERT INTO t (x) VALUES (1)"
+store i2 as execute db with "INSERT INTO t (x) VALUES (2)"
+store updated as execute db with "UPDATE t SET x = x + 10"
+close database db
+"#;
+        let interpreter = run_wfl(code).await.expect("program should run");
+        let updated = get_global(&interpreter, "updated");
+        assert_eq!(
+            expect_number(&expect_object_key(&updated, "affected_rows")),
+            2.0
+        );
+    }
+
+    #[tokio::test]
+    async fn test_real_and_bool_types() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+store created as execute db with "CREATE TABLE t (price REAL, active BOOLEAN)"
+store inserted as execute db with "INSERT INTO t (price, active) VALUES (?, ?)" and parameters [9.5 and yes]
+store rows as query db with "SELECT price, active FROM t"
+close database db
+"#;
+        let interpreter = run_wfl(code).await.expect("program should run");
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        assert_eq!(expect_number(&expect_object_key(&rows[0], "price")), 9.5);
+        let active = expect_object_key(&rows[0], "active");
+        assert!(
+            matches!(active, Value::Bool(true) | Value::Number(_)),
+            "BOOLEAN column should decode as a boolean-ish value, got {active:?}"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_wait_for_query_form() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+store created as execute db with "CREATE TABLE t (x INTEGER)"
+store inserted as execute db with "INSERT INTO t (x) VALUES (7)"
+wait for store rows as query db with "SELECT x FROM t"
+close database db
+"#;
+        let interpreter = run_wfl(code).await.expect("program should run");
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        assert_eq!(expect_number(&expect_object_key(&rows[0], "x")), 7.0);
+    }
+
+    #[tokio::test]
+    async fn test_connect_to_database_alias() {
+        let code = r#"
+connect to database at "sqlite::memory:" as db
+store created as execute db with "CREATE TABLE t (x INTEGER)"
+close database db
+"#;
+        run_wfl(code)
+            .await
+            .expect("connect to database should work");
+    }
+
+    #[tokio::test]
+    async fn test_bad_scheme_is_catchable() {
+        let code = r#"
+store result as "no error"
+try:
+    open database at "oracle://localhost/db" as db
+when error:
+    store result as "caught"
+end try
+"#;
+        let interpreter = run_wfl(code).await.expect("error should be catchable");
+        assert_eq!(expect_text(&get_global(&interpreter, "result")), "caught");
+    }
+
+    #[tokio::test]
+    async fn test_malformed_sql_is_catchable() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+store result as "no error"
+try:
+    store rows as query db with "SELEKT * FROM nowhere"
+when error:
+    store result as "caught"
+end try
+close database db
+"#;
+        let interpreter = run_wfl(code).await.expect("error should be catchable");
+        assert_eq!(expect_text(&get_global(&interpreter, "result")), "caught");
+    }
+
+    #[tokio::test]
+    async fn test_unknown_handle_errors() {
+        let code = r#"
+store result as "no error"
+try:
+    store rows as query missing_db with "SELECT 1"
+when error:
+    store result as "caught"
+end try
+"#;
+        let interpreter = run_wfl(code).await.expect("error should be catchable");
+        assert_eq!(expect_text(&get_global(&interpreter, "result")), "caught");
+    }
+
+    #[tokio::test]
+    async fn test_query_after_close_errors() {
+        let code = r#"
+open database at "sqlite::memory:" as db
+close database db
+store result as "no error"
+try:
+    store rows as query db with "SELECT 1"
+when error:
+    store result as "caught"
+end try
+"#;
+        let interpreter = run_wfl(code).await.expect("error should be catchable");
+        assert_eq!(expect_text(&get_global(&interpreter, "result")), "caught");
+    }
+}
+
+mod gated_backend_tests {
+    use super::*;
+
+    async fn run_crud_matrix(url: &str, placeholder: &dyn Fn(usize) -> String) {
+        let table = format!("wfl_test_{}", std::process::id());
+        let p1 = placeholder(1);
+        let p2 = placeholder(2);
+        let code = format!(
+            r#"
+open database at "{url}" as db
+store dropped as execute db with "DROP TABLE IF EXISTS {table}"
+store created as execute db with "CREATE TABLE {table} (id INTEGER, name VARCHAR(100), active BOOLEAN)"
+store inserted as execute db with "INSERT INTO {table} (id, name, active) VALUES ({p1}, {p2}, TRUE)" and parameters [7 and "Bob"]
+store rows as query db with "SELECT id, name, active FROM {table}"
+store cleaned as execute db with "DROP TABLE {table}"
+close database db
+"#
+        );
+        let interpreter = run_wfl(&code).await.expect("program should run");
+
+        let inserted = get_global(&interpreter, "inserted");
+        assert_eq!(
+            expect_number(&expect_object_key(&inserted, "affected_rows")),
+            1.0
+        );
+
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        assert_eq!(rows.len(), 1);
+        assert_eq!(expect_number(&expect_object_key(&rows[0], "id")), 7.0);
+        assert_eq!(expect_text(&expect_object_key(&rows[0], "name")), "Bob");
+        let active = expect_object_key(&rows[0], "active");
+        assert!(
+            matches!(active, Value::Bool(true) | Value::Number(_)),
+            "BOOLEAN should decode as a boolean-ish value, got {active:?}"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_postgres_crud() {
+        let Ok(url) = std::env::var("WFL_TEST_POSTGRES_URL") else {
+            println!("Skipping PostgreSQL test: WFL_TEST_POSTGRES_URL not set");
+            return;
+        };
+        run_crud_matrix(&url, &|n| format!("${n}")).await;
+    }
+
+    #[tokio::test]
+    async fn test_postgres_returning_clause() {
+        let Ok(url) = std::env::var("WFL_TEST_POSTGRES_URL") else {
+            println!("Skipping PostgreSQL test: WFL_TEST_POSTGRES_URL not set");
+            return;
+        };
+        let table = format!("wfl_ret_{}", std::process::id());
+        let code = format!(
+            r#"
+open database at "{url}" as db
+store dropped as execute db with "DROP TABLE IF EXISTS {table}"
+store created as execute db with "CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT)"
+store rows as query db with "INSERT INTO {table} (name) VALUES ($1) RETURNING id" and parameters ["Carol"]
+store cleaned as execute db with "DROP TABLE {table}"
+close database db
+"#
+        );
+        let interpreter = run_wfl(&code).await.expect("program should run");
+        let rows = expect_list(&get_global(&interpreter, "rows"));
+        assert_eq!(expect_number(&expect_object_key(&rows[0], "id")), 1.0);
+    }
+
+    #[tokio::test]
+    async fn test_mariadb_crud() {
+        let Ok(url) = std::env::var("WFL_TEST_MYSQL_URL") else {
+            println!("Skipping MariaDB test: WFL_TEST_MYSQL_URL not set");
+            return;
+        };
+        run_crud_matrix(&url, &|_| "?".to_string()).await;
+    }
+
+    #[tokio::test]
+    async fn test_mariadb_last_insert_id() {
+        let Ok(url) = std::env::var("WFL_TEST_MYSQL_URL") else {
+            println!("Skipping MariaDB test: WFL_TEST_MYSQL_URL not set");
+            return;
+        };
+        let table = format!("wfl_lid_{}", std::process::id());
+        let code = format!(
+            r#"
+open database at "{url}" as db
+store dropped as execute db with "DROP TABLE IF EXISTS {table}"
+store created as execute db with "CREATE TABLE {table} (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)"
+store inserted as execute db with "INSERT INTO {table} (name) VALUES (?)" and parameters ["Dave"]
+store cleaned as execute db with "DROP TABLE {table}"
+close database db
+"#
+        );
+        let interpreter = run_wfl(&code).await.expect("program should run");
+        let inserted = get_global(&interpreter, "inserted");
+        assert_eq!(
+            expect_number(&expect_object_key(&inserted, "last_insert_id")),
+            1.0
+        );
+    }
+}
diff --git a/tests/header_access_runtime_test.rs b/tests/header_access_runtime_test.rs
new file mode 100644
index 00000000..82ad0311
--- /dev/null
+++ b/tests/header_access_runtime_test.rs
@@ -0,0 +1,90 @@
+// Regression test for header access against a real HTTP request.
+// HTTP header names are case-insensitive and warp normalizes them to
+// lowercase, so `header "User-Agent" of req` must find the "user-agent"
+// entry. Previously the lookup was exact-match and returned nothing for
+// every canonically-spelled header name.
+
+use std::time::Duration;
+use wfl::Interpreter;
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+
+fn start_server_thread(code: String) -> std::thread::JoinHandle<()> {
+    std::thread::spawn(move || {
+        let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime");
+        rt.block_on(async {
+            let tokens = lex_wfl_with_positions(&code);
+            let mut parser = Parser::new(&tokens);
+            let ast = parser.parse().expect("Failed to parse WFL code");
+            let mut interpreter = Interpreter::new();
+            let _ = interpreter.interpret(&ast).await;
+        });
+    })
+}
+
+#[tokio::test]
+async fn test_header_access_is_case_insensitive() {
+    let port = 8121;
+    let server_code = format!(
+        r#"
+        listen on port {port} as test_server
+        wait for request comes in on test_server as req with timeout 10000
+        store agent as header "User-Agent" of req
+        store agent_text as "Agent: " with agent
+        respond to req with agent_text
+        close server test_server
+    "#
+    );
+
+    let server_handle = start_server_thread(server_code);
+    tokio::time::sleep(Duration::from_millis(300)).await;
+
+    let client = reqwest::Client::new();
+    let response = client
+        .get(format!("http://127.0.0.1:{port}/"))
+        .header("User-Agent", "wfl-header-test")
+        .send()
+        .await
+        .expect("Failed to send request");
+
+    let body = response.text().await.expect("Failed to read body");
+    assert_eq!(
+        body, "Agent: wfl-header-test",
+        "header \"User-Agent\" should resolve the lowercase 'user-agent' entry"
+    );
+
+    let _ = server_handle.join();
+}
+
+#[tokio::test]
+async fn test_missing_header_is_nothing() {
+    let port = 8122;
+    let server_code = format!(
+        r#"
+        listen on port {port} as test_server
+        wait for request comes in on test_server as req with timeout 10000
+        store custom as header "X-Custom-Header" of req
+        check if custom is nothing:
+            respond to req with "missing"
+        otherwise:
+            respond to req with "present"
+        end check
+        close server test_server
+    "#
+    );
+
+    let server_handle = start_server_thread(server_code);
+    tokio::time::sleep(Duration::from_millis(300)).await;
+
+    let client = reqwest::Client::new();
+    let response = client
+        .get(format!("http://127.0.0.1:{port}/"))
+        .send()
+        .await
+        .expect("Failed to send request");
+
+    let body = response.text().await.expect("Failed to read body");
+    assert_eq!(body, "missing", "absent header should compare as nothing");
+
+    let _ = server_handle.join();
+}
diff --git a/tests/main_loop_parser_test.rs b/tests/main_loop_parser_test.rs
index cc0f192f..35aeaed1 100644
--- a/tests/main_loop_parser_test.rs
+++ b/tests/main_loop_parser_test.rs
@@ -76,6 +76,70 @@ fn test_parse_main_loop_multiple_statements() {
     );
 }
 
+/// Regression test for Docs/Archive/FRAMEWORK_FINAL_REPORT.md, which reported
+/// "Unexpected end of line in expression" for `wait for request comes in on
+/// <server> as <req>` and parsing issues for try/catch in the main request loop.
+#[test]
+fn test_parse_web_request_loop_with_try_catch() {
+    use wfl::lexer::lex_wfl_with_positions;
+    use wfl::parser::Parser;
+
+    let source = r#"
+        listen on port 8080 as web_server
+        main loop:
+            try:
+                wait for request comes in on web_server as req
+                respond to req with "ok" and content_type "text/plain"
+            when error:
+                display "request failed"
+            end try
+        end loop
+    "#;
+
+    let tokens = lex_wfl_with_positions(source);
+    let mut parser = Parser::new(&tokens);
+    let result = parser.parse();
+
+    assert!(
+        result.is_ok(),
+        "Should parse try/when error around wait-for-request inside main loop: {:?}",
+        result.err()
+    );
+}
+
+/// Same shape with catch-style error handling and a request property access.
+#[test]
+fn test_parse_web_request_loop_with_catch_and_properties() {
+    use wfl::lexer::lex_wfl_with_positions;
+    use wfl::parser::Parser;
+
+    let source = r#"
+        listen on port 8081 as web_server
+        store request_count as 0
+        main loop:
+            try:
+                wait for request comes in on web_server as req
+                change request_count to request_count plus 1
+                store request_path as path of req
+                store agent as header "User-Agent" of req
+                respond to req with request_path and content_type "text/plain"
+            catch:
+                display "request failed"
+            end try
+        end loop
+    "#;
+
+    let tokens = lex_wfl_with_positions(source);
+    let mut parser = Parser::new(&tokens);
+    let result = parser.parse();
+
+    assert!(
+        result.is_ok(),
+        "Should parse catch around request handling with property and header access: {:?}",
+        result.err()
+    );
+}
+
 #[test]
 fn test_parse_nested_try_in_main_loop() {
     use wfl::lexer::lex_wfl_with_positions;
diff --git a/tests/respond_statement_parser_test.rs b/tests/respond_statement_parser_test.rs
new file mode 100644
index 00000000..af7a82ec
--- /dev/null
+++ b/tests/respond_statement_parser_test.rs
@@ -0,0 +1,125 @@
+// Regression tests for parsing `respond to ... with ... and status ... and
+// content_type ...`. The status/content_type values must be parsed as primary
+// expressions; previously `and status 404 and content_type "text/plain"`
+// parsed the status as the boolean expression `404 and content_type`, which
+// failed at runtime (undefined variable `content_type`) and left the HTTP
+// request unanswered.
+
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+use wfl::parser::ast::{Expression, Literal, Statement};
+
+fn parse_respond(code: &str) -> Statement {
+    let tokens = lex_wfl_with_positions(code);
+    let mut parser = Parser::new(&tokens);
+    let program = parser
+        .parse()
+        .unwrap_or_else(|e| panic!("Failed to parse {code:?}: {e:?}"));
+    program
+        .statements
+        .into_iter()
+        .find(|s| matches!(s, Statement::RespondStatement { .. }))
+        .expect("No RespondStatement found")
+}
+
+fn assert_integer(expr: &Expression, expected: i64, what: &str) {
+    match expr {
+        Expression::Literal(Literal::Integer(n), ..) => {
+            assert_eq!(*n, expected, "{what} literal mismatch")
+        }
+        other => panic!("{what} should be an integer literal, got {other:?}"),
+    }
+}
+
+fn assert_string(expr: &Expression, expected: &str, what: &str) {
+    match expr {
+        Expression::Literal(Literal::String(s), ..) => {
+            assert_eq!(s.as_ref(), expected, "{what} literal mismatch")
+        }
+        other => panic!("{what} should be a string literal, got {other:?}"),
+    }
+}
+
+#[test]
+fn test_respond_with_status_then_content_type() {
+    let stmt = parse_respond(
+        r#"respond to req with "Not Found" and status 404 and content_type "text/plain""#,
+    );
+    match stmt {
+        Statement::RespondStatement {
+            status,
+            content_type,
+            ..
+        } => {
+            assert_integer(&status.expect("status missing"), 404, "status");
+            assert_string(
+                &content_type.expect("content_type missing"),
+                "text/plain",
+                "content_type",
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn test_respond_with_content_type_then_status() {
+    let stmt = parse_respond(
+        r#"respond to req with "Created" and content_type "application/json" and status 201"#,
+    );
+    match stmt {
+        Statement::RespondStatement {
+            status,
+            content_type,
+            ..
+        } => {
+            assert_integer(&status.expect("status missing"), 201, "status");
+            assert_string(
+                &content_type.expect("content_type missing"),
+                "application/json",
+                "content_type",
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn test_respond_with_status_only() {
+    let stmt = parse_respond(r#"respond to req with "" and status 204"#);
+    match stmt {
+        Statement::RespondStatement {
+            status,
+            content_type,
+            ..
+        } => {
+            assert_integer(&status.expect("status missing"), 204, "status");
+            assert!(content_type.is_none());
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn test_respond_with_variable_status() {
+    let stmt = parse_respond(
+        r#"
+store code as 404
+respond to req with "Not Found" and status code and content_type "text/plain"
+"#,
+    );
+    match stmt {
+        Statement::RespondStatement {
+            status,
+            content_type,
+            ..
+        } => {
+            assert!(
+                matches!(status, Some(Expression::Variable(ref name, ..)) if name == "code"),
+                "status should be the variable 'code', got {status:?}"
+            );
+            assert!(content_type.is_some());
+        }
+        _ => unreachable!(),
+    }
+}
diff --git a/tests/route_params_test.rs b/tests/route_params_test.rs
new file mode 100644
index 00000000..6b1f42a0
--- /dev/null
+++ b/tests/route_params_test.rs
@@ -0,0 +1,212 @@
+// TDD tests for web route parameter helpers: path_params and path_matches
+// These tests are written before the implementation (stdlib/web.rs).
+
+use wfl::interpreter::Interpreter;
+use wfl::interpreter::value::Value;
+use wfl::lexer::lex_wfl_with_positions;
+use wfl::parser::Parser;
+
+#[cfg(test)]
+mod route_param_tests {
+    use super::*;
+
+    /// Run WFL code and return the value of the `result` variable.
+    async fn run_wfl_code(code: &str) -> Result<Value, String> {
+        let tokens = lex_wfl_with_positions(code);
+        let mut parser = Parser::new(&tokens);
+        let ast = parser
+            .parse()
+            .map_err(|e| format!("Parse error: {:?}", e))?;
+
+        let mut interpreter = Interpreter::new();
+        let _ = interpreter
+            .interpret(&ast)
+            .await
+            .map_err(|e| format!("Runtime error: {:?}", e))?;
+
+        if let Some(result_value) = interpreter.global_env().borrow().get("result") {
+            Ok(result_value)
+        } else {
+            Err("Variable 'result' not found after execution".to_string())
+        }
+    }
+
+    fn expect_object_key(value: &Value, key: &str) -> Value {
+        match value {
+            Value::Object(obj) => obj
+                .borrow()
+                .get(key)
+                .cloned()
+                .unwrap_or_else(|| panic!("Object missing key '{key}'")),
+            other => panic!("Expected object, got {other:?}"),
+        }
+    }
+
+    fn expect_text(value: &Value) -> String {
+        match value {
+            Value::Text(t) => t.to_string(),
+            other => panic!("Expected text, got {other:?}"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_path_params_single_capture() {
+        let code = r#"
+            store result as path_params of "/users/42" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        let id = expect_object_key(&result, "id");
+        assert_eq!(expect_text(&id), "42");
+    }
+
+    #[tokio::test]
+    async fn test_path_params_multiple_captures() {
+        let code = r#"
+            store result as path_params of "/users/42/posts/7" and "/users/:user_id/posts/:post_id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert_eq!(expect_text(&expect_object_key(&result, "user_id")), "42");
+        assert_eq!(expect_text(&expect_object_key(&result, "post_id")), "7");
+    }
+
+    #[tokio::test]
+    async fn test_path_params_no_match_returns_nothing() {
+        let code = r#"
+            store result as path_params of "/posts/42" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert!(
+            matches!(result, Value::Null),
+            "Non-matching path should return nothing, got {result:?}"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_path_params_segment_count_mismatch() {
+        // Too few segments
+        let code = r#"
+            store result as path_params of "/users" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert!(matches!(result, Value::Null));
+
+        // Too many segments
+        let code = r#"
+            store result as path_params of "/users/1/extra" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert!(matches!(result, Value::Null));
+    }
+
+    #[tokio::test]
+    async fn test_path_params_exact_match_returns_empty_object() {
+        let code = r#"
+            store result as path_params of "/about" and "/about"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        match &result {
+            Value::Object(obj) => assert!(obj.borrow().is_empty()),
+            other => panic!("Exact match should return empty object, got {other:?}"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_path_params_trailing_slash_tolerated() {
+        let code = r#"
+            store result as path_params of "/users/42/" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert_eq!(expect_text(&expect_object_key(&result, "id")), "42");
+    }
+
+    #[tokio::test]
+    async fn test_path_params_strips_query_string() {
+        let code = r#"
+            store result as path_params of "/users/42?page=2&limit=10" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert_eq!(expect_text(&expect_object_key(&result, "id")), "42");
+    }
+
+    #[tokio::test]
+    async fn test_path_params_percent_decodes_captures() {
+        let code = r#"
+            store result as path_params of "/users/John%20Doe" and "/users/:name"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert_eq!(expect_text(&expect_object_key(&result, "name")), "John Doe");
+    }
+
+    #[tokio::test]
+    async fn test_path_params_wildcard_tail() {
+        let code = r#"
+            store result as path_params of "/static/css/main.css" and "/static/*filepath"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert_eq!(
+            expect_text(&expect_object_key(&result, "filepath")),
+            "css/main.css"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_path_params_wildcard_requires_at_least_one_segment() {
+        let code = r#"
+            store result as path_params of "/static" and "/static/*filepath"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert!(matches!(result, Value::Null));
+    }
+
+    #[tokio::test]
+    async fn test_path_params_literal_segments_must_match() {
+        let code = r#"
+            store result as path_params of "/users/42/comments/7" and "/users/:user_id/posts/:post_id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_params should run");
+        assert!(matches!(result, Value::Null));
+    }
+
+    #[tokio::test]
+    async fn test_path_matches_true() {
+        let code = r#"
+            store result as path_matches of "/users/42" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_matches should run");
+        assert!(matches!(result, Value::Bool(true)));
+    }
+
+    #[tokio::test]
+    async fn test_path_matches_false() {
+        let code = r#"
+            store result as path_matches of "/posts/42" and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await.expect("path_matches should run");
+        assert!(matches!(result, Value::Bool(false)));
+    }
+
+    #[tokio::test]
+    async fn test_path_params_usable_in_check_if_nothing() {
+        // End-to-end routing flow as documented for web servers
+        let code = r#"
+            store request_path as "/users/42"
+            store params as path_params of request_path and "/users/:id"
+            check if params is nothing:
+                store result as "not found"
+            otherwise:
+                store result as params["id"]
+            end check
+        "#;
+        let result = run_wfl_code(code).await.expect("routing flow should run");
+        assert_eq!(expect_text(&result), "42");
+    }
+
+    #[tokio::test]
+    async fn test_path_params_wrong_arg_type_errors() {
+        let code = r#"
+            store result as path_params of 42 and "/users/:id"
+        "#;
+        let result = run_wfl_code(code).await;
+        assert!(result.is_err(), "Non-text path should be a runtime error");
+    }
+}