Astro 6.3: Advanced Routing with Hono Is Live Now

Astro 6.3 landed on May 7 with one headline feature: experimental advanced routing. Every stage of Astro’s request pipeline is now a composable handler. You wire them together in a src/app.ts file and decide exactly what runs, in what order, on what routes. Two entrypoints ship — astro/fetch for a minimal Web Fetch-based API, and astro/hono for full integration with Hono’s middleware ecosystem. It is behind an opt-in flag and explicitly experimental, but the direction it signals is not subtle.

The Problem With Astro’s Old Pipeline

Before 6.3, Astro processed every request through a fixed sequence: trailing slash normalization, redirects, sessions, actions, user middleware, page rendering, i18n, caching. That sequence was non-negotiable. You could hook in with a middleware function, but you could not control where in the pipeline your code ran relative to Astro’s own stages.

In practice, that meant workarounds. Auth checks in middleware ran after actions — the wrong order for most apps. Rate limiting had to live outside Astro entirely, pushed to platform-level edge configs. CORS handling on API routes required fragile checks inside middleware that applied globally. None of this was a bug; it was a design limit that grew more painful as Astro moved deeper into full-stack territory.

How Advanced Routing Works

Enable the flag in your config:

// astro.config.ts
import { defineConfig } from 'astro/config';

export default defineConfig({
  experimental: {
    advancedRouting: true,
  },
});

With the flag on, Astro looks for a src/app.ts file. If it exists, that file becomes the entrypoint for all server-rendered requests. Inside it, you compose handlers from either astro/fetch or astro/hono. The available handlers — trailingSlash, redirects, sessions, actions, middleware, pages, cache, i18n — map to the old fixed pipeline stages. Call them in any order, skip them, or wrap custom logic around them.

astro/hono: The Practical Option

astro/hono wraps every Astro stage as a Hono middleware, which means you get app.use() composition and the full Hono middleware library alongside Astro’s own pipeline. Logger, CORS, JWT, rate limiting, Zod request validation — all available as drop-ins. Here is a realistic example:

// src/app.ts
import { Hono } from 'hono';
import { logger } from 'hono/logger';
import { cors } from 'hono/cors';
import { getCookie } from 'hono/cookie';
import { actions, middleware, pages, i18n, trailingSlash, redirects } from 'astro/hono';

const app = new Hono();

// Log every request
app.use(logger());

// CORS only on API routes
app.use('/api/*', cors({ origin: 'https://yourdomain.com' }));

// Auth gate — runs before actions and page rendering
app.use('/dashboard/*', async (c, next) => {
  const session = getCookie(c, 'session');
  if (!session) return c.redirect('/login');
  return next();
});

// Astro's pipeline stages
app.use(trailingSlash());
app.use(redirects());
app.use(actions());
app.use(middleware());
app.use(pages());
app.use(i18n());

export default app;

The auth check in this example runs before actions() — that was not possible before 6.3. The CORS rule is scoped to /api/* only, with no global middleware bleed. This is the composability that full-stack Astro apps have been missing.

astro/fetch: The Escape Hatch

If you want the same pipeline control without a Hono dependency, astro/fetch exposes the same handlers as plain functions operating on a FetchState object:

// src/app.ts
import { FetchState, trailingSlash, redirects, actions, middleware, pages, i18n } from 'astro/fetch';

export default {
  async fetch(request: Request) {
    const state = new FetchState(request);
    return (
      trailingSlash(state) ??
      redirects(state) ??
      (await actions(state)) ??
      (await middleware(state)) ??
      (await pages(state)) ??
      i18n(state)
    );
  },
};

This is the better fit for non-Cloudflare deployments where Hono’s edge focus is not needed. Both astro/fetch and astro/hono produce identical request handling — the difference is ergonomics and dependencies.

The Cloudflare Angle

It is worth naming why this feature exists in this form. Cloudflare acquired Astro in January 2026. Hono is already the dominant framework for Cloudflare Workers — the thing most Workers developers reach for when they need structured routing and middleware. The astro/hono entrypoint is not a coincidence. It is Cloudflare positioning Astro as the preferred full-stack framework for Workers deployments, while keeping the MIT license and multi-platform support intact.

For teams already running Workers and Astro together, advanced routing removes the last reason to push request-level logic outside the framework. For teams not on Cloudflare, astro/fetch is the hedge — same control, no platform lock-in. Astro is not forcing the choice. But it is betting on one outcome.

What to Do Now

Advanced routing is experimental. The official docs note the API may change before stable. Do not ship to production yet — but do enable it in a dev branch. The Astro team is actively soliciting feedback on the API design, and this is the window to influence how it stabilizes.

• Upgrade to Astro 6.3: npm install astro@6.3
• Add experimental.advancedRouting: true to astro.config.ts
• Create src/app.ts and start with the minimal astro/fetch setup
• Layer in astro/hono when you need middleware composability
• Check the Astro 6.3 release post for the full API reference

The fixed pipeline was a reasonable constraint for a static site tool. Astro is not that anymore, and 6.3 makes that official.