@markless/router 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jack Shelton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @markless/router
+
+Markless router: client-side navigation with SSR streaming and build-time
+preload maps. Used through `@markless/core/router` and the
+`@markless/router/vite` plugin.
+
+See the repository for documentation: https://github.com/markless-dev/markless

package/dist/index.d.ts

@@ -0,0 +1,175 @@
+//#region src/route-manifest.d.ts
+interface RouteManifestRoute {
+  readonly pathname: string;
+  readonly pattern: string;
+  readonly file: string;
+  readonly params: readonly RouteManifestParam[];
+}
+interface RouteManifestParam {
+  readonly name: string;
+  readonly kind: 'dynamic' | 'catch-all';
+}
+interface RouteManifestStatusPages {
+  readonly notFound?: string;
+  readonly error?: string;
+}
+interface RouteManifest {
+  readonly routes: readonly RouteManifestRoute[];
+  readonly statusPages: RouteManifestStatusPages;
+}
+interface RouteManifestMatch {
+  readonly route: RouteManifestRoute;
+  readonly params: Readonly<Record<string, string>>;
+}
+declare function buildRouteManifestFromFileIds(fileIds: readonly string[]): RouteManifest;
+declare function normalizeRequestPathname(pathname: string): string;
+declare function normalizeRouteFileId(fileId: string): string;
+declare function matchRouteManifest(pathname: string, manifest: RouteManifest): RouteManifestMatch | undefined;
+//#endregion
+//#region src/request-files.d.ts
+type RequestFileDiagnosticCode = 'http-method-export' | 'invalid-cache-metadata' | 'missing-default-function';
+interface RequestFileDiagnostic {
+  readonly code: RequestFileDiagnosticCode;
+  readonly message: string;
+}
+interface RequestFileDefaultExport {
+  readonly kind: 'function';
+  readonly parameterName?: string;
+}
+interface RequestFileParam {
+  readonly name: string;
+  readonly kind: 'dynamic' | 'catch-all';
+}
+interface ApiRequestFileRoute {
+  readonly pathname: string;
+  readonly pattern: string;
+  readonly params: readonly RequestFileParam[];
+}
+interface ApiRequestFileCache {
+  readonly maxAge: number;
+}
+interface RequestFileTransformResult {
+  readonly code: string;
+  readonly file: string;
+  readonly kind: 'api' | 'middleware';
+}
+type ApiRequestFileMethod = 'all' | 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type RequestFileParseResult = {
+  readonly diagnostics: readonly [];
+  readonly file: string;
+  readonly kind: 'none';
+} | {
+  readonly cache?: ApiRequestFileCache;
+  readonly defaultExport?: RequestFileDefaultExport;
+  readonly diagnostics: readonly RequestFileDiagnostic[];
+  readonly file: string;
+  readonly kind: 'api';
+  readonly method: ApiRequestFileMethod;
+  readonly route: ApiRequestFileRoute;
+} | {
+  readonly defaultExport?: RequestFileDefaultExport;
+  readonly diagnostics: readonly RequestFileDiagnostic[];
+  readonly file: string;
+  readonly kind: 'middleware';
+};
+declare function parseRequestFile(fileId: string, sourceText: string): RequestFileParseResult;
+declare function normalizeRequestFileId(fileId: string): string;
+declare function transformRequestFileSource(fileId: string, sourceText: string): RequestFileTransformResult | undefined;
+//#endregion
+//#region src/route-renderer.d.ts
+declare function startRouteUpdateRenderer(document?: Document): void;
+//#endregion
+//#region src/route-state.d.ts
+declare const MARKLESS_ROUTER_ROUTE_EVENT = "marklessrouternavigate";
+interface RouteState {
+  readonly file: string;
+  readonly params: Readonly<Record<string, string>>;
+  readonly status: number;
+  readonly url: string;
+}
+interface RoutePageModule {
+  readonly default?: unknown;
+}
+interface RouteDocumentModule {
+  readonly default?: unknown;
+}
+interface RouteUpdate {
+  readonly document?: RouteDocumentModule;
+  readonly page: RoutePageModule;
+  readonly route: RouteState;
+  readonly signal?: AbortSignal;
+  readonly onRendered?: () => void;
+}
+declare function routePageProps(route: RouteState): PageProps;
+declare function dispatchRouteUpdate(document: Document, update: RouteUpdate): void;
+//#endregion
+//#region src/index.d.ts
+interface PageProps<Params extends object = Readonly<Record<string, string>>> {
+  readonly params: Readonly<Params>;
+  readonly url: {
+    readonly href: string;
+    readonly pathname: string;
+    readonly search: string;
+  };
+  readonly status: number;
+}
+interface MarklessRouterGeneratedRoutes {}
+interface LinkNavigationProps {
+  readonly prefetch?: boolean | 'intent' | 'viewport';
+  readonly replace?: boolean;
+  readonly scroll?: boolean;
+}
+type DefaultLinkProps = {
+  readonly href?: string;
+  readonly children?: unknown;
+  readonly class?: string;
+  readonly id?: string;
+  readonly target?: string;
+  readonly rel?: string;
+  readonly [prop: string]: unknown;
+} & LinkNavigationProps;
+type LinkProps = MarklessRouterGeneratedRoutes extends {
+  readonly link: infer Props;
+} ? Props : DefaultLinkProps;
+interface AppLocals {}
+interface HttpResponse {
+  readonly headers: Headers;
+  status?: number;
+  statusText?: string;
+}
+interface HttpContext<Locals extends object = AppLocals> {
+  readonly locals: Locals;
+  readonly request: Request;
+  readonly response: HttpResponse;
+  readonly url: URL;
+}
+interface EndpointHttpContext<Params extends object = Readonly<Record<string, string>>, Locals extends object = AppLocals> extends HttpContext<Locals> {
+  readonly params: Readonly<Params>;
+}
+interface MiddlewareHttpContext<Locals extends object = AppLocals> extends HttpContext<Locals> {}
+type RuntimeHttpEvent = {
+  readonly context?: Record<string, unknown>;
+  readonly req?: Request;
+  readonly res?: HttpResponse;
+  readonly url?: URL;
+};
+declare function __marklessCreateHttpContext<Params extends object = Readonly<Record<string, string>>, Locals extends object = AppLocals>(event: RuntimeHttpEvent): EndpointHttpContext<Params, Locals>;
+declare const Html: ((props: {
+  readonly children?: unknown;
+}) => unknown) & {
+  renderSsr(props?: {
+    readonly children?: unknown;
+  }): {
+    html: string;
+  };
+};
+declare const Link: ((props?: LinkProps) => unknown) & {
+  renderCsr(props?: LinkProps): {
+    root: HTMLAnchorElement;
+  };
+  renderSsr(props?: LinkProps): {
+    html: string;
+  };
+};
+//#endregion
+export { type ApiRequestFileCache, type ApiRequestFileMethod, type ApiRequestFileRoute, AppLocals, DefaultLinkProps, EndpointHttpContext, Html, HttpContext, HttpResponse, Link, LinkNavigationProps, LinkProps, MARKLESS_ROUTER_ROUTE_EVENT, MarklessRouterGeneratedRoutes, MiddlewareHttpContext, PageProps, type RequestFileDefaultExport, type RequestFileDiagnostic, type RequestFileDiagnosticCode, type RequestFileParam, type RequestFileParseResult, type RequestFileTransformResult, type RouteDocumentModule, type RouteManifest, type RouteManifestMatch, type RouteManifestParam, type RouteManifestRoute, type RouteManifestStatusPages, type RoutePageModule, type RouteState, type RouteUpdate, __marklessCreateHttpContext, buildRouteManifestFromFileIds, dispatchRouteUpdate, matchRouteManifest, normalizeRequestFileId, normalizeRequestPathname, normalizeRouteFileId, parseRequestFile, routePageProps, startRouteUpdateRenderer, transformRequestFileSource };

package/dist/index.js

@@ -0,0 +1,123 @@
+import { i as normalizeRouteFileId, n as matchRouteManifest, r as normalizeRequestPathname, t as buildRouteManifestFromFileIds } from "./route-manifest-OTaWQ_TC.js";
+import { n as parseRequestFile, r as transformRequestFileSource, t as normalizeRequestFileId } from "./request-files-DTkeaKxU.js";
+import { render } from "@markless/web/render";
+import { MARKLESS_PENDING_MIN_VISIBLE_MS as MARKLESS_NAV_PENDING_MIN_MS, settleOrPendingDeadline } from "@markless/web";
+//#region src/navigation-hold.ts
+async function holdNavigationSwapUntilSettled(input) {
+	const settled = input.runtime.whenAsyncBoundariesSettled?.();
+	if (settled) {
+		if (await settleOrPendingDeadline(settled, input.clock?.wait) === "deadline") await input.runtime.holdPendingSettleCommits?.(MARKLESS_NAV_PENDING_MIN_MS);
+	}
+	if (input.signal?.aborted) return false;
+}
+//#endregion
+//#region src/route-state.ts
+const MARKLESS_ROUTER_ROUTE_EVENT = "marklessrouternavigate";
+const MARKLESS_ROUTER_RENDERER_STARTED = "__marklessRouterRouteRendererStarted";
+function routePageProps(route) {
+	const url = new URL(route.url);
+	return {
+		params: route.params,
+		status: route.status,
+		url: {
+			href: url.href,
+			pathname: url.pathname,
+			search: url.search
+		}
+	};
+}
+function dispatchRouteUpdate(document, update) {
+	document.dispatchEvent(new CustomEvent(MARKLESS_ROUTER_ROUTE_EVENT, { detail: update }));
+}
+//#endregion
+//#region src/route-renderer.ts
+function startRouteUpdateRenderer(document = window.document) {
+	const state = document;
+	if (state["__marklessRouterRouteRendererStarted"]) return;
+	state[MARKLESS_ROUTER_RENDERER_STARTED] = true;
+	document.addEventListener(MARKLESS_ROUTER_ROUTE_EVENT, (event) => {
+		renderRouteUpdate(document, event.detail);
+	});
+}
+async function renderRouteUpdate(document, update) {
+	try {
+		const artifact = update.page.default;
+		if (!artifact || update.signal?.aborted) return;
+		const props = routePageProps(update.route);
+		if (typeof artifact.renderCsr === "function") {
+			await render({ renderCsr: () => artifact.renderCsr?.(props) }, {
+				target: document.body,
+				beforeMount: (container) => holdNavigationSwapUntilSettled({
+					runtime: container.runtime,
+					signal: update.signal
+				})
+			});
+			return;
+		}
+		if (typeof artifact.renderSsr === "function") document.body.innerHTML = (await artifact.renderSsr(props)).html;
+	} finally {
+		update.onRendered?.();
+	}
+}
+//#endregion
+//#region src/index.ts
+function __marklessCreateHttpContext(event) {
+	const context = event.context ?? {};
+	const url = event.url ?? new URL("http://localhost/");
+	return {
+		locals: context,
+		params: context.params ?? {},
+		request: event.req ?? new Request(url),
+		response: event.res ?? { headers: new Headers() },
+		url
+	};
+}
+const Html = Object.assign(function Html(props) {
+	return props.children;
+}, { renderSsr(props = {}) {
+	return { html: props.children == null ? "" : String(props.children) };
+} });
+const Link = Object.assign(function Link(props = {}) {
+	return props.children;
+}, {
+	renderCsr(props = {}) {
+		const anchor = document.createElement("a");
+		for (const [name, value] of linkAnchorAttributes(props)) anchor.setAttribute(name, value);
+		anchor.innerHTML = linkChildrenHtml(props);
+		return { root: anchor };
+	},
+	renderSsr(props = {}) {
+		return { html: `<a ${linkAnchorAttributes(props).map(([name, value]) => value === "" ? name : `${name}="${escapeHtml(value)}"`).join(" ")}>${linkChildrenHtml(props)}</a>` };
+	}
+});
+function linkAnchorAttributes(props) {
+	const attributes = /* @__PURE__ */ new Map();
+	const input = props;
+	for (const [name, value] of Object.entries(input)) {
+		if (isLinkInternalProp(name)) continue;
+		const attributeValue = linkAttributeValue(value);
+		if (attributeValue !== void 0) attributes.set(name, attributeValue);
+	}
+	attributes.set("href", typeof props.href === "string" ? props.href : "#");
+	attributes.set("data-markless-router-link", "");
+	if (props.replace) attributes.set("data-markless-router-replace", "");
+	if (props.scroll === false) attributes.set("data-markless-router-scroll", "manual");
+	return [...attributes];
+}
+function isLinkInternalProp(name) {
+	return name === "children" || name === "params" || name === "prefetch" || name === "replace" || name === "scroll" || name === "__marklessSsrCallbacks";
+}
+function linkAttributeValue(value) {
+	if (value === true) return "";
+	if (value === false || value == null) return void 0;
+	if (typeof value === "function" || typeof value === "symbol") return void 0;
+	return String(value);
+}
+function linkChildrenHtml(props) {
+	return props.children == null ? "" : String(props.children);
+}
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+//#endregion
+export { Html, Link, MARKLESS_ROUTER_ROUTE_EVENT, __marklessCreateHttpContext, buildRouteManifestFromFileIds, dispatchRouteUpdate, matchRouteManifest, normalizeRequestFileId, normalizeRequestPathname, normalizeRouteFileId, parseRequestFile, routePageProps, startRouteUpdateRenderer, transformRequestFileSource };

package/dist/request-files-DTkeaKxU.js

@@ -0,0 +1,232 @@
+import { basename, extname, join, normalize, relative } from "pathe";
+import { joinURL, withLeadingSlash, withoutLeadingSlash } from "ufo";
+//#region src/request-files.ts
+const API_DIR = "api";
+const MIDDLEWARE_DIR = "middleware";
+const REQUEST_FILE_EXTENSION = ".ts";
+const HTTP_METHODS = new Set([
+	"connect",
+	"delete",
+	"get",
+	"head",
+	"options",
+	"patch",
+	"post",
+	"put",
+	"trace"
+]);
+function parseRequestFile(fileId, sourceText) {
+	const file = normalizeRequestFileId(fileId);
+	const apiFile = apiRelativeFile(file);
+	if (apiFile) return parseApiRequestFile(file, apiFile, sourceText);
+	if (middlewareRelativeFile(file)) return parseMiddlewareRequestFile(file, sourceText);
+	return {
+		diagnostics: [],
+		file,
+		kind: "none"
+	};
+}
+function normalizeRequestFileId(fileId) {
+	return withoutLeadingSlash(normalize(fileId));
+}
+function transformRequestFileSource(fileId, sourceText) {
+	const requestFile = parseRequestFile(fileId, sourceText);
+	if (requestFile.kind === "none" || requestFile.diagnostics.length > 0 || !requestFile.defaultExport) return;
+	const handler = localizeDefaultExport(sourceText);
+	if (!handler) return;
+	return {
+		code: requestFileWrapperSource(requestFile, handler.code, handler.name),
+		file: requestFile.file,
+		kind: requestFile.kind
+	};
+}
+function parseApiRequestFile(file, apiFile, sourceText) {
+	const defaultExport = findDefaultFunctionExport(sourceText);
+	const cache = parseCacheMetadata(sourceText);
+	const diagnostics = [
+		...missingDefaultFunctionDiagnostics("api", defaultExport),
+		...httpMethodExportDiagnostics(sourceText),
+		...cacheMetadataDiagnostics(sourceText, cache)
+	];
+	return {
+		...cache ? { cache } : {},
+		...defaultExport ? { defaultExport } : {},
+		diagnostics,
+		file,
+		kind: "api",
+		...apiRouteFromFile(apiFile)
+	};
+}
+function parseMiddlewareRequestFile(file, sourceText) {
+	const defaultExport = findDefaultFunctionExport(sourceText);
+	const diagnostics = missingDefaultFunctionDiagnostics("middleware", defaultExport);
+	return {
+		...defaultExport ? { defaultExport } : {},
+		diagnostics,
+		file,
+		kind: "middleware"
+	};
+}
+function apiRouteFromFile(apiFile) {
+	const rawSegments = normalize(join(apiFile.slice(0, -3))).split("/");
+	const finalSegment = rawSegments.at(-1);
+	const method = methodSuffix(finalSegment);
+	if (method !== "all") rawSegments[rawSegments.length - 1] = finalSegment.slice(0, -(method.length + 1));
+	if (rawSegments.at(-1) === "index") rawSegments.pop();
+	const normalizedSegments = rawSegments.filter(Boolean).map(normalizeRouteSegment);
+	const pathnameSegments = normalizedSegments.map((segment) => segment.pathname);
+	const patternSegments = normalizedSegments.map((segment) => segment.pattern);
+	return {
+		method,
+		route: {
+			params: normalizedSegments.flatMap((segment) => segment.params),
+			pathname: requestPathname([API_DIR, ...pathnameSegments]),
+			pattern: requestPathname([API_DIR, ...patternSegments])
+		}
+	};
+}
+function normalizeRouteSegment(segment) {
+	const catchAll = segment.match(/^\[\.\.\.([A-Za-z_$][\w$]*)\]$/);
+	if (catchAll) return {
+		params: [{
+			kind: "catch-all",
+			name: catchAll[1]
+		}],
+		pathname: "**",
+		pattern: `[...${catchAll[1]}]`
+	};
+	const dynamic = segment.match(/^\[([A-Za-z_$][\w$]*)\]$/);
+	if (dynamic) return {
+		params: [{
+			kind: "dynamic",
+			name: dynamic[1]
+		}],
+		pathname: `:${dynamic[1]}`,
+		pattern: `[${dynamic[1]}]`
+	};
+	return {
+		params: [],
+		pathname: segment,
+		pattern: segment
+	};
+}
+function requestPathname(segments) {
+	if (segments.length === 0) return "/";
+	const [base, ...rest] = segments;
+	return withLeadingSlash(joinURL(base, ...rest));
+}
+function methodSuffix(finalSegment) {
+	const suffix = finalSegment.split(".").at(-1);
+	return suffix && HTTP_METHODS.has(suffix) ? suffix : "all";
+}
+function findDefaultFunctionExport(sourceText) {
+	const directFunction = sourceText.match(/\bexport\s+default\s+(?:async\s+)?function(?:\s+[A-Za-z_$][\w$]*)?\s*\(\s*([A-Za-z_$][\w$]*)?/);
+	if (directFunction) return {
+		kind: "function",
+		parameterName: directFunction[1]
+	};
+	const directArrow = sourceText.match(/\bexport\s+default\s+(?:async\s+)?(?:\(\s*([A-Za-z_$][\w$]*)?\s*\)|([A-Za-z_$][\w$]*))\s*=>/);
+	if (directArrow) return {
+		kind: "function",
+		parameterName: directArrow[1] ?? directArrow[2]
+	};
+	const defaultIdentifier = sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;/)?.[1];
+	if (!defaultIdentifier) return;
+	const escapedIdentifier = escapeRegExp(defaultIdentifier);
+	const constArrow = sourceText.match(new RegExp(`\\bconst\\s+${escapedIdentifier}\\s*=\\s*(?:async\\s+)?(?:\\(\\s*([A-Za-z_$][\\w$]*)?\\s*\\)|([A-Za-z_$][\\w$]*))\\s*=>`));
+	if (constArrow) return {
+		kind: "function",
+		parameterName: constArrow[1] ?? constArrow[2]
+	};
+	const functionDeclaration = sourceText.match(new RegExp(`\\b(?:async\\s+)?function\\s+${escapedIdentifier}\\s*\\(\\s*([A-Za-z_$][\\w$]*)?`));
+	if (functionDeclaration) return {
+		kind: "function",
+		parameterName: functionDeclaration[1]
+	};
+}
+function parseCacheMetadata(sourceText) {
+	const objectLiteral = sourceText.match(/\bexport\s+const\s+cache\s*=\s*(\{[\s\S]*?\})\s*;?/)?.[1];
+	if (!objectLiteral) return;
+	const maxAge = objectLiteral.match(/^\{\s*maxAge\s*:\s*(\d+(?:\.\d+)?)\s*,?\s*\}$/)?.[1];
+	return maxAge ? { maxAge: Number(maxAge) } : void 0;
+}
+function missingDefaultFunctionDiagnostics(kind, defaultExport) {
+	if (defaultExport) return [];
+	return [{
+		code: "missing-default-function",
+		message: kind === "api" ? "API files must default export a function." : "Middleware files must default export a function."
+	}];
+}
+function httpMethodExportDiagnostics(sourceText) {
+	const exportedMethods = /* @__PURE__ */ new Set();
+	for (const pattern of [
+		/\bexport\s+(?:async\s+)?function\s+([A-Z]+)\b/g,
+		/\bexport\s+const\s+([A-Z]+)\b/g,
+		/\bexport\s*\{([^}]+)\}/g
+	]) for (const match of sourceText.matchAll(pattern)) {
+		const exportClause = match[1];
+		if (!exportClause) continue;
+		if (exportClause.includes(",")) {
+			for (const exportName of exportClause.split(",")) addHttpMethodExport(exportedMethods, exportName);
+			continue;
+		}
+		addHttpMethodExport(exportedMethods, exportClause);
+	}
+	return Array.from(exportedMethods).toSorted().map((method) => ({
+		code: "http-method-export",
+		message: `Do not export ${method}; the HTTP method comes from the filename.`
+	}));
+}
+function addHttpMethodExport(methods, exportName) {
+	const method = exportName.trim().split(/\s+as\s+/i).at(-1)?.trim();
+	if (method && HTTP_METHODS.has(method.toLowerCase())) methods.add(method.toUpperCase());
+}
+function cacheMetadataDiagnostics(sourceText, cache) {
+	if (!/\bexport\s+const\s+cache\b/.test(sourceText) || cache) return [];
+	return [{
+		code: "invalid-cache-metadata",
+		message: "Use export const cache for endpoint cache metadata."
+	}];
+}
+function apiRelativeFile(file) {
+	if (!isRequestModuleFile(file) || file === API_DIR || !file.startsWith(`${API_DIR}/`)) return;
+	return relative(API_DIR, file);
+}
+function middlewareRelativeFile(file) {
+	if (!isRequestModuleFile(file) || file === MIDDLEWARE_DIR || !file.startsWith(`${MIDDLEWARE_DIR}/`)) return;
+	return relative(MIDDLEWARE_DIR, file);
+}
+function localizeDefaultExport(sourceText) {
+	const defaultIdentifierMatch = sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;/);
+	if (defaultIdentifierMatch) return {
+		code: sourceText.replace(defaultIdentifierMatch[0], ""),
+		name: defaultIdentifierMatch[1]
+	};
+	const directDefaultMatch = sourceText.match(/\bexport\s+default\b/);
+	if (!directDefaultMatch || directDefaultMatch.index === void 0) return;
+	return {
+		code: `${sourceText.slice(0, directDefaultMatch.index)}const __markless_request_handler__ =${sourceText.slice(directDefaultMatch.index + directDefaultMatch[0].length)}`,
+		name: "__markless_request_handler__"
+	};
+}
+function requestFileWrapperSource(requestFile, sourceText, handlerName) {
+	const defineImport = requestFile.kind === "api" && requestFile.cache ? "import { defineCachedHandler as __markless_define_handler__ } from \"nitro/cache\";" : "import { defineHandler as __markless_define_handler__ } from \"nitro\";";
+	const wrappedHandler = `(event) =>
+	${handlerName}(__markless_create_http_context__(event))`;
+	const wrappedDefault = requestFile.kind === "api" && requestFile.cache ? `__markless_define_handler__(${wrappedHandler}, cache)` : `__markless_define_handler__(${wrappedHandler})`;
+	return `${defineImport}
+import { __marklessCreateHttpContext as __markless_create_http_context__ } from "@markless/router";
+
+${sourceText.trimEnd()}
+
+export default ${wrappedDefault};
+`;
+}
+function isRequestModuleFile(file) {
+	return extname(file) === REQUEST_FILE_EXTENSION && basename(file) !== REQUEST_FILE_EXTENSION;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+export { parseRequestFile as n, transformRequestFileSource as r, normalizeRequestFileId as t };