Introducción
Desde Fresh
Fresh y el kit de sitios de Ascua comparten el modelo —rutas por archivo, HTML del servidor e islas—. Qué se traduce uno a uno, qué cambia y qué todavía no tiene Ascua.
En octubre de 2026 el equipo de Deno pasó a Cloudflare. El runtime de Deno tendrá un año más de arreglos y parches de seguridad, Deno Deploy cierra en seis meses, y el anuncio no dice nada de Fresh. Si tienes un sitio en Fresh y buscas adónde llevarlo, esta página compara los dos con honestidad.
Lo que se parece. El kit de sitios de Ascua tiene el mismo modelo que Fresh: una página por archivo de rutas, HTML hecho en el servidor y JavaScript solo en las islas. Las carpetas, los layouts, la carga de datos y los formularios se traducen casi uno a uno.
Lo que cambia. Fresh escribe los componentes en JSX con Preact; Ascua, en
plantillas view, sin JSX ni Virtual DOM. Migrar no es renombrar archivos:
hay que reescribir los componentes. La estructura, en cambio, se queda.
Dónde corre. El mismo build de Ascua corre en Node, Bun, Deno y
workerd —el runtime de Workers, también en servidores propios—. Ver
Sitios.
Lado a lado
| Fresh 2 | Ascua |
|---|---|
deno run -Ar jsr:@fresh/init |
deno run -A npm:create-ascua |
routes/about.tsx |
src/routes/about.ts |
routes/blog/[slug].tsx |
src/routes/blog/[slug].ts |
routes/old/[...path].tsx |
src/routes/old/[...path].ts |
routes/docs/[[version]].tsx |
src/routes/docs/[[version]].ts |
routes/(marketing)/about.tsx |
src/routes/(marketing)/about.ts |
routes/_layout.tsx |
src/routes/_layout.ts |
routes/_middleware.ts |
src/routes/_middleware.ts |
ctx.state |
locals |
f-client-nav y <Partial name="main"> |
site: { partials: true } y data-partial="main" |
await ctx.next() |
await next(), igual: una Response que se cambia o se reemplaza |
routes/_app.tsx |
index.html, el esqueleto |
routes/_404.tsx |
src/routes/404.ts |
routes/_error.tsx |
src/routes/500.ts, con el error en props.error |
islands/counter.tsx |
src/islands/counter.ts, con defineIsland |
handler con GET y page({ … }) |
export async function load() → prop data |
throw new HttpError(404) |
throw notFound() |
handler con POST y ctx.req.formData() |
export const actions |
handlers con GET, PUT, DELETE… |
export const PUT: RequestHandler, uno por método |
| Validación a mano | validate con field o cualquier Standard Schema |
| Plugin de CSRF | De serie: solo formularios del mismo origen |
useSignal de @preact/signals |
signal de ascua |
| Partials, para formularios | enhance() desde una isla |
| Deno Deploy | Node, Bun, Deno, workerd, Cloudflare Workers |
Una página con datos
En Fresh, el handler de GET carga y la página recibe data:
// Fresh: routes/projects/[id].tsx
export const handler = define.handlers({
async GET(ctx) {
const project = await db.projects.findOne(ctx.params.id);
if (!project) throw new HttpError(404);
return page({ project });
},
});
export default define.page<typeof handler>(({ data }) => (
<div>
<h1>{data.project.name}</h1>
<p>{data.project.stars} stars</p>
</div>
));En Ascua, load() recibe los parámetros y lo que devuelve llega en data:
// Ascua: src/routes/projects/[id].ts
import { notFound } from "vite-plugin-ascua/site";
export async function load({ id }: { id: string }) {
const project = await db.projects.findOne(id);
if (!project) throw notFound();
return project;
}
type Project = Awaited<ReturnType<typeof load>>;
export const title = ({ data }: { data: Project }) => data.name;
export default function ProjectPage({ data }: { data: Project }) {
return view`
<div>
<h1>${data.name}</h1>
<p>${data.stars} stars</p>
</div>`;
}title, description y head son exportaciones de la ruta, no un
componente aparte. En un sitio estático, una ruta con parámetros dice qué
páginas generar con paths(); con servidor (site: { mode: "server" }),
cualquier valor llega a load().
Una isla
Fresh pone las islas en islands/ y las usa como un componente más:
// Fresh: islands/counter.tsx
import { useSignal } from "@preact/signals";
export default function Counter(props: { start: number }) {
const count = useSignal(props.start);
return <button onClick={() => (count.value += 1)}>Count: {count}</button>;
}En Ascua la isla declara el esquema de sus props, que viajan como JSON:
// Ascua: src/islands/counter.ts
import { defineIsland, p, signal } from "ascua";
function Counter(props: { start: number }) {
const count = signal(props.start);
return view`<button onclick=${() => count.update((n) => n + 1)}>Count: ${() => count()}</button>`;
}
export const CounterIsland = defineIsland("counter", { start: p.number }, Counter);// la página
import { CounterIsland } from "../islands/counter.js";
export default function Home() {
return view`<main><CounterIsland start=${3}/></main>`;
}Las diferencias:
- Un signal es una función. Se lee con
count(), no concount.value, y en la plantilla va dentro de() => …para que el texto se actualice. - Las props se validan. El esquema de
defineIslandcomprueba al hidratar lo que llegó del servidor. Aceptapo cualquier Standard Schema (Zod, Valibot…). Date,Map,Set,URL,bigint, con su esquema. Fresh los serializa solo; en Ascua viajan como JSON y el esquema (p.date,p.map(…)…) dice en qué se convierten al llegar. JSX hecho en el servidor como hijos de la isla no viaja.- El cliente adopta el HTML. Al hidratar, Ascua usa los nodos que llegaron del servidor en vez de volver a crearlos.
Un formulario
En Fresh, el POST lee el formulario, valida a mano y redirige con un 303
escrito a mano:
// Fresh: routes/subscribe.tsx
export const handler = define.handlers({
async POST(ctx) {
const form = await ctx.req.formData();
const email = form.get("email")?.toString();
// validar…
const headers = new Headers();
headers.set("location", "/thanks-for-subscribing");
return new Response(null, { status: 303, headers });
},
});En Ascua es una acción, con la validación y la redirección incluidas:
// Ascua: src/routes/subscribe.ts
import { fail, field, fields, redirect, validate, type ActionContext, type FormResult } from "vite-plugin-ascua/site";
const Subscription = fields({ email: field.email() });
export const actions = {
async default({ formData }: ActionContext) {
const result = await validate(Subscription, formData);
if (!result.ok) return fail(400, result);
await subscribe(result.data.email);
throw redirect("/thanks-for-subscribing");
},
};
export default function Subscribe({ form }: { form?: FormResult<typeof Subscription> }) {
const error = form?.ok === false ? form.errors.email : "";
return view`
<form method="post">
<input name="email" type="email">
<p class="error">${error ?? ""}</p>
<button>Subscribe</button>
</form>`;
}Sin configurar nada, la acción solo acepta formularios del mismo origen
—el CSRF que en Fresh es un plugin—, el cuerpo tiene un límite y la página
sale con una Content-Security-Policy con el hash de cada script en línea.
Para enviarlo sin recargar, el formulario va en una isla con
enhance().
Lo que Ascua todavía no tiene
Mejor saberlo antes que a mitad de la migración:
- JSX. Si el equipo no quiere dejar JSX, Ascua no es para ese proyecto.
- HTML del servidor dentro de una isla. En Fresh se le pasa JSX ya pintado como prop o hijo; en Ascua una isla recibe datos, no marcado.
- Saltarse el layout en una página (
skipInheritedLayouts,skipAppWrapper): toda página hereda los_layout.tsde sus carpetas. - Partials que añaden (
mode="append"/"prepend"): los de Ascua reemplazan la región. - Más tipos en las props de una isla: Fresh lleva también
RegExp,Uint8Array,Temporaly referencias repetidas; Ascua,Date,URL,Map,Setybigint. - Middlewares de serie para CORS y la barra final de la URL: se escriben
con
_middleware.ts.
Por dónde empezar
- Crea el sitio con
deno run -A npm:create-ascua my-site --template servery copia tu esqueleto (_app.tsx) aindex.html. - Pasa primero las rutas sin islas: el layout, las páginas con
load()y la 404. Se ven sin JavaScript, así que se comparan con el sitio viejo página por página. - Después las islas, una por una, con su esquema.
- Al final, los formularios, pasando cada
POSTa una acción.