@junejs/server 0.1.0-dev.4 → 0.1.0-dev.5

package/dist/pipeline-B2V6tKfO.d.ts

@@ -0,0 +1,49 @@
+import { BrandedRoute, RouteContext } from "@junejs/core/route";
+import { AgentConfig } from "@junejs/core/config";
+import React from "react";
+import { DocumentConfig } from "@junejs/core/document";
+import { I18nConfig } from "@junejs/core/i18n";
+import { Resources } from "@junejs/core/resources";
+//#region src/pipeline.d.ts
+type LayoutComponent = React.ComponentType<{
+  children: React.ReactNode;
+}>;
+type LoadingComponent = React.ComponentType;
+type Resolved = {
+  def: BrandedRoute;
+  params: Record<string, string>;
+  chain: LayoutComponent[];
+  loading?: React.ComponentType;
+  boundaryIndex?: number | null;
+  boundaryKey?: string | null;
+};
+type ResourceHandler = (request: Request, ctx: RouteContext) => Response | Promise<Response>;
+type ResolvedResource = {
+  handler: ResourceHandler;
+  params: Record<string, string>;
+};
+type RouteResolver = (pathname: string) => Promise<Resolved | ResolvedResource | null>;
+type PipelineConfig = {
+  docConfig: DocumentConfig;
+  agent: AgentConfig;
+  agentSurface?: MiddlewareHandler;
+  i18n?: I18nConfig;
+  routeList: () => Promise<string[]> | string[];
+  resolve: RouteResolver;
+  resources?: () => Promise<Resources> | Resources;
+  earlyHints?: string[];
+  htmlCacheControl?: string;
+  notFoundComponent?: React.ComponentType<{
+    pathname: string;
+  }>;
+  extra?: ExtraHandler;
+};
+type MiddlewareHandler = (request: Request, url: URL) => Promise<Response | null> | Response | null;
+/** @deprecated the former name (app/_extra); use {@link MiddlewareHandler}. */
+type ExtraHandler = MiddlewareHandler;
+type Pipeline = {
+  fetch(request: Request): Promise<Response>;
+};
+declare function createPipeline(cfg: PipelineConfig): Pipeline;
+//#endregion
+export { Pipeline as a, ResolvedResource as c, createPipeline as d, MiddlewareHandler as i, ResourceHandler as l, LayoutComponent as n, PipelineConfig as o, LoadingComponent as r, Resolved as s, ExtraHandler as t, RouteResolver as u };

package/dist/pipeline.d.ts

@@ -0,0 +1,2 @@
+import { a as Pipeline, c as ResolvedResource, d as createPipeline, i as MiddlewareHandler, l as ResourceHandler, n as LayoutComponent, o as PipelineConfig, r as LoadingComponent, s as Resolved, t as ExtraHandler, u as RouteResolver } from "./pipeline-B2V6tKfO.js";
+export { ExtraHandler, LayoutComponent, LoadingComponent, MiddlewareHandler, Pipeline, PipelineConfig, Resolved, ResolvedResource, ResourceHandler, RouteResolver, createPipeline };

package/dist/pipeline.js

@@ -0,0 +1,235 @@
+import { SEGMENT_HEADER, TITLE_HEADER, encodeTitle, negotiate } from "./negotiate.js";
+import { LoaderDataContext } from "@junejs/core/route";
+import React, { Suspense, use } from "react";
+import { renderToReadableStream } from "react-dom/server";
+import { Document } from "@junejs/core/document";
+import { apiCatalog, buildLinkHeader, llmsTxt, mcpServerCard, robotsTxt, sitemapXml } from "@junejs/core/discovery";
+import { mcpHandler, mcpTools } from "@junejs/core/mcp";
+import { ensureScope, runInScope, setRequestLocale } from "@junejs/db";
+import { LOCALE_COOKIE, localeAlternates, localeDir, matchPinnedLocale, negotiateLocale } from "@junejs/core/i18n";
+//#region src/pipeline.ts
+function readCookie(request, name) {
+	const header = request.headers.get("cookie");
+	if (!header) return void 0;
+	for (const part of header.split(";")) {
+		const eq = part.indexOf("=");
+		if (eq === -1) continue;
+		if (part.slice(0, eq).trim() === name) return decodeURIComponent(part.slice(eq + 1).trim());
+	}
+}
+const DefaultNotFound = ({ pathname }) => React.createElement("main", null, React.createElement("h1", null, "404 — Not found"), React.createElement("p", null, pathname));
+function text(body, contentType, init) {
+	const headers = new Headers(init?.headers);
+	headers.set("content-type", contentType);
+	return new Response(body, {
+		...init,
+		headers
+	});
+}
+function provideLoaderData(data, node) {
+	return React.createElement(LoaderDataContext.Provider, { value: data }, node);
+}
+function StreamedView({ loadPromise, def, ctx }) {
+	const data = use(loadPromise);
+	return provideLoaderData(data, def.view ? def.view(data, ctx) : null);
+}
+function letterFavicon(siteName) {
+	return text(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="12" fill="#1d1d1f"/><text x="32" y="32" dy=".36em" text-anchor="middle" font-family="ui-sans-serif, system-ui, sans-serif" font-size="34" font-weight="600" fill="#fbfbf8">${((siteName ?? "").trim().charAt(0) || "•").toUpperCase().replace(/[<>&"']/g, "") || "•"}</text></svg>\n`, "image/svg+xml", { headers: { "cache-control": "public, max-age=86400" } });
+}
+function createPipeline(cfg) {
+	const { docConfig, agent } = cfg;
+	const NotFound = cfg.notFoundComponent ?? DefaultNotFound;
+	function htmlHeaders() {
+		const headers = new Headers({ "content-type": "text/html; charset=utf-8" });
+		const links = [buildLinkHeader(agent), ...cfg.earlyHints ?? []].filter(Boolean);
+		if (links.length) headers.set("link", links.join(", "));
+		if (cfg.htmlCacheControl) headers.set("cache-control", cfg.htmlCacheControl);
+		return headers;
+	}
+	function langDir(locale) {
+		const lang = locale ?? docConfig.site.lang ?? "en";
+		return {
+			lang,
+			dir: localeDir(lang, cfg.i18n)
+		};
+	}
+	function alternatesFor(ctx) {
+		if (!cfg.i18n) return void 0;
+		const pinned = matchPinnedLocale(cfg.i18n, ctx.url.host, ctx.url.pathname);
+		const routePath = pinned ? pinned.pathname : ctx.url.pathname;
+		return localeAlternates(cfg.i18n, routePath, {
+			currentHost: ctx.url.host,
+			protocol: ctx.url.protocol.replace(":", "")
+		});
+	}
+	async function renderDocument(node, metadata, status, chain, locale, boundaryKey, alternates) {
+		const wrapped = chain.reduceRight((acc, L) => React.createElement(L, null, acc), node);
+		const stream = await renderToReadableStream(React.createElement(Document, {
+			config: docConfigForRender(),
+			metadata,
+			children: wrapped,
+			shellKey: boundaryKey,
+			alternates,
+			...langDir(locale)
+		}));
+		await stream.allReady;
+		return new Response(stream, {
+			status,
+			headers: htmlHeaders()
+		});
+	}
+	async function renderFragment(node, metadata, chain, boundaryIndex, boundaryKey) {
+		const segmented = typeof boundaryIndex === "number" && boundaryKey != null;
+		const stream = await renderToReadableStream((segmented ? chain.slice(boundaryIndex + 1) : chain).reduceRight((acc, L) => React.createElement(L, null, acc), node));
+		await stream.allReady;
+		const html = await new Response(stream).text();
+		const headers = new Headers({ "content-type": "text/html; charset=utf-8" });
+		const title = typeof metadata?.title === "string" ? metadata.title : void 0;
+		if (title) headers.set(TITLE_HEADER, encodeTitle(title));
+		if (segmented) headers.set(SEGMENT_HEADER, boundaryKey);
+		return new Response(html, {
+			status: 200,
+			headers
+		});
+	}
+	function docConfigForRender() {
+		const webmcpTools = agent.webmcp && agent.mcp ? mcpTools() : null;
+		return webmcpTools?.length ? {
+			...docConfig,
+			webmcpTools
+		} : docConfig;
+	}
+	async function renderStreamingDocument(resolved, loadPromise, ctx) {
+		const { def, chain, loading: Loading, boundaryKey } = resolved;
+		const leaf = React.createElement(StreamedView, {
+			loadPromise,
+			def,
+			ctx
+		});
+		const boundary = React.createElement(Suspense, { fallback: Loading ? React.createElement(Loading) : null }, leaf);
+		const wrapped = chain.reduceRight((acc, L) => React.createElement(L, null, acc), boundary);
+		const metadata = typeof def.metadata === "object" ? def.metadata : void 0;
+		const stream = await renderToReadableStream(React.createElement(Document, {
+			config: docConfigForRender(),
+			metadata,
+			children: wrapped,
+			shellKey: boundaryKey,
+			alternates: alternatesFor(ctx),
+			...langDir(ctx.locale)
+		}), { onError: (e) => console.error("[june] streaming render error:", e) });
+		return new Response(stream, {
+			status: 200,
+			headers: htmlHeaders()
+		});
+	}
+	function notFoundResponse(target, pathname, locale) {
+		return target !== "view" ? Response.json({
+			error: "Not Found",
+			path: pathname
+		}, { status: 404 }) : renderDocument(React.createElement(NotFound, { pathname }), {
+			title: "Not found",
+			robots: "noindex"
+		}, 404, [], locale);
+	}
+	function resolveMeta(def, data, ctx) {
+		return typeof def.metadata === "function" ? def.metadata(data, ctx) : def.metadata;
+	}
+	async function renderMarkdown(def, data, ctx) {
+		const jsonData = typeof def.json === "function" ? await def.json(data, ctx) : def.json === false ? null : data;
+		const body = typeof def.md === "function" ? await def.md(data, ctx) : "```json\n" + JSON.stringify(jsonData, null, 2) + "\n```\n";
+		return text(body, "text/markdown; charset=utf-8", { headers: { "x-markdown-tokens": String(Math.ceil(body.length / 4)) } });
+	}
+	async function renderProjection(resolved, target, data, ctx) {
+		const { def, chain, boundaryIndex, boundaryKey } = resolved;
+		if (target !== "fragment" && def[target] === false) return notFoundResponse(target, ctx.url.pathname, ctx.locale);
+		const res = await renderTarget(target, def, data, ctx, chain, boundaryIndex, boundaryKey);
+		res.headers.set("vary", "accept");
+		return res;
+	}
+	async function renderTarget(target, def, data, ctx, chain, boundaryIndex, boundaryKey) {
+		if (target === "md") return renderMarkdown(def, data, ctx);
+		if (target === "json") {
+			const payload = typeof def.json === "function" ? await def.json(data, ctx) : data;
+			return Response.json(payload);
+		}
+		const node = provideLoaderData(data, def.view ? def.view(data, ctx) : null);
+		const meta = resolveMeta(def, data, ctx);
+		if (target === "fragment") return renderFragment(node, meta, chain, boundaryIndex, boundaryKey);
+		return renderDocument(node, meta, 200, chain, ctx.locale, boundaryKey, alternatesFor(ctx));
+	}
+	async function discovery(url) {
+		switch (url.pathname) {
+			case "/llms.txt": return text(llmsTxt(url.origin, await cfg.routeList(), agent, docConfig.site), "text/markdown; charset=utf-8");
+			case "/robots.txt": return text(robotsTxt(url.origin), "text/plain; charset=utf-8");
+			case "/sitemap.xml": return text(sitemapXml(url.origin, await cfg.routeList(), cfg.i18n), "application/xml; charset=utf-8");
+			case "/.well-known/api-catalog": return text(JSON.stringify(apiCatalog(url.origin, agent)), "application/linkset+json");
+			case "/.well-known/mcp/server-card.json": return agent.mcp ? Response.json(mcpServerCard(url.origin)) : null;
+			default: return null;
+		}
+	}
+	async function handleRequest(request) {
+		const url = new URL(request.url);
+		if (url.pathname === "/mcp") {
+			if (!agent.mcp) return notFoundResponse("view", url.pathname);
+			return mcpHandler(request, { request });
+		}
+		if (request.method === "GET" && agent.discovery) {
+			const d = await discovery(url);
+			if (d) return d;
+		}
+		if (agent.runtime.enabled && cfg.agentSurface) {
+			const a = await cfg.agentSurface(request, url);
+			if (a) return a;
+		}
+		if (cfg.extra) {
+			const out = await cfg.extra(request, url);
+			if (out) return out;
+		}
+		if (request.method === "GET" && !docConfig.site.icon && (url.pathname === "/favicon.svg" || url.pathname === "/favicon.ico")) return letterFavicon(docConfig.site.name);
+		let locale;
+		let routeBase = url.pathname;
+		if (cfg.i18n) {
+			const pinned = matchPinnedLocale(cfg.i18n, url.host, url.pathname);
+			if (pinned) {
+				locale = pinned.locale;
+				routeBase = pinned.pathname;
+			} else {
+				const override = cfg.i18n.resolveLocale?.({
+					url,
+					headers: request.headers
+				});
+				locale = override && cfg.i18n.locales[override] ? override : negotiateLocale(cfg.i18n, {
+					acceptLanguage: request.headers.get("accept-language"),
+					cookie: readCookie(request, LOCALE_COOKIE)
+				});
+			}
+			if (locale) setRequestLocale(locale);
+		}
+		const { target, pathname, speculative } = negotiate(url, request, routeBase);
+		const resolved = await cfg.resolve(pathname);
+		if (!resolved) return notFoundResponse(target, pathname, locale);
+		const ctx = {
+			request,
+			url,
+			params: resolved.params,
+			target,
+			locale,
+			speculative
+		};
+		if ("handler" in resolved) return resolved.handler(request, ctx);
+		if (target === "view" && resolved.loading && typeof resolved.def.metadata !== "function") return renderStreamingDocument(resolved, Promise.resolve(resolved.def.load ? resolved.def.load(ctx) : void 0), ctx);
+		let data;
+		try {
+			data = resolved.def.load ? await resolved.def.load(ctx) : void 0;
+		} catch {
+			return notFoundResponse(target, pathname, locale);
+		}
+		return renderProjection(resolved, target, data, ctx);
+	}
+	return { async fetch(request) {
+		await ensureScope();
+		return runInScope({ resources: cfg.resources ? await cfg.resources() : {} }, () => handleRequest(request));
+	} };
+}
+//#endregion
+export { createPipeline };

package/dist/postgres-driver-DkkBFikA.d.ts

@@ -0,0 +1,15 @@
+import { DbFactory, JuneDb } from "@junejs/core/resources";
+//#region src/postgres-driver.d.ts
+interface PgClientLike {
+  query(sql: string, params?: unknown[]): Promise<{
+    rows: unknown[];
+    rowCount: number | null;
+  }>;
+  end(): Promise<void>;
+}
+declare function pgJuneDb(client: PgClientLike): JuneDb;
+declare function postgres(opts: {
+  url: string;
+}): DbFactory;
+//#endregion
+export { pgJuneDb as n, postgres as r, PgClientLike as t };

package/dist/postgres-driver.d.ts

@@ -0,0 +1,2 @@
+import { n as pgJuneDb, r as postgres, t as PgClientLike } from "./postgres-driver-DkkBFikA.js";
+export { PgClientLike, pgJuneDb, postgres };

package/dist/postgres-driver.js

@@ -0,0 +1,50 @@
+//#region src/postgres-driver.ts
+function pgJuneDb(client) {
+	const self = {
+		dialect: "postgres",
+		async query(sql, params = []) {
+			return (await client.query(sql, params)).rows;
+		},
+		async get(sql, params = []) {
+			return (await client.query(sql, params)).rows[0] ?? void 0;
+		},
+		async run(sql, params = []) {
+			return {
+				changes: (await client.query(sql, params)).rowCount ?? 0,
+				lastInsertRowid: 0
+			};
+		},
+		async exec(sql) {
+			await client.query(sql);
+		},
+		async transaction(fn) {
+			await client.query("begin");
+			try {
+				const out = await fn(self);
+				await client.query("commit");
+				return out;
+			} catch (e) {
+				await client.query("rollback");
+				throw e;
+			}
+		},
+		async close() {
+			await client.end();
+		}
+	};
+	return self;
+}
+function postgres(opts) {
+	return {
+		kind: "postgres",
+		open: async () => {
+			const mod = await import("pg");
+			const Client = (mod.default ?? mod).Client;
+			const client = new Client({ connectionString: opts.url });
+			await client.connect();
+			return pgJuneDb(client);
+		}
+	};
+}
+//#endregion
+export { pgJuneDb, postgres };

package/dist/resources.d.ts

@@ -0,0 +1,15 @@
+import { t as D1Database } from "./d1-BkdUg9kg.js";
+import { ResourceConfig, Resources } from "@junejs/core/resources";
+//#region src/resources.d.ts
+declare function memoizeResources(config?: ResourceConfig): () => Promise<Resources>;
+type WorkerEnv = {
+  DB?: D1Database;
+} & Record<string, unknown>;
+type ResourceFlags = {
+  db?: boolean;
+  kv?: boolean;
+  blob?: boolean;
+};
+declare function bindWorkerResources(flags: ResourceFlags): (env?: unknown) => Promise<Resources>;
+//#endregion
+export { ResourceFlags, WorkerEnv, bindWorkerResources, memoizeResources };

package/dist/resources.js

@@ -0,0 +1,31 @@
+import { d1 } from "./d1.js";
+//#region src/resources.ts
+function memoizeResources(config) {
+	if (!config || !config.db && !config.kv && !config.blob) {
+		const empty = {};
+		return () => Promise.resolve(empty);
+	}
+	let opened = null;
+	return () => {
+		if (!opened) opened = (async () => ({
+			db: config.db ? await config.db.open() : void 0,
+			kv: config.kv ? await config.kv.open() : void 0,
+			blob: config.blob ? await config.blob.open() : void 0
+		}))();
+		return opened;
+	};
+}
+function bindWorkerResources(flags) {
+	if (!flags.db && !flags.kv && !flags.blob) {
+		const empty = {};
+		return () => Promise.resolve(empty);
+	}
+	let opened = null;
+	return (rawEnv) => {
+		const env = rawEnv;
+		if (!opened) opened = (async () => ({ db: flags.db && env?.DB ? await d1(env.DB).open() : void 0 }))();
+		return opened;
+	};
+}
+//#endregion
+export { bindWorkerResources, memoizeResources };

package/dist/router.d.ts

@@ -0,0 +1,32 @@
+//#region src/router.d.ts
+type RouteMatch = {
+  file: string;
+  params: Record<string, string>;
+};
+type SegmentMatch = {
+  dir: string;
+  layout?: string;
+  loading?: string;
+  error?: string;
+  notFound?: string;
+};
+type RouteTreeMatch = {
+  file: string;
+  params: Record<string, string>;
+  segments: SegmentMatch[];
+};
+declare function findMiddlewareFile(appDir: string): string | null;
+type MatchOptions = {
+  pageConvention?: boolean;
+};
+declare function isResourceFile(file: string): boolean;
+declare function matchRouteTree(appDir: string, pathname: string, options?: MatchOptions): Promise<RouteTreeMatch | null>;
+declare function resolveNotFound(appDir: string, pathname: string): Promise<{
+  segments: SegmentMatch[];
+  notFound?: string;
+}>;
+declare function routeFiles(appDir: string, options?: MatchOptions): Promise<string[]>;
+declare function listRoutes(appDir: string, options?: MatchOptions): Promise<string[]>;
+declare function matchRoute(appDir: string, pathname: string, options?: MatchOptions): Promise<RouteMatch | null>;
+//#endregion
+export { MatchOptions, RouteMatch, RouteTreeMatch, SegmentMatch, findMiddlewareFile, isResourceFile, listRoutes, matchRoute, matchRouteTree, resolveNotFound, routeFiles };

package/dist/router.js

@@ -0,0 +1,183 @@
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+//#region src/router.ts
+const routeExtensions = /* @__PURE__ */ new Set([
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+]);
+function findMiddlewareFile(appDir) {
+	for (const ext of routeExtensions) {
+		const f = join(appDir, `_middleware${ext}`);
+		if (existsSync(f)) return f;
+	}
+	for (const ext of routeExtensions) {
+		const f = join(appDir, `_extra${ext}`);
+		if (existsSync(f)) {
+			console.warn("[june] app/_extra is deprecated — rename it to app/_middleware.");
+			return f;
+		}
+	}
+	return null;
+}
+function baseName(file) {
+	return (file.split(sep).pop() ?? "").replace(/\.[^.]+$/, "");
+}
+function isPageFile(file) {
+	const base = baseName(file);
+	return base === "page" || base === "index";
+}
+function isResourceFile(file) {
+	return baseName(file) === "route";
+}
+const SPECIAL_FILES = /* @__PURE__ */ new Set([
+	"layout",
+	"loading",
+	"error",
+	"not-found"
+]);
+function isSpecialFile(file) {
+	return SPECIAL_FILES.has(baseName(file));
+}
+const isRouteGroup = (name) => /^\(.+\)$/.test(name);
+const isParamDir = (name) => /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
+const isOptionalDir = (name) => /^\[\[([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
+const isOptionalCatchAllDir = (name) => /^\[\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
+const isCatchAllDir = (name) => /^\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
+const paramName = (name) => name.replace(/^\[+(\.\.\.)?|\]+$/g, "");
+async function listDir(dir) {
+	return (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((e) => !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => ({
+		name: e.name,
+		dir: e.isDirectory()
+	}));
+}
+function fileFor(entries, dir, base) {
+	for (const ext of [
+		".tsx",
+		".jsx",
+		".ts",
+		".js"
+	]) if (entries.some((e) => !e.dir && e.name === base + ext)) return join(dir, base + ext);
+}
+function segmentAt(dir, entries) {
+	return {
+		dir,
+		layout: fileFor(entries, dir, "layout"),
+		loading: fileFor(entries, dir, "loading"),
+		error: fileFor(entries, dir, "error"),
+		notFound: fileFor(entries, dir, "not-found")
+	};
+}
+async function walk(dir) {
+	const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+	return (await Promise.all(entries.map((entry) => {
+		const path = join(dir, entry.name);
+		return entry.isDirectory() ? walk(path) : [path];
+	}))).flat();
+}
+function routePath(appDir, file) {
+	const parts = relative(appDir, file).split(sep).join("/").replace(/\.[^.]+$/, "").split("/").filter((p) => !isRouteGroup(p));
+	if (parts.at(-1) === "page" || parts.at(-1) === "index" || parts.at(-1) === "route") parts.pop();
+	return `/${parts.join("/")}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+async function matchRouteTree(appDir, pathname, options = {}) {
+	const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);
+	async function descend(dir, rest, params, chain) {
+		const entries = await listDir(dir);
+		const segments = [...chain, segmentAt(dir, entries)];
+		if (rest.length === 0) {
+			const page = fileFor(entries, dir, "page") ?? fileFor(entries, dir, "index") ?? fileFor(entries, dir, "route");
+			if (page) return {
+				file: page,
+				params,
+				segments
+			};
+		} else if (!options.pageConvention) {
+			if (rest.length === 1) {
+				const leaf = fileFor(entries, dir, rest[0]);
+				if (leaf && !isSpecialFile(leaf) && !isPageFile(leaf)) return {
+					file: leaf,
+					params,
+					segments
+				};
+			}
+		}
+		for (const e of entries) {
+			if (!e.dir || !isRouteGroup(e.name)) continue;
+			const hit = await descend(join(dir, e.name), rest, params, segments);
+			if (hit) return hit;
+		}
+		if (rest.length === 0) {
+			for (const e of entries) {
+				if (!e.dir || !(isOptionalDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
+				const hit = await descend(join(dir, e.name), [], params, segments);
+				if (hit) return hit;
+			}
+			return null;
+		}
+		const [head, ...tail] = rest;
+		if (entries.find((e) => e.dir && e.name === head)) {
+			const hit = await descend(join(dir, head), tail, params, segments);
+			if (hit) return hit;
+		}
+		for (const e of entries) {
+			if (!e.dir || !(isParamDir(e.name) || isOptionalDir(e.name))) continue;
+			const hit = await descend(join(dir, e.name), tail, {
+				...params,
+				[paramName(e.name)]: head
+			}, segments);
+			if (hit) return hit;
+		}
+		for (const e of entries) {
+			if (!e.dir || !(isCatchAllDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
+			const hit = await descend(join(dir, e.name), [], {
+				...params,
+				[paramName(e.name)]: rest.join("/")
+			}, segments);
+			if (hit) return hit;
+		}
+		return null;
+	}
+	return descend(appDir, urlSegments, {}, []);
+}
+async function resolveNotFound(appDir, pathname) {
+	const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);
+	const segments = [];
+	let dir = appDir;
+	for (let i = 0; i <= urlSegments.length; i++) {
+		const entries = await listDir(dir);
+		segments.push(segmentAt(dir, entries));
+		if (i === urlSegments.length) break;
+		const next = entries.find((e) => e.dir && e.name === urlSegments[i]);
+		if (!next) break;
+		dir = join(dir, next.name);
+	}
+	return {
+		segments,
+		notFound: [...segments].reverse().find((s) => s.notFound)?.notFound
+	};
+}
+async function routeFiles(appDir, options = {}) {
+	return (await walk(appDir)).filter((file) => {
+		if (!routeExtensions.has(file.match(/\.[^.]+$/)?.[0] ?? "")) return false;
+		if (isSpecialFile(file)) return false;
+		if (file.split(sep).some((p) => p.startsWith("_"))) return false;
+		if (options.pageConvention && !isPageFile(file) && !isResourceFile(file)) return false;
+		return true;
+	});
+}
+async function listRoutes(appDir, options = {}) {
+	const files = (await routeFiles(appDir, options)).filter((file) => !isResourceFile(file));
+	return [...new Set(files.map((file) => routePath(appDir, file)))].sort();
+}
+async function matchRoute(appDir, pathname, options = {}) {
+	const tree = await matchRouteTree(appDir, pathname, options);
+	return tree ? {
+		file: tree.file,
+		params: tree.params
+	} : null;
+}
+//#endregion
+export { findMiddlewareFile, isResourceFile, listRoutes, matchRoute, matchRouteTree, resolveNotFound, routeFiles };

package/dist/rsc-build.d.ts

@@ -0,0 +1,17 @@
+import { DocumentConfig } from "@junejs/core/document";
+//#region src/rsc-build.d.ts
+type RscRoute = {
+  path: string;
+  file: string;
+};
+declare function findRscRoutes(appDir: string): RscRoute[];
+type RscBuildResult = {
+  worker: string;
+  server: string;
+  paths: string[];
+} | null;
+declare function buildRsc(appRoot: string, outDir: string, docConfig: DocumentConfig): Promise<RscBuildResult>;
+type Fetcher = (request: Request) => Promise<Response>;
+declare function createRscDispatch(ssrFetch: Fetcher, rscFetch: Fetcher, rscPaths: Iterable<string>): Fetcher;
+//#endregion
+export { RscBuildResult, RscRoute, buildRsc, createRscDispatch, findRscRoutes };