Fullstack from day one. Fewer architectural decisions. Predictable code for humans and agents — under one CLI and one set of conventions. Agents know what to write. Humans know how to review. Everything underneath remains yours.
Proven libraries, one coherent framework — Bun · Elysia · Vite · TypeBox
A generated project rather than a description of one — same layout every time, documented for a person, an agent, and a compiler.
Click a file or a tab — 1–3 work too. The terminal is live.
# AGENTS.md Every Typeway app ships this file. It is written for the tools that write code here, and it is generated — not maintained by hand. ## Layout app/ domain logic. models, context, use cases. config/ typed configuration. env is validated at boot. db/ schema and migrations. one table per file. server/ http. elysia routes, middleware, the app instance. src/ frontend. src/server.ts is the SSR entry — the name is load-bearing, do not rename it. tests/ integration tests. unit tests live beside sources. ## Rules - Models are app/models/<singular>.ts and export queries, never a bare table. The table lives in db/schema/. - Database access goes through getDb(), which resolves the request scope. Never import the connection directly. - Validation is TypeBox everywhere: request schemas, config, models. Do not add a second validation library. - Routes are registered on the Elysia app; anything unmatched is the frontend's. Do not add a catch-all route. ## Commands bun run dev api + ssr + hmr, one process bun run build client, ssr and server bundles bun test unit and integration typeway generate scaffolds code and the docs for it ## When you add a capability Run typeway add <name> rather than wiring it by hand. It writes the integration, the conventions section in this file, and a skill — so the next agent starts where you finished.
// The one SSR entry. Dev and production run this exact module. import { connect } from "@typeway/connect"; import { app } from "../server/app"; import { createServer } from "vite"; const dev = process.env.NODE_ENV !== "production"; if (dev) { const vite = await createServer({ server: { middlewareMode: true }, }); // Registered routes never reach the bridge — Elysia's router // gives them precedence over the wildcard connect() mounts. app.use( connect(vite.middlewares, { fallback: async (request) => { const { default: ssr } = await vite.environments.ssr.runner .import("./src/server.ts"); return ssr.fetch(request); }, }), ); } else { // The build emits a fetch-native handler, so production mounts it // directly (~0.4 µs) instead of paying for a bridge round-trip. app.mount(await loadBuiltHandler()); } app.listen(3000);
Typeway gives every change a familiar shape. Agents follow deterministic, greppable conventions, while generated guidance keeps intent next to implementation — so reviewers can focus on behavior instead of reconstructing how the project is organized.
A full-stack framework with strong conventions for every part of your application.
Domain models in a known place, TypeBox schemas everywhere, migrations and factories as convention — on the ORM you choose.
Typed Elysia routes for the backend; anything unmatched is the frontend. No catch-all route to invent, and registered routes never touch the Vite bridge.
One app, three rendering strategies — each a one-line decision, each tested in development and production.
typeway add for better-auth, a Postgres-backed job queue, react-email, websocket
channels, and Bun's native S3 client — wired and documented the same way every time.
Factories and request specs through Eden, safe defaults from the first request, and one-binary
deploys with bun --compile.
One command scaffolds the table, the domain model, and the docs for both.
$ typeway generate model article
✓ db/schema/article.ts
✓ app/models/article.ts
✓ AGENTS.md # documented where the next agent will lookQueries live with the model. The table stays in db/schema/. Validation is TypeBox.
export const Article = {
recent: () => getDb().query.articles.findMany({
orderBy: (t, { desc }) => desc(t.createdAt),
limit: 25,
}),
create: (input: Static<typeof ArticleInput>) =>
getDb().insert(articles).values(input).returning(),
};Elysia handlers stay thin. Params and bodies are typed once and shared with the client.
app.get("/api/articles", () => Article.recent())
.post("/api/articles", ({ body }) => Article.create(body), {
body: ArticleInput,
});Same request scope reaches the database from SSR — no second data layer to invent.
export const Route = createFileRoute("/articles")({
loader: () => Article.recent(),
component: ArticlesPage,
});Generators write the knowledge to maintain what they just wrote — so the next edit starts where this one finished.
# from AGENTS.md — generated, not hand-maintained
- Models are app/models/<singular>.ts and export queries, never a bare table.
- Database access goes through getDb(), which resolves the request scope.
- Validation is TypeBox everywhere. Do not add a second validation library.Written as a log rather than a promise: what shipped, on what day, and what it cost. Everything not started yet is at the bottom, where it belongs.
typeway new, generate, add, db and
console — the terminal tab above is what it will feel like. Generators write the
code and the docs for that code in the same pass: an AGENTS.md section and a
skill land next to every file they scaffold.
A domain layer with conventions for structure, relations, migrations, seeds and factories, so a model is a file in a known place rather than a decision. Built on whichever ORM you like — Drizzle is the default because it is the thinnest, but the conventions are the part Typeway ships, so the ORM underneath stays yours to swap.
AsyncLocalStorage gives every incoming request its own scope, so your API routes
and the server-rendering half of your frontend reach the same database handle, the same open
transaction and the same current user — without threading any of it through every function
call. One request, one context, both sides of the app.
The built SSR handler is fetch-native, so production mounts it directly on Elysia
(.mount(), ~0.4 µs) instead of paying for a Connect round-trip, and the client
build is registered as static routes at boot. The bridge is now what it should always have
been: a dev-mode component for Vite.
Not "Typeway does N req/s" — every arm is measured back to back against its own baseline on one machine, interleaved round by round, median by RPS. The question was what the glue costs.
| scenario | ratio | Δ µs/req |
|---|---|---|
| registered route, bridge mounted | 0.985× | +0.2 |
| SSR via connect() fallback | 1.010× | −2.0 |
| static asset, prod path | 0.995× | +0.2 |
| bare bridge round-trip (GET) — dev only | 0.485× | +10.6 |
The last row is the honest one, and it only ever happens in development: a bridge hop costs ~10 µs, which is most of a request that does nothing and none of a request that does something. Production never touches the bridge — the built handler is mounted straight onto Elysia.
One route per TanStack feature that crosses HTTP — streaming SSR, server functions, redirects,
notFound(), cookies, multipart, SSE, binary assets — tested against both the dev
server and a production build, because they are different failure surfaces.
The smoke checks became a real suite that boots the actual dev and production servers. A scheduled job re-runs it against the latest Bun, Elysia, Vite and TanStack, so upstream drift shows up as a red build instead of as a surprise.
The first real piece: run Connect/Express middleware inside an Elysia app, mounted as a
wildcard route so registered routes never touch it. Raw streamed request bodies, streaming
responses, multiple Set-Cookie values preserved, null bodies for 204/304. Zero
runtime dependencies, and that is a constraint we intend to keep.
One commit: a README and an opinion.
typeway add auth over better-auth. A Postgres-backed job queue, because most apps
never needed Redis. react-email templates with adapters and dev previews.
Elysia websockets with channel conventions. A thin layer over Bun's native S3 client. A database-backed cache with Redis as an opt-in, not a prerequisite.
Factories and request specs through Eden, type-checked against your routes. CORS, secure headers and rate limiting on from the first request. Structured logging and OpenTelemetry as a convention rather than a weekend project.
bun --compile, copy it to a box, run it.
One email when bun create typeway actually works — no drip campaign, no countdown.
The build log keeps moving either way.