W6

tests/wasm_benchmark.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Phase 5 native/WASM benchmark harness.
+
+This runner intentionally has no third-party dependencies. It records a warmed
+native HTTP baseline now and can compare against a future wasm worker by passing
+--wasm-base-url. Results are written as JSON plus a small Markdown table.
+"""
+from __future__ import annotations
+
+import argparse
+import http.client
+import json
+import statistics
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+@dataclass
+class Target:
+    name: str
+    url: str
+    expected: str
+
+
+@dataclass
+class Measurement:
+    backend: str
+    target: str
+    url: str
+    ok: bool
+    status: int
+    samples_ms: list[float]
+    median_ms: float
+    mean_ms: float
+    min_ms: float
+    max_ms: float
+    note: str = ""
+
+
+def request_once(base_url: str, host_header: str, path: str, timeout: float) -> tuple[int, bytes, float]:
+    parsed = urlparse(base_url)
+    if parsed.scheme not in ("http", "https") or not parsed.hostname:
+        raise SystemExit(f"invalid base url: {base_url}")
+    port = parsed.port or (443 if parsed.scheme == "https" else 80)
+    conn_cls = http.client.HTTPSConnection if parsed.scheme == "https" else http.client.HTTPConnection
+    headers = {}
+    if host_header:
+        headers["Host"] = host_header
+    started = time.perf_counter()
+    conn = conn_cls(parsed.hostname, port, timeout=timeout)
+    try:
+        conn.request("GET", path, headers=headers)
+        response = conn.getresponse()
+        body = response.read()
+        elapsed_ms = (time.perf_counter() - started) * 1000.0
+        return response.status, body, elapsed_ms
+    finally:
+        conn.close()
+
+
+def measure_backend(backend: str, base_url: str, host_header: str, targets: list[Target], warmups: int, samples: int, timeout: float) -> list[Measurement]:
+    results: list[Measurement] = []
+    for target in targets:
+        for _ in range(warmups):
+            request_once(base_url, host_header, target.url, timeout)
+        durations: list[float] = []
+        status = 0
+        ok = True
+        note = ""
+        for _ in range(samples):
+            status, body, elapsed_ms = request_once(base_url, host_header, target.url, timeout)
+            durations.append(elapsed_ms)
+            text = body.decode("utf-8", errors="replace")
+            if status != 200:
+                ok = False
+                note = f"HTTP {status}"
+            elif target.expected and target.expected not in text:
+                ok = False
+                note = f"missing marker {target.expected!r}"
+        results.append(Measurement(
+            backend=backend,
+            target=target.name,
+            url=target.url,
+            ok=ok,
+            status=status,
+            samples_ms=durations,
+            median_ms=statistics.median(durations),
+            mean_ms=statistics.fmean(durations),
+            min_ms=min(durations),
+            max_ms=max(durations),
+            note=note,
+        ))
+    return results
+
+
+def compare(results: list[Measurement]) -> list[str]:
+    native = {r.target: r for r in results if r.backend == "native"}
+    lines = ["| target | backend | median ms | mean ms | budget | status |", "|---|---:|---:|---:|---|---|"]
+    for result in results:
+        budget = "baseline"
+        status = "PASS" if result.ok else "FAIL"
+        if result.backend != "native" and result.target in native:
+            limit = native[result.target].median_ms * 2.0
+            budget = f"≤ {limit:.1f} ms"
+            if result.median_ms > limit:
+                status = "FAIL"
+        lines.append(f"| {result.target} | {result.backend} | {result.median_ms:.1f} | {result.mean_ms:.1f} | {budget} | {status} {result.note} |")
+    return lines
+
+
+def build_targets() -> list[Target]:
+    return [
+        Target("template-heavy-doc", "/doc/singlepage.uce", "UCE API"),
+        Target("sqlite-page", "/demo/sqlite.uce", "SQLite"),
+        Target("component-heavy-starter", "/examples/uce-starter/?dashboard", "Dashboard"),
+    ]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Phase 5 native/wasm benchmark harness")
+    parser.add_argument("--native-base-url", default="http://localhost:80")
+    parser.add_argument("--wasm-base-url", default="", help="optional wasm worker URL; omitted until worker exists")
+    parser.add_argument("--backend-label", default="native", help="label for --native-base-url measurements when running one backend at a time")
+    parser.add_argument("--compare-native-json", default="", help="optional prior native benchmark.json for budget comparison")
+    parser.add_argument("--host-header", default="uce.openfu.com")
+    parser.add_argument("--warmups", type=int, default=2)
+    parser.add_argument("--samples", type=int, default=20)
+    parser.add_argument("--timeout", type=float, default=10.0)
+    parser.add_argument("--out-dir", default="/tmp/uce/wasm-phase5")
+    args = parser.parse_args()
+
+    targets = build_targets()
+    results: list[Measurement] = []
+    if args.compare_native_json:
+        for row in json.loads(Path(args.compare_native_json).read_text()):
+            results.append(Measurement(**row))
+    results.extend(measure_backend(args.backend_label, args.native_base_url, args.host_header, targets, args.warmups, args.samples, args.timeout))
+    if args.wasm_base_url:
+        results.extend(measure_backend("wasm", args.wasm_base_url, args.host_header, targets, args.warmups, args.samples, args.timeout))
+
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / "benchmark.json").write_text(json.dumps([asdict(r) for r in results], indent=2) + "\n")
+    md_lines = ["# Phase 5 benchmark report", "", *compare(results), ""]
+    if not args.wasm_base_url and args.backend_label == "native" and not args.compare_native_json:
+        md_lines.append("WASM worker URL was not provided; this report is the native baseline that future wasm runs compare against.")
+    (out_dir / "benchmark.md").write_text("\n".join(md_lines) + "\n")
+    print("\n".join(md_lines))
+    print(f"wrote {out_dir / 'benchmark.json'} and {out_dir / 'benchmark.md'}")
+    return 0 if all(r.ok for r in results) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tests/wasm_site_audit.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Phase 5 audit for cross-request/static state risks in site code files."""
+from __future__ import annotations
+
+import argparse
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SITE = ROOT / "site"
+
+PATTERNS = [
+    ("static local/global", "static "),
+    ("once hook", "ONCE("),
+    ("init hook", "INIT("),
+    ("background task", "task_"),
+]
+
+SKIP_PARTS = {".git", "tmp", "work", "bin", "pkg", "__pycache__"}
+CODE_SUFFIXES = {".uce", ".h"}
+DOC_SUFFIXES = {".txt"}
+
+
+@dataclass
+class Finding:
+    path: str
+    line: int
+    kind: str
+    severity: str
+    text: str
+    note: str
+
+
+def iter_files(include_doc_text: bool) -> list[Path]:
+    suffixes = CODE_SUFFIXES | (DOC_SUFFIXES if include_doc_text else set())
+    result: list[Path] = []
+    for path in SITE.rglob("*"):
+        if not path.is_file():
+            continue
+        if any(part in SKIP_PARTS for part in path.parts):
+            continue
+        if path.suffix not in suffixes:
+            continue
+        result.append(path)
+    return sorted(result)
+
+
+def note_for(kind: str, severity: str) -> str:
+    if severity == "documentation":
+        return "Documentation prose mention; useful for terminology review, not a direct static-state migration finding."
+    if kind in {"once hook", "init hook"}:
+        return "Audit behavior under per-request wasm workspaces; ONCE/INIT may need host-side cache semantics if used for cross-request state."
+    if kind == "background task":
+        return "Task APIs cross request lifetimes; verify they are host handles, not guest statics."
+    return "Check whether state is request-local, immutable, or intentionally persistent; unit statics reset per wasm workspace."
+
+
+def severity_for(path: Path) -> str:
+    return "documentation" if path.suffix in DOC_SUFFIXES else "code"
+
+
+def scan(include_doc_text: bool) -> list[Finding]:
+    findings: list[Finding] = []
+    for path in iter_files(include_doc_text):
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except UnicodeDecodeError:
+            continue
+        severity = severity_for(path)
+        for lineno, line in enumerate(lines, 1):
+            stripped = line.strip()
+            if severity == "code" and (stripped.startswith("//") or stripped.startswith("# ")):
+                continue
+            for kind, needle in PATTERNS:
+                if needle in line:
+                    findings.append(Finding(
+                        path=str(path.relative_to(ROOT)),
+                        line=lineno,
+                        kind=kind,
+                        severity=severity,
+                        text=stripped[:180],
+                        note=note_for(kind, severity),
+                    ))
+    return findings
+
+
+def write_reports(findings: list[Finding], out_dir: Path) -> None:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / "site-static-audit.json").write_text(json.dumps([asdict(f) for f in findings], indent=2) + "\n")
+    lines = ["# Phase 5 site static-state audit", ""]
+    if not findings:
+        lines.append("No candidate cross-request/static-state patterns found.")
+    else:
+        code_count = sum(1 for f in findings if f.severity == "code")
+        doc_count = sum(1 for f in findings if f.severity == "documentation")
+        lines.append(f"Findings: {code_count} code, {doc_count} documentation prose.")
+        lines.append("")
+        lines.extend(["| file | line | severity | kind | code | note |", "|---|---:|---|---|---|---|"])
+        for f in findings:
+            code = f.text.replace("|", "\\|")
+            note = f.note.replace("|", "\\|")
+            lines.append(f"| {f.path} | {f.line} | {f.severity} | {f.kind} | `{code}` | {note} |")
+    (out_dir / "site-static-audit.md").write_text("\n".join(lines) + "\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Phase 5 site static/cross-request-state audit")
+    parser.add_argument("--include-doc-text", action="store_true", help="include site/doc .txt prose as documentation-severity findings")
+    parser.add_argument("--out-dir", default="/tmp/uce/wasm-phase5")
+    args = parser.parse_args()
+    out_dir = Path(args.out_dir)
+    findings = scan(args.include_doc_text)
+    write_reports(findings, out_dir)
+    print(f"Found {len(findings)} candidate static/cross-request patterns")
+    print(f"wrote {out_dir / 'site-static-audit.json'} and {out_dir / 'site-static-audit.md'}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())