@junejs/server 0.1.2 → 0.2.0

package/dist/pipeline.js

@@ -1,11 +1,16 @@
+import { iconLetter } from "./icon-letter.js";
+import { collectLlmsLinks, collectSitemapPages } from "./llms-links.js";
+import { webManifest } from "./web-manifest.js";
 import { SEGMENT_HEADER, TITLE_HEADER, encodeTitle, negotiate } from "./negotiate.js";
 import { ensureScope, runInScope, setRequestLocale } from "@junejs/db";
 import { LoaderDataContext } from "@junejs/core/route";
+import { siteShortName } from "@junejs/core/config";
 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 { Document, PRERENDER_ORIGIN, documentTitle, pageCanonical } from "@junejs/core/document";
+import { AGENT_SKILLS_INDEX_PATH, AI_CATALOG_PATH, API_CATALOG_CONTENT_TYPE, ARD_PATH, MCP_SERVER_CARD_TYPE, agentSkillsIndex, aiCatalog, apiCatalog, buildLinkHeader, llmsTxt, mcpServerCard, robotsTxt, siteSkill, sitemapXml } from "@junejs/core/discovery";
+import { mcpForbidden, mcpHandler, mcpServerIdentity, mcpTools, originRejection } from "@junejs/core/mcp";
+import { OPENAPI_MEDIA_TYPE, apiActionId, apiForbidden, apiHandler, apiNamespaceResponse, isApiNamespace, openApiDocument } from "@junejs/core/api";
 import { LOCALE_COOKIE, localeAlternates, localeDir, matchPinnedLocale, negotiateLocale } from "@junejs/core/i18n";
 //#region src/pipeline.ts
 function readCookie(request, name) {
@@ -18,6 +23,7 @@ function readCookie(request, name) {
 	}
 }
 const DefaultNotFound = ({ pathname }) => React.createElement("main", null, React.createElement("h1", null, "404 — Not found"), React.createElement("p", null, pathname));
+const CORS = { "access-control-allow-origin": "*" };
 function text(body, contentType, init) {
 	const headers = new Headers(init?.headers);
 	headers.set("content-type", contentType);
@@ -34,14 +40,51 @@ function StreamedView({ loadPromise, def, ctx }) {
 	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" } });
+	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">${(iconLetter(siteName) || "•").replace(/[<>&"']/g, "") || "•"}</text></svg>\n`, "image/svg+xml", { headers: { "cache-control": "public, max-age=86400" } });
+}
+function markdownPath(pathname, isHome) {
+	const path = pathname.replace(/\/+$/, "");
+	return isHome ? `${path.replace(/\/index$/, "")}/index.md` : `${path}.md`;
+}
+function htmlPath(pathname, isHome) {
+	const path = pathname.endsWith(".md") ? pathname.slice(0, -3) : pathname;
+	if (!isHome) return path;
+	return path.replace(/\/+$/, "").replace(/\/index$/, "") || "/";
+}
+const SERVER_CARD_PATH = "/.well-known/mcp/server-card.json";
+const SERVER_CARD_CORS = {
+	"access-control-allow-origin": "*",
+	"access-control-allow-methods": "GET, HEAD",
+	"access-control-allow-headers": "Content-Type, If-None-Match",
+	"access-control-expose-headers": "ETag"
+};
+function humanizeSegment(segment) {
+	let s = segment;
+	try {
+		s = decodeURIComponent(segment);
+	} catch {}
+	s = s.replace(/[-_]+/g, " ").trim();
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+const routePathOf = /* @__PURE__ */ new WeakMap();
+function isDecodablePath(pathname) {
+	try {
+		for (const segment of pathname.split("/"));
+		return true;
+	} catch {
+		return false;
+	}
 }
 function createPipeline(cfg) {
 	const { docConfig, agent } = cfg;
 	const NotFound = cfg.notFoundComponent ?? DefaultNotFound;
+	const publishesCatalogs = agent.discovery && !docConfig.basePath;
 	function htmlHeaders() {
-		const headers = new Headers({ "content-type": "text/html; charset=utf-8" });
-		const links = [buildLinkHeader(agent), ...cfg.earlyHints ?? []].filter(Boolean);
+		const headers = new Headers({
+			"content-type": "text/html; charset=utf-8",
+			vary: "accept"
+		});
+		const links = [buildLinkHeader(agent, { catalogs: publishesCatalogs }), ...cfg.earlyHints ?? []].filter(Boolean);
 		if (links.length) headers.set("link", links.join(", "));
 		if (cfg.htmlCacheControl) headers.set("cache-control", cfg.htmlCacheControl);
 		return headers;
@@ -62,14 +105,57 @@ function createPipeline(cfg) {
 			protocol: ctx.url.protocol.replace(":", "")
 		});
 	}
-	async function renderDocument(node, metadata, status, chain, locale, boundaryKey, alternates) {
+	function pageProps(ctx, def) {
+		const isHome = routePathOf.get(ctx) === "/";
+		return {
+			pageUrl: ctx.url.href,
+			isHome,
+			onLocaleDomain: onLocaleDomain(ctx),
+			markdownHref: agent.discovery && def.md !== false ? markdownPath(ctx.url.pathname, isHome) : void 0
+		};
+	}
+	async function breadcrumbsFor(ctx, meta) {
+		const routePath = routePathOf.get(ctx);
+		if (!routePath || routePath === "/" || meta?.breadcrumb === false) return void 0;
+		const urlPath = ctx.url.pathname.replace(/\/+$/, "") || "/";
+		const route = routePath.replace(/\/+$/, "");
+		const prefix = urlPath.endsWith(route) ? urlPath.slice(0, urlPath.length - route.length) : "";
+		const home = {
+			name: siteShortName(docConfig.site) ?? documentTitle(void 0, docConfig.site),
+			path: prefix || "/"
+		};
+		if (Array.isArray(meta?.breadcrumb)) return [home, ...meta.breadcrumb];
+		const segments = route.split("/").filter(Boolean);
+		const trail = [home];
+		for (let i = 1; i < segments.length; i++) {
+			const ancestor = "/" + segments.slice(0, i).join("/");
+			const r = await resolveRoute(ancestor);
+			if (!r || "handler" in r || Object.keys(r.params).length > 0) continue;
+			const title = typeof r.def.metadata === "object" ? r.def.metadata?.title : void 0;
+			trail.push({
+				name: title || humanizeSegment(segments[i - 1]),
+				path: prefix + ancestor
+			});
+		}
+		trail.push({
+			name: meta?.title || humanizeSegment(segments[segments.length - 1]),
+			path: urlPath
+		});
+		return trail;
+	}
+	function onLocaleDomain(ctx) {
+		const host = ctx.url.hostname.toLowerCase();
+		return cfg.i18n ? Object.values(cfg.i18n.locales).some((l) => l.domain?.toLowerCase() === host) : false;
+	}
+	async function renderDocument(node, metadata, status, chain, locale, boundaryKey, alternates, page) {
 		const wrapped = chain.reduceRight((acc, L) => React.createElement(L, null, acc), node);
 		const stream = await renderToReadableStream(React.createElement(Document, {
-			config: docConfigForRender(),
+			config: docConfigForRender(page?.pageUrl),
 			metadata,
 			children: wrapped,
 			shellKey: boundaryKey,
 			alternates,
+			...page,
 			...langDir(locale)
 		}));
 		await stream.allReady;
@@ -80,7 +166,8 @@ function createPipeline(cfg) {
 	}
 	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));
+		const wrapped = (segmented ? chain.slice(boundaryIndex + 1) : chain).reduceRight((acc, L) => React.createElement(L, null, acc), node);
+		const stream = await renderToReadableStream(wrapped);
 		await stream.allReady;
 		const html = await new Response(stream).text();
 		const headers = new Headers({ "content-type": "text/html; charset=utf-8" });
@@ -92,14 +179,16 @@ function createPipeline(cfg) {
 			headers
 		});
 	}
-	function docConfigForRender() {
+	function docConfigForRender(pageUrl) {
 		const webmcpTools = agent.webmcp && agent.mcp ? mcpTools() : null;
-		return webmcpTools?.length ? {
+		const servesCatalog = !!pageUrl && catalogOrigin(new URL(pageUrl)) !== null;
+		return {
 			...docConfig,
-			webmcpTools
-		} : docConfig;
+			...webmcpTools?.length ? { webmcpTools } : {},
+			...servesCatalog ? { aiCatalog: AI_CATALOG_PATH } : {}
+		};
 	}
-	async function renderStreamingDocument(resolved, loadPromise, ctx) {
+	async function renderStreamingDocument(resolved, loadPromise, ctx, breadcrumbs) {
 		const { def, chain, loading: Loading, boundaryKey } = resolved;
 		const leaf = React.createElement(StreamedView, {
 			loadPromise,
@@ -110,11 +199,13 @@ function createPipeline(cfg) {
 		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(),
+			config: docConfigForRender(ctx.url.href),
 			metadata,
 			children: wrapped,
 			shellKey: boundaryKey,
 			alternates: alternatesFor(ctx),
+			...pageProps(ctx, def),
+			breadcrumbs,
 			...langDir(ctx.locale)
 		}), { onError: (e) => console.error("[june] streaming render error:", e) });
 		return new Response(stream, {
@@ -122,23 +213,74 @@ function createPipeline(cfg) {
 			headers: htmlHeaders()
 		});
 	}
-	function notFoundResponse(target, pathname, locale) {
-		return target !== "view" ? Response.json({
+	async function resolveRoute(pathname) {
+		return isDecodablePath(pathname) ? cfg.resolve(pathname) : null;
+	}
+	function notFoundResponse(target, pathname, locale, unmatched) {
+		if (unmatched && agent.api) {
+			const url = new URL(unmatched.url);
+			if (isApiNamespace(url.pathname)) return apiNamespaceResponse(unmatched, url.origin);
+		}
+		if (target === "md") return discoveryLinks().then((links) => text(notFoundMarkdown(pathname, links), "text/markdown; charset=utf-8", {
+			status: 404,
+			headers: { vary: "accept" }
+		}));
+		if (target !== "view") return discoveryLinks().then((links) => Response.json({
 			error: "Not Found",
-			path: pathname
-		}, { status: 404 }) : renderDocument(React.createElement(NotFound, { pathname }), {
+			code: "not_found",
+			path: pathname,
+			hint: notFoundHint(links)
+		}, {
+			status: 404,
+			headers: { vary: "accept" }
+		}));
+		return renderDocument(React.createElement(NotFound, { pathname }), {
 			title: "Not found",
 			robots: "noindex"
 		}, 404, [], locale);
 	}
+	async function discoveryLinks() {
+		const links = [];
+		if (agent.discovery) links.push(["llms.txt — the site index for agents", "/llms.txt"], ["sitemap.xml — every page", "/sitemap.xml"]);
+		if (agent.mcp) links.push(["MCP server — this site's tools", "/mcp"]);
+		if (agent.api) links.push(["OpenAPI — the same tools over HTTP", "/openapi.json"]);
+		const home = await cfg.resolve("/");
+		if (home && "def" in home && home.def.md !== false) links.push(["Home page (Markdown)", "/index.md"]);
+		return links;
+	}
+	function notFoundHint(links) {
+		return links.length ? `No page at this path. Start from ${links.map(([, h]) => h).join(", ")}.` : "No page at this path.";
+	}
+	function notFoundMarkdown(pathname, links) {
+		const site = docConfig.site.name ? ` on ${docConfig.site.name}` : "";
+		return [
+			"# 404 — Not found",
+			"",
+			links.length ? `There is no page at \`${pathname}\`${site}. Try one of these instead:` : `There is no page at \`${pathname}\`${site}.`,
+			"",
+			...links.map(([label, href]) => `- [${label}](${href})`),
+			""
+		].join("\n");
+	}
 	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";
+		const body = withFrontmatter(typeof def.md === "function" ? await def.md(data, ctx) : "```json\n" + JSON.stringify(jsonData, null, 2) + "\n```\n", resolveMeta(def, data, ctx), ctx);
 		return text(body, "text/markdown; charset=utf-8", { headers: { "x-markdown-tokens": String(Math.ceil(body.length / 4)) } });
 	}
+	function withFrontmatter(body, meta, ctx) {
+		if (/^---\r?\n/.test(body)) return body;
+		const title = meta?.title || documentTitle(meta, docConfig.site);
+		const description = meta?.description ?? docConfig.site.description;
+		const canonical = pageCanonical(docConfig, meta, ctx.url.href, htmlPath(ctx.url.pathname, routePathOf.get(ctx) === "/"), onLocaleDomain(ctx));
+		const lines = ["---", `title: ${JSON.stringify(title)}`];
+		if (description) lines.push(`description: ${JSON.stringify(description)}`);
+		if (canonical) lines.push(`canonical: ${JSON.stringify(canonical)}`);
+		lines.push("---", "");
+		return lines.join("\n") + body;
+	}
 	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);
@@ -155,27 +297,129 @@ function createPipeline(cfg) {
 		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));
+		const page = {
+			...pageProps(ctx, def),
+			breadcrumbs: await breadcrumbsFor(ctx, meta)
+		};
+		return renderDocument(node, meta, 200, chain, ctx.locale, boundaryKey, alternatesFor(ctx), page);
+	}
+	function catalogOrigin(url) {
+		return publishesCatalogs ? publicOrigin(url) : null;
+	}
+	function publicOrigin(url) {
+		if (url.origin !== PRERENDER_ORIGIN) return url.origin;
+		return docConfig.site.url ? new URL(docConfig.site.url).origin : docConfig.deployOrigin ?? null;
+	}
+	function publicBase(url) {
+		const origin = publicOrigin(url);
+		return origin === null ? null : origin + (docConfig.basePath ?? "");
+	}
+	async function agentCatalog(url) {
+		const { pathname } = url;
+		if (!pathname.startsWith("/.well-known/")) return null;
+		const origin = catalogOrigin(url);
+		if (!origin) return null;
+		if (pathname === AGENT_SKILLS_INDEX_PATH) return Response.json(await agentSkillsIndex(origin, agent, docConfig.site), { headers: CORS });
+		if (pathname === AI_CATALOG_PATH || pathname === ARD_PATH) return Response.json(aiCatalog(origin, agent, docConfig.site), { headers: CORS });
+		const skill = siteSkill(origin, agent, docConfig.site);
+		if (pathname === new URL(skill.url).pathname) return text(skill.markdown, "text/markdown; charset=utf-8", { headers: CORS });
+		if (pathname.startsWith("/.well-known/agent-skills/")) return Response.json({
+			error: "Not Found",
+			path: pathname
+		}, {
+			status: 404,
+			headers: CORS
+		});
+		return null;
 	}
 	async function discovery(url) {
+		const catalog = await agentCatalog(url);
+		if (catalog) return catalog;
 		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;
+			case "/llms.txt": {
+				const routes = await cfg.routeList();
+				const base = publicBase(url) ?? docConfig.basePath ?? "";
+				const links = await collectLlmsLinks(base, routes, cfg.resolve);
+				return text(llmsTxt(base, routes, agent, docConfig.site, links), "text/markdown; charset=utf-8");
+			}
+			case "/robots.txt": {
+				const base = publicBase(url);
+				if (base === null) return text("Not Found\n", "text/plain; charset=utf-8", { status: 404 });
+				return text(robotsTxt(base, { catalogs: catalogOrigin(url) !== null }), "text/plain; charset=utf-8");
+			}
+			case "/sitemap.xml": {
+				const base = publicBase(url);
+				if (base === null) return text("Not Found\n", "text/plain; charset=utf-8", { status: 404 });
+				return text(sitemapXml(base, await collectSitemapPages(await cfg.routeList(), cfg.resolve, {
+					i18n: !!cfg.i18n,
+					staticPaths: cfg.staticBuild === true
+				}), cfg.i18n), "application/xml; charset=utf-8");
+			}
+			case "/.well-known/api-catalog": return text(JSON.stringify(apiCatalog(url.origin, agent)), API_CATALOG_CONTENT_TYPE, { headers: { link: `</.well-known/api-catalog>; rel="api-catalog"` } });
+			case SERVER_CARD_PATH: return agent.mcp ? text(JSON.stringify(mcpServerCard(url.origin, {
+				site: docConfig.site,
+				agent,
+				icons: docConfig.icons,
+				basePath: docConfig.basePath
+			})), MCP_SERVER_CARD_TYPE, { headers: {
+				...SERVER_CARD_CORS,
+				"cache-control": "public, max-age=3600"
+			} }) : null;
 			default: return null;
 		}
 	}
+	const originPolicy = {
+		allowedOrigins: agent.allowedOrigins,
+		allowedHosts: agent.allowedHosts
+	};
+	const callerIdentity = async (request) => request.method === "POST" && cfg.identity ? await cfg.identity(request) : void 0;
 	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 });
+			const refused = originRejection(request, originPolicy);
+			if (refused !== void 0) return mcpForbidden(refused);
+			const identity = await callerIdentity(request);
+			return mcpHandler(request, {
+				request,
+				...identity
+			}, mcpServerIdentity(url.origin, {
+				site: docConfig.site,
+				agent
+			}), originPolicy);
 		}
-		if (request.method === "GET" && agent.discovery) {
+		if (agent.api) {
+			if (url.pathname === "/openapi.json" && (request.method === "GET" || request.method === "HEAD")) {
+				const doc = Response.json(openApiDocument(url.origin, docConfig.site), { headers: {
+					"content-type": OPENAPI_MEDIA_TYPE,
+					"access-control-allow-origin": "*"
+				} });
+				return request.method === "HEAD" ? new Response(null, {
+					status: doc.status,
+					headers: doc.headers
+				}) : doc;
+			}
+			const actionId = apiActionId(url.pathname);
+			if (actionId) {
+				const refused = originRejection(request, originPolicy);
+				if (refused !== void 0) return apiForbidden(request, refused);
+				const identity = await callerIdentity(request);
+				return apiHandler(request, actionId, {
+					request,
+					...identity
+				}, originPolicy);
+			}
+		}
+		if (request.method === "OPTIONS" && agent.discovery && agent.mcp && url.pathname === SERVER_CARD_PATH) return new Response(null, {
+			status: 204,
+			headers: SERVER_CARD_CORS
+		});
+		if ((request.method === "GET" || request.method === "HEAD") && agent.discovery) {
 			const d = await discovery(url);
-			if (d) return d;
+			if (d) return request.method === "HEAD" ? new Response(null, {
+				status: d.status,
+				headers: d.headers
+			}) : d;
 		}
 		if (agent.runtime.enabled && cfg.agentSurface) {
 			const a = await cfg.agentSurface(request, url);
@@ -186,6 +430,7 @@ function createPipeline(cfg) {
 			if (out) return out;
 		}
 		if (request.method === "GET" && !docConfig.site.icon && (url.pathname === "/favicon.svg" || url.pathname === "/favicon.ico")) return letterFavicon(docConfig.site.name);
+		if (request.method === "GET" && docConfig.icons?.generated && url.pathname === "/manifest.webmanifest") return text(webManifest(docConfig), "application/manifest+json", { headers: { "cache-control": "public, max-age=86400" } });
 		let locale;
 		let routeBase = url.pathname;
 		if (cfg.i18n) {
@@ -206,8 +451,8 @@ function createPipeline(cfg) {
 			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 resolved = await resolveRoute(pathname);
+		if (!resolved) return notFoundResponse(target, pathname, locale, request);
 		const ctx = {
 			request,
 			url,
@@ -216,8 +461,12 @@ function createPipeline(cfg) {
 			locale,
 			speculative
 		};
+		routePathOf.set(ctx, pathname);
 		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);
+		if (target === "view" && resolved.loading && typeof resolved.def.metadata !== "function") {
+			const breadcrumbs = await breadcrumbsFor(ctx, resolved.def.metadata);
+			return renderStreamingDocument(resolved, Promise.resolve(resolved.def.load ? resolved.def.load(ctx) : void 0), ctx, breadcrumbs);
+		}
 		let data;
 		try {
 			data = resolved.def.load ? await resolved.def.load(ctx) : void 0;
@@ -228,11 +477,13 @@ function createPipeline(cfg) {
 	}
 	return { async fetch(request) {
 		await ensureScope();
+		const resources = cfg.resources ? await cfg.resources() : {};
+		const services = cfg.services ? await cfg.services() : void 0;
 		return runInScope({
-			resources: cfg.resources ? await cfg.resources() : {},
-			services: cfg.services ? await cfg.services() : void 0
+			resources,
+			services
 		}, () => handleRequest(request));
 	} };
 }
 //#endregion
-export { createPipeline };
+export { createPipeline, htmlPath, isDecodablePath, markdownPath };

package/dist/resources.d.ts

@@ -1,15 +1,14 @@
 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 = {
+export declare function memoizeResources(config?: ResourceConfig): () => Promise<Resources>;
+export type WorkerEnv = {
   DB?: D1Database;
 } & Record<string, unknown>;
-type ResourceFlags = {
+export type ResourceFlags = {
   db?: boolean;
   kv?: boolean;
   blob?: boolean;
 };
-declare function bindWorkerResources(flags: ResourceFlags): (env?: unknown) => Promise<Resources>;
-//#endregion
-export { ResourceFlags, WorkerEnv, bindWorkerResources, memoizeResources };
+export declare function bindWorkerResources(flags: ResourceFlags): (env?: unknown) => Promise<Resources>;
+//#endregion

package/dist/route-rank.d.ts

@@ -0,0 +1,10 @@
+//#region src/route-rank.d.ts
+export type SegmentKind = "static" | "param" | "optional" | "catchAll" | "optionalCatchAll";
+export declare function parseSegment(segment: string): {
+  kind: SegmentKind;
+  name?: string;
+};
+export declare function segmentRank(segment: string): number;
+export declare function compareSegments(a: string, b: string): number;
+export declare function compareRoutePatterns(a: string, b: string): number;
+//#endregion

package/dist/route-rank.js

@@ -0,0 +1,38 @@
+//#region src/route-rank.ts
+const DYNAMIC = /^\[(\[)?(\.\.\.)?([A-Za-z_][A-Za-z0-9_]*)\](\])?$/;
+function parseSegment(segment) {
+	const m = segment.match(DYNAMIC);
+	if (!m || !!m[1] !== !!m[4]) return { kind: "static" };
+	const optional = !!m[1];
+	return {
+		kind: !!m[2] ? optional ? "optionalCatchAll" : "catchAll" : optional ? "optional" : "param",
+		name: m[3]
+	};
+}
+const RANK = {
+	static: 0,
+	param: 1,
+	optional: 2,
+	catchAll: 3,
+	optionalCatchAll: 4
+};
+function segmentRank(segment) {
+	return RANK[parseSegment(segment).kind];
+}
+function compareSegments(a, b) {
+	return segmentRank(a) - segmentRank(b) || (a < b ? -1 : a > b ? 1 : 0);
+}
+function compareRoutePatterns(a, b) {
+	const as = a.split("/").filter(Boolean);
+	const bs = b.split("/").filter(Boolean);
+	for (let i = 0; i < Math.max(as.length, bs.length); i++) {
+		const x = as[i];
+		const y = bs[i];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		if (x !== y) return compareSegments(x, y);
+	}
+	return 0;
+}
+//#endregion
+export { compareRoutePatterns, compareSegments, parseSegment, segmentRank };

package/dist/route-scan-BMbBzPIB.d.ts

@@ -0,0 +1,20 @@
+//#region src/route-scan.d.ts
+type RouteEntry = {
+  path: string;
+  file: string;
+  dynamic: boolean;
+  resource?: boolean;
+  generated?: boolean;
+  layouts: string[];
+  loading?: string;
+};
+declare function scanRoutes(appDir: string, dir?: string, layouts?: string[], out?: RouteEntry[], loading?: string): Promise<RouteEntry[]>;
+declare function scanAppRoutes(appRoot: string): Promise<RouteEntry[]>;
+declare function routeConflicts(routes: RouteEntry[]): Array<{
+  path: string;
+  files: string[];
+}>;
+declare function misplacedSegments(routes: RouteEntry[]): RouteEntry[];
+declare function routeProblems(trees: RouteEntry[][], appRoot: string): string | null;
+//#endregion
+export { scanAppRoutes as a, routeProblems as i, misplacedSegments as n, scanRoutes as o, routeConflicts as r, RouteEntry as t };

package/dist/route-scan.d.ts

@@ -0,0 +1,2 @@
+import { a as scanAppRoutes, i as routeProblems, n as misplacedSegments, o as scanRoutes, r as routeConflicts, t as RouteEntry } from "./route-scan-BMbBzPIB.js";
+export { RouteEntry, misplacedSegments, routeConflicts, routeProblems, scanAppRoutes, scanRoutes };

package/dist/route-scan.js

@@ -0,0 +1,100 @@
+import { parseSegment } from "./route-rank.js";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { basename, join, relative, sep } from "node:path";
+//#region src/route-scan.ts
+const PAGE_BASENAMES = /* @__PURE__ */ new Set(["page", "index"]);
+const ROUTE_EXTS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+const isRouteGroup = (name) => /^\(.+\)$/.test(name);
+function segmentFile(dir, base) {
+	return ROUTE_EXTS.map((e) => join(dir, `${base}${e}`)).find(existsSync);
+}
+async function scanRoutes(appDir, dir = appDir, layouts = [], out = [], loading) {
+	const ownLayout = segmentFile(dir, "layout");
+	const chain = ownLayout ? [...layouts, ownLayout] : layouts;
+	const nearestLoading = segmentFile(dir, "loading") ?? loading;
+	const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+	for (const e of entries) {
+		if (e.name.startsWith("_") || e.name.startsWith(".")) continue;
+		const full = join(dir, e.name);
+		if (e.isDirectory()) {
+			await scanRoutes(appDir, full, chain, out, nearestLoading);
+			continue;
+		}
+		const ext = e.name.match(/\.[^.]+$/)?.[0] ?? "";
+		if (!ROUTE_EXTS.includes(ext)) continue;
+		const base = basename(e.name, ext);
+		const resource = base === "route";
+		if (!PAGE_BASENAMES.has(base) && !resource) continue;
+		const relDir = relative(appDir, dir);
+		const path = "/" + (relDir === "" ? [] : relDir.split(sep).filter((s) => !isRouteGroup(s))).join("/");
+		out.push({
+			path: path === "/" ? "/" : path,
+			file: full,
+			dynamic: /\[.+\]/.test(path),
+			resource,
+			layouts: chain,
+			loading: nearestLoading
+		});
+	}
+	return out;
+}
+async function scanAppRoutes(appRoot) {
+	const appDir = join(appRoot, "app");
+	const juneRoutesDir = join(appRoot, ".june", "routes");
+	const appRoutes = await scanRoutes(appDir);
+	const frameworkRoutes = existsSync(juneRoutesDir) ? await scanRoutes(juneRoutesDir) : [];
+	const problems = routeProblems([appRoutes, frameworkRoutes], appRoot);
+	if (problems) throw new Error(problems);
+	const appPaths = new Set(appRoutes.map((r) => r.path));
+	const generated = frameworkRoutes.filter((r) => !appPaths.has(r.path)).map((r) => ({
+		...r,
+		generated: true
+	}));
+	return [...appRoutes, ...generated].sort((a, b) => a.path.localeCompare(b.path));
+}
+function routeConflicts(routes) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const r of routes) {
+		const key = `${r.resource ? "route" : "page"} ${r.path}`;
+		const hit = byKey.get(key);
+		if (hit) hit.files.push(r.file);
+		else byKey.set(key, {
+			path: r.path,
+			files: [r.file]
+		});
+	}
+	return [...byKey.values()].filter((c) => c.files.length > 1).map((c) => ({
+		path: c.path,
+		files: c.files.sort()
+	})).sort((a, b) => a.path.localeCompare(b.path));
+}
+const ENDS_PATH = /* @__PURE__ */ new Set([
+	"optional",
+	"catchAll",
+	"optionalCatchAll"
+]);
+const beforeLast = (path) => path.split("/").filter(Boolean).slice(0, -1).map((s) => parseSegment(s).kind);
+function misplacedSegments(routes) {
+	return routes.filter((r) => beforeLast(r.path).some((k) => ENDS_PATH.has(k))).sort((a, b) => a.path.localeCompare(b.path) || a.file.localeCompare(b.file));
+}
+function routeProblems(trees, appRoot) {
+	const rel = (f) => relative(appRoot, f).split(sep).join("/");
+	const sections = [];
+	const conflicts = trees.flatMap(routeConflicts);
+	if (conflicts.length) sections.push("[june] more than one route file resolves to the same path — keep one per path:\n" + conflicts.map((c) => `  ${c.path}: ${c.files.map(rel).join(", ")}`).join("\n"));
+	const misplaced = trees.flatMap(misplacedSegments);
+	if (misplaced.length) {
+		const lines = misplaced.map((r) => `  ${r.path}: ${rel(r.file)}`);
+		if (misplaced.some((r) => beforeLast(r.path).includes("optional"))) lines.push("  Unlike SvelteKit, June does not skip a [[param]] mid-path. For a locale prefix, set i18n.locales in june.config.ts instead of a [[lang]] directory.");
+		sections.push("[june] an optional or catch-all segment must be the last segment of a route path — nothing may follow it:\n" + lines.join("\n"));
+	}
+	return sections.length ? sections.join("\n") : null;
+}
+//#endregion
+export { misplacedSegments, routeConflicts, routeProblems, scanAppRoutes, scanRoutes };