joist 1.0.0

A backend framework for Rust: routing, middleware, JSON, config and plugins, with no third-party dependencies.
Documentation
# Roadmap

What Joist does not do yet. Everything here is absent rather than stubbed: there
is no function that accepts a call and quietly does nothing, so if it compiles
against 0.1 it works in 0.1.

## Not implemented

| Area | Status | Notes |
| :-- | :-- | :-- |
| WebSockets | Planned | Needs the connection upgrade path and a frame codec. The threaded model suits this badly, see below. |
| Authentication | Planned | Session and token helpers. The middleware hooks already make a guard easy to write by hand today. |
| Database migrations | Planned | Needs a driver, which means the first third-party dependency or a hand-written wire protocol. |
| Background jobs | Planned | The thread pool is most of the machinery; what is missing is scheduling and retries. |
| Queues | Planned | Only meaningful with a broker, so it depends on the driver question above. |
| Caching | Planned | An in-process TTL map is straightforward. A shared cache needs a driver. |
| Observability | Planned | Structured logs and metrics. `RequestLog` is the current extent. |
| Streaming and file responses | Planned | Every body is currently read or built in memory. `Body` is opaque and its accessors already return `Option` so a streaming variant can be added without changing anything that carries a body. |
| TLS | Not planned | Terminate at a reverse proxy. Shipping a TLS stack means either a large dependency or hand-rolled cryptography, and hand-rolled cryptography is a bad idea. |
| `chunked` request bodies | Planned | Currently returns `501` rather than misreading chunk markers as content. |
| HTTP/2 | Not planned | Requires HPACK, framing and multiplexing. That is a different project. |

## The dependency question

Several items above need a database or broker driver. Writing PostgreSQL's wire
protocol by hand is possible and would preserve the zero-dependency property.
Writing five such protocols is not a good use of anyone's life.

The likely answer is optional features: the core stays dependency-free, and a
driver is something you opt into. Nothing is decided.

## The threading question

WebSockets hold connections open for a long time doing very little, which is the
exact workload a thread-per-connection server is worst at. A thousand idle
sockets means a thousand parked threads.

So WebSockets in Joist realistically means one of:

1. A dedicated poll-based loop for upgraded connections, separate from the
   worker pool.
2. Accepting the cost and documenting a much lower connection ceiling.
3. Moving the whole server to async, which would change every handler signature
   and give up most of what makes this framework what it is.

Option 1 is the plan. It is also the reason WebSockets are not simply the next
thing to build.

## Not on the list

Templating, an ORM, an admin panel, and a CLI scaffolder. Not because they are
bad, but because each is a project in its own right and pretending otherwise is
how a framework ends up with ten mediocre subsystems.