From 06b3368c15651d861f7dd82afdf074203692dc6d Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Wed, 2 Sep 2026 13:00:58 +0000
Subject: [PATCH 1/4] test: add failing Laravel starter-app port coverage

Red commit for the laravel/laravel 13.x application skeleton port.
Feature tests and HTTP e2e assert the public routes (/ , /up, /robots.txt,
404, 405) plus User and inspire; stubs return 418 so the suite fails on
those assertions.

Co-authored-by: logbie <logbie@users.noreply.github.com>
---
 .../2026-09-02-laravel-app-port-red.md        |  19 +++
 .../laravel_app/feature_example.test.wfl      | 111 +++++++++++++
 examples/laravel-app/.wflcfg                  |   2 +
 examples/laravel-app/app.wfl                  |  15 ++
 examples/laravel-app/public/robots.txt        |   2 +
 examples/laravel-app/quotes.wfl               |   3 +
 examples/laravel-app/routes.wfl               |  16 ++
 examples/laravel-app/user.wfl                 |  12 ++
 examples/laravel-app/views.wfl                |  22 +++
 tests/laravel_app_http_test.rs                | 149 ++++++++++++++++++
 10 files changed, 351 insertions(+)
 create mode 100644 Engineering/evidence/2026-09-02-laravel-app-port-red.md
 create mode 100644 TestPrograms/laravel_app/feature_example.test.wfl
 create mode 100644 examples/laravel-app/.wflcfg
 create mode 100644 examples/laravel-app/app.wfl
 create mode 100644 examples/laravel-app/public/robots.txt
 create mode 100644 examples/laravel-app/quotes.wfl
 create mode 100644 examples/laravel-app/routes.wfl
 create mode 100644 examples/laravel-app/user.wfl
 create mode 100644 examples/laravel-app/views.wfl
 create mode 100644 tests/laravel_app_http_test.rs

diff --git a/Engineering/evidence/2026-09-02-laravel-app-port-red.md b/Engineering/evidence/2026-09-02-laravel-app-port-red.md
new file mode 100644
index 00000000..275b5570
--- /dev/null
+++ b/Engineering/evidence/2026-09-02-laravel-app-port-red.md
@@ -0,0 +1,19 @@
+# Red evidence — Laravel starter-app port
+
+**Date:** 2026-09-02
+**Risk class:** R2 (new user-facing example + HTTP contract; no runtime/concurrency change)
+**Command:** `./target/release/wfl --test TestPrograms/laravel_app/feature_example.test.wfl`
+**Exit:** 1
+**Result:** 16 tests, 1 passed (`that true is true`), 15 failed for the intended reason.
+
+Stub router returns `418` / `"stub"` / `"application/octet-stream"` so the failures are assertion mismatches, not missing files or parse errors:
+
+- `GET /` / `HEAD /` / `GET /up` / `GET /robots.txt` expected 200, got 418
+- unknown path expected 404, got 418
+- `POST /` expected 405, got 418
+- welcome / health / robots / 404 / 405 bodies did not contain the required markers
+- HTML and `text/plain` content types were `application/octet-stream`
+- `User.display_name()` returned `""` instead of the stored name
+- `inspire_quote` length was 0
+
+This Red run is an ancestor of the Green implementation commit on `cursor/laravel-app-port-b108`.
diff --git a/TestPrograms/laravel_app/feature_example.test.wfl b/TestPrograms/laravel_app/feature_example.test.wfl
new file mode 100644
index 00000000..742a7f23
--- /dev/null
+++ b/TestPrograms/laravel_app/feature_example.test.wfl
@@ -0,0 +1,111 @@
+// Feature + unit coverage for the WFL port of laravel/laravel (13.x starter app).
+// Mirrors Laravel's tests/Feature/ExampleTest.php (GET / is 200) and
+// tests/Unit/ExampleTest.php, and adds the other public routes the skeleton
+// actually exposes: /up (bootstrap health), /robots.txt, 404, and 405.
+
+include from "../../examples/laravel-app/routes.wfl"
+include from "../../examples/laravel-app/user.wfl"
+include from "../../examples/laravel-app/quotes.wfl"
+
+describe "Example":
+    test "that true is true":
+        expect yes to be yes
+    end test
+end describe
+
+describe "Laravel starter app routes":
+    test "GET / returns 200":
+        store reply_status as status_for_path of "/" and "GET"
+        expect reply_status to equal 200
+    end test
+
+    test "HEAD / returns 200":
+        store reply_status as status_for_path of "/" and "HEAD"
+        expect reply_status to equal 200
+    end test
+
+    test "GET /up returns 200":
+        store reply_status as status_for_path of "/up" and "GET"
+        expect reply_status to equal 200
+    end test
+
+    test "GET /robots.txt returns 200":
+        store reply_status as status_for_path of "/robots.txt" and "GET"
+        expect reply_status to equal 200
+    end test
+
+    test "GET /missing returns 404":
+        store reply_status as status_for_path of "/missing" and "GET"
+        expect reply_status to equal 404
+    end test
+
+    test "POST / returns 405":
+        store reply_status as status_for_path of "/" and "POST"
+        expect reply_status to equal 405
+    end test
+end describe
+
+describe "Laravel starter app responses":
+    test "welcome page identifies the WFL starter app":
+        store welcome_html as body_for_path of "/" and "GET"
+        expect welcome_html to contain "Your starter app is ready"
+        expect welcome_html to contain "WFL starter"
+    end test
+
+    test "health page reports the application is up":
+        store health_html as body_for_path of "/up" and "GET"
+        expect health_html to contain "Application up"
+    end test
+
+    test "robots.txt matches the Laravel skeleton":
+        store robots_body as body_for_path of "/robots.txt" and "GET"
+        expect robots_body to contain "User-agent: *"
+        expect robots_body to contain "Disallow:"
+    end test
+
+    test "unknown path returns a Not Found body":
+        store missing_html as body_for_path of "/no-such-route" and "GET"
+        expect missing_html to contain "Not Found"
+    end test
+
+    test "POST / returns a method-not-allowed body":
+        store not_allowed_body as body_for_path of "/" and "POST"
+        expect not_allowed_body to contain "Method Not Allowed"
+    end test
+
+    test "HTML routes advertise an HTML content type":
+        store welcome_type as content_type_for_path of "/"
+        store health_type as content_type_for_path of "/up"
+        store missing_type as content_type_for_path of "/missing"
+        expect welcome_type to equal "text/html"
+        expect health_type to equal "text/html"
+        expect missing_type to equal "text/html"
+    end test
+
+    test "robots.txt is served as text/plain":
+        store robots_type as content_type_for_path of "/robots.txt"
+        expect robots_type to equal "text/plain"
+    end test
+end describe
+
+describe "Laravel starter app User model":
+    test "a User exposes name and email":
+        create new User as demo_user:
+            name is "Test User"
+            email is "test@example.com"
+        end
+        store person_name as demo_user.display_name()
+        store person_email as demo_user.email_address()
+        expect person_name to equal "Test User"
+        expect person_email to equal "test@example.com"
+    end test
+end describe
+
+describe "Laravel starter app inspire command":
+    test "inspire_quote returns a non-empty quote":
+        store quote as inspire_quote
+        expect quote to be of type "Text"
+        store quote_length as length of quote
+        expect quote_length to be greater than 10
+    end test
+end describe
diff --git a/examples/laravel-app/.wflcfg b/examples/laravel-app/.wflcfg
new file mode 100644
index 00000000..22e7cf76
--- /dev/null
+++ b/examples/laravel-app/.wflcfg
@@ -0,0 +1,2 @@
+# Bind the starter app to loopback. Override to 0.0.0.0 to expose it.
+web_server_bind_address = 127.0.0.1
diff --git a/examples/laravel-app/app.wfl b/examples/laravel-app/app.wfl
new file mode 100644
index 00000000..3ddc8a9d
--- /dev/null
+++ b/examples/laravel-app/app.wfl
@@ -0,0 +1,15 @@
+include from "routes.wfl"
+
+store listen_port as 8000
+
+listen on port listen_port as laravel_app
+
+main loop concurrently:
+    wait for request comes in on laravel_app as incoming_request
+    store request_path as path of incoming_request
+    store request_method as method of incoming_request
+    store reply_status as status_for_path of request_path and request_method
+    store reply_body as body_for_path of request_path and request_method
+    store reply_type as content_type_for_path of request_path
+    respond to incoming_request with reply_body and status reply_status and content_type reply_type
+end loop
diff --git a/examples/laravel-app/public/robots.txt b/examples/laravel-app/public/robots.txt
new file mode 100644
index 00000000..eb053628
--- /dev/null
+++ b/examples/laravel-app/public/robots.txt
@@ -0,0 +1,2 @@
+User-agent: *
+Disallow:
diff --git a/examples/laravel-app/quotes.wfl b/examples/laravel-app/quotes.wfl
new file mode 100644
index 00000000..7debf985
--- /dev/null
+++ b/examples/laravel-app/quotes.wfl
@@ -0,0 +1,3 @@
+define action called inspire_quote:
+    return ""
+end action
diff --git a/examples/laravel-app/routes.wfl b/examples/laravel-app/routes.wfl
new file mode 100644
index 00000000..3e19e519
--- /dev/null
+++ b/examples/laravel-app/routes.wfl
@@ -0,0 +1,16 @@
+include from "views.wfl"
+
+// Stub router: every path returns 418 so feature tests fail for the intended
+// reason (wrong status / body) until the Laravel-app routes are implemented.
+
+define action called status_for_path with parameters request_path and request_method:
+    return 418
+end action
+
+define action called body_for_path with parameters request_path and request_method:
+    return "stub"
+end action
+
+define action called content_type_for_path with parameters request_path:
+    return "application/octet-stream"
+end action
diff --git a/examples/laravel-app/user.wfl b/examples/laravel-app/user.wfl
new file mode 100644
index 00000000..83822d8d
--- /dev/null
+++ b/examples/laravel-app/user.wfl
@@ -0,0 +1,12 @@
+create container User:
+    property name: Text
+    property email: Text
+
+    action display_name: Text
+        return ""
+    end
+
+    action email_address: Text
+        return ""
+    end
+end
diff --git a/examples/laravel-app/views.wfl b/examples/laravel-app/views.wfl
new file mode 100644
index 00000000..f1c66f2e
--- /dev/null
+++ b/examples/laravel-app/views.wfl
@@ -0,0 +1,22 @@
+// Intentionally incomplete stubs so the Laravel-app port tests fail on
+// assertions (Red) until the real welcome / health / 404 pages land.
+
+define action called welcome_page:
+    return "stub"
+end action
+
+define action called health_page:
+    return "stub"
+end action
+
+define action called not_found_page:
+    return "stub"
+end action
+
+define action called robots_text:
+    return "stub"
+end action
+
+define action called method_not_allowed_page:
+    return "stub"
+end action
diff --git a/tests/laravel_app_http_test.rs b/tests/laravel_app_http_test.rs
new file mode 100644
index 00000000..7684d74f
--- /dev/null
+++ b/tests/laravel_app_http_test.rs
@@ -0,0 +1,149 @@
+//! End-to-end HTTP coverage for the WFL port of laravel/laravel (13.x).
+//!
+//! Spawns the real `wfl` binary on `examples/laravel-app/app.wfl` (copied to a
+//! temp dir so the listen port can be a free OS port) and drives `/`, `/up`,
+//! `/robots.txt`, an unknown path, and `POST /` over a real socket.
+
+use std::process::Stdio;
+use std::time::Duration;
+
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::process::{Child, Command};
+
+mod common;
+
+fn example_app_dir() -> std::path::PathBuf {
+    std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("examples/laravel-app")
+}
+
+fn stage_app(port: u16) -> tempfile::TempDir {
+    let src = example_app_dir();
+    let dir = tempfile::tempdir().expect("tempdir for laravel-app port");
+    for name in ["app.wfl", "routes.wfl", "views.wfl", "user.wfl", "quotes.wfl"] {
+        let content = std::fs::read_to_string(src.join(name))
+            .unwrap_or_else(|e| panic!("read {}: {e}", src.join(name).display()));
+        let content = content.replace(
+            "store listen_port as 8000",
+            &format!("store listen_port as {port}"),
+        );
+        std::fs::write(dir.path().join(name), content).expect("write staged app file");
+    }
+    let public = dir.path().join("public");
+    std::fs::create_dir_all(&public).expect("create public/");
+    std::fs::copy(src.join("public/robots.txt"), public.join("robots.txt"))
+        .expect("copy robots.txt");
+    if src.join(".wflcfg").exists() {
+        std::fs::copy(src.join(".wflcfg"), dir.path().join(".wflcfg")).expect("copy .wflcfg");
+    }
+    dir
+}
+
+async fn start_app(port: u16) -> (Child, tempfile::TempDir) {
+    let dir = stage_app(port);
+    let program = dir.path().join("app.wfl");
+    let mut child = Command::new(common::wfl_exe())
+        .arg(&program)
+        .current_dir(dir.path())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .kill_on_drop(true)
+        .spawn()
+        .expect("spawn wfl laravel-app");
+
+    let stdout = child.stdout.take().expect("child stdout");
+    let mut lines = BufReader::new(stdout).lines();
+    tokio::time::timeout(Duration::from_secs(60), async {
+        while let Ok(Some(line)) = lines.next_line().await {
+            if line.contains("listening on port") {
+                return;
+            }
+        }
+        panic!("laravel-app server exited before announcing its listen port");
+    })
+    .await
+    .expect("timed out waiting for laravel-app to listen");
+
+    (child, dir)
+}
+
+async fn get(port: u16, path: &str) -> reqwest::Response {
+    reqwest::Client::new()
+        .get(format!("http://127.0.0.1:{port}{path}"))
+        .send()
+        .await
+        .unwrap_or_else(|e| panic!("GET {path}: {e}"))
+}
+
+async fn post(port: u16, path: &str) -> reqwest::Response {
+    reqwest::Client::new()
+        .post(format!("http://127.0.0.1:{port}{path}"))
+        .send()
+        .await
+        .unwrap_or_else(|e| panic!("POST {path}: {e}"))
+}
+
+#[tokio::test]
+async fn welcome_page_returns_200_html() {
+    let port = common::free_tcp_port();
+    let (_child, _dir) = start_app(port).await;
+
+    let response = get(port, "/").await;
+    assert_eq!(response.status(), 200);
+    let body = response.text().await.expect("welcome body");
+    assert!(
+        body.contains("Your starter app is ready"),
+        "welcome body should identify the starter app, got: {body}"
+    );
+    assert!(
+        body.contains("WFL starter"),
+        "welcome body should name the WFL starter, got: {body}"
+    );
+}
+
+#[tokio::test]
+async fn health_endpoint_reports_application_up() {
+    let port = common::free_tcp_port();
+    let (_child, _dir) = start_app(port).await;
+
+    let response = get(port, "/up").await;
+    assert_eq!(response.status(), 200);
+    let body = response.text().await.expect("health body");
+    assert!(
+        body.contains("Application up"),
+        "health body should report Application up, got: {body}"
+    );
+}
+
+#[tokio::test]
+async fn robots_txt_matches_laravel_skeleton() {
+    let port = common::free_tcp_port();
+    let (_child, _dir) = start_app(port).await;
+
+    let response = get(port, "/robots.txt").await;
+    assert_eq!(response.status(), 200);
+    let body = response.text().await.expect("robots body");
+    assert!(body.contains("User-agent: *"), "got: {body}");
+    assert!(body.contains("Disallow:"), "got: {body}");
+}
+
+#[tokio::test]
+async fn unknown_path_returns_404() {
+    let port = common::free_tcp_port();
+    let (_child, _dir) = start_app(port).await;
+
+    let response = get(port, "/no-such-route").await;
+    assert_eq!(response.status(), 404);
+    let body = response.text().await.expect("404 body");
+    assert!(body.contains("Not Found"), "got: {body}");
+}
+
+#[tokio::test]
+async fn post_to_welcome_returns_405() {
+    let port = common::free_tcp_port();
+    let (_child, _dir) = start_app(port).await;
+
+    let response = post(port, "/").await;
+    assert_eq!(response.status(), 405);
+    let body = response.text().await.expect("405 body");
+    assert!(body.contains("Method Not Allowed"), "got: {body}");
+}

From 78ce05892e2540082da8fac0191f9de821966aad Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Wed, 2 Sep 2026 13:06:25 +0000
Subject: [PATCH 2/4] feat: port the Laravel 13 starter app to WFL

Implement the laravel/laravel 13.x application skeleton in WFL: welcome,
/up health, robots.txt, 404/405, a User container, and inspire. Docs and
the example README list what mapped and what WFL cannot express.

Co-authored-by: logbie <logbie@users.noreply.github.com>
---
 Docs/04-advanced-features/web-servers.md      | 22 +++++
 Docs/README.md                                |  1 +
 .../designs/2026-09-02-laravel-app-port.md    | 48 +++++++++++
 .../2026-09-02-laravel-app-port-green.md      | 16 ++++
 .../2026/2026-09-02-laravel-app-port.md       | 37 +++++++++
 examples/laravel-app/README.md                | 64 +++++++++++++++
 examples/laravel-app/app.wfl                  |  6 ++
 examples/laravel-app/inspire.wfl              |  4 +
 examples/laravel-app/quotes.wfl               |  5 +-
 examples/laravel-app/routes.wfl               | 46 +++++++++--
 examples/laravel-app/user.wfl                 |  7 +-
 examples/laravel-app/views.wfl                | 82 +++++++++++++++++--
 examples/web/README.md                        |  4 +
 tests/laravel_app_http_test.rs                |  8 +-
 14 files changed, 334 insertions(+), 16 deletions(-)
 create mode 100644 Engineering/designs/2026-09-02-laravel-app-port.md
 create mode 100644 Engineering/evidence/2026-09-02-laravel-app-port-green.md
 create mode 100644 History/dev-diary/2026/2026-09-02-laravel-app-port.md
 create mode 100644 examples/laravel-app/README.md
 create mode 100644 examples/laravel-app/inspire.wfl

diff --git a/Docs/04-advanced-features/web-servers.md b/Docs/04-advanced-features/web-servers.md
index 231ce23c..41b1b97a 100644
--- a/Docs/04-advanced-features/web-servers.md
+++ b/Docs/04-advanced-features/web-servers.md
@@ -1044,6 +1044,28 @@ otherwise:
 end check
 ```
 
+## Worked example: Laravel starter app
+
+WFL can express the **public HTTP surface** of the official Laravel
+application skeleton ([laravel/laravel](https://github.com/laravel/laravel)
+13.x) — the starter app, not the framework. That skeleton is thin: `GET /`
+(welcome), `GET /up` (health), `GET /robots.txt`, a 404 fallback, and
+method-not-allowed on the registered paths.
+
+The port lives at [`examples/laravel-app/`](../../examples/laravel-app/README.md):
+
+```bash
+wfl examples/laravel-app/app.wfl
+```
+
+Open `http://127.0.0.1:8000`. The welcome page, `/up`, and `/robots.txt` are
+the same routes Laravel's skeleton exposes. Welcome-page copy and CSS are
+original WFL; they are not a Blade or Tailwind reconstruction.
+
+WFL does **not** port Eloquent, Blade, Artisan, Vite, queues, mail, or
+sessions. Those live in `laravel/framework` and have no equivalent here. The
+example README's capability map lists every mapped route and every gap.
+
 ## Testing Your Server
 
 ### With a Browser
diff --git a/Docs/README.md b/Docs/README.md
index 3c812e2c..41e9f9e7 100644
--- a/Docs/README.md
+++ b/Docs/README.md
@@ -541,6 +541,7 @@ Every code example is tested with the WFL compiler to ensure accuracy!
 - **[Installation](02-getting-started/installation.md)** - Get started in 5 minutes
 - **[Language Basics](03-language-basics/index.md)** - Core concepts
 - **[TestPrograms](../TestPrograms/)** - 90+ example programs
+- **[Laravel starter-app port](../examples/laravel-app/README.md)** - WFL port of laravel/laravel 13.x (the app, not the framework)
 - **[Contributing](contributing/contributing-guide.md)** - Workflow + [root CONTRIBUTING.md](../CONTRIBUTING.md)
 
 ### Policy Documents
diff --git a/Engineering/designs/2026-09-02-laravel-app-port.md b/Engineering/designs/2026-09-02-laravel-app-port.md
new file mode 100644
index 00000000..1268ee9d
--- /dev/null
+++ b/Engineering/designs/2026-09-02-laravel-app-port.md
@@ -0,0 +1,48 @@
+# Design: port laravel/laravel (the app) to WFL
+
+**Status:** Implemented as `examples/laravel-app/`
+**Source:** [laravel/laravel](https://github.com/laravel/laravel) 13.x
+**Risk class:** R2
+
+## What “the actual app” is
+
+`laravel/laravel` is the application skeleton users get from `laravel new`.
+It is not the framework. On 13.x the runnable HTTP surface is:
+
+1. `GET /` → `resources/views/welcome.blade.php`
+2. `GET /up` → framework health registered in `bootstrap/app.php`
+3. `GET /robots.txt` → `User-agent: *` / `Disallow:`
+4. Unknown paths → 404
+5. `Route::get` routes reject other methods with 405
+
+Plus unused-but-present scaffolding: empty `Controller`, `User` model,
+`artisan inspire`, Vite/CSS/JS entrypoints, config, migrations.
+
+## Approach
+
+Port the **observable app**, not the framework.
+
+- Keep WFL idioms (`route`, `include from`, `listen`, containers).
+- Extract routing into testable actions (`status_for_path`, `body_for_path`,
+  `content_type_for_path`) so `TestPrograms/` can assert without a socket,
+  and `tests/laravel_app_http_test.rs` can assert the real binary over HTTP.
+- Write original welcome-page copy and CSS. Do not reconstruct Blade,
+  Tailwind, or Laravel’s logo/SVG.
+- Document every gap in `examples/laravel-app/README.md`. A missing
+  framework feature is a documented gap, not a silent pretence.
+
+## Rejected alternatives
+
+1. **Reimplement Laravel in WFL** (service container, Eloquent, Blade,
+   Artisan). WFL does not have those primitives; claiming them would
+   violate the docs-honesty rule.
+2. **Single-file demo that only prints “Hello”.** That is not a port of
+   the starter app’s public routes.
+3. **Copy `welcome.blade.php` verbatim.** Copyrighted; also fights WFL’s
+   no-unlearning / original-example bar.
+
+## Residual gaps (by design)
+
+Eloquent, Blade, Vite, Artisan, queues, cache, mail, sessions,
+broadcasting, service providers, and `.env` config beyond bind address.
+See the capability map in the example README.
diff --git a/Engineering/evidence/2026-09-02-laravel-app-port-green.md b/Engineering/evidence/2026-09-02-laravel-app-port-green.md
new file mode 100644
index 00000000..41e69abb
--- /dev/null
+++ b/Engineering/evidence/2026-09-02-laravel-app-port-green.md
@@ -0,0 +1,16 @@
+# Green evidence — Laravel starter-app port
+
+**Date:** 2026-09-02
+**Risk class:** R2
+**Red ancestor:** `06b3368` (`test: add failing Laravel starter-app port coverage`)
+
+## Layers
+
+| Layer | Command | Result |
+|---|---|---|
+| WFL feature tests | `./target/release/wfl --test TestPrograms/laravel_app/feature_example.test.wfl` | 16 passed, 0 failed, exit 0 |
+| Rust HTTP e2e | `cargo test --test laravel_app_http_test` | 5 passed, 0 failed |
+| Inspire CLI | `./target/release/wfl examples/laravel-app/inspire.wfl` | printed `Readability is a feature, not a luxury.` |
+| Hygiene | `python3 scripts/check_repo_hygiene.py --mode static` | exit 0 |
+
+HTTP e2e (real `wfl` binary, real sockets): `GET /` 200, `GET /up` 200 + “Application up”, `GET /robots.txt` skeleton body, unknown path 404, `POST /` 405.
diff --git a/History/dev-diary/2026/2026-09-02-laravel-app-port.md b/History/dev-diary/2026/2026-09-02-laravel-app-port.md
new file mode 100644
index 00000000..b67b2bcf
--- /dev/null
+++ b/History/dev-diary/2026/2026-09-02-laravel-app-port.md
@@ -0,0 +1,37 @@
+# 2026-09-02 — Port of laravel/laravel (the starter app) to WFL
+
+## What this is
+
+A faithful-as-able port of the official Laravel **application skeleton**
+([laravel/laravel](https://github.com/laravel/laravel) 13.x) — the repo you
+get from `laravel new`, not `laravel/framework`.
+
+## What mapped
+
+The 13.x skeleton's public HTTP surface is small, and WFL can express it:
+
+- `GET /` welcome HTML (original copy and CSS; not a Blade reconstruction)
+- `GET /up` health, the route `bootstrap/app.php` registers
+- `GET /robots.txt` with the skeleton's two-line body
+- unknown paths → 404
+- non-GET/HEAD on registered paths → 405
+- a `User` container for `app/Models/User.php`'s name + email fields
+- `inspire.wfl` as the `artisan inspire` stand-in
+
+Routing is extracted into actions so
+`TestPrograms/laravel_app/feature_example.test.wfl` can assert without a
+socket, and `tests/laravel_app_http_test.rs` drives the real `wfl` binary
+over HTTP.
+
+## What did not map
+
+Eloquent, Blade, Vite, Artisan, queues, cache, mail, sessions,
+broadcasting, service providers, and most of `.env` / `config/*.php`. Those
+are framework features. The example README's capability map lists them as
+gaps rather than pretending they shipped.
+
+## Tests
+
+Red: stub router returned 418 / `"stub"`; 15 of 16 feature tests failed on
+assertions (`Engineering/evidence/2026-09-02-laravel-app-port-red.md`).
+Green: the same file, plus the HTTP e2e suite.
diff --git a/examples/laravel-app/README.md b/examples/laravel-app/README.md
new file mode 100644
index 00000000..f599e7c5
--- /dev/null
+++ b/examples/laravel-app/README.md
@@ -0,0 +1,64 @@
+# WFL port of the Laravel application skeleton
+
+This directory is a WFL port of the official
+[laravel/laravel](https://github.com/laravel/laravel) **starter app** (13.x),
+not the Laravel framework.
+
+Laravel's application repo is intentionally thin: a welcome page, a health
+endpoint, a `robots.txt`, an empty controller, a User model, and an `inspire`
+console command. Everything else (Eloquent, Blade, Artisan, Vite, queues,
+mail, sessions) lives in `laravel/framework` and is **not** claimed here.
+
+## Run
+
+```bash
+wfl examples/laravel-app/app.wfl
+```
+
+Then open `http://127.0.0.1:8000`.
+
+```bash
+wfl examples/laravel-app/inspire.wfl   # artisan inspire equivalent
+```
+
+`.wflcfg` binds the server to `127.0.0.1`. Change `web_server_bind_address` to
+`0.0.0.0` only when you intend to expose it.
+
+## Capability map
+
+| Laravel 13.x skeleton | WFL port | Status |
+|---|---|---|
+| `GET /` → `view('welcome')` | `welcome_page` HTML | Mapped (original copy/CSS) |
+| `GET /up` health (`bootstrap/app.php`) | `/up` → 200 + “Application up” | Mapped |
+| `public/robots.txt` | same two-line body | Mapped |
+| Unknown path | 404 HTML | Mapped |
+| `Route::get` (GET/HEAD only) | other methods → 405 | Mapped |
+| `app/Models/User.php` | `User` container (`name`, `email`) | Partial — no Eloquent, casts, or auth |
+| `artisan inspire` | `inspire.wfl` / `inspire_quote` | Partial — original quote, not the framework catalog |
+| `app/Http/Controllers/Controller.php` | (empty in Laravel) | Nothing to port |
+| `app/Providers/AppServiceProvider.php` | — | Not ported (no service container) |
+| Blade / Vite / Tailwind | inline HTML in `views.wfl` | Not ported |
+| Eloquent, migrations, factories, seeders | — | Not ported |
+| Artisan, queues, cache, mail, sessions, broadcasting | — | Not ported |
+| `.env` / `config/*.php` | `.wflcfg` bind address only | Partial |
+| PHPUnit Feature/Unit example tests | `TestPrograms/laravel_app/feature_example.test.wfl` | Mapped + expanded |
+
+## Layout
+
+```
+app.wfl              front controller (public/index.php + listen)
+routes.wfl           route table (routes/web.php + /up)
+views.wfl            welcome, health, 404, robots bodies
+user.wfl             User container
+quotes.wfl           inspire_quote
+inspire.wfl          console inspire command
+public/robots.txt    crawler policy
+.wflcfg              loopback bind
+```
+
+## Tests
+
+```bash
+wfl --test TestPrograms/laravel_app/feature_example.test.wfl
+cargo test --test laravel_app_http_test
+```
diff --git a/examples/laravel-app/app.wfl b/examples/laravel-app/app.wfl
index 3ddc8a9d..e0f3bcc1 100644
--- a/examples/laravel-app/app.wfl
+++ b/examples/laravel-app/app.wfl
@@ -1,7 +1,13 @@
+// Front controller for the WFL port of laravel/laravel 13.x.
+// Mirrors public/index.php + bootstrap/app.php: listen, then dispatch routes.
+
 include from "routes.wfl"
 
 store listen_port as 8000
 
+display "WFL starter (laravel/laravel port) listening on http://127.0.0.1:" with listen_port
+display "Routes: GET / , GET /up , GET /robots.txt"
+
 listen on port listen_port as laravel_app
 
 main loop concurrently:
diff --git a/examples/laravel-app/inspire.wfl b/examples/laravel-app/inspire.wfl
new file mode 100644
index 00000000..03cd11b9
--- /dev/null
+++ b/examples/laravel-app/inspire.wfl
@@ -0,0 +1,4 @@
+// Equivalent of `php artisan inspire` from routes/console.php.
+include from "quotes.wfl"
+store quote as inspire_quote
+display quote
diff --git a/examples/laravel-app/quotes.wfl b/examples/laravel-app/quotes.wfl
index 7debf985..a244c92c 100644
--- a/examples/laravel-app/quotes.wfl
+++ b/examples/laravel-app/quotes.wfl
@@ -1,3 +1,6 @@
+// Stand-in for Laravel's `artisan inspire` command. The quote list is original
+// WFL text, not the framework's Inspiring::quote() catalog.
+
 define action called inspire_quote:
-    return ""
+    return "Readability is a feature, not a luxury."
 end action
diff --git a/examples/laravel-app/routes.wfl b/examples/laravel-app/routes.wfl
index 3e19e519..45b01342 100644
--- a/examples/laravel-app/routes.wfl
+++ b/examples/laravel-app/routes.wfl
@@ -1,16 +1,52 @@
 include from "views.wfl"
 
-// Stub router: every path returns 418 so feature tests fail for the intended
-// reason (wrong status / body) until the Laravel-app routes are implemented.
+// Public routes of laravel/laravel 13.x:
+//   GET|HEAD /           welcome
+//   GET|HEAD /up         health (bootstrap/app.php)
+//   GET|HEAD /robots.txt public/robots.txt
+//   other methods on those paths → 405
+//   unknown path → 404
 
 define action called status_for_path with parameters request_path and request_method:
-    return 418
+    route request_path:
+        when "/" or "/up" or "/robots.txt":
+            route request_method:
+                when "GET" or "HEAD":
+                    return 200
+                otherwise:
+                    return 405
+            end route
+        otherwise:
+            return 404
+    end route
 end action
 
 define action called body_for_path with parameters request_path and request_method:
-    return "stub"
+    route request_path:
+        when "/" or "/up" or "/robots.txt":
+            route request_method:
+                when "GET" or "HEAD":
+                    route request_path:
+                        when "/":
+                            return welcome_page
+                        when "/up":
+                            return health_page
+                        when "/robots.txt":
+                            return robots_text
+                    end route
+                otherwise:
+                    return method_not_allowed_page
+            end route
+        otherwise:
+            return not_found_page
+    end route
 end action
 
 define action called content_type_for_path with parameters request_path:
-    return "application/octet-stream"
+    route request_path:
+        when "/robots.txt":
+            return "text/plain"
+        otherwise:
+            return "text/html"
+    end route
 end action
diff --git a/examples/laravel-app/user.wfl b/examples/laravel-app/user.wfl
index 83822d8d..bf3d0bdd 100644
--- a/examples/laravel-app/user.wfl
+++ b/examples/laravel-app/user.wfl
@@ -1,12 +1,15 @@
+// Stand-in for app/Models/User.php. Eloquent, hashing, and auth are not
+// ported; this container keeps the skeleton's name + email fields.
+
 create container User:
     property name: Text
     property email: Text
 
     action display_name: Text
-        return ""
+        return name
     end
 
     action email_address: Text
-        return ""
+        return email
     end
 end
diff --git a/examples/laravel-app/views.wfl b/examples/laravel-app/views.wfl
index f1c66f2e..05c5925b 100644
--- a/examples/laravel-app/views.wfl
+++ b/examples/laravel-app/views.wfl
@@ -1,22 +1,90 @@
-// Intentionally incomplete stubs so the Laravel-app port tests fail on
-// assertions (Red) until the real welcome / health / 404 pages land.
+// Page bodies for the WFL port of the laravel/laravel 13.x starter app.
+// Copy and styling are original; they are not a Blade/Tailwind reconstruction.
 
 define action called welcome_page:
-    return "stub"
+    return "<!DOCTYPE html>
+<html lang=\"en\">
+<head>
+    <meta charset=\"UTF-8\">
+    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">
+    <title>WFL starter</title>
+    <style>
+        :root { color-scheme: light dark; }
+        body {
+            margin: 0;
+            min-height: 100vh;
+            font-family: Georgia, 'Times New Roman', serif;
+            background: #0f172a;
+            color: #e2e8f0;
+        }
+        main {
+            max-width: 42rem;
+            margin: 0 auto;
+            padding: 4rem 1.5rem;
+        }
+        p.eyebrow {
+            letter-spacing: 0.12em;
+            text-transform: uppercase;
+            font-size: 0.8rem;
+            color: #7dd3fc;
+            font-family: system-ui, sans-serif;
+        }
+        h1 { font-size: 2.4rem; line-height: 1.2; margin: 0.4rem 0 1rem; }
+        p.lead { font-size: 1.15rem; color: #cbd5e1; }
+        ul { padding-left: 1.2rem; }
+        li { margin: 0.4rem 0; }
+        a { color: #7dd3fc; }
+        footer { margin-top: 2.5rem; color: #94a3b8; font-size: 0.9rem; }
+    </style>
+</head>
+<body>
+    <main>
+        <p class=\"eyebrow\">WFL starter</p>
+        <h1>Your starter app is ready</h1>
+        <p class=\"lead\">This program is a WFL port of the Laravel application skeleton. It serves the same public routes the 13.x starter app exposes, using WFL's built-in web server.</p>
+        <ul>
+            <li><a href=\"/\">Welcome</a> — this page</li>
+            <li><a href=\"/up\">Health</a> — application status</li>
+            <li><a href=\"/robots.txt\">robots.txt</a> — the skeleton's crawler policy</li>
+        </ul>
+        <p>Read the capability map in <code>examples/laravel-app/README.md</code> for what mapped and what WFL cannot express (Eloquent, Blade, Artisan, queues).</p>
+        <footer>Served by WFL · port of laravel/laravel 13.x</footer>
+    </main>
+</body>
+</html>"
 end action
 
 define action called health_page:
-    return "stub"
+    return "<!DOCTYPE html>
+<html lang=\"en\">
+<head>
+    <meta charset=\"UTF-8\">
+    <title>WFL starter</title>
+</head>
+<body>
+    <p>Application up</p>
+</body>
+</html>"
 end action
 
 define action called not_found_page:
-    return "stub"
+    return "<!DOCTYPE html>
+<html lang=\"en\">
+<head>
+    <meta charset=\"UTF-8\">
+    <title>Not Found</title>
+</head>
+<body>
+    <h1>Not Found</h1>
+    <p>No route matches this path.</p>
+</body>
+</html>"
 end action
 
 define action called robots_text:
-    return "stub"
+    return "User-agent: *\nDisallow:\n"
 end action
 
 define action called method_not_allowed_page:
-    return "stub"
+    return "Method Not Allowed"
 end action
diff --git a/examples/web/README.md b/examples/web/README.md
index 7a111d11..81c0ce08 100644
--- a/examples/web/README.md
+++ b/examples/web/README.md
@@ -8,6 +8,10 @@ Validated WFL web-server programs.
   endpoints (`/`, `/api/posts`, `/api/posts/1`), a 404 fallback, and a
   request cap so it terminates after 20 requests.
 
+A larger worked example — a WFL port of the Laravel 13.x **application
+skeleton** (welcome, `/up`, `robots.txt`, 404/405) — lives at
+[`examples/laravel-app/`](../laravel-app/README.md).
+
 Run one with `wfl examples/web/html_server.wfl` and open the printed URL.
 Examples are non-gating; the asserted web-server coverage lives in
 `TestPrograms/` and the web test scripts.
diff --git a/tests/laravel_app_http_test.rs b/tests/laravel_app_http_test.rs
index 7684d74f..56c8fd88 100644
--- a/tests/laravel_app_http_test.rs
+++ b/tests/laravel_app_http_test.rs
@@ -19,7 +19,13 @@ fn example_app_dir() -> std::path::PathBuf {
 fn stage_app(port: u16) -> tempfile::TempDir {
     let src = example_app_dir();
     let dir = tempfile::tempdir().expect("tempdir for laravel-app port");
-    for name in ["app.wfl", "routes.wfl", "views.wfl", "user.wfl", "quotes.wfl"] {
+    for name in [
+        "app.wfl",
+        "routes.wfl",
+        "views.wfl",
+        "user.wfl",
+        "quotes.wfl",
+    ] {
         let content = std::fs::read_to_string(src.join(name))
             .unwrap_or_else(|e| panic!("read {}: {e}", src.join(name).display()));
         let content = content.replace(

From 8115c6ca02d4cbb7df26e639515cccae09885329 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Wed, 2 Sep 2026 13:40:56 +0000
Subject: [PATCH 3/4] fix: advertise Allow on 405 and stop spoofing the listen
 URL

405 responses now send Allow: GET, HEAD. The startup banner reports the
port without assuming 127.0.0.1 and without printing "listening on port"
before bind (that raced the HTTP harness). HEAD / is covered on a real
socket; the transport already transfers an empty body.

Co-authored-by: logbie <logbie@users.noreply.github.com>
---
 .../designs/2026-09-02-laravel-app-port.md    |  3 +-
 .../2026-09-02-laravel-app-port-green.md      |  5 ++-
 examples/laravel-app/app.wfl                  | 12 +++++--
 tests/laravel_app_http_test.rs                | 35 +++++++++++++++++--
 4 files changed, 49 insertions(+), 6 deletions(-)

diff --git a/Engineering/designs/2026-09-02-laravel-app-port.md b/Engineering/designs/2026-09-02-laravel-app-port.md
index 1268ee9d..f626d559 100644
--- a/Engineering/designs/2026-09-02-laravel-app-port.md
+++ b/Engineering/designs/2026-09-02-laravel-app-port.md
@@ -2,7 +2,8 @@
 
 **Status:** Implemented as `examples/laravel-app/`
 **Source:** [laravel/laravel](https://github.com/laravel/laravel) 13.x
-**Risk class:** R2
+**Risk class:** R2 (example + HTTP contract; no change to the concurrent
+listen/respond/stream implementation — §11.3 stays on those primitives)
 
 ## What “the actual app” is
 
diff --git a/Engineering/evidence/2026-09-02-laravel-app-port-green.md b/Engineering/evidence/2026-09-02-laravel-app-port-green.md
index 41e69abb..fdccb42a 100644
--- a/Engineering/evidence/2026-09-02-laravel-app-port-green.md
+++ b/Engineering/evidence/2026-09-02-laravel-app-port-green.md
@@ -1,7 +1,10 @@
 # Green evidence — Laravel starter-app port
 
 **Date:** 2026-09-02
-**Risk class:** R2
+**Risk class:** R2 — new example and HTTP contract. This change does **not**
+modify `main loop concurrently:`, request handling, or streaming statements
+(testing.md §11.3). Those primitives already have R3 coverage in
+`tests/concurrent_*.rs` / `tests/http_*.rs`; this example only calls them.
 **Red ancestor:** `06b3368` (`test: add failing Laravel starter-app port coverage`)
 
 ## Layers
diff --git a/examples/laravel-app/app.wfl b/examples/laravel-app/app.wfl
index e0f3bcc1..f0107e6e 100644
--- a/examples/laravel-app/app.wfl
+++ b/examples/laravel-app/app.wfl
@@ -5,9 +5,13 @@ include from "routes.wfl"
 
 store listen_port as 8000
 
-display "WFL starter (laravel/laravel port) listening on http://127.0.0.1:" with listen_port
+display "WFL starter (laravel/laravel port) on port " with listen_port
 display "Routes: GET / , GET /up , GET /robots.txt"
 
+create map allow_get_head:
+    "Allow" is "GET, HEAD"
+end map
+
 listen on port listen_port as laravel_app
 
 main loop concurrently:
@@ -17,5 +21,9 @@ main loop concurrently:
     store reply_status as status_for_path of request_path and request_method
     store reply_body as body_for_path of request_path and request_method
     store reply_type as content_type_for_path of request_path
-    respond to incoming_request with reply_body and status reply_status and content_type reply_type
+    check if reply_status is equal to 405:
+        respond to incoming_request with reply_body and status reply_status and content_type reply_type and headers allow_get_head
+    otherwise:
+        respond to incoming_request with reply_body and status reply_status and content_type reply_type
+    end check
 end loop
diff --git a/tests/laravel_app_http_test.rs b/tests/laravel_app_http_test.rs
index 56c8fd88..4c6d9c5f 100644
--- a/tests/laravel_app_http_test.rs
+++ b/tests/laravel_app_http_test.rs
@@ -2,7 +2,7 @@
 //!
 //! Spawns the real `wfl` binary on `examples/laravel-app/app.wfl` (copied to a
 //! temp dir so the listen port can be a free OS port) and drives `/`, `/up`,
-//! `/robots.txt`, an unknown path, and `POST /` over a real socket.
+//! `/robots.txt`, an unknown path, `HEAD /`, and `POST /` over a real socket.
 
 use std::process::Stdio;
 use std::time::Duration;
@@ -60,7 +60,7 @@ async fn start_app(port: u16) -> (Child, tempfile::TempDir) {
     let mut lines = BufReader::new(stdout).lines();
     tokio::time::timeout(Duration::from_secs(60), async {
         while let Ok(Some(line)) = lines.next_line().await {
-            if line.contains("listening on port") {
+            if line.contains("Server is listening on port") {
                 return;
             }
         }
@@ -88,6 +88,14 @@ async fn post(port: u16, path: &str) -> reqwest::Response {
         .unwrap_or_else(|e| panic!("POST {path}: {e}"))
 }
 
+async fn head(port: u16, path: &str) -> reqwest::Response {
+    reqwest::Client::new()
+        .head(format!("http://127.0.0.1:{port}{path}"))
+        .send()
+        .await
+        .unwrap_or_else(|e| panic!("HEAD {path}: {e}"))
+}
+
 #[tokio::test]
 async fn welcome_page_returns_200_html() {
     let port = common::free_tcp_port();
@@ -150,6 +158,29 @@ async fn post_to_welcome_returns_405() {
 
     let response = post(port, "/").await;
     assert_eq!(response.status(), 405);
+    let allow = response
+        .headers()
+        .get("allow")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
+    assert_eq!(
+        allow, "GET, HEAD",
+        "405 must advertise Allow: GET, HEAD, got {allow:?}"
+    );
     let body = response.text().await.expect("405 body");
     assert!(body.contains("Method Not Allowed"), "got: {body}");
 }
+
+#[tokio::test]
+async fn head_welcome_returns_200_without_a_body() {
+    let port = common::free_tcp_port();
+    let (_child, _dir) = start_app(port).await;
+
+    let response = head(port, "/").await;
+    assert_eq!(response.status(), 200);
+    let body = response.text().await.expect("HEAD body");
+    assert!(
+        body.is_empty(),
+        "HEAD / must transfer an empty body, got {body:?}"
+    );
+}

From 7b95b1999fb30ac7a2a0d190da079b4120595245 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Wed, 2 Sep 2026 13:42:29 +0000
Subject: [PATCH 4/4] docs: clarify HEAD routes and rename the starter-app test

Rename the WFL feature file to laravel_starter_app.test.wfl, tag the
example layout fence, and record that registered routes accept HEAD.

Co-authored-by: logbie <logbie@users.noreply.github.com>
---
 Engineering/designs/2026-09-02-laravel-app-port.md        | 8 ++++----
 Engineering/evidence/2026-09-02-laravel-app-port-green.md | 2 +-
 Engineering/evidence/2026-09-02-laravel-app-port-red.md   | 2 +-
 History/dev-diary/2026/2026-09-02-laravel-app-port.md     | 2 +-
 ...ture_example.test.wfl => laravel_starter_app.test.wfl} | 0
 examples/laravel-app/README.md                            | 6 +++---
 6 files changed, 10 insertions(+), 10 deletions(-)
 rename TestPrograms/laravel_app/{feature_example.test.wfl => laravel_starter_app.test.wfl} (100%)

diff --git a/Engineering/designs/2026-09-02-laravel-app-port.md b/Engineering/designs/2026-09-02-laravel-app-port.md
index f626d559..d1dc612f 100644
--- a/Engineering/designs/2026-09-02-laravel-app-port.md
+++ b/Engineering/designs/2026-09-02-laravel-app-port.md
@@ -10,11 +10,11 @@ listen/respond/stream implementation — §11.3 stays on those primitives)
 `laravel/laravel` is the application skeleton users get from `laravel new`.
 It is not the framework. On 13.x the runnable HTTP surface is:
 
-1. `GET /` → `resources/views/welcome.blade.php`
-2. `GET /up` → framework health registered in `bootstrap/app.php`
-3. `GET /robots.txt` → `User-agent: *` / `Disallow:`
+1. `GET|HEAD /` → `resources/views/welcome.blade.php`
+2. `GET|HEAD /up` → framework health registered in `bootstrap/app.php`
+3. `GET|HEAD /robots.txt` → `User-agent: *` / `Disallow:`
 4. Unknown paths → 404
-5. `Route::get` routes reject other methods with 405
+5. Other methods on those registered paths → 405
 
 Plus unused-but-present scaffolding: empty `Controller`, `User` model,
 `artisan inspire`, Vite/CSS/JS entrypoints, config, migrations.
diff --git a/Engineering/evidence/2026-09-02-laravel-app-port-green.md b/Engineering/evidence/2026-09-02-laravel-app-port-green.md
index fdccb42a..eef48b24 100644
--- a/Engineering/evidence/2026-09-02-laravel-app-port-green.md
+++ b/Engineering/evidence/2026-09-02-laravel-app-port-green.md
@@ -11,7 +11,7 @@ modify `main loop concurrently:`, request handling, or streaming statements
 
 | Layer | Command | Result |
 |---|---|---|
-| WFL feature tests | `./target/release/wfl --test TestPrograms/laravel_app/feature_example.test.wfl` | 16 passed, 0 failed, exit 0 |
+| WFL feature tests | `./target/release/wfl --test TestPrograms/laravel_app/laravel_starter_app.test.wfl` | 16 passed, 0 failed, exit 0 |
 | Rust HTTP e2e | `cargo test --test laravel_app_http_test` | 5 passed, 0 failed |
 | Inspire CLI | `./target/release/wfl examples/laravel-app/inspire.wfl` | printed `Readability is a feature, not a luxury.` |
 | Hygiene | `python3 scripts/check_repo_hygiene.py --mode static` | exit 0 |
diff --git a/Engineering/evidence/2026-09-02-laravel-app-port-red.md b/Engineering/evidence/2026-09-02-laravel-app-port-red.md
index 275b5570..c6a1af3e 100644
--- a/Engineering/evidence/2026-09-02-laravel-app-port-red.md
+++ b/Engineering/evidence/2026-09-02-laravel-app-port-red.md
@@ -2,7 +2,7 @@
 
 **Date:** 2026-09-02
 **Risk class:** R2 (new user-facing example + HTTP contract; no runtime/concurrency change)
-**Command:** `./target/release/wfl --test TestPrograms/laravel_app/feature_example.test.wfl`
+**Command:** `./target/release/wfl --test TestPrograms/laravel_app/laravel_starter_app.test.wfl`
 **Exit:** 1
 **Result:** 16 tests, 1 passed (`that true is true`), 15 failed for the intended reason.
 
diff --git a/History/dev-diary/2026/2026-09-02-laravel-app-port.md b/History/dev-diary/2026/2026-09-02-laravel-app-port.md
index b67b2bcf..8f3ff77c 100644
--- a/History/dev-diary/2026/2026-09-02-laravel-app-port.md
+++ b/History/dev-diary/2026/2026-09-02-laravel-app-port.md
@@ -19,7 +19,7 @@ The 13.x skeleton's public HTTP surface is small, and WFL can express it:
 - `inspire.wfl` as the `artisan inspire` stand-in
 
 Routing is extracted into actions so
-`TestPrograms/laravel_app/feature_example.test.wfl` can assert without a
+`TestPrograms/laravel_app/laravel_starter_app.test.wfl` can assert without a
 socket, and `tests/laravel_app_http_test.rs` drives the real `wfl` binary
 over HTTP.
 
diff --git a/TestPrograms/laravel_app/feature_example.test.wfl b/TestPrograms/laravel_app/laravel_starter_app.test.wfl
similarity index 100%
rename from TestPrograms/laravel_app/feature_example.test.wfl
rename to TestPrograms/laravel_app/laravel_starter_app.test.wfl
diff --git a/examples/laravel-app/README.md b/examples/laravel-app/README.md
index f599e7c5..740f8b38 100644
--- a/examples/laravel-app/README.md
+++ b/examples/laravel-app/README.md
@@ -41,11 +41,11 @@ wfl examples/laravel-app/inspire.wfl   # artisan inspire equivalent
 | Eloquent, migrations, factories, seeders | — | Not ported |
 | Artisan, queues, cache, mail, sessions, broadcasting | — | Not ported |
 | `.env` / `config/*.php` | `.wflcfg` bind address only | Partial |
-| PHPUnit Feature/Unit example tests | `TestPrograms/laravel_app/feature_example.test.wfl` | Mapped + expanded |
+| PHPUnit Feature/Unit example tests | `TestPrograms/laravel_app/laravel_starter_app.test.wfl` | Mapped + expanded |
 
 ## Layout
 
-```
+```text
 app.wfl              front controller (public/index.php + listen)
 routes.wfl           route table (routes/web.php + /up)
 views.wfl            welcome, health, 404, robots bodies
@@ -59,6 +59,6 @@ public/robots.txt    crawler policy
 ## Tests
 
 ```bash
-wfl --test TestPrograms/laravel_app/feature_example.test.wfl
+wfl --test TestPrograms/laravel_app/laravel_starter_app.test.wfl
 cargo test --test laravel_app_http_test
 ```