From 31e8fed49f64e3438a4690b9c6b39a0a3e4c5111 Mon Sep 17 00:00:00 2001
From: gl0w <gl0w@world>
Date: Thu, 10 Sep 2026 06:50:13 +0100
Subject: [PATCH] m6/favicon: icons, head standards, manifest + mime (127
 tests)

---
 src/build.rs                |  15 ++
 src/layout.rs               |  34 ++++-
 src/serve.rs                |  10 ++
 static/favicon.svg          |   8 +
 static/manifest.webmanifest |   1 +
 tests/favicon.rs            | 289 ++++++++++++++++++++++++++++++++++++
 6 files changed, 356 insertions(+), 1 deletion(-)
 create mode 100644 static/favicon.svg
 create mode 100644 static/manifest.webmanifest
 create mode 100644 tests/favicon.rs

diff --git a/src/build.rs b/src/build.rs
index d743377..7eb9b0d 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -222,6 +222,20 @@ fn write_style(out: &Path) -> Result<(), String> {
     std::fs::write(out.join("style.css"), css).map_err(|e| format!("hu13: write style.css: {e}"))
 }
 
+/// Write `out/favicon.svg` + `out/manifest.webmanifest` from the embedded
+/// static files (m6 favicon, f0rge issue #16). SVG-first, zero binary
+/// blobs: the favicon is the hand-written logo mark, and the manifest
+/// points at it (`icons` svg, `short_name` hu13, `display` minimal-ui).
+fn write_favicon_and_manifest(out: &Path) -> Result<(), String> {
+    let icon = include_str!("../static/favicon.svg");
+    std::fs::write(out.join("favicon.svg"), icon)
+        .map_err(|e| format!("hu13: write favicon.svg: {e}"))?;
+    let manifest = include_str!("../static/manifest.webmanifest");
+    std::fs::write(out.join("manifest.webmanifest"), manifest)
+        .map_err(|e| format!("hu13: write manifest.webmanifest: {e}"))?;
+    Ok(())
+}
+
 /// Build the full static site. Returns a summary on success.
 pub fn run_build(repo: &Path, out: &Path, opts: &BuildOptions) -> Result<BuildSummary, String> {
     let branch = gitx::resolve_branch(repo, opts.branch_flag.as_deref())
@@ -264,6 +278,7 @@ pub fn run_build(repo: &Path, out: &Path, opts: &BuildOptions) -> Result<BuildSu
         .map_err(|e| format!("hu13: create files dir: {e}"))?;
     std::fs::create_dir_all(out.join("raw")).map_err(|e| format!("hu13: create raw dir: {e}"))?;
     write_style(out)?;
+    write_favicon_and_manifest(out)?;
 
     // f0rge readers (m3, issue #7): on-disk `.forge/`. Load once up front
     // so every page (including file pages below) gets a nav with live
diff --git a/src/layout.rs b/src/layout.rs
index af05dbd..691a85f 100644
--- a/src/layout.rs
+++ b/src/layout.rs
@@ -39,6 +39,13 @@ pub fn page(title: &str, nav: &str, body: &str) -> String {
 /// and `og:description` / `meta[name=description]` carry `description`
 /// when present. `site_name` and `description` are escaped (hostile
 /// `<script>` renders as text). `nav`/`body` are inlined as-is like [`page`].
+///
+/// Head standards (m6 favicon, f0rge issue #16) ride along on every page:
+/// SVG-first favicon (`rel=icon` + `apple-touch-icon` both point at
+/// `/favicon.svg` — no binary blobs in the repo), light/dark
+/// `theme-color` (Tokyo Night `#d5d6db` / `#1a1b26`, matching
+/// `static/style.css`), `og:type=website`, and the `manifest.webmanifest`
+/// link..
 #[must_use]
 pub fn page_site(
     title: &str,
@@ -54,9 +61,15 @@ pub fn page_site(
 <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n\
 <meta name=\"color-scheme\" content=\"dark light\">\n\
 <link rel=\"stylesheet\" href=\"/style.css\">\n\
+<link rel=\"icon\" type=\"image/svg+xml\" href=\"/favicon.svg\">\n\
+<link rel=\"apple-touch-icon\" href=\"/favicon.svg\">\n\
+<meta name=\"theme-color\" media=\"(prefers-color-scheme: light)\" content=\"#d5d6db\">\n\
+<meta name=\"theme-color\" media=\"(prefers-color-scheme: dark)\" content=\"#1a1b26\">\n\
+<link rel=\"manifest\" href=\"/manifest.webmanifest\">\n\
 <link rel=\"alternate\" type=\"application/atom+xml\" href=\"/feed.atom\">\n\
 <title>{title_e}</title>\n\
-<meta property=\"og:title\" content=\"{title_e}\">\n"
+<meta property=\"og:title\" content=\"{title_e}\">\n\
+<meta property=\"og:type\" content=\"website\">\n"
     );
     if let Some(d) = description {
         let d_e = esc(d);
@@ -124,4 +137,23 @@ mod tests {
         assert!(html.contains("ok"));
         assert!(html.contains("<main"));
     }
+
+    #[test]
+    fn head_carries_favicon_manifest_theme_og_standards() {
+        // m6 favicon (f0rge issue #16): every layout page carries the
+        // icon links, apple-touch-icon, both theme-colors, og tags,
+        // and the manifest link.
+        let html = page("t", "<nav></nav>", "<p>b</p>");
+        for needle in [
+            "<link rel=\"icon\" type=\"image/svg+xml\" href=\"/favicon.svg\">",
+            "<link rel=\"apple-touch-icon\" href=\"/favicon.svg\">",
+            "<meta name=\"theme-color\" media=\"(prefers-color-scheme: light)\" content=\"#d5d6db\">",
+            "<meta name=\"theme-color\" media=\"(prefers-color-scheme: dark)\" content=\"#1a1b26\">",
+            "<meta property=\"og:title\"",
+            "<meta property=\"og:type\" content=\"website\">",
+            "<link rel=\"manifest\" href=\"/manifest.webmanifest\">",
+        ] {
+            assert!(html.contains(needle), "head carries {needle}");
+        }
+    }
 }
diff --git a/src/serve.rs b/src/serve.rs
index ed60894..796c6fa 100644
--- a/src/serve.rs
+++ b/src/serve.rs
@@ -339,6 +339,10 @@ fn content_type_for(name: &str) -> &'static str {
         "text/html; charset=utf-8"
     } else if lower.ends_with(".css") {
         "text/css; charset=utf-8"
+    } else if lower.ends_with(".svg") {
+        "image/svg+xml"
+    } else if lower.ends_with(".webmanifest") {
+        "application/manifest+json"
     } else if lower.ends_with(".json") {
         "application/json"
     } else if lower.ends_with(".atom") {
@@ -710,6 +714,12 @@ mod tests {
         assert!(content_type_for("s.css").starts_with("text/css"));
         assert!(content_type_for("x.json").starts_with("application/json"));
         assert!(content_type_for("f.atom").contains("atom"));
+        // m6 favicon (f0rge issue #16): svg icon + web app manifest.
+        assert_eq!(content_type_for("favicon.svg"), "image/svg+xml");
+        assert_eq!(
+            content_type_for("manifest.webmanifest"),
+            "application/manifest+json"
+        );
         assert_eq!(content_type_for("b.bundle"), "application/octet-stream");
     }
 
diff --git a/static/favicon.svg b/static/favicon.svg
new file mode 100644
index 0000000..35a4426
--- /dev/null
+++ b/static/favicon.svg
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32" role="img" aria-label="hu13 logo">
+  <title>hu13</title>
+  <rect x="0" y="0" width="32" height="32" fill="#1a1b26"/>
+  <rect x="0.5" y="0.5" width="31" height="31" fill="none" stroke="#292e42"/>
+  <polygon points="16,6 26,16 16,26 6,16" fill="none" stroke="#7aa2f7" stroke-width="3"/>
+  <rect x="13" y="13" width="6" height="6" fill="#7dcfff"/>
+</svg>
diff --git a/static/manifest.webmanifest b/static/manifest.webmanifest
new file mode 100644
index 0000000..125c919
--- /dev/null
+++ b/static/manifest.webmanifest
@@ -0,0 +1 @@
+{"background_color":"#1a1b26","description":"tiny static-site generator + text-only inbox for one repo","display":"minimal-ui","icons":[{"purpose":"any","sizes":"any","src":"/favicon.svg","type":"image/svg+xml"}],"name":"hu13","short_name":"hu13","start_url":"/","theme_color":"#1a1b26"}
\ No newline at end of file
diff --git a/tests/favicon.rs b/tests/favicon.rs
new file mode 100644
index 0000000..4277749
--- /dev/null
+++ b/tests/favicon.rs
@@ -0,0 +1,289 @@
+//! Favicon + head standards (m6, f0rge issue #16):
+//! `static/favicon.svg` (SVG-first, no binary blobs) + head tags on every
+//! built page (icon links, `apple-touch-icon`, light+dark `theme-color`,
+//! og tags, manifest link) + `manifest.webmanifest` valid JSON in the
+//! output + correct serve mime types over HTTP.
+
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::TcpStream;
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, Stdio};
+use std::time::Duration;
+
+fn bin() -> &'static str {
+    env!("CARGO_BIN_EXE_hu13")
+}
+
+fn manifest_dir() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+}
+
+fn fresh(prefix: &str) -> PathBuf {
+    let dir = std::env::temp_dir().join(format!(
+        "hu13-favicon-{prefix}-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_nanos())
+            .unwrap_or(0)
+    ));
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+fn git(repo: &Path, args: &[&str]) {
+    let st = Command::new("git")
+        .arg("-C")
+        .arg(repo)
+        .args(args)
+        .status()
+        .expect("spawn git");
+    assert!(st.success(), "git {args:?} failed");
+}
+
+/// Minimal repo: README + one file + one subdir file, one commit.
+fn fixture_repo() -> PathBuf {
+    let dir = fresh("repo");
+    git(&dir, &["init", "-b", "main"]);
+    git(&dir, &["config", "user.name", "hu13-test"]);
+    git(&dir, &["config", "user.email", "hu13@test.local"]);
+    git(&dir, &["config", "commit.gpgsign", "false"]);
+    std::fs::write(dir.join("README.md"), "# favicon fixture\n").unwrap();
+    std::fs::write(dir.join("hello.txt"), "hello\n").unwrap();
+    std::fs::create_dir_all(dir.join("sub")).unwrap();
+    std::fs::write(dir.join("sub").join("nested.txt"), "nested\n").unwrap();
+    git(&dir, &["add", "-A"]);
+    git(&dir, &["commit", "-m", "init"]);
+    dir
+}
+
+fn build_fixture() -> (PathBuf, PathBuf) {
+    let repo = fixture_repo();
+    let out = fresh("out");
+    let st = Command::new(bin())
+        .arg("build")
+        .arg(&repo)
+        .arg("-o")
+        .arg(&out)
+        .status()
+        .expect("spawn hu13 build");
+    assert!(st.success(), "fixture build exits 0");
+    (repo, out)
+}
+
+/// Every head tag the rubric requires on every page.
+const HEAD_TAGS: &[&str] = &[
+    "<link rel=\"icon\" type=\"image/svg+xml\" href=\"/favicon.svg\">",
+    "<link rel=\"apple-touch-icon\" href=\"/favicon.svg\">",
+    "<meta name=\"theme-color\" media=\"(prefers-color-scheme: light)\" content=\"#d5d6db\">",
+    "<meta name=\"theme-color\" media=\"(prefers-color-scheme: dark)\" content=\"#1a1b26\">",
+    "<meta property=\"og:title\"",
+    "<meta property=\"og:type\" content=\"website\">",
+    "<link rel=\"manifest\" href=\"/manifest.webmanifest\">",
+];
+
+fn collect_html(dir: &Path) -> Vec<PathBuf> {
+    let mut out = Vec::new();
+    let mut stack = vec![dir.to_path_buf()];
+    while let Some(d) = stack.pop() {
+        for ent in std::fs::read_dir(&d).expect("read_dir") {
+            let p = ent.expect("dir entry").path();
+            if p.is_dir() {
+                stack.push(p);
+            } else if p.extension().is_some_and(|e| e == "html") {
+                out.push(p.strip_prefix(dir).expect("prefix").to_path_buf());
+            }
+        }
+    }
+    out.sort();
+    out
+}
+
+#[test]
+fn every_built_page_carries_head_standards() {
+    let (_repo, out) = build_fixture();
+    let pages = collect_html(&out);
+    assert!(
+        pages.len() >= 5,
+        "fixture emits several pages, got {pages:?}"
+    );
+    // Spot-check the headline pages explicitly, then sweep all of them.
+    for spot in ["index.html", "commits.html", "issues/index.html"] {
+        assert!(
+            out.join(spot).exists(),
+            "spot page {spot} exists, pages: {pages:?}"
+        );
+    }
+    for rel in &pages {
+        let html = std::fs::read_to_string(out.join(rel)).expect("read page");
+        for tag in HEAD_TAGS {
+            assert!(html.contains(tag), "{} carries {tag}", rel.display());
+        }
+    }
+}
+
+#[test]
+fn manifest_emitted_and_valid_json() {
+    let (_repo, out) = build_fixture();
+    let raw = std::fs::read_to_string(out.join("manifest.webmanifest"))
+        .expect("build emits manifest.webmanifest");
+    let v: serde_json::Value = serde_json::from_str(&raw).expect("manifest parses as JSON");
+    assert_eq!(v["short_name"], "hu13", "short_name hu13");
+    assert_eq!(v["name"], "hu13", "name hu13");
+    assert!(
+        v["display"].as_str().is_some_and(|d| d.contains("minimal")),
+        "display minimal, got {}",
+        v["display"]
+    );
+    assert_eq!(v["theme_color"], "#1a1b26", "dark theme color");
+    let icons = v["icons"].as_array().expect("icons array");
+    assert!(!icons.is_empty(), "at least one icon");
+    assert!(
+        icons
+            .iter()
+            .any(|i| i["type"] == "image/svg+xml" && i["src"] == "/favicon.svg"),
+        "svg icon entry, got {icons:?}"
+    );
+    // The emitted manifest matches the static source byte-for-byte.
+    let src = std::fs::read_to_string(manifest_dir().join("static").join("manifest.webmanifest"))
+        .expect("static/manifest.webmanifest exists");
+    assert_eq!(raw, src, "emitted manifest mirrors static source");
+}
+
+#[test]
+fn favicon_emitted_svg_only_no_binary_blobs() {
+    let (_repo, out) = build_fixture();
+    let raw = std::fs::read(out.join("favicon.svg")).expect("build emits favicon.svg");
+    assert!(!raw.contains(&0), "favicon has no NUL bytes (text SVG)");
+    let text = String::from_utf8(raw).expect("favicon is valid UTF-8 text");
+    assert!(text.contains("<svg"), "favicon is an SVG document");
+    assert!(text.contains("viewBox"), "scales via viewBox");
+    // Mirrors the logo mark (same diamond-hub geometry, same palette).
+    let logo =
+        std::fs::read_to_string(manifest_dir().join("static").join("logo.svg")).expect("logo.svg");
+    assert_eq!(text, logo, "favicon adapts logo.svg exactly");
+    // No binary icon formats anywhere in static/ or the build output.
+    for dir in [manifest_dir().join("static"), out.clone()] {
+        let mut stack = vec![dir.clone()];
+        while let Some(d) = stack.pop() {
+            for ent in std::fs::read_dir(&d).expect("read_dir") {
+                let p = ent.expect("dir entry").path();
+                if p.is_dir() {
+                    stack.push(p);
+                    continue;
+                }
+                let ext = p
+                    .extension()
+                    .map(|e| e.to_string_lossy().to_ascii_lowercase())
+                    .unwrap_or_default();
+                assert!(
+                    !["ico", "png", "icns"].contains(&ext.as_str()),
+                    "no binary icon blobs: {}",
+                    p.display()
+                );
+            }
+        }
+    }
+}
+
+// ---- serve mime over HTTP ----------------------------------------------
+
+struct Server {
+    child: Child,
+    addr: String,
+}
+
+impl Drop for Server {
+    fn drop(&mut self) {
+        self.child.kill().ok();
+        self.child.wait().ok();
+    }
+}
+
+fn start_server(www: &Path, inbox: &Path) -> Server {
+    let mut child = Command::new(bin())
+        .arg("serve")
+        .arg("--www")
+        .arg(www)
+        .arg("--inbox-dir")
+        .arg(inbox)
+        .arg("--listen")
+        .arg("127.0.0.1:0")
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .expect("spawn hu13 serve");
+    let stdout = child.stdout.take().expect("piped stdout");
+    let mut lines = BufReader::new(stdout).lines();
+    let mut addr = String::new();
+    for _ in 0..50 {
+        match lines.next() {
+            Some(Ok(line)) if line.contains("listening on ") => {
+                addr = line
+                    .rsplit("listening on ")
+                    .next()
+                    .unwrap_or("")
+                    .trim()
+                    .to_string();
+                break;
+            }
+            Some(Ok(_)) => continue,
+            _ => break,
+        }
+    }
+    assert!(!addr.is_empty(), "serve printed no `listening on` line");
+    std::thread::sleep(Duration::from_millis(100));
+    Server { child, addr }
+}
+
+fn get(addr: &str, path: &str) -> String {
+    let mut s = TcpStream::connect(addr).expect("connect");
+    s.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
+    s.set_write_timeout(Some(Duration::from_secs(10))).unwrap();
+    let req = format!("GET {path} HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n");
+    s.write_all(req.as_bytes()).expect("write");
+    let mut out = Vec::new();
+    s.read_to_end(&mut out).expect("read");
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+fn header<'a>(resp: &'a str, name: &str) -> Option<&'a str> {
+    let want = name.to_ascii_lowercase();
+    resp.split("\r\n").find_map(|line| {
+        let (k, v) = line.split_once(':')?;
+        if k.trim().to_ascii_lowercase() == want {
+            Some(v.trim())
+        } else {
+            None
+        }
+    })
+}
+
+#[test]
+fn serve_maps_webmanifest_and_svg_mime() {
+    let (_repo, out) = build_fixture();
+    let inbox = fresh("inbox");
+    let srv = start_server(&out, &inbox);
+
+    let m = get(&srv.addr, "/manifest.webmanifest");
+    assert!(
+        m.split("\r\n").next().unwrap_or("").contains("200"),
+        "manifest serves 200, got: {m}"
+    );
+    assert_eq!(
+        header(&m, "Content-Type"),
+        Some("application/manifest+json"),
+        "webmanifest mime, got: {m}"
+    );
+
+    let f = get(&srv.addr, "/favicon.svg");
+    assert!(
+        f.split("\r\n").next().unwrap_or("").contains("200"),
+        "favicon serves 200, got: {f}"
+    );
+    assert_eq!(
+        header(&f, "Content-Type"),
+        Some("image/svg+xml"),
+        "svg mime, got: {f}"
+    );
+}
-- 
2.55.0