@gracile/engine 0.8.2 → 0.9.0-next.10

package/dist/server/request.js

@@ -1,59 +1,56 @@
 import { Readable } from 'node:stream';
-import * as assert from '@gracile/internal-utils/assertions';
 import { getLogger } from '@gracile/internal-utils/logger/helpers';
 import c from 'picocolors';
-// import { GracileError } from '../errors/errors.js';
 import { builtIn404Page, builtInErrorPage } from '../errors/pages.js';
 import { renderRouteTemplate } from '../render/route-template.js';
-import { renderLitTemplate } from '../render/utils.js';
+import { renderLitTemplate } from '../render/lit-ssr.js';
 import { getRoute } from '../routes/match.js';
-const CONTENT_TYPE_HTML = { 'Content-Type': 'text/html' };
-const PREMISE_REGEXES = {
-    properties: /\/__(.*?)\.props\.json$/,
-    document: /\/__(.*?)\.doc\.html$/,
-};
-export function isRedirect(response) {
-    const location = response.headers.get('location');
-    if (response.status >= 300 && response.status <= 303 && location) {
-        return { location };
-    }
-    return null;
-}
+import { CONTENT_TYPE_HTML, rewriteHiddenRoutes, resolvePremises, executeHandler, renderWithoutHandler, buildResponse, } from './request-pipeline.js';
 export function createGracileHandler({ vite, routes, routeImports, routeAssets, root, serverMode, gracileConfig, }) {
     const logger = getLogger();
     const middleware = async (request, locals) => {
         const { url: requestedUrl, method } = request;
         let emitViteBetterError = null;
         if (vite)
-            emitViteBetterError = await import('../errors/create-vite-better-error.js').then(({ emitViteBetterError: error }) => error);
+            emitViteBetterError =
+                await import('../errors/create-vite-better-error.js').then(({ emitViteBetterError: error }) => error);
         try {
-            // MARK: Rewrite hidden route siblings
-            const fullUrl = requestedUrl.replace(/\/__(.*)$/, '/');
-            // MARK: Setup premises
-            const propertiesOnly = PREMISE_REGEXES.properties.test(requestedUrl);
-            const documentOnly = PREMISE_REGEXES.document.test(requestedUrl);
-            const allowPremises = Boolean(gracileConfig.pages?.premises?.expose);
-            if (allowPremises === false && (propertiesOnly || documentOnly))
-                throw new Error('Accessed a page premise but they are not activated. You must enable `pages.premises.expose`.');
-            const premises = allowPremises ? { propertiesOnly, documentOnly } : null;
-            // MARK: Get route infos
+            // MARK: 1. Rewrite hidden route siblings
+            const fullUrl = rewriteHiddenRoutes(requestedUrl);
+            // MARK: 2. Setup premises
+            const premises = resolvePremises(requestedUrl, gracileConfig);
+            // MARK: 3. Route resolution + 404 fallback
             const routeOptions = {
                 url: fullUrl,
                 vite,
                 routes,
                 routeImports,
+                trailingSlash: gracileConfig.trailingSlash ?? 'ignore',
             };
             const responseInit = {};
-            let routeInfos = await getRoute(routeOptions);
-            // MARK: 404
+            const routeResult = await getRoute(routeOptions);
+            // Trailing slash redirect (301 for GET, 308 for other methods)
+            if (routeResult && 'redirect' in routeResult) {
+                const redirectUrl = new URL(routeResult.redirect, fullUrl).href;
+                const status = method === 'GET' ? 301 : 308;
+                return { response: Response.redirect(redirectUrl, status) };
+            }
+            let routeInfos = routeResult;
             if (routeInfos === null) {
                 responseInit.status = 404;
+                // Use 'ignore' for the internal 404 lookup to avoid redirect loops.
                 const url = new URL('/404/', fullUrl).href;
-                const options = { ...routeOptions, url };
-                const notFound = await getRoute(options);
-                routeInfos = notFound;
+                const options = {
+                    ...routeOptions,
+                    url,
+                    trailingSlash: 'ignore',
+                };
+                const notFoundResult = await getRoute(options);
+                routeInfos =
+                    notFoundResult && !('redirect' in notFoundResult)
+                        ? notFoundResult
+                        : null;
             }
-            // MARK: fallback 404
             if (routeInfos === null) {
                 const page = builtIn404Page(new URL(fullUrl).pathname, Boolean(vite));
                 return {
@@ -65,163 +62,49 @@ export function createGracileHandler({ vite, routes, routeImports, routeAssets,
             const routeTemplateOptions = {
                 url: fullUrl,
                 vite,
-                mode: 'dev', // vite && vite.config.mode === 'dev' ? 'dev' : 'build',
+                mode: 'dev',
                 routeAssets,
                 root,
                 serverMode,
                 routeInfos,
                 docOnly: premises?.documentOnly,
+                renderInfo: gracileConfig.litSsr?.renderInfo,
             };
             logger.info(`[${c.yellow(method)}] ${c.yellow(fullUrl)}`, {
                 timestamp: true,
             });
+            // MARK: 4. Handler dispatch
             let output;
-            let providedLocals = {};
-            if (locals && assert.isUnknownObject(locals))
-                providedLocals = locals;
-            // MARK: Server handler
-            const handler = routeInfos.routeModule.handler;
-            if (('handler' in routeInfos.routeModule && handler !== undefined) ||
-                // TODO: Explain this condition
-                (handler && 'GET' in handler === false && method !== 'GET')) {
-                const routeContext = Object.freeze({
-                    request,
-                    url: new URL(fullUrl),
-                    responseInit,
-                    params: routeInfos.params,
-                    locals: providedLocals,
-                });
-                // MARK: Run user middleware
-                // NOTE: Experimental
-                /// eslint-disable-next-line no-inner-declarations
-                // async function useHandler() {}
-                // if (vite) {
-                // 	const middleware = await vite
-                // 		.ssrLoadModule('/src/middleware.ts')
-                // 		.catch(() => null)
-                // 		.then((m) => m.default);
-                // 	if (middleware)
-                // 		await middleware(
-                // 			routeContext,
-                // 			async () => {
-                // 				await useHandler();
-                // 			},
-                // 		);
-                // 	else await useHandler();
-                // } else {
-                // 	await useHandler();
-                // }
-                //
-                // MARK: Handler(s)
-                const hasTopLevelHandler = typeof handler === 'function';
-                if (hasTopLevelHandler || method in handler) {
-                    const handlerWithMethod = hasTopLevelHandler
-                        ? handler
-                        : handler[method];
-                    if (typeof handlerWithMethod !== 'function')
-                        throw new TypeError('Handler must be a function.');
-                    const handlerOutput = await Promise.resolve(handlerWithMethod(routeContext));
-                    if (assert.isResponseOrPatchedResponse(handlerOutput))
-                        output = handlerOutput;
-                    else {
-                        routeTemplateOptions.routeInfos.props = hasTopLevelHandler
-                            ? handlerOutput
-                            : { [method]: handlerOutput };
-                        if (premises?.documentOnly) {
-                            const { document } = await renderRouteTemplate(routeTemplateOptions);
-                            return {
-                                response: new Response(document, {
-                                    headers: { ...CONTENT_TYPE_HTML },
-                                }),
-                            };
-                        }
-                        if (premises?.propertiesOnly)
-                            return {
-                                response: Response.json(routeTemplateOptions.routeInfos.props),
-                            };
-                        output = await renderRouteTemplate(routeTemplateOptions).then((r) => r.output);
-                    }
-                    // MARK: No GET, render page
-                }
-                else {
-                    const statusText = `This route doesn't handle the \`${method}\` method!`;
-                    return {
-                        response: new Response(statusText, { status: 405, statusText }),
-                    };
-                }
+            const handlerResult = await executeHandler({
+                routeInfos,
+                method,
+                request,
+                fullUrl,
+                locals,
+                responseInit,
+                premises,
+                routeTemplateOptions,
+            });
+            if (handlerResult.type === 'response')
+                return handlerResult.value;
+            if (handlerResult.type === 'output') {
+                output = handlerResult.value;
             }
             else {
-                if (premises?.documentOnly) {
-                    const { document } = await renderRouteTemplate(routeTemplateOptions);
-                    return {
-                        response: new Response(document, {
-                            headers: { ...CONTENT_TYPE_HTML },
-                        }),
-                    };
-                }
-                if (premises?.propertiesOnly)
-                    return {
-                        response: Response.json(routeTemplateOptions.routeInfos.props || {}),
-                    };
-                output = await renderRouteTemplate(routeTemplateOptions).then((r) => r.output);
-            }
-            // MARK: Return response
-            // NOTE: try directly with the requestPonyfill. This might not be necessary
-            if (assert.isResponseOrPatchedResponse(output)) {
-                const redirect = isRedirect(output);
-                if (redirect?.location)
-                    return {
-                        response: Response.redirect(redirect.location, output.status),
-                    };
-                return { response: output };
-                // MARK: Stream page render
-            }
-            // MARK: Page stream error
-            if (output instanceof Readable) {
-                responseInit.headers = {
-                    ...responseInit.headers,
-                    ...CONTENT_TYPE_HTML,
-                };
-                return {
-                    body: output.on('error', (error) => {
-                        const errorMessage = `[SSR Error] There was an error while rendering a template chunk on server-side.\n` +
-                            `It was omitted from the resulting HTML.\n`;
-                        if (vite) {
-                            logger.error(errorMessage + error.stack);
-                            // emitViteBetterError(new GracileError(GracileErrorData.FailedToGlobalLogger), vite);
-                            const payload = {
-                                type: 'error',
-                                // FIXME: Use the emitViteBetterError instead (but flaky for now with streaming)
-                                // err: new GracileError({}),
-                                err: {
-                                    name: 'StreamingError',
-                                    message: errorMessage,
-                                    stack: error.stack,
-                                    hint: 'This is often caused by a wrong template location dynamic interpolation.',
-                                    cause: error,
-                                    // highlightedCode: error.message,
-                                },
-                            };
-                            //
-                            setTimeout(() => {
-                                // @ts-expect-error ...........
-                                vite.hot.send(payload);
-                                // NOTE: Arbitrary value. Lower seems to be too fast, higher is not guaranteed to work.
-                            }, 200);
-                        }
-                        else {
-                            logger.error(errorMessage);
-                        }
-                    }),
-                    init: responseInit,
-                };
+                // MARK: 5. Template-only render (no handler)
+                const renderResult = await renderWithoutHandler({
+                    premises,
+                    routeTemplateOptions,
+                });
+                if (renderResult && 'response' in renderResult)
+                    return renderResult;
+                output = renderResult;
             }
-            return null;
+            // MARK: 6. Build final response
+            return buildResponse({ output, responseInit, vite, logger });
             // MARK: Errors
         }
         catch (error) {
-            // const safeError = createSafeError(error);
-            // TODO: User defined dev/runtime 500 error
             const ultimateErrorPage = vite && emitViteBetterError
                 ? await emitViteBetterError({ vite, error: error })
                 : await renderLitTemplate(builtInErrorPage(error.name));
@@ -236,3 +119,25 @@ export function createGracileHandler({ vite, routes, routeImports, routeAssets,
     };
     return middleware;
 }
+// MARK: Run user middleware
+// NOTE: Experimental
+/// eslint-disable-next-line no-inner-declarations
+// async function useHandler() {}
+// if (vite) {
+// 	const middleware = await vite
+// 		.ssrLoadModule('/src/middleware.ts')
+// 		.catch(() => null)
+// 		.then((m) => m.default);
+// 	if (middleware)
+// 		await middleware(
+// 			routeContext,
+// 			async () => {
+// 				await useHandler();
+// 			},
+// 		);
+// 	else await useHandler();
+// } else {
+// 	await useHandler();
+// }
+//
+export { isRedirect, } from './request-pipeline.js';

package/dist/server/{utils.d.ts → utilities.d.ts}

@@ -18,4 +18,4 @@ import type { AddressInfo } from 'node:net';
  * ```
  */
 export declare function printUrls(server: string | AddressInfo | null): void;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=utilities.d.ts.map

package/dist/server/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/server/utilities.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAY5C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,QA0C5D"}

package/dist/test/init.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/test/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/test/init.ts"],"names":[],"mappings":""}

package/dist/test/init.js

@@ -0,0 +1,7 @@
+/**
+ * Side-effect import: initializes the Gracile logger globally.
+ * Import this at the top of any engine unit test that touches modules
+ * which call `getLogger()` at module scope.
+ */
+import { createLogger } from '@gracile/internal-utils/logger/helpers';
+createLogger();

package/dist/user-config.d.ts

@@ -1,3 +1,4 @@
+import type { RenderInfo } from '@lit-labs/ssr';
 import type { Connect } from 'vite';
 /**
  * @example
@@ -37,6 +38,19 @@ export interface GracileConfig {
      * @defaultValue 'static'
      */
     output?: 'static' | 'server';
+    /**
+     * Controls how trailing slashes are matched on incoming URLs.
+     *
+     * - `'ignore'` — Match regardless of whether a trailing `/` is present.
+     *   `/about` and `/about/` both resolve to the same route. *(default)*
+     * - `'always'` — Only match URLs that include a trailing slash (e.g. `/about/`).
+     *   Requests without one are redirected: `301` for GET, `308` for other methods.
+     * - `'never'` — Only match URLs that do not include a trailing slash (e.g. `/about`).
+     *   Requests with one are redirected: `301` for GET, `308` for other methods.
+     *
+     * @defaultValue 'ignore'
+     */
+    trailingSlash?: 'always' | 'never' | 'ignore';
     /**
      * Settings for the development mode.
      */
@@ -93,6 +107,40 @@ export interface GracileConfig {
             exclude?: string[];
         };
     };
+    litSsr?: {
+        /**
+         * Lets you extend Gracile's SSR pipeline with
+         * custom Lit SSR `ElementRenderer` subclasses. This is the foundation for
+         * features like [Islands](/docs/add-ons/islands/), which register a renderer
+         * for the `<is-land>` custom element to server-render components from other
+         * UI frameworks.
+         *
+         * In most cases, you do **not** set this option manually — add-on plugins
+         * (like `gracileIslands()`) register their renderers automatically via the
+         * plugin context communication channel. However,
+         * you can use it directly for advanced use cases:
+         *
+         * ```ts
+         * import { gracile } from '@gracile/gracile/plugin';
+         * import { defineConfig } from 'vite';
+         *
+         * export default defineConfig({
+         *   plugins: [
+         *     gracile({
+         *       litSsr: {
+         *         renderInfo: {
+         *           elementRenderers: [
+         *             // Your custom ElementRenderer subclass
+         *           ],
+         *         },
+         *       },
+         *     }),
+         *   ],
+         * });
+         * ```
+         */
+        renderInfo?: Partial<RenderInfo>;
+    };
     /**
      * Future, unstable features flags.
      */

package/dist/user-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-config.d.ts","sourceRoot":"","sources":["../src/user-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,aAAa;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAE7B;;OAEG;IACH,GAAG,CAAC,EAAE;QACL;;;;;WAKG;QACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE;YAAE,WAAW,EAAE,OAAO,CAAC,eAAe,CAAA;SAAE,KAAK,OAAO,CAAC;KACxE,CAAC;IAEF;;OAEG;IACH,MAAM,CAAC,EAAE;QACR;;WAEG;QACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IAEF;;OAEG;IACH,KAAK,CAAC,EAAE;QACP;;;;;;;;;;;;;WAaG;QACH,QAAQ,CAAC,EAAE;YACV;;eAEG;YACH,MAAM,CAAC,EAAE,OAAO,CAAC;YAGjB;;eAEG;YACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;YAEnB;;eAEG;YACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;SACnB,CAAC;KACF,CAAC;IAEF;;OAEG;IACH,YAAY,CAAC,EAAE;QACd;;;WAGG;QACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;KAOhC,CAAC;CACF"}
+{"version":3,"file":"user-config.d.ts","sourceRoot":"","sources":["../src/user-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,aAAa;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAE7B;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IAE9C;;OAEG;IACH,GAAG,CAAC,EAAE;QACL;;;;;WAKG;QACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE;YAAE,WAAW,EAAE,OAAO,CAAC,eAAe,CAAA;SAAE,KAAK,OAAO,CAAC;KACxE,CAAC;IAEF;;OAEG;IACH,MAAM,CAAC,EAAE;QACR;;WAEG;QACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IAEF;;OAEG;IACH,KAAK,CAAC,EAAE;QACP;;;;;;;;;;;;;WAaG;QACH,QAAQ,CAAC,EAAE;YACV;;eAEG;YACH,MAAM,CAAC,EAAE,OAAO,CAAC;YAGjB;;eAEG;YACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;YAEnB;;eAEG;YACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;SACnB,CAAC;KACF,CAAC;IACF,MAAM,CAAC,EAAE;QACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8BG;QACH,UAAU,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;KACjC,CAAC;IAEF;;OAEG;IACH,YAAY,CAAC,EAAE;QACd;;;WAGG;QACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;KAOhC,CAAC;CACF"}

package/dist/vite/build-routes.d.ts

@@ -1,4 +1,4 @@
-import { type Plugin, type ViteDevServer } from 'vite';
+import { type ViteDevServer } from 'vite';
 import { type RenderedRouteDefinition } from '../routes/render.js';
 import type { RoutesManifest } from '../routes/route.js';
 import type { GracileConfig } from '../user-config.js';
@@ -12,6 +12,5 @@ export declare const buildRoutes: ({ routes, viteServerForBuild, root, gracileCo
     routes: RoutesManifest;
     renderedRoutes: RenderedRouteDefinition[];
     inputList: string[];
-    plugin: Plugin[];
 }>;
 //# sourceMappingURL=build-routes.d.ts.map

package/dist/vite/build-routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-routes.d.ts","sourceRoot":"","sources":["../../src/vite/build-routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,MAAM,CAAC;AAErE,OAAO,EAEN,KAAK,uBAAuB,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AASvD,eAAO,MAAM,WAAW,qEAMrB;IACF,MAAM,EAAE,cAAc,CAAC;IACvB,kBAAkB,EAAE,aAAa,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB,KAAG,OAAO,CAAC;IACX,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,EAAE,uBAAuB,EAAE,CAAC;IAC1C,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB,CA6JA,CAAC"}
+{"version":3,"file":"build-routes.d.ts","sourceRoot":"","sources":["../../src/vite/build-routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,MAAM,CAAC;AAExD,OAAO,EAEN,KAAK,uBAAuB,EAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AASvD,eAAO,MAAM,WAAW,GAAU,kEAM/B;IACF,MAAM,EAAE,cAAc,CAAC;IACvB,kBAAkB,EAAE,aAAa,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB,KAAG,OAAO,CAAC;IACX,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,EAAE,uBAAuB,EAAE,CAAC;IAC1C,SAAS,EAAE,MAAM,EAAE,CAAC;CACpB,CAkCA,CAAC"}

package/dist/vite/build-routes.js

@@ -1,7 +1,5 @@
-import { basename, extname, join } from 'node:path';
 import { createFilter } from 'vite';
 import { renderRoutes, } from '../routes/render.js';
-import { REGEX_TAG_LINK, REGEX_TAG_SCRIPT } from '../render/route-template.js';
 function stripPremises(input) {
     return input
         .replace(/index\.html$/, '__index.doc.html')
@@ -9,7 +7,6 @@ function stripPremises(input) {
         .replace(/500\.html$/, '__500.doc.html');
 }
 export const buildRoutes = async ({ routes, viteServerForBuild, root, gracileConfig, serverMode = false, }) => {
-    // TODO: extract upstream, return just the plugins
     const { renderedRoutes } = await renderRoutes({
         vite: viteServerForBuild,
         serverMode,
@@ -35,100 +32,5 @@ export const buildRoutes = async ({ routes, viteServerForBuild, root, gracileCon
         routes,
         renderedRoutes,
         inputList,
-        plugin: [
-            {
-                name: 'gracile-html-routes',
-                apply: 'build',
-                enforce: 'pre',
-                resolveId(id) {
-                    if (extname(id) === '.html' && inputList.includes(id))
-                        return join(root, id);
-                    return null;
-                },
-                load(id) {
-                    if (extname(id) === '.html') {
-                        if (['index.html', '404.html', '500.html'].includes(basename(id))) {
-                            const content = renderedRoutes.find((index) => index.absoluteId === id)?.html;
-                            if (content)
-                                return content;
-                        }
-                        if (gracileConfig.pages?.premises?.expose) {
-                            if (basename(id).endsWith('doc.html')) {
-                                const content = renderedRoutes.find((index) => stripPremises(index.absoluteId) === id)?.static.document;
-                                if (content)
-                                    return content;
-                            }
-                            const content = renderedRoutes.find((index) => index.name === basename(id))?.html;
-                            if (content)
-                                return content;
-                            // return '';}
-                        }
-                    }
-                    return null;
-                },
-            },
-            {
-                name: 'gracile-collect-handler-assets',
-                enforce: 'post',
-                buildStart() {
-                    if (!gracileConfig.pages?.premises?.expose || !premisesFilter)
-                        return;
-                    for (const route of renderedRoutes) {
-                        if (premisesFilter(route.name) === false)
-                            continue;
-                        if (serverMode && route.savePrerender !== true)
-                            continue;
-                        const fileNameParts = route.name.split('/');
-                        const last = fileNameParts.pop();
-                        const properties = last?.replace(/(.*)\.html$/, (_, r) => `__${r}.props.json`);
-                        if (!properties)
-                            throw new Error('No props.');
-                        fileNameParts.push(properties);
-                        const fileName = fileNameParts.join('/');
-                        this.emitFile({
-                            fileName,
-                            type: 'asset',
-                            source: JSON.stringify(route.static.props ?? {}),
-                        });
-                    }
-                },
-                generateBundle(_, bundle) {
-                    if (serverMode === false)
-                        return;
-                    for (const fileKey in bundle) {
-                        const file = bundle[fileKey];
-                        if (fileKey.endsWith('.html') && file && 'source' in file) {
-                            const source = file.source.toString();
-                            const collectedAssets = [
-                                ...[...source.matchAll(REGEX_TAG_SCRIPT)]
-                                    .map((v) => v[0])
-                                    // NOTE: Too brittle
-                                    .filter((v) => v.includes(`type="module"`)),
-                                ...[...source.matchAll(REGEX_TAG_LINK)]
-                                    .map((v) => v[0])
-                                    // NOTE: Too brittle
-                                    .filter((v) => /rel="(stylesheet|modulepreload)"/.test(v)),
-                            ].join('\n');
-                            // NOTE: Not used (for now?)
-                            // file.source = alteredContent;
-                            const route = renderedRoutes.find((r) => {
-                                if (gracileConfig.pages?.premises?.expose)
-                                    return (`/${r.name}` ===
-                                        `/${fileKey}`.replace(/(.*?)\/__(.*?)\.doc\.html$/, (a, b, c) => `${b}/${c}.html`));
-                                return r.name === fileKey;
-                            });
-                            if (route)
-                                route.handlerAssets = collectedAssets;
-                            if (route?.savePrerender !== true) {
-                                delete bundle[fileKey];
-                                // NOTE: Not sure if it's useful
-                                if (route?.html)
-                                    route.html = null;
-                            }
-                        }
-                    }
-                },
-            },
-        ],
     };
 };

package/dist/vite/plugin-build-environment.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Vite plugin: build environment configuration.
+ *
+ * Owns all Environment API concerns for builds:
+ * - Top-level config: `builder.sharedConfigBuild`, `ssr.external` (server mode)
+ * - `configEnvironment('client')`: rollupOptions.input, outDir
+ * - `configEnvironment('ssr')`: outDir, SSR-specific build options, rollupOptions
+ * - `buildApp()`: orchestrates build order (client-only or client → SSR)
+ *
+ * `rollupOptions.input` must be set via `configEnvironment` (not the
+ * top-level `config` hook) because `builder.build(env)` uses
+ * environment-resolved config, not the top-level config.
+ *
+ * @internal
+ */
+import type { PluginOption } from 'vite';
+import type { PluginSharedState } from './plugin-shared-state.js';
+export declare function gracileBuildEnvironmentPlugin({ state, }: {
+    state: PluginSharedState;
+}): PluginOption;
+//# sourceMappingURL=plugin-build-environment.d.ts.map

package/dist/vite/plugin-build-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-build-environment.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-build-environment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,MAAM,CAAC;AAEtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,wBAAgB,6BAA6B,CAAC,EAC7C,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,CA4Ef"}

package/dist/vite/plugin-build-environment.js

@@ -0,0 +1,83 @@
+/**
+ * Vite plugin: build environment configuration.
+ *
+ * Owns all Environment API concerns for builds:
+ * - Top-level config: `builder.sharedConfigBuild`, `ssr.external` (server mode)
+ * - `configEnvironment('client')`: rollupOptions.input, outDir
+ * - `configEnvironment('ssr')`: outDir, SSR-specific build options, rollupOptions
+ * - `buildApp()`: orchestrates build order (client-only or client → SSR)
+ *
+ * `rollupOptions.input` must be set via `configEnvironment` (not the
+ * top-level `config` hook) because `builder.build(env)` uses
+ * environment-resolved config, not the top-level config.
+ *
+ * @internal
+ */
+import { join } from 'node:path';
+export function gracileBuildEnvironmentPlugin({ state, }) {
+    const isServerMode = state.outputMode === 'server';
+    return {
+        name: 'vite-plugin-gracile-build-env',
+        apply: 'build',
+        config() {
+            return {
+                ...(isServerMode ? { ssr: { external: ['@gracile/gracile'] } } : {}),
+                builder: { sharedConfigBuild: true },
+            };
+        },
+        configEnvironment(name, config) {
+            if (name === 'client') {
+                if (!state.clientBuildInputList)
+                    return null;
+                return {
+                    build: {
+                        rollupOptions: {
+                            input: state.clientBuildInputList,
+                        },
+                        outDir: join(config.build?.outDir || 'dist', isServerMode ? 'client' : ''),
+                    },
+                };
+            }
+            if (name === 'ssr' && isServerMode) {
+                return {
+                    build: {
+                        outDir: 'dist/server',
+                        copyPublicDir: false,
+                        ssrEmitAssets: true,
+                        cssMinify: true,
+                        cssCodeSplit: true,
+                        rollupOptions: {
+                            input: 'entrypoint.js',
+                            output: {
+                                entryFileNames: '[name].js',
+                                assetFileNames: (chunkInfo) => {
+                                    if (chunkInfo.name) {
+                                        const fileName = state.clientAssets[chunkInfo.name];
+                                        if (fileName)
+                                            return fileName;
+                                        return `assets/${chunkInfo.name.replace(/\.(.*)$/, '')}-[hash].[ext]`;
+                                    }
+                                    return 'assets/[name]-[hash].[ext]';
+                                },
+                                chunkFileNames: 'chunk/[name].js',
+                            },
+                        },
+                    },
+                };
+            }
+            return null;
+        },
+        async buildApp(builder) {
+            const client = builder.environments['client'];
+            if (!client)
+                throw new Error('Missing client build environment.');
+            await builder.build(client);
+            if (isServerMode) {
+                const ssr = builder.environments['ssr'];
+                if (!ssr)
+                    throw new Error('Missing ssr build environment.');
+                await builder.build(ssr);
+            }
+        },
+    };
+}