@gracile/engine 0.9.0-next.4 → 0.9.0-next.5

package/dist/server/request.js

@@ -1,24 +1,11 @@
 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/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) => {
@@ -28,16 +15,11 @@ export function createGracileHandler({ vite, routes, routeImports, routeAssets,
             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,
@@ -46,15 +28,12 @@ export function createGracileHandler({ vite, routes, routeImports, routeAssets,
             };
             const responseInit = {};
             let routeInfos = await getRoute(routeOptions);
-            // MARK: 404
             if (routeInfos === null) {
                 responseInit.status = 404;
                 const url = new URL('/404/', fullUrl).href;
                 const options = { ...routeOptions, url };
-                const notFound = await getRoute(options);
-                routeInfos = notFound;
+                routeInfos = await getRoute(options);
             }
-            // MARK: fallback 404
             if (routeInfos === null) {
                 const page = builtIn404Page(new URL(fullUrl).pathname, Boolean(vite));
                 return {
@@ -66,7 +45,7 @@ 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,
@@ -77,153 +56,38 @@ export function createGracileHandler({ vite, routes, routeImports, routeAssets,
             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));
@@ -238,3 +102,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/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/vite/plugin-client-build.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Vite plugin: client-side build configuration.
+ *
+ * During `vite build`, this spins up a temporary dev server to render
+ * all routes into static HTML, then configures Rollup with the
+ * generated HTML pages as inputs.
+ *
+ * @internal
+ */
+import { type PluginOption } from 'vite';
+import type { PluginSharedState } from './plugin-shared-state.js';
+export declare function gracileClientBuildPlugin({ state, virtualRoutesForClient, }: {
+    state: PluginSharedState;
+    virtualRoutesForClient: PluginOption;
+}): PluginOption;
+//# sourceMappingURL=plugin-client-build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-client-build.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-client-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAGvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,wBAAgB,wBAAwB,CAAC,EACxC,KAAK,EACL,sBAAsB,GACtB,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;IACzB,sBAAsB,EAAE,YAAY,CAAC;CACrC,GAAG,YAAY,CAkDf"}

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

@@ -0,0 +1,49 @@
+/**
+ * Vite plugin: client-side build configuration.
+ *
+ * During `vite build`, this spins up a temporary dev server to render
+ * all routes into static HTML, then configures Rollup with the
+ * generated HTML pages as inputs.
+ *
+ * @internal
+ */
+import { join } from 'node:path';
+import { getPluginContext } from '@gracile/internal-utils/plugin-context';
+import { createServer } from 'vite';
+import { buildRoutes } from './build-routes.js';
+export function gracileClientBuildPlugin({ state, virtualRoutesForClient, }) {
+    return {
+        name: 'vite-plugin-gracile-build',
+        apply: 'build',
+        async config(viteConfig) {
+            const viteServerForClientHtmlBuild = await createServer({
+                root: viteConfig.root || process.cwd(),
+                server: { middlewareMode: true },
+                // NOTE: Stub. KEEP IT!
+                optimizeDeps: { include: [] },
+                plugins: [virtualRoutesForClient],
+            });
+            // NOTE: Important. Get the dev. server elements renderers.
+            state.gracileConfig.litSsr ??= {};
+            state.gracileConfig.litSsr.renderInfo = getPluginContext(viteServerForClientHtmlBuild.config)?.litSsrRenderInfo;
+            const htmlPages = await buildRoutes({
+                viteServerForBuild: viteServerForClientHtmlBuild,
+                root: viteConfig.root || process.cwd(),
+                gracileConfig: state.gracileConfig,
+                serverMode: state.outputMode === 'server',
+                routes: state.routes,
+            });
+            state.renderedRoutes = htmlPages.renderedRoutes;
+            await viteServerForClientHtmlBuild.close();
+            return {
+                build: {
+                    rollupOptions: {
+                        input: htmlPages.inputList,
+                        plugins: [htmlPages.plugin],
+                    },
+                    outDir: join(viteConfig.build?.outDir || 'dist', state.outputMode === 'server' ? 'client' : ''),
+                },
+            };
+        },
+    };
+}

package/dist/vite/plugin-serve.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Vite plugin: development server middleware.
+ *
+ * Sets up the Gracile request handler, route watcher, and dev-time
+ * logging for `vite dev`.
+ *
+ * @internal
+ */
+import type { Logger, PluginOption } from 'vite';
+import type { GracileConfig } from '../user-config.js';
+import type { PluginSharedState } from './plugin-shared-state.js';
+export declare function gracileServePlugin({ state, config, logger, resetClientBuiltFlag, }: {
+    state: PluginSharedState;
+    config: GracileConfig | undefined;
+    logger: Logger;
+    resetClientBuiltFlag: () => void;
+}): PluginOption;
+//# sourceMappingURL=plugin-serve.d.ts.map

package/dist/vite/plugin-serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-serve.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-serve.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAIjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,wBAAgB,kBAAkB,CAAC,EAClC,KAAK,EACL,MAAM,EACN,MAAM,EACN,oBAAoB,GACpB,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;IACzB,MAAM,EAAE,aAAa,GAAG,SAAS,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,MAAM,IAAI,CAAC;CACjC,GAAG,YAAY,CA6Df"}

package/dist/vite/plugin-serve.js

@@ -0,0 +1,62 @@
+/**
+ * Vite plugin: development server middleware.
+ *
+ * Sets up the Gracile request handler, route watcher, and dev-time
+ * logging for `vite dev`.
+ *
+ * @internal
+ */
+import { getVersion } from '@gracile/internal-utils/version';
+import c from 'picocolors';
+import { createDevelopmentHandler } from '../dev/development.js';
+import { nodeAdapter } from '../server/adapters/node.js';
+export function gracileServePlugin({ state, config, logger, resetClientBuiltFlag, }) {
+    return {
+        name: 'vite-plugin-gracile-serve-middleware',
+        apply: 'serve',
+        config(_, environment) {
+            if (environment.isPreview)
+                return null;
+            return {
+                // NOTE: Supresses message: `Could not auto-determine entry point from rollupOptions or html files…`
+                // FIXME: It's not working when reloading the Vite config.
+                // Is user config, putting `optimizeDeps: { include: [] }` solve this.
+                optimizeDeps: { include: [] },
+                // NOTE: Useful? It breaks preview (expected)
+                appType: 'custom',
+            };
+        },
+        async configureServer(server) {
+            // HACK: We know we are in dev here, this will prevent incorrect
+            // vite.config hot reloading. Will be removed when adopting env. API.
+            resetClientBuiltFlag();
+            const version = getVersion();
+            logger.info(`${c.cyan(c.italic(c.underline('🧚 Gracile')))}` +
+                ` ${c.dim(`~`)} ${c.green(`v${version ?? 'X'}`)}`);
+            const { handler } = await createDevelopmentHandler({
+                routes: state.routes,
+                vite: server,
+                gracileConfig: state.gracileConfig,
+            });
+            logger.info(c.dim('Vite development server is starting…'), {
+                timestamp: true,
+            });
+            server.watcher.on('ready', () => {
+                setTimeout(() => {
+                    logger.info('');
+                    logger.info(c.green('Watching for file changes…'), {
+                        timestamp: true,
+                    });
+                    logger.info('');
+                    // NOTE: We want it to show after the Vite intro stuff
+                }, 100);
+            });
+            return () => {
+                server.middlewares.use((request, response, next) => {
+                    const locals = config?.dev?.locals?.({ nodeRequest: request });
+                    Promise.resolve(nodeAdapter(handler, { logger })(request, response, locals)).catch((error) => next(error));
+                });
+            };
+        },
+    };
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Vite plugins: server-side build pipeline.
+ *
+ * After the client build completes, these plugins run a nested
+ * `vite build` in SSR mode to produce the server entrypoint.
+ *
+ * Includes:
+ * - Client asset filename collector (from the client writeBundle)
+ * - Server build trigger (closeBundle)
+ * - Virtual entrypoint codegen
+ * - Server-to-client asset mover
+ *
+ * @internal
+ */
+import { type PluginOption } from 'vite';
+import type { PluginSharedState } from './plugin-shared-state.js';
+/**
+ * Tracks client bundle assets so the server build can reference them
+ * with their hashed filenames.
+ */
+export declare function gracileCollectClientAssetsPlugin({ state, }: {
+    state: PluginSharedState;
+}): PluginOption;
+/**
+ * After the client build finishes (`closeBundle`), run a nested SSR
+ * build that produces the server entrypoint and moves assets back into
+ * the client output directory.
+ */
+export declare function gracileServerBuildPlugin({ state, virtualRoutesForClient, }: {
+    state: PluginSharedState;
+    virtualRoutesForClient: PluginOption;
+}): PluginOption;
+//# sourceMappingURL=plugin-server-build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-server-build.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-server-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAGhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,EAChD,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,CAYf;AAID;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,EACxC,KAAK,EACL,sBAAsB,GACtB,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;IACzB,sBAAsB,EAAE,YAAY,CAAC;CACrC,GAAG,YAAY,CAqEf"}

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

@@ -0,0 +1,157 @@
+/**
+ * Vite plugins: server-side build pipeline.
+ *
+ * After the client build completes, these plugins run a nested
+ * `vite build` in SSR mode to produce the server entrypoint.
+ *
+ * Includes:
+ * - Client asset filename collector (from the client writeBundle)
+ * - Server build trigger (closeBundle)
+ * - Virtual entrypoint codegen
+ * - Server-to-client asset mover
+ *
+ * @internal
+ */
+import { join } from 'node:path';
+import { rename, rm } from 'node:fs/promises';
+import { build } from 'vite';
+import { virtualRoutes } from './virtual-routes.js';
+// ── Client asset collector ───────────────────────────────────────────
+/**
+ * Tracks client bundle assets so the server build can reference them
+ * with their hashed filenames.
+ */
+export function gracileCollectClientAssetsPlugin({ state, }) {
+    return {
+        name: 'vite-plugin-gracile-collect-client-assets-for-server',
+        writeBundle(_, bundle) {
+            if (state.outputMode === 'static')
+                return;
+            for (const file of Object.values(bundle))
+                if (file.type === 'asset' && file.name)
+                    state.clientAssets[file.name] = file.fileName;
+        },
+    };
+}
+// ── Server build trigger ─────────────────────────────────────────────
+/**
+ * After the client build finishes (`closeBundle`), run a nested SSR
+ * build that produces the server entrypoint and moves assets back into
+ * the client output directory.
+ */
+export function gracileServerBuildPlugin({ state, virtualRoutesForClient, }) {
+    return {
+        name: 'vite-plugin-gracile-server-build',
+        apply: 'build',
+        config(viteConfig) {
+            state.root = viteConfig.root || null;
+        },
+        async closeBundle() {
+            if (state.outputMode === 'static' ||
+                !state.routes ||
+                !state.renderedRoutes)
+                return;
+            const root = state.root || process.cwd();
+            await build({
+                root,
+                ssr: { external: ['@gracile/gracile'] },
+                build: {
+                    target: 'esnext',
+                    ssr: true,
+                    copyPublicDir: false,
+                    outDir: 'dist/server',
+                    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;
+                                    // NOTE: When not imported at all from client
+                                    return `assets/${chunkInfo.name.replace(/\.(.*)$/, '')}-[hash].[ext]`;
+                                }
+                                return 'assets/[name]-[hash].[ext]';
+                            },
+                            chunkFileNames: 'chunk/[name].js',
+                        },
+                    },
+                },
+                plugins: [
+                    virtualRoutesForClient,
+                    virtualRoutes({
+                        routes: state.routes,
+                        renderedRoutes: state.renderedRoutes,
+                    }),
+                    gracileEntrypointPlugin(state),
+                    gracileMoveServerAssetsPlugin(state),
+                ],
+            });
+        },
+    };
+}
+// ── Virtual entrypoint ───────────────────────────────────────────────
+/**
+ * Generates the virtual `entrypoint.js` module for the server build.
+ * This is the server's main entry: it imports routes and creates the
+ * Gracile handler.
+ */
+function gracileEntrypointPlugin(state) {
+    return {
+        name: 'vite-plugin-gracile-entry',
+        resolveId(id) {
+            if (id === 'entrypoint.js') {
+                return id;
+            }
+            return null;
+        },
+        load(id) {
+            if (id === 'entrypoint.js' && state.routes && state.renderedRoutes) {
+                return `
+import { routeAssets, routeImports, routes } from 'gracile:routes';
+import { createGracileHandler } from '@gracile/gracile/_internals/server-runtime';
+import { createLogger } from '@gracile/gracile/_internals/logger';
+
+createLogger();
+
+export const handler = createGracileHandler({
+	root: process.cwd(),
+	routes,
+	routeImports,
+	routeAssets,
+	serverMode: true,
+	gracileConfig: ${JSON.stringify(state.gracileConfig, null, 2)}
+});
+`;
+            }
+            return null;
+        },
+    };
+}
+// ── Server asset mover ───────────────────────────────────────────────
+/**
+ * After the server build writes its bundle, move any assets from
+ * `dist/server/assets/` into `dist/client/assets/` so the client
+ * can serve them.
+ */
+function gracileMoveServerAssetsPlugin(state) {
+    return {
+        name: 'gracile-move-server-assets',
+        async writeBundle(_, bundle) {
+            const cwd = state.root || process.cwd();
+            await Promise.all(Object.entries(bundle).map(async ([file]) => {
+                if (file.startsWith('assets/') === false)
+                    return;
+                await rename(join(cwd, `/dist/server/${file}`), join(cwd, `/dist/client/${file}`));
+            }));
+            // NOTE: Disabled for now, because it conflict with test's folder comparer
+            await rm(join(cwd, `/dist/server/assets`), {
+                recursive: true,
+            }).catch(() => null);
+        },
+    };
+}