@gracile/engine 0.9.0 → 0.9.1

package/dist/user-config.d.ts

@@ -38,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.
      */

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,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;;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"}
+{"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,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;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);
+            }
+        },
+    };
+}

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"}