@jk2908/solas 0.2.1 → 0.2.3

package/README.md

@@ -315,9 +315,9 @@ export default defineConfig(({ mode }) => ({
 		solas({
 			url: mode === 'production' ? 'https://example.com' : 'http://localhost:8787',
 			sitemap: {
-				async routes(discovered) {
-					const posts = await fetchPostSlugs()
-					return [...discovered, ...posts.map(s => `/blog/${s}`)]
+				async routes(existing) {
+					const posts = await getPosts()
+					return [...existing, ...posts.map(p => `/blog/${p.slug}`)]
 				},
 			},
 		}),

package/dist/cli.js

@@ -36,8 +36,8 @@ async function build() {
         const raw = await fs.readFile(manifestPath, 'utf-8');
         manifest = JSON.parse(raw);
     }
-    catch {
-        logger.error('[build] failed to read build manifest');
+    catch (err) {
+        logger.error('[build] failed to read build manifest', err);
         process.exit(1);
     }
     const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
@@ -223,8 +223,8 @@ async function preview() {
     try {
         await fs.access(rscEntry);
     }
-    catch {
-        logger.error(`[preview] missing ${path.relative(cwd, rscEntry)} - run \`${Solas.Config.SLUG} build\` first`);
+    catch (err) {
+        logger.error(`[preview] missing ${path.relative(cwd, rscEntry)} - run \`${Solas.Config.SLUG} build\` first`, err);
         process.exit(1);
     }
     const { default: app } = await import(/* @vite-ignore */ rscEntry);

package/dist/index.js

@@ -104,8 +104,8 @@ function solas(c) {
         // early return if nothing has changed
         if (!changed.length)
             return;
-        await Promise.all(changed.map(filePath => Format.run(filePath).catch(() => {
-            logger.error(`[build] Failed to format file: ${filePath}`);
+        await Promise.all(changed.map(filePath => Format.run(filePath).catch(err => {
+            logger.error(`[build] Failed to format file: ${filePath}`, err);
         })));
         return changed;
     }
@@ -214,7 +214,9 @@ function solas(c) {
             // resolve sitemap routes
             let sitemapRoutes = [];
             if (config.sitemap && config.url) {
-                const auto = [...new Set([...buildContext.knownRoutes, ...buildContext.prerenderRoutes])];
+                const auto = [
+                    ...new Set([...buildContext.knownRoutes, ...buildContext.prerenderRoutes]),
+                ];
                 if (typeof config.sitemap === 'object' && config.sitemap.routes) {
                     sitemapRoutes = await config.sitemap.routes(auto);
                 }

package/dist/internal/build.d.ts

@@ -1,5 +1,15 @@
 import type { BuildContext, Endpoint, PluginConfig, Segment } from '../types';
+/**
+ * Types, constants, and the Finder class for route discovery and manifest generation.
+ * The Finder walks the app directory, builds inheritance chains, and transforms
+ * the scan result into codegen artifacts consumed by generated entry files
+ */
 export declare namespace Build {
+    /**
+     * Raw output of the filesystem scan before any processing. Segments
+     * are renderable routes (pages and layout wrappers), endpoints are
+     * API routes with HTTP verb handlers
+     */
     type ScanResult = {
         segments: {
             dir: string;
@@ -18,6 +28,10 @@ export declare namespace Build {
             middlewares: (string | null)[];
         }[];
     };
+    /**
+     * Collected import paths keyed by entry id. Static imports are eagerly
+     * loaded, dynamic imports are lazy-loaded via React.lazy
+     */
     type Imports = {
         endpoints: {
             static: Map<string, string>;
@@ -30,6 +44,11 @@ export declare namespace Build {
             static: Map<string, string>;
         };
     };
+    /**
+     * Maps each entry id to the ids of its shell, layouts, page, error boundaries,
+     * loaders, and middleware. Used by codegen to produce the import map
+     * that the resolver reads at runtime
+     */
     type Modules = Record<string, {
         shellId?: string;
         layoutIds?: (string | null)[];
@@ -55,7 +74,8 @@ export declare namespace Build {
         readonly ENDPOINT: "$E";
     };
     /**
-     * Finder class to process application routes
+     * Encapsulates the logic for scanning the app directory and processing the
+     * result into the manifest, import map, and module map
      */
     class Finder {
         #private;
@@ -75,15 +95,13 @@ export declare namespace Build {
          */
         static toCanonicalRoute(file: string): string;
         /**
-         * Get the import path for a file
-         * This finds the relative path from the generated
-         * directory to the file, removes the extension and
-         * replaces backslashes with forward slashes.
+         * Get the import path for a file relative to the generated directory,
+         * with the extension stripped and backslashes normalised
          */
         static getImportPath(file: string): string;
         /**
-         * Run the Finder to get the app route and associated data
-         * needed for codegen
+         * Entry point: scan the app directory then process the result
+         * into the manifest, import map, and module map
          */
         run(): Promise<{
             manifest: Record<string, (Endpoint | Segment)[] | Endpoint | Segment>;
@@ -93,7 +111,9 @@ export declare namespace Build {
             knownRoutes: Set<string>;
         }>;
         /**
-         * Process the scanned route data
+         * Transform the raw scan result into the route manifest, import map,
+         * and module map for codegen, along with route sets for
+         * prerendering and sitemap generation
          */
         process(res: ScanResult): Promise<{
             manifest: Record<string, (Endpoint | Segment)[] | Endpoint | Segment>;

package/dist/internal/build.js

@@ -5,9 +5,16 @@ import { Logger } from '../utils/logger';
 import { normalisePathname } from './router/utils';
 import { Prerender } from './prerender';
 export { Build };
+/**
+ * Types, constants, and the Finder class for route discovery and manifest generation.
+ * The Finder walks the app directory, builds inheritance chains, and transforms
+ * the scan result into codegen artifacts consumed by generated entry files
+ */
 var Build;
 (function (Build) {
     const HTTP_VERBS = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'];
+    // short prefixes used to namespace entry ids by kind.
+    // these appear in the generated manifest and import map
     Build.EntryKind = {
         SHELL: '$S',
         LAYOUT: '$L',
@@ -21,8 +28,85 @@ var Build;
         ENDPOINT: '$E',
     };
     const logger = new Logger();
+    // file extensions recognised for page components vs api endpoints
+    const EXTENSIONS = {
+        page: ['tsx', 'jsx'],
+        api: ['ts', 'js'],
+    };
+    // canonical file names for each route file type
+    const TYPES = {
+        page: '+page',
+        '401': '+401',
+        '403': '+403',
+        '404': '+404',
+        '500': '+500',
+        layout: '+layout',
+        loading: '+loading',
+        middleware: '+middleware',
+        endpoint: '+endpoint',
+    };
+    // pre-computed sets of valid filenames for each type so we can
+    // use O(1) lookups during the recursive scan
+    const validFiles = {
+        [TYPES.page]: new Set(EXTENSIONS.page.map(ext => `${TYPES.page}.${ext}`)),
+        [TYPES['401']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['401']}.${ext}`)),
+        [TYPES['403']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['403']}.${ext}`)),
+        [TYPES['404']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['404']}.${ext}`)),
+        [TYPES['500']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['500']}.${ext}`)),
+        [TYPES.loading]: new Set(EXTENSIONS.page.map(ext => `${TYPES.loading}.${ext}`)),
+        [TYPES.layout]: new Set(EXTENSIONS.page.map(ext => `${TYPES.layout}.${ext}`)),
+        [TYPES.middleware]: new Set(EXTENSIONS.api.map(ext => `${TYPES.middleware}.${ext}`)),
+        [TYPES.endpoint]: new Set(EXTENSIONS.api.map(ext => `${TYPES.endpoint}.${ext}`)),
+    };
+    const EMPTY_CHAINS = {
+        layouts: [],
+        '401s': [],
+        '403s': [],
+        '404s': [],
+        '500s': [],
+        loaders: [],
+        middlewares: [],
+    };
+    /**
+     * Append the current directory's files to each inherited chain, inserting
+     * null when the directory does not declare that file type
+     */
+    function extendChains(prev, state) {
+        return {
+            layouts: [...prev.layouts, state.layout ?? null],
+            '401s': [...prev['401s'], state['401'] ?? null],
+            '403s': [...prev['403s'], state['403'] ?? null],
+            '404s': [...prev['404s'], state['404'] ?? null],
+            '500s': [...prev['500s'], state['500'] ?? null],
+            loaders: [...prev.loaders, state.loader ?? null],
+            middlewares: [...prev.middlewares, state.middleware ?? null],
+        };
+    }
+    /**
+     * Create a segment entry from the accumulated chains. Returns null when no
+     * shell (root layout) exists, which means this path cannot render.
+     * The shell is always layouts[0]; remaining are nested
+     */
+    function buildSegment(dir, page, chains) {
+        const shell = chains.layouts[0];
+        if (!shell)
+            return null;
+        return {
+            dir,
+            page,
+            '401s': chains['401s'],
+            '403s': chains['403s'],
+            '404s': chains['404s'],
+            '500s': chains['500s'],
+            loaders: chains.loaders,
+            middlewares: chains.middlewares,
+            layouts: chains.layouts.length > 1 ? chains.layouts.slice(1) : [],
+            shell,
+        };
+    }
     /**
-     * Finder class to process application routes
+     * Encapsulates the logic for scanning the app directory and processing the
+     * result into the manifest, import map, and module map
      */
     class Finder {
         buildContext;
@@ -61,10 +145,8 @@ var Build;
             return route.startsWith('/') ? route : `/${route}`;
         }
         /**
-         * Get the import path for a file
-         * This finds the relative path from the generated
-         * directory to the file, removes the extension and
-         * replaces backslashes with forward slashes.
+         * Get the import path for a file relative to the generated directory,
+         * with the extension stripped and backslashes normalised
          */
         static getImportPath(file) {
             const cwd = process.cwd();
@@ -75,8 +157,8 @@ var Build;
                 .replace(/\.(t|j)sx?$/, '');
         }
         /**
-         * Run the Finder to get the app route and associated data
-         * needed for codegen
+         * Entry point: scan the app directory then process the result
+         * into the manifest, import map, and module map
          */
         async run() {
             try {
@@ -88,51 +170,16 @@ var Build;
             }
         }
         /**
-         * Scan the filesystem to get all routes for processing
+         * Recursively walk the filesystem starting at `dir`, collecting route files
+         * into segments and endpoints. Inheritable files (layouts, error boundaries,
+         * loaders, middleware) propagate down through `prev` so child
+         * directories inherit parent chains.
          */
-        async #scan(dir, res = { segments: [], endpoints: [] }, prev = {
-            layouts: [],
-            '401s': [],
-            '403s': [],
-            '404s': [],
-            '500s': [],
-            loaders: [],
-            middlewares: [],
-        }) {
+        async #scan(dir, res = { segments: [], endpoints: [] }, prev = EMPTY_CHAINS) {
             try {
-                // define valid route files
-                const EXTENSIONS = {
-                    page: ['tsx', 'jsx'],
-                    api: ['ts', 'js'],
-                };
-                // define route file types
-                const TYPES = {
-                    page: '+page',
-                    '401': '+401',
-                    '403': '+403',
-                    '404': '+404',
-                    '500': '+500',
-                    layout: '+layout',
-                    loading: '+loading',
-                    middleware: '+middleware',
-                    endpoint: '+endpoint',
-                };
-                // map of valid files for each type
-                const validFiles = {
-                    [TYPES.page]: new Set(EXTENSIONS.page.map(ext => `${TYPES.page}.${ext}`)),
-                    [TYPES['401']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['401']}.${ext}`)),
-                    [TYPES['403']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['403']}.${ext}`)),
-                    [TYPES['404']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['404']}.${ext}`)),
-                    [TYPES['500']]: new Set(EXTENSIONS.page.map(ext => `${TYPES['500']}.${ext}`)),
-                    [TYPES.loading]: new Set(EXTENSIONS.page.map(ext => `${TYPES.loading}.${ext}`)),
-                    [TYPES.layout]: new Set(EXTENSIONS.page.map(ext => `${TYPES.layout}.${ext}`)),
-                    [TYPES.middleware]: new Set(EXTENSIONS.api.map(ext => `${TYPES.middleware}.${ext}`)),
-                    [TYPES.endpoint]: new Set(EXTENSIONS.api.map(ext => `${TYPES.endpoint}.${ext}`)),
-                };
                 const files = await fs.readdir(dir, { withFileTypes: true });
-                // keep a predictable order so layout/loading are picked
-                // up before page. Avoids OS dir ordering causing pages
-                // to steal layout/loaders first and drop alignment
+                // keep a predictable order so layout/loading are picked up before page.
+                // Avoids OS dir ordering causing alignment issues
                 files.sort((a, b) => {
                     if (a.isFile() && b.isDirectory())
                         return -1;
@@ -165,143 +212,71 @@ var Build;
                     }
                     return 0;
                 });
-                // current layout, status boundaries, loader, middleware, and page files for this segment
-                let currentLayout;
-                let current401;
-                let current403;
-                let current404;
-                let current500;
-                let currentLoader;
-                let currentMiddleware;
+                const state = {};
                 let currentPage;
                 for (const file of files) {
                     const route = path.join(dir, file.name);
                     if (file.isDirectory()) {
-                        // before recursing, create segment for current dir if it
-                        // has a layout (defines a wrapper for child routes)
-                        if (!currentPage && currentLayout) {
-                            const layouts = [...prev.layouts, currentLayout];
-                            const unauthorized = [...prev['401s'], current401 ?? null];
-                            const forbidden = [...prev['403s'], current403 ?? null];
-                            const notFounds = [...prev['404s'], current404 ?? null];
-                            const serverErrors = [...prev['500s'], current500 ?? null];
-                            const loaders = [...prev.loaders, currentLoader ?? null];
-                            const middlewares = [...prev.middlewares, currentMiddleware ?? null];
-                            const shell = layouts[0];
-                            if (shell) {
-                                res.segments.push({
-                                    dir,
-                                    page: undefined,
-                                    '401s': unauthorized,
-                                    '403s': forbidden,
-                                    '404s': notFounds,
-                                    '500s': serverErrors,
-                                    loaders,
-                                    middlewares,
-                                    layouts: layouts.length > 1 ? layouts.slice(1) : [],
-                                    shell,
-                                });
-                            }
+                        // before recursing, create segment for current dir
+                        // if it has a layout (wraps child routes)
+                        if (!currentPage && state.layout) {
+                            const segment = buildSegment(dir, undefined, extendChains(prev, state));
+                            if (segment)
+                                res.segments.push(segment);
                         }
-                        const next = {
-                            layouts: [...prev.layouts, currentLayout ?? null],
-                            '401s': [...prev['401s'], current401 ?? null],
-                            '403s': [...prev['403s'], current403 ?? null],
-                            '404s': [...prev['404s'], current404 ?? null],
-                            '500s': [...prev['500s'], current500 ?? null],
-                            loaders: [...prev.loaders, currentLoader ?? null],
-                            middlewares: [...prev.middlewares, currentMiddleware ?? null],
-                        };
-                        await this.#scan(route, res, next);
+                        await this.#scan(route, res, extendChains(prev, state));
                     }
                     else {
                         const base = path.basename(file.name);
                         const relative = path.relative(process.cwd(), route).replace(/\\/g, '/');
                         if (validFiles[TYPES.layout].has(base)) {
-                            currentLayout = relative;
+                            state.layout = relative;
                         }
                         else if (validFiles[TYPES['401']].has(base)) {
-                            current401 = relative;
+                            state['401'] = relative;
                         }
                         else if (validFiles[TYPES['403']].has(base)) {
-                            current403 = relative;
+                            state['403'] = relative;
                         }
                         else if (validFiles[TYPES['404']].has(base)) {
-                            current404 = relative;
+                            state['404'] = relative;
                         }
                         else if (validFiles[TYPES['500']].has(base)) {
-                            current500 = relative;
+                            state['500'] = relative;
                         }
                         else if (validFiles[TYPES.loading].has(base)) {
-                            currentLoader = relative;
+                            state.loader = relative;
                         }
                         else if (validFiles[TYPES.middleware].has(base)) {
-                            currentMiddleware = relative;
+                            state.middleware = relative;
                         }
                         else if (validFiles[TYPES.endpoint].has(base)) {
                             res.endpoints.push({
                                 file: relative,
-                                middlewares: [...prev.middlewares, currentMiddleware ?? null],
+                                middlewares: [...prev.middlewares, state.middleware ?? null],
                             });
                         }
                         else if (validFiles[TYPES.page].has(base)) {
                             currentPage = relative;
-                            const layouts = [...prev.layouts, currentLayout ?? null];
-                            const unauthorized = [...prev['401s'], current401 ?? null];
-                            const forbidden = [...prev['403s'], current403 ?? null];
-                            const notFounds = [...prev['404s'], current404 ?? null];
-                            const serverErrors = [...prev['500s'], current500 ?? null];
-                            const loaders = [...prev.loaders, currentLoader ?? null];
-                            const middlewares = [...prev.middlewares, currentMiddleware ?? null];
-                            const shell = layouts?.[0];
-                            if (!shell)
+                            const segment = buildSegment(dir, relative, extendChains(prev, state));
+                            if (!segment)
                                 throw new Error('Missing app shell');
-                            res.segments.push({
-                                dir,
-                                page: relative,
-                                '401s': unauthorized,
-                                '403s': forbidden,
-                                '404s': notFounds,
-                                '500s': serverErrors,
-                                loaders,
-                                middlewares,
-                                layouts: layouts.length > 1 ? layouts.slice(1) : [],
-                                shell,
-                            });
+                            res.segments.push(segment);
                         }
                     }
                 }
                 // warn if segment has status boundaries/loading but no page or layout
                 if (!currentPage &&
-                    !currentLayout &&
-                    (current401 || current403 || current404 || current500 || currentLoader)) {
+                    !state.layout &&
+                    (state['401'] || state['403'] || state['404'] || state['500'] || state.loader)) {
                     logger.warn(`[Build:Finder:#scan]: ${dir} has status route files or +loading but no +page or +layout. This path will not be routable (404), but these files will still be inherited by child routes`);
                 }
-                // create segment if we have a layout but no page and
-                // haven't created one yet (no subdirectories triggered it)
-                if (!currentPage && currentLayout && !res.segments.some(s => s.dir === dir)) {
-                    const layouts = [...prev.layouts, currentLayout];
-                    const unauthorized = [...prev['401s'], current401 ?? null];
-                    const forbidden = [...prev['403s'], current403 ?? null];
-                    const notFounds = [...prev['404s'], current404 ?? null];
-                    const serverErrors = [...prev['500s'], current500 ?? null];
-                    const loaders = [...prev.loaders, currentLoader ?? null];
-                    const middlewares = [...prev.middlewares, currentMiddleware ?? null];
-                    const shell = layouts[0];
-                    if (shell) {
-                        res.segments.push({
-                            dir,
-                            page: undefined,
-                            '401s': unauthorized,
-                            '403s': forbidden,
-                            '404s': notFounds,
-                            '500s': serverErrors,
-                            loaders,
-                            middlewares,
-                            layouts: layouts.length > 1 ? layouts.slice(1) : [],
-                            shell,
-                        });
-                    }
+                // create segment if we have a layout but no page
+                // and haven't created one yet
+                if (!currentPage && state.layout && !res.segments.some(s => s.dir === dir)) {
+                    const segment = buildSegment(dir, undefined, extendChains(prev, state));
+                    if (segment)
+                        res.segments.push(segment);
                 }
                 return res;
             }
@@ -314,35 +289,52 @@ var Build;
             }
         }
         /**
-         * Process the scanned route data
+         * Transform the raw scan result into the route manifest, import map,
+         * and module map for codegen, along with route sets for
+         * prerendering and sitemap generation
          */
         async process(res) {
             const processed = new Set();
+            // concrete routes to prerender at build time
+            // (static, or dynamic with static params)
             const prerenderRoutes = new Set();
+            // all concrete (non-dynamic, non-wildcard) page
+            // routes for sitemap generation
             const knownRoutes = new Set();
             const trailingSlash = this.config?.trailingSlash ?? 'never';
+            // route path → segment/endpoint entries, used at runtime
+            // to look up the component tree for a matched route
             const manifest = {};
-            // imports for endpoints and components
+            // entry id → import path. Split into static (shell, middleware,
+            // endpoints) and dynamic (layouts, pages, boundaries)
+            // so the bundler can code-split
             const imports = {
                 endpoints: { static: new Map() },
                 components: { static: new Map(), dynamic: new Map() },
                 middlewares: { static: new Map() },
             };
+            // entry id → related entry ids. Wires up which shell,
+            // layouts, loaders, and middleware belong
+            // to each page
             const modules = {};
+            // cache prerender flags per file path so shared layouts
+            // only trigger one export read across routes
             const prerenderCache = new Map();
             for (const segment of res.segments) {
                 try {
                     if (!this.buildContext || !this.config)
                         continue;
                     const { shell: shellPath, layouts: layoutPaths, '401s': unauthorizedPaths, '403s': forbiddenPaths, page: pagePath, '404s': notFoundPaths, '500s': serverErrorPaths, loaders: loaderPaths, middlewares: middlewarePaths, dir, } = segment;
-                    // route is derived from dir path, not page
+                    // derive the route pattern from the directory path, falling
+                    // back to a synthetic +page.tsx when this is
+                    // a layout-only segment
                     const route = Finder.toCanonicalRoute(pagePath ?? `${dir.replace(/\\/g, '/')}/+page.tsx`);
                     const params = Finder.getParams(dir);
                     const depth = Finder.getDepth(route);
                     const isDynamic = route.includes(':');
                     const isWildcard = route.includes('*');
-                    // effective mode for this segment; start from global config then
-                    // apply shell/layout/page overrides
+                    // effective mode for this segment; start from global
+                    // config then apply shell/layout/page overrides
                     let currentPrerenderMode = this.config?.prerender ?? false;
                     /**
                      * Apply explicit prerender mode overrides in inheritance order
@@ -463,8 +455,8 @@ var Build;
                         const middlewareId = `${Build.EntryKind.MIDDLEWARE}${Bun.hash(middlewareImport)}`;
                         middlewareIds.push(middlewareId);
                         if (!processed.has(middlewarePath)) {
-                            // route scanning only tells us this is a +middleware file path so
-                            // we still validate that the module actually exports middleware
+                            // route scanning only tells us this is a +middleware file path
+                            // so we still validate the module exports middleware
                             if (!(await this.buildContext.exportReader.has(middlewarePath, 'middleware'))) {
                                 throw new Error(`Missing middleware export in ${middlewarePath}`);
                             }
@@ -482,10 +474,13 @@ var Build;
                         imports.components.dynamic.set(entryId, Finder.getImportPath(pagePath));
                         processed.add(pagePath);
                     }
+                    // resolve final prerender mode after shell → layout → page overrides
                     const shouldPrerender = currentPrerenderMode !== false;
                     const prerenderMode = shouldPrerender
                         ? currentPrerenderMode
                         : false;
+                    // collect concrete prerender routes; for dynamic routes,
+                    // expand using the page's exported static params
                     if (shouldPrerender) {
                         if (!isDynamic && !isWildcard) {
                             prerenderRoutes.add(normalisePathname(route, trailingSlash));
@@ -497,6 +492,8 @@ var Build;
                             }
                         }
                     }
+                    // track all concrete routes regardless of prerender mode
+                    // so the sitemap can include ssr-only pages too
                     if (!isDynamic && !isWildcard) {
                         knownRoutes.add(normalisePathname(route, trailingSlash));
                     }
@@ -552,6 +549,9 @@ var Build;
                     logger.error('[Build:Finder:process]: failed to process segment', err);
                 }
             }
+            // process api endpoints — each file can export multiple HTTP
+            // verbs which become separate manifest entries grouped
+            // under the same route
             for (const endpoint of res.endpoints) {
                 try {
                     const endpointFilePath = endpoint.file;
@@ -575,8 +575,8 @@ var Build;
                             const middlewareImport = Finder.getImportPath(middlewarePath);
                             const middlewareId = `${Build.EntryKind.MIDDLEWARE}${Bun.hash(middlewareImport)}`;
                             if (!processed.has(middlewarePath)) {
-                                // endpoint middleware discovery gives us file paths, not proof of the export
-                                // so check the module shape before we register the import
+                                // endpoint middleware discovery gives us file paths, not proof
+                                // of the export so check the module shape first
                                 if (!(await this.buildContext.exportReader.has(middlewarePath, 'middleware'))) {
                                     throw new Error(`Missing middleware export in ${middlewarePath}`);
                                 }
@@ -597,6 +597,9 @@ var Build;
                         modules[endpointId] = { endpointId, middlewareIds };
                         processed.add(endpointFilePath);
                     }
+                    // single-verb endpoints store a plain entry, multi-verb
+                    // endpoints store an array so the router can
+                    // match by method at request time
                     const entry = group.length === 1 ? group[0] : group;
                     if (endpointMiddlewarePaths.length) {
                         modules[route] = {

package/dist/internal/env/rsc.d.ts

@@ -22,7 +22,7 @@ export declare function action(req: SolasRequest): Promise<{
  * Check if a request is an action request and reuse parsed FormData
  * when multipart action detection already had to inspect the body
  */
-export declare function maybeActionWithParsedFormData(req: Request): Promise<{
+export declare function maybeAction(req: Request): Promise<{
     action: boolean;
     formData: null;
 } | {

package/dist/internal/env/rsc.js

@@ -186,7 +186,7 @@ export async function action(req) {
  * Check if a request is an action request and reuse parsed FormData
  * when multipart action detection already had to inspect the body
  */
-export async function maybeActionWithParsedFormData(req) {
+export async function maybeAction(req) {
     if (req.method !== 'POST')
         return { action: false, formData: null };
     if (req.headers.has('x-rsc-action-id'))

package/dist/internal/router/router.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { match as createMatch } from 'path-to-regexp';
 import { Solas } from '../../solas';
 import { getAlternatePathname, normalisePathname, toPathPattern } from './utils';
-import { maybeActionWithParsedFormData } from '../env/rsc';
+import { maybeAction } from '../env/rsc';
 import { HttpException } from '../navigation/http-exception';
 /**
  * Handle routing and matching for server requests
@@ -180,7 +180,7 @@ export class Router {
                 url.pathname = path;
                 req = new Request(url.toString(), req);
             }
-            const { action: isAction, formData: parsedFormData } = await maybeActionWithParsedFormData(req);
+            const { action: isAction, formData: parsedFormData } = await maybeAction(req);
             action = isAction;
             // action requests stay on the same pathname only the method is
             // normalised to GET this lets page/layout routes match for

package/dist/internal/ui/defaults/error.js

@@ -2,5 +2,5 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 export default function Err({ error }) {
     const title = 'status' in error ? `${error.status} - ${error.message}` : error.message;
     return (_jsxs(_Fragment, { children: [
-            _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx("title", { children: title }), _jsx("h1", { children: title }), _jsx("p", { children: error.message }), process.env.NODE_ENV === 'development' && error?.stack && (_jsx("pre", { children: error.stack }))] }));
+            _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx("title", { children: title }), _jsx("h1", { children: title }), _jsx("p", { children: error.message }), process.env.NODE_ENV === 'development' && error?.stack && _jsx("pre", { children: error.stack })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "A React Server Components meta-framework powered by Vite",
 	"keywords": [
 		"framework",