Web Stack Status

seed ships an operational minimal web transport plus ported policy/validation packages. There is still no full clean-language web framework: the integrated serving facades (web, web_core runtime, web_runtime, webapp, websocket_server) remain archived until the persistent connection-to-response loop, cancellation, and shutdown drain are closed end to end.

Current operational surface

Package/capability	Current surface
`web_core`	operational transport slice: listener setup with address reuse, bounded blocking reads, zero-copy request-line/header parser, allocation-free method/path routing, bounded response builder, retrying full writes (`EINTR`)
`http_server`	parser slice only: allocation-free bounded HTTP/1.1 request parser (`http_server_available() == false`); no connection ownership, keep-alive, chunked bodies, or TLS
`http_client`, `http_fetch`, `tls13`	client-side HTTP/1.1 over raw TCP or TLS 1.3 (G12/G14); bounded redirects, timeouts, and framing
`std-web-request`, `std-web-response`	bounded origin-form target and status/body-limit validation (G15, no I/O)
`std-web-security`	secure-cookie, CSP, and frame policy (G15)
`std-web-static`	traversal-safe relative paths (G15); file serving itself is app-owned
`std-web-template`	escaped/raw-mode policy with safe-text validation (G15)
`std-web-middleware`, `std-web-db`	ordered priorities and backend-neutral query validation (G15/G16)
`std-router`	route-pattern validation only; registration/dispatch are future layers
`oauth` (`grove/libs/oauth`)	embedded OAuth 2.0 authorization-server core over Ridge: registration, PKCE, code exchange, refresh rotation, family revocation (flow test green; site integration open)
`net`, `io`, `byte_buffer`, `text`, `parse`, `task`, `bytes`/`shared_bytes`, `str`/slices	foundations: owned sockets, typed I/O, initialized buffers, token cursor, checked parsing, structured concurrency, ownership-checked binary/text views

Still roadmap items (not operational): TLS server, request-body parsing, chunked transfer, keep-alive connection ownership, cancellation/drain, and WebSocket serving.

Deployed evidence

Ridge Admin (grove/apps/ridge-admin): browser-based app served by a local seed process on loopback — authenticated session, CSRF, origin/Host checks, CSP, bounded HTTP parsing, graceful shutdown. This is the reference pattern for serving a site on the current stack.
web-core-bench tracer: builds web_core through separate compilation and serves one bounded loopback request on port 8080 (deterministic smoke; a persistent multiworker benchmark server is a separate scaling step).

Grove web corpus

Older-generation sources remain under grove/libs/ (e.g. web, web_request, web_response, web_runtime, web_middleware, web_security, web_static, web_template, web_db, web_metrics). They are porting input, not current clean packages: e.g.

./seed/seed check grove/libs/web/src/lib.sd

fails during parsing because the source uses legacy capitalized nominal names and additional superseded forms. Consequently, examples that return types such as WebAppStable, WebContext, or WebResponse must not be presented as operational clean seed code. Use the std-* ports and web_core instead.

Requirements for new web packages

A Grove web package becomes current only after it satisfies all of the following:

Uses clean lower-snake syntax and passes the operational parser/type checker.
Replaces implicit legacy runtime calls with current ordinary packages or explicit audited runtime interfaces.
Uses owned bytes/shared_bytes and borrowed slices for binary request and response bodies.
Makes allocation, blocking, panic, I/O, FFI, and unsafe effects visible.
Encodes socket, connection, request-body, and response-buffer ownership with exact cleanup.
Preserves input/receiver provenance for zero-copy header, path, query, and body views.
Provides typed errors for parse, transport, TLS, timeout, and application failures.
Produces and consumes current .sdi interfaces without source fallback.
Declares platform/runtime requirements and supplies INSTALL.md for FFI.
Passes positive, negative, sanitizer, malformed-input, cancellation, and separate-compilation tests.

Production claims

Until the archived serving layers are closed, seed documentation must not claim current support for:

production (persistent, multiworker) HTTP serving;
TLS server operation;
framework sessions, CORS, or full middleware/WebSocket stacks beyond the ported policy/validation slices;
TechEmpower-compatible product performance through the clean stack;
direct use of legacy Grove web imports (web, webapp, …) by current applications.

Loopback bounded serving in the Ridge Admin pattern, the web_core transport slice, the G15/G16 policy ports, and the oauth flow are covered by their named baselines and tests, and may be claimed exactly as evidenced.

Historical benchmarks over Grove code may remain as explicitly labeled historical evidence. They do not establish operational support for the current language.

Next slices

The transport slice the old roadmap asked for now exists (web_core). The credible next slices, in order, are:

1. request-body parsing (bounded, Content-Length; then chunked)
2. persistent connection loop: keep-alive, cancellation, shutdown drain
3. TLS server
4. dispatch router + static-file serving on the verified loop
5. session/middleware composition on std-* policies + oauth

Routing, middleware, TLS, pooling, templates, and higher application layers should build on the verified transport slice rather than preserving legacy APIs solely for source compatibility.

Track ecosystem priorities in Library Roadmap. The current compiler/library boundary is documented in Operational Library Reference, and Grove compatibility rules are in Grove Compatibility Tree. Gate evidence: G11 (crypto/session/jwt), G12/G14 (HTTP client), G15/G16 (web policy ports, serving archived) under seed/compiler/llvm/tests/GROVE_G*.md.