Documentation

• Getting started — Scaffold, develop, build, and deploy a June app in four commands.
• Dual audience — One page definition serves humans (HTML) and agents (markdown, JSON, MCP).
• Build & deploy — What june build generates, how prerender works, and the deploy adapters.
• Deployment — One portable core, one host interface, one adapter per target — Workers today, self-hosted and Vercel on the same seam.

Features

• Built-in MCP — Every June app is an MCP server — defineAction() is simultaneously a server action, an MCP tool, and a manifest entry, behind one authorization gate.
• Built-in llms.txt — The agent discovery surface — llms.txt, sitemap, robots, api-catalog, and per-route manifests — derives from your routes automatically.
• Markdown without drift — Append .md to any page and get markdown — for authored content it's your source file byte-for-byte, never a lossy HTML reconstruction.
• OG images, typeset at the edge — Social cards as a route that returns a PNG — satori + resvg in the worker, with runtime font subsetting so CJK titles work.
• React Server Components, server-first — Every page is a server component tree rendered on the server; client code is an explicit island; actions are server functions with one authorization gate.
• App Router: the filesystem is the route table — page.tsx is a route, [slug] is a param, (group) shapes the tree without the URL, _anything colocates — one matcher drives dev and the build.
• Layouts: nested, composed, frozen — layout.tsx wraps its segment and everything below; chains compose root → leaf, and the build freezes the same chain dev resolves.
• Islands: zero client JS by default — Pages ship no JavaScript unless a subtree opts in — one <Island> hydrates against an explicit registry while the rest stays server-rendered HTML.
• Styling: global CSS, Tailwind, CSS Modules — app/global.css is auto-linked (no import); Tailwind v4 is the blessed default; *.module.css scopes deterministically. Dev serves readable CSS with HMR, build ships hashed, immutable, minified.
• Navigation: instant without a client router — Hover prerenders the next page (Speculation Rules), the click is zero-network, View Transitions animate the swap — the browser is the router.
• Client Router: the opt-in SPA layer — Off by default — turn it on for app-like surfaces that need in-memory state to survive navigation. Soft swaps over the same HTML the server already serves, with <Island persist> for websockets.
• Live updates: a connection that survives navigation — Put a server-push connection (SSE or WebSocket) inside a persist island — it keeps streaming across soft navigations instead of reconnecting on every click. Plus what to know about connection limits when you deploy.
• Data: ambient db + cache magic — Declare db/kv/blob once and reach them with `import { db } from "@junejs/db"` — no request object threaded; a write auto-invalidates cached reads and N reads auto-batch.
• Web Standards end to end — The whole framework is one fetch handler — Request in, Response out, Web Streams in between. Standards are the portability mechanism, not a checkbox.
• Runtime: Bun-first toolchain, runtime-agnostic core — One tool runs install/test/dev; the core assumes no runtime at all — which is why the same app serves from Bun, Node, and workerd.
• DX: a loop with no assembly — Zero-config dev, dev/built parity by construction, an oracle for every artifact — and push-based HMR on the experimental runtime track.
• The june CLI — Five verbs — dev, build, deploy, gen, info — installed locally by the scaffold, version-pinned per project, with --dry-run as the CI contract.