@gracile/engine 0.9.0 → 0.9.1-next.0

package/dist/dev/development.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"development.d.ts","sourceRoot":"","sources":["../../src/dev/development.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,MAAM,CAAC;AAG1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAEN,KAAK,cAAc,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIvD,wBAAsB,wBAAwB,CAAC,EAC9C,MAAM,EACN,IAAI,EACJ,aAAa,GACb,EAAE;IACF,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,aAAa,CAAC;CAC7B,GAAG,OAAO,CAAC;IACX,OAAO,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,cAAc,CAAC;CACvB,CAAC,CAgDD"}
+{"version":3,"file":"development.d.ts","sourceRoot":"","sources":["../../src/dev/development.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,MAAM,CAAC;AAG1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAEN,KAAK,cAAc,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIvD,wBAAsB,wBAAwB,CAAC,EAC9C,MAAM,EACN,IAAI,EACJ,aAAa,GACb,EAAE;IACF,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,aAAa,CAAC;CAC7B,GAAG,OAAO,CAAC;IACX,OAAO,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,cAAc,CAAC;CACvB,CAAC,CAqDD"}

package/dist/dev/development.js

@@ -10,7 +10,7 @@ export async function createDevelopmentHandler({ routes, vite, gracileConfig, })
     logger.info('');
     logger.info(c.dim('Creating the request handler…'), { timestamp: true });
     const collectAndCodegen = async () => {
-        await collectRoutes(routes, root, gracileConfig.routes?.exclude);
+        await collectRoutes(routes, root, gracileConfig.routes?.exclude, gracileConfig.trailingSlash);
         if (gracileConfig.experimental?.generateRoutesTypings)
             await generateRoutesTypings(root, routes).catch((error) => logger.error(String(error)));
     };

package/dist/dev/ssr-ce-tracker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Server-side Custom Elements registry tracker for dev HMR.
+ *
+ * Wraps the Lit SSR DOM shim's `customElements` so orphaned CEs
+ * can be blocked when their import is removed during development.
+ *
+ * @internal — dev-only, never runs in production builds.
+ */
+export declare function installCeTracker(): void;
+/**
+ * Block all CEs registered by a given module.
+ * They will be unblocked if the module is re-evaluated and calls define() again.
+ */
+export declare function blockCesForModule(moduleId: string): void;
+/** Check whether a module has registered any CEs. */
+export declare function hasCeRegistrations(moduleId: string): boolean;
+/**
+ * Reset tracking state.
+ * @param full - Also reset installation state (for test suite teardown
+ *   so a subsequent `installCeTracker` call takes effect).
+ */
+export declare function resetCeTracker(full?: boolean): void;
+/** Read-only view of currently blocked tags. For test assertions. */
+export declare function getBlockedTags(): ReadonlySet<string>;
+/** Read-only view of module → tag-names mappings. For test assertions. */
+export declare function getModuleToTags(): ReadonlyMap<string, ReadonlySet<string>>;
+//# sourceMappingURL=ssr-ce-tracker.d.ts.map

package/dist/dev/ssr-ce-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-ce-tracker.d.ts","sourceRoot":"","sources":["../../src/dev/ssr-ce-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAwDH,wBAAgB,gBAAgB,SA+B/B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,QAMjD;AAED,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,UAAQ,QAK1C;AAED,qEAAqE;AACrE,wBAAgB,cAAc,IAAI,WAAW,CAAC,MAAM,CAAC,CAEpD;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,IAAI,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAE1E"}

package/dist/dev/ssr-ce-tracker.js

@@ -0,0 +1,113 @@
+/**
+ * Server-side Custom Elements registry tracker for dev HMR.
+ *
+ * Wraps the Lit SSR DOM shim's `customElements` so orphaned CEs
+ * can be blocked when their import is removed during development.
+ *
+ * @internal — dev-only, never runs in production builds.
+ */
+// ── Tracking state ──────────────────────────────────────────────────
+/** module ID → tag names that module registered */
+const moduleToTags = new Map();
+/** Tags blocked from registry lookup (orphaned modules) */
+const blocked = new Set();
+/** Which module is currently being evaluated (set by transform-injected code) */
+let currentModuleId = null;
+let installed = false;
+// ── Registry wrapper ────────────────────────────────────────────────
+function wrapRegistry(registry) {
+    const origDefine = registry.define.bind(registry);
+    const origGet = registry.get.bind(registry);
+    registry.define = function (name, ctor, options) {
+        // If re-registered after being blocked, unblock.
+        blocked.delete(name);
+        if (currentModuleId) {
+            let tags = moduleToTags.get(currentModuleId);
+            if (!tags) {
+                tags = new Set();
+                moduleToTags.set(currentModuleId, tags);
+            }
+            tags.add(name);
+        }
+        try {
+            origDefine(name, ctor, options);
+        }
+        catch {
+            // Already defined — expected during HMR re-evaluation.
+        }
+    };
+    registry.get = function (name) {
+        if (blocked.has(name))
+            return;
+        return origGet(name);
+    };
+}
+// ── Public API ──────────────────────────────────────────────────────
+export function installCeTracker() {
+    if (installed)
+        return;
+    installed = true;
+    if (globalThis.customElements) {
+        wrapRegistry(globalThis.customElements);
+    }
+    else {
+        // Shim not yet installed — intercept the assignment so we can
+        // wrap it the moment Lit SSR's DOM shim sets it up.
+        let _ce;
+        Object.defineProperty(globalThis, 'customElements', {
+            get: () => _ce,
+            set(value) {
+                _ce = value;
+                wrapRegistry(value);
+            },
+            configurable: true,
+            enumerable: true,
+        });
+    }
+    // Expose for transform-injected code.
+    // Runs in the same process via Vite's ssrLoadModule.
+    globalThis['__gracile_ce_tracker'] = {
+        setModule(id) {
+            currentModuleId = id;
+        },
+        clearModule() {
+            currentModuleId = null;
+        },
+    };
+}
+/**
+ * Block all CEs registered by a given module.
+ * They will be unblocked if the module is re-evaluated and calls define() again.
+ */
+export function blockCesForModule(moduleId) {
+    const tags = moduleToTags.get(moduleId);
+    if (!tags)
+        return;
+    for (const tag of tags) {
+        blocked.add(tag);
+    }
+}
+/** Check whether a module has registered any CEs. */
+export function hasCeRegistrations(moduleId) {
+    return moduleToTags.has(moduleId);
+}
+/**
+ * Reset tracking state.
+ * @param full - Also reset installation state (for test suite teardown
+ *   so a subsequent `installCeTracker` call takes effect).
+ */
+export function resetCeTracker(full = false) {
+    moduleToTags.clear();
+    blocked.clear();
+    currentModuleId = null;
+    if (full)
+        installed = false;
+}
+/** Read-only view of currently blocked tags. For test assertions. */
+export function getBlockedTags() {
+    return blocked;
+}
+/** Read-only view of module → tag-names mappings. For test assertions. */
+export function getModuleToTags() {
+    return moduleToTags;
+}

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAQtD;;;;;;;;;;;;;;;;GAgBG;AAIH,eAAO,MAAM,OAAO,GAAI,SAAS,aAAa,KAAG,GAAG,EAuVnD,CAAC;AAEF,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAsBtD;;;;;;;;;;;;;;;;GAgBG;AAIH,eAAO,MAAM,OAAO,GAAI,SAAS,aAAa,KAAG,GAAG,EA2EnD,CAAC;AAEF,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/plugin.js

@@ -1,18 +1,19 @@
-import { join } from 'node:path';
-import { rename, rm } from 'node:fs/promises';
 import { createLogger } from '@gracile/internal-utils/logger/helpers';
 import { getPluginContext, } from '@gracile/internal-utils/plugin-context';
-import { getVersion } from '@gracile/internal-utils/version';
-// import { betterErrors } from '@gracile-labs/better-errors/plugin';
-import c from 'picocolors';
-import { build, createServer } from 'vite';
-import {} from './routes/render.js';
-import { createDevelopmentHandler } from './dev/development.js';
-import { nodeAdapter } from './server/adapters/node.js';
-import { buildRoutes } from './vite/build-routes.js';
 import { htmlRoutesLoader } from './vite/html-routes.js';
-import { virtualRoutes, virtualRoutesClient } from './vite/virtual-routes.js';
 import { hmrSsrReload } from './vite/hmr.js';
+import { virtualRoutesClient, virtualRoutes } from './vite/virtual-routes.js';
+import { createPluginSharedState } from './vite/plugin-shared-state.js';
+import { gracileServePlugin } from './vite/plugin-serve.js';
+import { gracileClientBuildPlugin } from './vite/plugin-client-build.js';
+import { gracileBuildEnvironmentPlugin } from './vite/plugin-build-environment.js';
+import { gracileCollectClientAssetsPlugin, gracileEntrypointPlugin, gracileMoveServerAssetsPlugin, } from './vite/plugin-server-build.js';
+import { gracileCETrackerPlugin } from './vite/plugin-ce-tracker.js';
+import { gracileHtmlRoutesBuildPlugins } from './vite/plugin-html-routes-build.js';
+// When plugin-client-build creates a temporary dev server via createServer(),
+// the user's vite.config is re-evaluated, calling gracile() again.
+// This guard prevents that re-entrant call from initializing the full plugin set.
+// Reset in configureServer so dev-mode config hot-reloads still work.
 let isClientBuilt = false;
 /**
  * The main Vite plugin for loading the Gracile framework.
@@ -36,274 +37,60 @@ let isClientBuilt = false;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const gracile = (config) => {
     const logger = createLogger();
-    const outputMode = config?.output || 'static';
-    const clientAssets = {};
-    const routes = new Map();
-    let renderedRoutes = null;
-    let root = null;
-    const gracileConfig = config || {};
-    // HACK: Prevent duplicate client build for the SSR build step in server mode.
-    // TODO: Move to the new, clean, environments builders API.
+    const state = createPluginSharedState(config);
     if (isClientBuilt)
         return [];
     isClientBuilt = true;
     const virtualRoutesForClient = virtualRoutesClient({
-        mode: outputMode,
-        routes,
-        // NOTE: This will be a dedicated setting when it will not be experimental
-        // anymore.
-        gracileConfig,
-        // enabled: gracileConfig?.pages?.premises?.expose || false,
+        mode: state.outputMode,
+        routes: state.routes,
+        gracileConfig: state.gracileConfig,
     });
     let sharedPluginContext;
     return [
+        // MARK: 1. Plugin context setup
         {
             name: 'vite-plugin-gracile-context',
-            config(config) {
-                sharedPluginContext = getPluginContext(config);
-                gracileConfig.litSsr ??= { renderInfo: {} };
-                gracileConfig.litSsr.renderInfo = sharedPluginContext.litSsrRenderInfo;
+            config(viteConfig) {
+                sharedPluginContext = getPluginContext(viteConfig);
+                state.gracileConfig.litSsr ??= { renderInfo: {} };
+                state.gracileConfig.litSsr.renderInfo =
+                    sharedPluginContext.litSsrRenderInfo;
             },
         },
-        // betterErrors({
-        // 	overlayImportPath: '@gracile/gracile/_internals/vite-custom-overlay',
-        // }),
-        // 		{
-        // 			name: 'gracile-routes-codegen',
-        // 			// watchChange(change) {
-        // 			// 	console.log({ change });
-        // 			// },
-        // 			resolveId(id) {
-        // 				const virtualModuleId = 'gracile:route';
-        // 				const resolvedVirtualModuleId = `\0${virtualModuleId}`;
-        // 				if (id === virtualModuleId) {
-        // 					return resolvedVirtualModuleId;
-        // 				}
-        // 				return null;
-        // 			},
-        // 			load(id) {
-        // 				const virtualModuleId = 'gracile:route';
-        // 				const resolvedVirtualModuleId = `\0${virtualModuleId}`;
-        // 				if (id === resolvedVirtualModuleId) {
-        // 					return `
-        // export function route(input){
-        // return input;
-        // }`;
-        // 				}
-        // 				return null;
-        // 			},
-        // 		},
+        // MARK: 2. CE registry tracker (dev HMR cleanup)
+        gracileCETrackerPlugin(),
+        // MARK: 3. HMR SSR reload
         hmrSsrReload(),
-        {
-            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',
-                    // resolve: {
-                    // 	conditions: ['development'],
-                    // },
-                };
-            },
-            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.
+        // MARK: 4. Dev serve middleware
+        gracileServePlugin({
+            state,
+            config,
+            logger,
+            resetClientBuiltFlag: () => {
                 isClientBuilt = false;
-                // Infos
-                // // NOTE: Beware import.meta.resolve is only compatible
-                // // with v20.6.0 (without cli flag)and upward
-                // // Not working with StackBlitz ATM?
-                // const mainPjson = import.meta
-                // 	.resolve('@gracile/gracile')
-                // 	// NOTE: Weirdly, it will assume that it's `dist/**.js`,
-                // 	// even after fiddling with pjson exports.
-                // 	.replace('/dist/index.js', '/package.json');
-                // const { version } = JSON.parse(
-                // 	await readFile(new URL(mainPjson), 'utf-8'),
-                // ) as {
-                // 	version: number;
-                // };
-                const version = getVersion();
-                logger.info(`${c.cyan(c.italic(c.underline('🧚 Gracile')))}` +
-                    ` ${c.dim(`~`)} ${c.green(`v${version ?? 'X'}`)}`);
-                // ---
-                const { handler } = await createDevelopmentHandler({
-                    routes,
-                    vite: server,
-                    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));
-                    });
-                };
             },
-        },
+        }),
+        // MARK: 5. Client virtual routes
         virtualRoutesForClient,
+        // MARK: 6. HTML routes loader
         htmlRoutesLoader(),
-        {
-            name: 'vite-plugin-gracile-build',
-            apply: 'build',
-            async config(viteConfig) {
-                const viteServerForClientHtmlBuild = await createServer({
-                    // configFile: false,
-                    root: viteConfig.root || process.cwd(),
-                    server: { middlewareMode: true },
-                    // NOTE: Stub. KEEP IT!
-                    optimizeDeps: { include: [] },
-                    plugins: [virtualRoutesForClient],
-                });
-                // NOTE: Important. Get the dev. server elements renderers.
-                gracileConfig.litSsr ??= {};
-                gracileConfig.litSsr.renderInfo = getPluginContext(viteServerForClientHtmlBuild.config)?.litSsrRenderInfo;
-                const htmlPages = await buildRoutes({
-                    viteServerForBuild: viteServerForClientHtmlBuild,
-                    root: viteConfig.root || process.cwd(),
-                    gracileConfig,
-                    serverMode: outputMode === 'server',
-                    routes,
-                });
-                renderedRoutes = htmlPages.renderedRoutes;
-                await viteServerForClientHtmlBuild.close();
-                return {
-                    build: {
-                        // ssrManifest: true,
-                        rollupOptions: {
-                            input: htmlPages.inputList,
-                            plugins: [htmlPages.plugin],
-                        },
-                        outDir: join(viteConfig.build?.outDir || 'dist', outputMode === 'server' ? 'client' : ''),
-                    },
-                };
-            },
-        },
-        {
-            name: 'vite-plugin-gracile-collect-client-assets-for-server',
-            writeBundle(_, bundle) {
-                if (outputMode === 'static')
-                    return;
-                for (const file of Object.values(bundle))
-                    if (file.type === 'asset' && file.name)
-                        clientAssets[file.name] = file.fileName;
-            },
-        },
-        {
-            name: 'vite-plugin-gracile-server-build',
-            apply: 'build',
-            config(viteConfig) {
-                root = viteConfig.root || null;
-            },
-            async closeBundle() {
-                if (outputMode === 'static' || !routes || !renderedRoutes)
-                    return;
-                await build({
-                    root: root || process.cwd(),
-                    ssr: { external: ['@gracile/gracile'] },
-                    build: {
-                        target: 'esnext',
-                        ssr: true,
-                        // ssrManifest: true,
-                        copyPublicDir: false,
-                        outDir: 'dist/server',
-                        ssrEmitAssets: true,
-                        cssMinify: true,
-                        cssCodeSplit: true,
-                        rollupOptions: {
-                            input: 'entrypoint.js',
-                            // external: ['@gracile/gracile'],
-                            // FIXME: ~~MUST import css from client somewhere.~~
-                            // ~~Hack could be using dynamic imports on client, so asset is picked up~~
-                            output: {
-                                entryFileNames: '[name].js',
-                                // assetFileNames: 'assets/[name].[ext]',
-                                // NOTE: Useful for, e.g., link tag with `?url`
-                                assetFileNames: (chunkInfo) => {
-                                    if (chunkInfo.name) {
-                                        const fileName = clientAssets[chunkInfo.name];
-                                        if (fileName)
-                                            return fileName;
-                                        // NOTE: When not imported at all from client
-                                        return `assets/${chunkInfo.name.replace(/\.(.*)$/, '')}-[hash].[ext]`;
-                                    }
-                                    // throw new Error(`Not a client asset`);
-                                    return 'assets/[name]-[hash].[ext]';
-                                },
-                                chunkFileNames: 'chunk/[name].js',
-                            },
-                        },
-                    },
-                    plugins: [
-                        virtualRoutesForClient,
-                        virtualRoutes({ routes, renderedRoutes }),
-                        {
-                            name: 'vite-plugin-gracile-entry',
-                            resolveId(id) {
-                                if (id === 'entrypoint.js') {
-                                    return id;
-                                }
-                                return null;
-                            },
-                            load(id) {
-                                if (id === 'entrypoint.js' && routes && 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(gracileConfig, null, 2)}
-});
-`;
-                                }
-                                return null;
-                            },
-                        },
-                        {
-                            name: 'gracile-move-server-assets',
-                            async writeBundle(_, bundle) {
-                                const cwd = 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);
-                            },
-                        },
-                    ],
-                });
-            },
-        },
+        // MARK: 7. Client build (route rendering → populates shared state)
+        gracileClientBuildPlugin({
+            state,
+            virtualRoutesForClient,
+        }),
+        // MARK: 8. HTML route resolution + asset collection (client build only)
+        ...gracileHtmlRoutesBuildPlugins({ state }),
+        // MARK: 9. Build environment configuration (consumes shared state)
+        gracileBuildEnvironmentPlugin({ state }),
+        // MARK: 9. Collect client assets for server
+        gracileCollectClientAssetsPlugin({ state }),
+        // MARK: 10. Server virtual routes (SSR environment only)
+        ...virtualRoutes({ state }),
+        // MARK: 11. Server entrypoint (SSR environment only)
+        gracileEntrypointPlugin({ state }),
+        // MARK: 12. Move server assets (SSR environment only)
+        gracileMoveServerAssetsPlugin({ state }),
     ];
 };

package/dist/render/route-template-pipeline.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Pure, testable pipeline steps extracted from the route template renderer.
+ *
+ * Each function here is a focused stage of the document post-processing
+ * lifecycle. They are composed by `renderRouteTemplate` in
+ * `./route-template.ts`.
+ *
+ * @internal
+ */
+import { Readable } from 'node:stream';
+import type { RenderInfo } from '@lit-labs/ssr';
+export declare const REGEX_TAG_SCRIPT: RegExp;
+export declare const REGEX_TAG_LINK: RegExp;
+/**
+ * Concatenate multiple `Readable` streams into a single async iterable.
+ */
+export declare function concatStreams(...readables: Readable[]): AsyncGenerator<any, void, unknown>;
+/**
+ * Merge user-provided `RenderInfo` with the default `LitElementRenderer`.
+ * Always appends `LitElementRenderer` to whatever the user supplied.
+ */
+export declare function mergeRenderInfo(renderInfo: Partial<RenderInfo> | undefined): Partial<RenderInfo>;
+/**
+ * Inject sibling page assets into the rendered document HTML.
+ *
+ * Inserts the `PAGE_ASSETS_MARKER` before `</head>`, then replaces it
+ * with concrete `<script>` / `<link>` tags for each asset path.
+ *
+ * @param documentHtml  The rendered document string.
+ * @param pageAssets    Array of asset file paths (e.g. `['src/pages/about.css']`).
+ * @returns The document with asset tags injected (or unchanged if no assets).
+ */
+export declare function injectSiblingAssets(documentHtml: string, pageAssets: string[]): string;
+/**
+ * Prepend `<!doctype html>` if the document doesn't already start with one.
+ *
+ * @param documentHtml  The rendered document string.
+ * @returns The document guaranteed to start with a doctype declaration.
+ */
+export declare function ensureDoctype(documentHtml: string): string;
+/**
+ * The HMR error overlay script injected in dev mode.
+ * Returns the raw HTML string for the `<script>` tag.
+ */
+export declare function developmentOverlaySnippet(): string;
+/**
+ * Inject the dev overlay script right after `<head>`.
+ * Only applied when `mode === 'dev'`.
+ *
+ * @param documentHtml  The rendered document string.
+ * @returns The document with the overlay injected.
+ */
+export declare function injectDevelopmentOverlay(documentHtml: string): string;
+/**
+ * For server-output builds: strip dev-time `<script type="module">` and
+ * `<link rel="stylesheet">` tags, then inject the production asset string
+ * before `</head>`.
+ *
+ * @param documentHtml     The rendered document string.
+ * @param routeAssetsHtml  The production asset tags to inject.
+ * @returns The document with dev assets stripped and production assets injected.
+ */
+export declare function injectServerAssets(documentHtml: string, routeAssetsHtml: string): string;
+//# sourceMappingURL=route-template-pipeline.d.ts.map

package/dist/render/route-template-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-template-pipeline.d.ts","sourceRoot":"","sources":["../../src/render/route-template-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAMhD,eAAO,MAAM,gBAAgB,QACkC,CAAC;AAEhE,eAAO,MAAM,cAAc,QAA2B,CAAC;AAIvD;;GAEG;AACH,wBAAuB,aAAa,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE,sCAM5D;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,SAAS,GACzC,OAAO,CAAC,UAAU,CAAC,CAQrB;AASD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAClC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAAE,GAClB,MAAM,CA2BR;AAID;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAO1D;AAID;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAalD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAKrE;AAID;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CACjC,YAAY,EAAE,MAAM,EACpB,eAAe,EAAE,MAAM,GACrB,MAAM,CAWR"}