Web Stack Status

seed does not currently ship an operational clean-language web framework. The top-level Grove tree contains a substantial historical web stack, but its main packages have not been ported to the syntax, ownership model, interfaces, and runtime contracts of the operational LLVM compiler.

Current operational surface

The clean compiler currently stages only the foundations relevant to future web work:

Package/capability	Current surface
`net`	owned IPv4 stream-socket opening and descriptor access
`web_core`	bounded blocking HTTP header reads, zero-copy request-head parsing, and full writes with `EINTR` retry
`io`	typed partial/read-all input and write-all text/byte output
`byte_buffer`	fallible initialized byte-buffer construction
`text`	allocation-free ASCII-delimited token cursor
`parse`	checked integer parsing
`task`	structured channels, joins, events, cancellation, and synchronization
`bytes` / `shared_bytes`	unique mutable and shared read-only binary ownership
`str` / slices	checked provenance-preserving borrowed views

This is enough to build and test lower-level networking components, but it is not yet an HTTP server, router, middleware system, TLS stack, template engine, session layer, or production web runtime.

Grove web corpus

Directories such as these exist under grove/libs/:

web
web_core
web_request
web_response
web_runtime
web_middleware
web_security
web_static
web_template
web_db
web_metrics
websocket_server

They preserve significant API and implementation work from an earlier language generation. They are porting input, not current clean packages. For example:

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

currently 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.

Requirements for an operational web stack

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 those requirements are met, seed documentation must not claim current support for:

production HTTP serving or routing;
TLS client/server verification;
framework middleware, sessions, CSRF, CORS, templates, or static files;
WebSockets;
TechEmpower-compatible product performance through the clean stack;
direct use of Grove web imports by current applications.

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

Porting direction

The smallest credible vertical slice is:

owned socket → bounded read into initialized byte buffer
             → checked request-line/header parser over borrowed views
             → owned response bytes → write_all → exact connection cleanup

Routing, middleware, TLS, pooling, templates, and higher application layers should build on that 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.