@gracile/engine 0.8.2 → 0.9.0-next.10

package/dist/vite/plugin-ce-tracker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Vite plugin that tracks Custom Elements registrations on the server
+ * and cleans up orphaned CEs when imports are removed during dev HMR.
+ *
+ * How it works:
+ * 1. `configureServer` — installs the registry wrapper (before any modules load).
+ * 2. `transform` (SSR only) — injects module-context markers around files that
+ *    might call `customElements.define`, so the wrapper knows which module is
+ *    responsible for each registration.
+ * 3. `hotUpdate` — when a file changes, walks the OLD import tree, finds CE
+ *    modules in that tree, blocks their tags, and invalidates them. If they are
+ *    still imported after re-evaluation, `define()` fires again and unblocks.
+ *    If removed, they stay blocked.
+ *
+ * @internal
+ */
+import type { Plugin } from 'vite';
+export declare function gracileCETrackerPlugin(): Plugin;
+//# sourceMappingURL=plugin-ce-tracker.d.ts.map

package/dist/vite/plugin-ce-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-ce-tracker.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-ce-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAyB,MAAM,MAAM,CAAC;AAmC1D,wBAAgB,sBAAsB,IAAI,MAAM,CA6D/C"}

package/dist/vite/plugin-ce-tracker.js

@@ -0,0 +1,87 @@
+/**
+ * Vite plugin that tracks Custom Elements registrations on the server
+ * and cleans up orphaned CEs when imports are removed during dev HMR.
+ *
+ * How it works:
+ * 1. `configureServer` — installs the registry wrapper (before any modules load).
+ * 2. `transform` (SSR only) — injects module-context markers around files that
+ *    might call `customElements.define`, so the wrapper knows which module is
+ *    responsible for each registration.
+ * 3. `hotUpdate` — when a file changes, walks the OLD import tree, finds CE
+ *    modules in that tree, blocks their tags, and invalidates them. If they are
+ *    still imported after re-evaluation, `define()` fires again and unblocks.
+ *    If removed, they stay blocked.
+ *
+ * @internal
+ */
+import { installCeTracker, blockCesForModule, hasCeRegistrations, } from '../dev/ssr-ce-tracker.js';
+// ── Helpers ─────────────────────────────────────────────────────────
+/** Recursively collect all transitive imports of a module. */
+function collectImportTree(module_, seen = new Set()) {
+    if (!module_.id || seen.has(module_.id))
+        return seen;
+    seen.add(module_.id);
+    for (const imported of module_.importedModules) {
+        collectImportTree(imported, seen);
+    }
+    return seen;
+}
+/** Heuristic: does this source likely define a Custom Element? */
+function mightDefineCE(code) {
+    return (code.includes('customElements.define') ||
+        // Lit @customElement decorator — calls define() at eval time.
+        // Matches both TS source (`@customElement(`) and compiled output.
+        /\bcustomElement\s*\(/.test(code));
+}
+// ── Plugin ──────────────────────────────────────────────────────────
+export function gracileCETrackerPlugin() {
+    return {
+        name: 'vite-plugin-gracile-ce-tracker',
+        configureServer() {
+            installCeTracker();
+        },
+        // Inject module-context markers so the registry wrapper knows
+        // which module is responsible for each define() call.
+        transform(code, id, options) {
+            if (!options?.ssr)
+                return;
+            if (!mightDefineCE(code))
+                return;
+            const escaped = JSON.stringify(id);
+            return {
+                code: [
+                    `globalThis.__gracile_ce_tracker?.setModule(${escaped});`,
+                    code,
+                    `globalThis.__gracile_ce_tracker?.clearModule();`,
+                ].join('\n'),
+                map: null,
+            };
+        },
+        hotUpdate: {
+            order: 'pre',
+            handler({ modules, timestamp }) {
+                if (this.environment.name !== 'ssr')
+                    return;
+                const invalidated = new Set();
+                for (const module_ of modules) {
+                    if (!module_.id)
+                        continue;
+                    // Walk the OLD import tree (graph hasn't updated yet).
+                    const tree = collectImportTree(module_);
+                    for (const depId of tree) {
+                        if (!hasCeRegistrations(depId))
+                            continue;
+                        // Block this module's CEs. If the module is still imported
+                        // after re-evaluation, its define() will unblock them.
+                        blockCesForModule(depId);
+                        // Force re-evaluation so define() can re-fire.
+                        const depModule = this.environment.moduleGraph.getModuleById(depId);
+                        if (depModule) {
+                            this.environment.moduleGraph.invalidateModule(depModule, invalidated, timestamp, true);
+                        }
+                    }
+                }
+            },
+        },
+    };
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Vite plugin: client-side build route rendering.
+ *
+ * During `vite build`, this spins up a temporary dev server to render
+ * all routes into static HTML, then populates shared state with the
+ * rendered routes and input list.
+ *
+ * The actual HTML route resolution and asset collection are handled by
+ * separate Vite plugins (see `plugin-html-routes-build.ts`) that read
+ * from shared state and use `applyToEnvironment` to scope to the client.
+ *
+ * @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;;;;;;;;;;;;GAYG;AAGH,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,CAoDf"}

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

@@ -0,0 +1,55 @@
+/**
+ * Vite plugin: client-side build route rendering.
+ *
+ * During `vite build`, this spins up a temporary dev server to render
+ * all routes into static HTML, then populates shared state with the
+ * rendered routes and input list.
+ *
+ * The actual HTML route resolution and asset collection are handled by
+ * separate Vite plugins (see `plugin-html-routes-build.ts`) that read
+ * from shared state and use `applyToEnvironment` to scope to the client.
+ *
+ * @internal
+ */
+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) {
+            state.root = viteConfig.root || process.cwd();
+            const viteServerForClientHtmlBuild = await createServer({
+                root: state.root,
+                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;
+            state.clientBuildInputList = htmlPages.inputList;
+            // NOTE: Vite's dev server does not invoke Rollup's `closeWatcher`
+            // hook when shutting down. Plugins like @rollup/plugin-typescript
+            // use `ts.createWatchProgram()` which sets up hundreds of FS
+            // watchers; without an explicit `closeWatcher` call they are
+            // leaked and the Node process hangs after build.
+            for (const plugin of viteServerForClientHtmlBuild.config.plugins) {
+                if (typeof plugin.closeWatcher === 'function') {
+                    await plugin.closeWatcher();
+                }
+            }
+            await viteServerForClientHtmlBuild.close();
+        },
+    };
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Vite plugins: HTML route resolution and asset collection for builds.
+ *
+ * These are registered as Vite plugins (not Rollup plugins via
+ * `rollupOptions.plugins`) so they work correctly with the Environment
+ * API's `builder.build(env)`, which does not inherit top-level
+ * `rollupOptions` into environment builds.
+ *
+ * They use `applyToEnvironment` to scope to the client build only,
+ * preventing the SSR build from trying to resolve HTML entries.
+ *
+ * Data is read lazily from shared state, which is populated by the
+ * client build plugin's `config` hook before these hooks run.
+ *
+ * @internal
+ */
+import { type PluginOption } from 'vite';
+import type { PluginSharedState } from './plugin-shared-state.js';
+export declare function gracileHtmlRoutesBuildPlugins({ state, }: {
+    state: PluginSharedState;
+}): PluginOption[];
+//# sourceMappingURL=plugin-html-routes-build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-html-routes-build.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-html-routes-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAIvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AASlE,wBAAgB,6BAA6B,CAAC,EAC7C,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,EAAE,CAiJjB"}

package/dist/vite/plugin-html-routes-build.js

@@ -0,0 +1,140 @@
+/**
+ * Vite plugins: HTML route resolution and asset collection for builds.
+ *
+ * These are registered as Vite plugins (not Rollup plugins via
+ * `rollupOptions.plugins`) so they work correctly with the Environment
+ * API's `builder.build(env)`, which does not inherit top-level
+ * `rollupOptions` into environment builds.
+ *
+ * They use `applyToEnvironment` to scope to the client build only,
+ * preventing the SSR build from trying to resolve HTML entries.
+ *
+ * Data is read lazily from shared state, which is populated by the
+ * client build plugin's `config` hook before these hooks run.
+ *
+ * @internal
+ */
+import { basename, extname, join } from 'node:path';
+import { createFilter } from 'vite';
+import { REGEX_TAG_LINK, REGEX_TAG_SCRIPT } from '../render/route-template.js';
+function stripPremises(input) {
+    return input
+        .replace(/index\.html$/, '__index.doc.html')
+        .replace(/404\.html$/, '__404.doc.html')
+        .replace(/500\.html$/, '__500.doc.html');
+}
+export function gracileHtmlRoutesBuildPlugins({ state, }) {
+    return [
+        {
+            name: 'gracile-html-routes',
+            apply: 'build',
+            enforce: 'pre',
+            applyToEnvironment(environment) {
+                return environment.name !== 'ssr';
+            },
+            resolveId(id) {
+                const inputList = state.clientBuildInputList;
+                const root = state.root;
+                if (!inputList || !root)
+                    return null;
+                if (extname(id) === '.html' && inputList.includes(id))
+                    return join(root, id);
+                return null;
+            },
+            load(id) {
+                const renderedRoutes = state.renderedRoutes;
+                if (!renderedRoutes)
+                    return null;
+                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 (state.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 null;
+            },
+        },
+        {
+            name: 'gracile-collect-handler-assets',
+            apply: 'build',
+            enforce: 'post',
+            applyToEnvironment(environment) {
+                return environment.name !== 'ssr';
+            },
+            buildStart() {
+                const renderedRoutes = state.renderedRoutes;
+                if (!renderedRoutes)
+                    return;
+                if (!state.gracileConfig.pages?.premises?.expose)
+                    return;
+                const premisesFilter = createFilter(state.gracileConfig.pages.premises.include, state.gracileConfig.pages.premises.exclude);
+                for (const route of renderedRoutes) {
+                    if (premisesFilter(route.name) === false)
+                        continue;
+                    if (state.outputMode === 'server' && 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) {
+                const renderedRoutes = state.renderedRoutes;
+                if (!renderedRoutes)
+                    return;
+                if (state.outputMode !== 'server')
+                    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');
+                        const route = renderedRoutes.find((r) => {
+                            if (state.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-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,CA4Df"}

package/dist/vite/plugin-serve.js

@@ -0,0 +1,61 @@
+/**
+ * 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) {
+            // Reset so dev-mode config hot-reloads don't hit the guard.
+            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,43 @@
+/**
+ * Vite plugins: server-side build pipeline.
+ *
+ * Uses the Vite Environment API (`builder.buildApp()`) to coordinate
+ * client and SSR builds instead of a nested `build()` call.
+ *
+ * Includes:
+ * - Client asset filename collector (client env writeBundle)
+ * - Virtual entrypoint codegen (SSR env only)
+ * - Server-to-client asset mover (SSR env only)
+ *
+ * @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;
+/**
+ * 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.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export declare function gracileEntrypointPlugin({ state, }: {
+    state: PluginSharedState;
+}): PluginOption;
+/**
+ * After the server build writes its bundle, move any assets from
+ * `dist/server/assets/` into `dist/client/assets/` so the client
+ * can serve them.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export declare function gracileMoveServerAssetsPlugin({ state, }: {
+    state: PluginSharedState;
+}): 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;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC,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,CAgBf;AAID;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,EACvC,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,CAsCf;AAID;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,EAC7C,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,CA2Bf"}

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

@@ -0,0 +1,108 @@
+/**
+ * Vite plugins: server-side build pipeline.
+ *
+ * Uses the Vite Environment API (`builder.buildApp()`) to coordinate
+ * client and SSR builds instead of a nested `build()` call.
+ *
+ * Includes:
+ * - Client asset filename collector (client env writeBundle)
+ * - Virtual entrypoint codegen (SSR env only)
+ * - Server-to-client asset mover (SSR env only)
+ *
+ * @internal
+ */
+import { join } from 'node:path';
+import { rename, rm } from 'node:fs/promises';
+// ── 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',
+        applyToEnvironment(environment) {
+            return environment.name !== 'ssr';
+        },
+        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;
+        },
+    };
+}
+// ── 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.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export function gracileEntrypointPlugin({ state, }) {
+    return {
+        name: 'vite-plugin-gracile-entry',
+        apply: 'build',
+        applyToEnvironment(environment) {
+            return environment.name === 'ssr';
+        },
+        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.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export function gracileMoveServerAssetsPlugin({ state, }) {
+    return {
+        name: 'gracile-move-server-assets',
+        apply: 'build',
+        applyToEnvironment(environment) {
+            return environment.name === 'ssr';
+        },
+        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);
+        },
+    };
+}

package/dist/vite/plugin-shared-state.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared mutable state passed between the Gracile Vite plugin phases.
+ *
+ * This exists because Vite plugins in the same array share data through
+ * closures. Making the shared state explicit (instead of ad-hoc `let`
+ * variables) makes the data flow between plugins visible and auditable.
+ *
+ * @internal
+ */
+import type { RenderedRouteDefinition } from '../routes/render.js';
+import type { RoutesManifest } from '../routes/route.js';
+import type { GracileConfig } from '../user-config.js';
+export interface PluginSharedState {
+    /** Collected file-system routes (populated during dev and build). */
+    routes: RoutesManifest;
+    /** Rendered route definitions from the client build phase. */
+    renderedRoutes: RenderedRouteDefinition[] | null;
+    /** Rollup input list for the client build (populated by route renderer). */
+    clientBuildInputList: string[] | null;
+    /** Maps original asset names → hashed filenames from the client bundle. */
+    clientAssets: Record<string, string>;
+    /** Vite `root` captured during build config. */
+    root: string | null;
+    /** The resolved Gracile configuration. */
+    gracileConfig: GracileConfig;
+    /** The output mode: 'static' or 'server'. */
+    outputMode: 'static' | 'server';
+}
+/**
+ * Create a fresh shared state object.
+ */
+export declare function createPluginSharedState(config: GracileConfig | undefined): PluginSharedState;
+//# sourceMappingURL=plugin-shared-state.d.ts.map

package/dist/vite/plugin-shared-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-shared-state.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-shared-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,MAAM,WAAW,iBAAiB;IACjC,qEAAqE;IACrE,MAAM,EAAE,cAAc,CAAC;IAEvB,8DAA8D;IAC9D,cAAc,EAAE,uBAAuB,EAAE,GAAG,IAAI,CAAC;IAEjD,4EAA4E;IAC5E,oBAAoB,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAEtC,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErC,gDAAgD;IAChD,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpB,0CAA0C;IAC1C,aAAa,EAAE,aAAa,CAAC;IAE7B,6CAA6C;IAC7C,UAAU,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAChC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,aAAa,GAAG,SAAS,GAC/B,iBAAiB,CAUnB"}

package/dist/vite/plugin-shared-state.js

@@ -0,0 +1,23 @@
+/**
+ * Shared mutable state passed between the Gracile Vite plugin phases.
+ *
+ * This exists because Vite plugins in the same array share data through
+ * closures. Making the shared state explicit (instead of ad-hoc `let`
+ * variables) makes the data flow between plugins visible and auditable.
+ *
+ * @internal
+ */
+/**
+ * Create a fresh shared state object.
+ */
+export function createPluginSharedState(config) {
+    return {
+        routes: new Map(),
+        renderedRoutes: null,
+        clientBuildInputList: null,
+        clientAssets: {},
+        root: null,
+        gracileConfig: config || {},
+        outputMode: config?.output || 'static',
+    };
+}