@ecopages/lit 0.2.1-beta.0 → 0.3.0

package/src/lit-renderer.js

@@ -1,236 +1,116 @@
-import "./dom-shim.js";
-import { IntegrationRenderer } from "@ecopages/core/route-renderer/integration-renderer";
-import { LitSsrLazyPreloader } from "./lit-ssr-lazy-preloader.js";
-import { LIT_PLUGIN_NAME } from "./lit.constants.js";
-import {
-  injectLitRenderedChildren,
-  LIT_COMPONENT_CHILDREN_SLOT_MARKER,
-  normalizeLitHtml,
-  renderLitValueToString
-} from "./utils/lit-html-rendering.js";
-class LitRenderer extends IntegrationRenderer {
-  name = LIT_PLUGIN_NAME;
-  isFunctionComponent(component) {
-    return typeof component === "function";
-  }
-  async resolveQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken) {
-    if (children === void 0) {
-      return void 0;
-    }
-    if (typeof children !== "string") {
-      return children;
-    }
-    let renderedChildren = children;
-    renderedChildren = await this.foreignSubtreeExecutionService.resolveQueuedTokens(
-      renderedChildren,
-      queuedResolutionsByToken,
-      resolveToken
-    );
-    return renderedChildren;
-  }
-  async resolveQueuedForeignSubtreeHtml(html, runtimeContext) {
-    const queuedForeignSubtreeResolution = await this.foreignSubtreeExecutionService.resolveQueuedHtml({
-      currentIntegrationName: this.name,
-      html,
-      runtimeContext,
-      queueLabel: "Lit",
-      getOwningRenderer: (integrationName, rendererCache) => this.getIntegrationRendererForName(integrationName, rendererCache),
-      applyAttributesToFirstElement: (resolvedHtml, attributes) => this.htmlTransformer.applyAttributesToFirstElement(resolvedHtml, attributes),
-      dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
-      renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
-        const renderedChildren = await this.resolveQueuedForeignSubtreeChildren(
-          children,
-          queuedResolutionsByToken,
-          resolveToken
-        );
-        if (typeof renderedChildren !== "string") {
-          return {
-            assets: [],
-            children: renderedChildren
-          };
-        }
+/**
+ * This module contains the Lit renderer hooks.
+ * @module
+ */
+import { createIntegrationRenderer } from '@ecopages/core/integration';
+import { resolveQueuedTokens } from '@ecopages/core/integration';
+import { CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES, CustomElementScriptPreloader, } from '@ecopages/core/integration';
+import { requireAppRuntime } from '@ecopages/core/integration';
+import { createCustomElementServerModuleImporter } from '@ecopages/core/integration';
+import { ensureLitDomShim } from './dom-shim.js';
+import { LIT_PLUGIN_NAME } from './lit.constants.js';
+import { injectLitRenderedChildren, LIT_COMPONENT_CHILDREN_SLOT_MARKER, normalizeLitHtml, renderLitValueToString, } from './utils/lit-html-rendering.js';
+/**
+ * Creates the Lit renderer class with a lazy worker-session lookup.
+ *
+ * @remarks
+ * The plugin may create its renderer before `setup()` assigns the static render session, so hooks read the
+ * session when they run instead of capturing its construction-time value.
+ */
+export function createLitRenderer(getRenderSession = () => undefined) {
+    return createIntegrationRenderer(LIT_PLUGIN_NAME, ({ appConfig, resolveComponentDependencies, resolveDependencyPath }) => {
+        const ssrScriptPreloader = new CustomElementScriptPreloader({
+            cacheScope: CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.lit,
+            preloadScopes: requireAppRuntime(appConfig).customElementSsrPreloadScopes,
+            logLabel: 'lit',
+            requireLazyScriptEntry: true,
+            resolveDependencyPath,
+            importServerModule: createCustomElementServerModuleImporter(appConfig, '.lit-ssr'),
+        });
+        const preloadSsrScripts = async (components) => {
+            ensureLitDomShim();
+            const renderSession = getRenderSession();
+            if (renderSession) {
+                await renderSession.preloadSsrScripts(components);
+                return;
+            }
+            await ssrScriptPreloader.preloadSsrScripts(components);
+        };
         return {
-          assets: [],
-          html: renderedChildren
+            beforeRender: async (renderOptions) => preloadSsrScripts([
+                renderOptions.Page,
+                renderOptions.Layout,
+                ...(renderOptions.pageDependencyComponents ?? []),
+            ]),
+            transformDocumentHtml: normalizeLitHtml,
+            renderRemote: (routeOptions) => renderLitPageInWorker(routeOptions, getRenderSession),
+            renderComponent: async (input) => {
+                await preloadSsrScripts([input.component]);
+                if (!isFunctionComponent(input.component)) {
+                    throw new TypeError('Lit renderer expected a callable component.');
+                }
+                const component = input.component;
+                let renderedChildren;
+                if (input.children !== undefined) {
+                    renderedChildren =
+                        typeof input.children === 'string'
+                            ? input.children
+                            : await renderLitValueToString(input.children);
+                }
+                const props = renderedChildren === undefined
+                    ? input.props
+                    : {
+                        ...input.props,
+                        children: LIT_COMPONENT_CHILDREN_SLOT_MARKER,
+                    };
+                const content = await component(props);
+                const renderedHtml = await renderLitValueToString(content);
+                const html = renderedChildren === undefined
+                    ? renderedHtml
+                    : injectLitRenderedChildren(renderedHtml, renderedChildren);
+                const assets = input.component.config?.dependencies
+                    ? await resolveComponentDependencies([input.component])
+                    : undefined;
+                return {
+                    html,
+                    canAttachAttributes: true,
+                    integrationName: LIT_PLUGIN_NAME,
+                    assets,
+                };
+            },
+            renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
+                if (children === undefined) {
+                    return {};
+                }
+                if (typeof children !== 'string') {
+                    return { children };
+                }
+                return { html: await resolveQueuedTokens(children, queuedResolutionsByToken, resolveToken) };
+            },
         };
-      }
     });
-    return {
-      html: queuedForeignSubtreeResolution.html,
-      assets: queuedForeignSubtreeResolution.assets.length > 0 ? queuedForeignSubtreeResolution.assets : void 0
-    };
-  }
-  shouldRenderPageComponent() {
-    return false;
-  }
-  isLitManagedComponent(component) {
-    return component?.config?.integration === this.name || component?.config?.__eco?.integration === this.name;
-  }
-  /**
-   * Renders a Lit component for component-level orchestration.
-   *
-   * SSR-eligible lazy scripts are preloaded first so custom elements registered
-   * by the component can render their server markup even when the Lit renderer is
-   * entered through cross-integration foreign-child handoff.
-   *
-   * Includes component-scoped dependency assets when declared.
-   */
-  async renderComponent(input) {
-    await this.preloadSsrLazyScripts([input.component]);
-    if (!this.isFunctionComponent(input.component)) {
-      throw new TypeError("Lit renderer expected a callable component.");
-    }
-    const component = input.component;
-    let renderedChildren;
-    if (input.children !== void 0) {
-      renderedChildren = typeof input.children === "string" ? input.children : await renderLitValueToString(input.children);
-    }
-    let props = input.props;
-    if (renderedChildren !== void 0) {
-      props = {
-        ...input.props,
-        children: LIT_COMPONENT_CHILDREN_SLOT_MARKER
-      };
-    }
-    const content = await component(props);
-    const renderedHtml = await renderLitValueToString(content);
-    const html = renderedChildren === void 0 ? renderedHtml : injectLitRenderedChildren(renderedHtml, renderedChildren);
-    const queuedForeignSubtreeResolution = await this.resolveQueuedForeignSubtreeHtml(
-      html,
-      this.getQueuedForeignSubtreeResolutionContext(input)
-    );
-    const hasDependencies = Boolean(input.component.config?.dependencies);
-    const canResolveAssets = typeof this.assetProcessingService?.processDependencies === "function";
-    const assets = hasDependencies && canResolveAssets ? await this.processComponentDependencies([input.component]) : void 0;
-    return {
-      html: queuedForeignSubtreeResolution.html,
-      canAttachAttributes: true,
-      rootTag: this.getRootTagName(queuedForeignSubtreeResolution.html),
-      integrationName: this.name,
-      assets: this.htmlTransformer.dedupeProcessedAssets([
-        ...assets ?? [],
-        ...queuedForeignSubtreeResolution.assets ?? []
-      ])
-    };
-  }
-  ssrLazyPreloader = new LitSsrLazyPreloader({
-    resolveDependencyPath: this.resolveDependencyPath.bind(this),
-    processDependencies: this.assetProcessingService?.processDependencies?.bind(this.assetProcessingService)
-  });
-  /**
-   * Detects preload failures that are expected for browser-only modules.
-   *
-   * These errors are treated as non-fatal during SSR preload because some
-   * lazy client scripts intentionally depend on browser globals.
-   */
-  isExpectedSsrPreloadError(error) {
-    return this.ssrLazyPreloader.isExpectedSsrPreloadError(error);
-  }
-  /**
-   * Collects lazy script file paths eligible for SSR preloading.
-   *
-   * Only per-entry lazy script dependencies with `ssr: true` are collected.
-   * File-backed entries are required (`src` must be present);
-   * inline content lazy entries are intentionally skipped.
-   */
-  collectSsrPreloadScripts(components) {
-    return this.ssrLazyPreloader.collectSsrPreloadScripts(components);
-  }
-  /**
-   * Preloads SSR-eligible lazy scripts to register custom elements before render.
-   */
-  async preloadSsrLazyScripts(components) {
-    await this.ssrLazyPreloader.preloadSsrLazyScripts(components);
-  }
-  /**
-   * Resolves the concrete JS entrypoint used for SSR preloading.
-   *
-   * Scripts are passed through the asset pipeline so preload imports can use
-   * the same processed output shape as runtime dependencies.
-   */
-  async resolveSsrPreloadEntrypoint(scriptPath) {
-    return this.ssrLazyPreloader.resolveSsrPreloadEntrypoint(scriptPath);
-  }
-  async render({
-    params,
-    query,
-    props,
-    locals,
-    metadata,
-    Page,
-    Layout,
-    HtmlTemplate
-  }) {
-    try {
-      await this.preloadSsrLazyScripts([Page, Layout]);
-      return await this.renderPageWithDocumentShell({
-        page: {
-          component: Page,
-          props: {
-            params,
-            query,
-            ...props,
-            locals
-          }
-        },
-        layout: Layout ? {
-          component: Layout,
-          props: locals ? { locals } : {}
-        } : void 0,
-        htmlTemplate: HtmlTemplate,
-        metadata,
-        pageProps: props || {},
-        transformDocumentHtml: normalizeLitHtml
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering page", error);
-    }
-  }
-  async renderToResponse(view, props, ctx) {
-    try {
-      if (ctx.partial) {
-        return this.renderPartialViewResponse({
-          view,
-          props,
-          ctx,
-          transformHtml: normalizeLitHtml
-        });
-      }
-      const viewConfig = view.config;
-      const Layout = viewConfig?.layout;
-      const HtmlTemplate = await this.getHtmlTemplate();
-      const metadata = await this.resolveViewMetadata(view, props);
-      const normalizedProps = props ?? {};
-      await this.preloadSsrLazyScripts([view, Layout]);
-      await this.prepareViewDependencies(view, Layout);
-      const pageRender = await this.renderComponentWithForeignChildren({
-        component: view,
-        props: normalizedProps
-      });
-      const layoutRender = Layout ? await this.renderComponentWithForeignChildren({
-        component: Layout,
-        props: {},
-        children: pageRender.html
-      }) : void 0;
-      const documentRender = await this.renderComponentWithForeignChildren({
-        component: HtmlTemplate,
-        props: {
-          metadata,
-          pageProps: normalizedProps
-        },
-        children: layoutRender?.html ?? pageRender.html
-      });
-      this.appendProcessedDependencies(pageRender.assets, layoutRender?.assets, documentRender.assets);
-      const body = await this.finalizeResolvedHtml({
-        html: `${this.DOC_TYPE}${normalizeLitHtml(documentRender.html)}`,
-        partial: false
-      });
-      return this.createHtmlResponse(body, ctx);
-    } catch (error) {
-      throw this.createRenderError("Error rendering view", error);
+}
+export const LitRenderer = createLitRenderer();
+function isFunctionComponent(component) {
+    return typeof component === 'function';
+}
+/**
+ * Renders a Lit page route in its build-scoped worker when request data can cross the worker boundary.
+ *
+ * @remarks
+ * Locals and explicit props stay in-process: locals are request objects, and the worker re-imports the route module.
+ */
+async function renderLitPageInWorker(options, getRenderSession) {
+    const renderSession = getRenderSession();
+    if (!renderSession || options.locals !== undefined || options.props !== undefined) {
+        return undefined;
     }
-  }
+    const params = options.params ?? {};
+    const result = await renderSession.renderPageInWorker({
+        filePath: options.file,
+        params,
+        query: options.query,
+    });
+    const { html, ...metadata } = result;
+    return { body: html, ...metadata };
 }
-export {
-  LitRenderer
-};

package/src/lit-static-render-protocol.d.ts

@@ -0,0 +1,40 @@
+import type { PageParams, PageQuery } from '@ecopages/core';
+import type { RouteRenderResult } from '@ecopages/core/integration';
+/** A rendered page, its resolved metadata, and what the main thread needs to cache it. */
+export type LitStaticRenderResult = Pick<RouteRenderResult, 'cacheStrategy' | 'sourceDependencyPaths' | 'metadata'> & {
+    html: string;
+};
+export type LitStaticRenderWorkerInitMessage = {
+    type: 'init';
+    configModulePath: string;
+    runtimeOrigin: string;
+};
+export type LitStaticRenderWorkerRenderMessage = {
+    type: 'render';
+    id: string;
+    filePath: string;
+    /** Route params; multi-value keys stay as `string[]`. */
+    params: PageParams;
+    /** Serializable route query; preserves multi-value keys as `string[]`. */
+    query?: PageQuery;
+};
+export type LitStaticRenderWorkerShutdownMessage = {
+    type: 'shutdown';
+};
+export type LitStaticRenderWorkerRequestMessage = LitStaticRenderWorkerInitMessage | LitStaticRenderWorkerRenderMessage | LitStaticRenderWorkerShutdownMessage;
+export type LitStaticRenderWorkerReadyMessage = {
+    type: 'ready';
+};
+export type LitStaticRenderWorkerResultMessage = {
+    type: 'result';
+    id: string;
+} & LitStaticRenderResult;
+export type LitStaticRenderWorkerErrorMessage = {
+    type: 'error';
+    id?: string;
+    message: string;
+};
+export type LitStaticRenderWorkerShutdownCompleteMessage = {
+    type: 'shutdown-complete';
+};
+export type LitStaticRenderWorkerResponseMessage = LitStaticRenderWorkerReadyMessage | LitStaticRenderWorkerResultMessage | LitStaticRenderWorkerErrorMessage | LitStaticRenderWorkerShutdownCompleteMessage;

package/src/lit-static-render-protocol.js

@@ -0,0 +1 @@
+export {};

package/src/lit-static-render-result.d.ts

@@ -0,0 +1,10 @@
+import type { RouteRenderResult } from '@ecopages/core/integration';
+import type { LitStaticRenderResult } from './lit-static-render-protocol.js';
+/**
+ * Turns a route render into the message the worker posts back to the main thread.
+ *
+ * @remarks
+ * The resolved `metadata` travels with the HTML so the main thread can decide sitemap eligibility
+ * from the render instead of loading the page again.
+ */
+export declare function toLitStaticRenderResult(result: RouteRenderResult): Promise<LitStaticRenderResult>;

package/src/lit-static-render-result.js

@@ -0,0 +1,21 @@
+/**
+ * Turns a route render into the message the worker posts back to the main thread.
+ *
+ * @remarks
+ * The resolved `metadata` travels with the HTML so the main thread can decide sitemap eligibility
+ * from the render instead of loading the page again.
+ */
+export async function toLitStaticRenderResult(result) {
+    const { body, cacheStrategy, sourceDependencyPaths, metadata } = result;
+    const rendered = { cacheStrategy, sourceDependencyPaths, metadata };
+    if (typeof body === 'string') {
+        return { html: body, ...rendered };
+    }
+    if (Buffer.isBuffer(body)) {
+        return { html: body.toString('utf8'), ...rendered };
+    }
+    if (body instanceof ReadableStream) {
+        return { html: await new Response(body).text(), ...rendered };
+    }
+    throw new TypeError(`Unsupported Lit static render body type: ${typeof body}`);
+}

package/src/lit-static-render-session.d.ts

@@ -0,0 +1,65 @@
+import type { PageParams, PageQuery } from '@ecopages/core';
+import type { StaticExportContext } from '@ecopages/core/integration';
+import { type CustomElementSsrPreloadComponent } from '@ecopages/core/integration';
+import type { CustomElementScriptPreloadScopeState } from '@ecopages/core/integration';
+import { LitStaticRenderWorkerClient } from './lit-static-render-worker-client.js';
+import type { LitStaticRenderResult } from './lit-static-render-protocol.js';
+import type { AssetDefinition, AssetProcessingIntegration, ProcessedAsset } from '@ecopages/core/integration';
+type LitStaticRenderWorkerClientContract = Pick<LitStaticRenderWorkerClient, 'start' | 'renderPage' | 'dispose'>;
+type LitStaticRenderSessionOptions = {
+    preloadScopes: Map<string, CustomElementScriptPreloadScopeState>;
+    integration?: AssetProcessingIntegration;
+    resolveDependencyPath: (componentDir: string, sourcePath: string) => string;
+    processDependencies: (dependencies: AssetDefinition[], integration?: AssetProcessingIntegration) => Promise<ProcessedAsset[]>;
+    getInvalidationVersion?: () => number;
+    createWorkerClient?: (input: {
+        configModulePath: string;
+        runtimeOrigin: string;
+    }) => LitStaticRenderWorkerClientContract;
+};
+/**
+ * Plugin-runtime-scoped Lit server render session.
+ *
+ * @remarks
+ * Owns worker lifecycle and SSR preload for Lit page routes during static export
+ * and runtime/dev requests. Injected into `LitRenderer` via a lazy accessor from
+ * `LitPlugin`; there is no process-global coordinator.
+ *
+ * Worker init identity is sticky for the first `{ configModulePath, runtimeOrigin }`.
+ * Later `ensureWorker` calls with the same identity are no-ops; a different identity
+ * recreates the worker so stale config/origin is never silently reused.
+ */
+export declare class LitStaticRenderSession {
+    private readonly preloader;
+    private readonly createWorkerClient;
+    private workerClient;
+    private workerIdentity;
+    private readonly getInvalidationVersion;
+    private workerInvalidationVersion;
+    private renderChain;
+    constructor(options: LitStaticRenderSessionOptions);
+    /**
+     * Ensures the static render worker is running for the given identity.
+     *
+     * @remarks
+     * First successful start sticks that identity. Matching re-entry is a no-op.
+     * A different `configModulePath` or `runtimeOrigin` disposes and recreates.
+     */
+    ensureWorker(input: {
+        configModulePath: string;
+        runtimeOrigin: string;
+    }): Promise<void>;
+    preloadStaticRoutes(context: StaticExportContext): Promise<void>;
+    preloadSsrScripts(components: Array<CustomElementSsrPreloadComponent | undefined>): Promise<void>;
+    collectSsrPreloadScripts(components: Array<CustomElementSsrPreloadComponent | undefined>): string[];
+    renderPageInWorker(input: {
+        filePath: string;
+        params: PageParams;
+        query?: PageQuery;
+    }): Promise<LitStaticRenderResult>;
+    isExpectedSsrPreloadError(error: unknown): boolean;
+    dispose(): Promise<void>;
+    private preloadLitRoutes;
+    private isLitRoute;
+}
+export {};

package/src/lit-static-render-session.js

@@ -0,0 +1,145 @@
+import path from 'node:path';
+import { ensureLitDomShim } from './dom-shim.js';
+import { CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES, CustomElementScriptPreloader, } from '@ecopages/core/integration';
+import { LIT_PLUGIN_NAME } from './lit.constants.js';
+import { createCustomElementSsrPipelineImporter } from '@ecopages/core/integration';
+import { LitStaticRenderWorkerClient } from './lit-static-render-worker-client.js';
+/**
+ * Plugin-runtime-scoped Lit server render session.
+ *
+ * @remarks
+ * Owns worker lifecycle and SSR preload for Lit page routes during static export
+ * and runtime/dev requests. Injected into `LitRenderer` via a lazy accessor from
+ * `LitPlugin`; there is no process-global coordinator.
+ *
+ * Worker init identity is sticky for the first `{ configModulePath, runtimeOrigin }`.
+ * Later `ensureWorker` calls with the same identity are no-ops; a different identity
+ * recreates the worker so stale config/origin is never silently reused.
+ */
+export class LitStaticRenderSession {
+    preloader;
+    createWorkerClient;
+    workerClient = null;
+    workerIdentity = null;
+    getInvalidationVersion;
+    workerInvalidationVersion = 0;
+    renderChain = Promise.resolve();
+    constructor(options) {
+        this.getInvalidationVersion = options.getInvalidationVersion ?? (() => 0);
+        this.preloader = new CustomElementScriptPreloader({
+            cacheScope: CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.lit,
+            preloadScopes: options.preloadScopes,
+            logLabel: 'lit',
+            requireLazyScriptEntry: true,
+            resolveDependencyPath: options.resolveDependencyPath,
+            importServerModule: createCustomElementSsrPipelineImporter({
+                integration: options.integration,
+                processDependencies: options.processDependencies,
+            }),
+        });
+        this.createWorkerClient =
+            options.createWorkerClient ??
+                ((input) => new LitStaticRenderWorkerClient({
+                    configModulePath: input.configModulePath,
+                    runtimeOrigin: input.runtimeOrigin,
+                }));
+    }
+    /**
+     * Ensures the static render worker is running for the given identity.
+     *
+     * @remarks
+     * First successful start sticks that identity. Matching re-entry is a no-op.
+     * A different `configModulePath` or `runtimeOrigin` disposes and recreates.
+     */
+    async ensureWorker(input) {
+        if (this.workerClient &&
+            this.workerIdentity &&
+            this.workerIdentity.configModulePath === input.configModulePath &&
+            this.workerIdentity.runtimeOrigin === input.runtimeOrigin) {
+            return;
+        }
+        if (this.workerClient) {
+            await this.dispose();
+        }
+        this.workerIdentity = {
+            configModulePath: input.configModulePath,
+            runtimeOrigin: input.runtimeOrigin,
+        };
+        this.workerClient = this.createWorkerClient({
+            configModulePath: input.configModulePath,
+            runtimeOrigin: input.runtimeOrigin,
+        });
+        await this.workerClient.start();
+        this.workerInvalidationVersion = this.getInvalidationVersion();
+    }
+    async preloadStaticRoutes(context) {
+        await this.preloadLitRoutes(context);
+    }
+    async preloadSsrScripts(components) {
+        ensureLitDomShim();
+        await this.preloader.preloadSsrScripts(components);
+    }
+    collectSsrPreloadScripts(components) {
+        return this.preloader.collectSsrPreloadScripts(components);
+    }
+    async renderPageInWorker(input) {
+        if (!this.workerClient) {
+            throw new Error('Lit static render worker is not active');
+        }
+        const render = this.renderChain.then(async () => {
+            const version = this.getInvalidationVersion();
+            if (version !== this.workerInvalidationVersion && this.workerIdentity) {
+                const identity = this.workerIdentity;
+                await this.dispose();
+                await this.ensureWorker(identity);
+            }
+            if (!this.workerClient)
+                throw new Error('Lit static render worker is not active');
+            return this.workerClient.renderPage(input);
+        });
+        this.renderChain = render.then(() => undefined, () => undefined);
+        return render;
+    }
+    isExpectedSsrPreloadError(error) {
+        return this.preloader.isExpectedSsrPreloadError(error);
+    }
+    async dispose() {
+        await this.workerClient?.dispose();
+        this.workerClient = null;
+        this.workerIdentity = null;
+    }
+    async preloadLitRoutes(context) {
+        if (!context.routeRendererFactory) {
+            return;
+        }
+        const routes = await context.router.listStaticGenerationRoutes({ runtimeOrigin: context.baseUrl });
+        const components = [];
+        for (const route of routes) {
+            const filePath = route.templateRoute.filePath;
+            if (!this.isLitRoute(filePath, context.appConfig)) {
+                continue;
+            }
+            const pageRenderer = context.routeRendererFactory.getPageRenderer(filePath);
+            const pageModule = await pageRenderer.loadPageModule(filePath);
+            const page = pageModule.default;
+            if (page) {
+                components.push(page);
+                for (const layout of page.config?.layouts ?? []) {
+                    components.push(layout);
+                }
+                for (const nestedComponent of page.config?.dependencies?.components ?? []) {
+                    components.push(nestedComponent);
+                }
+            }
+        }
+        await this.preloadSsrScripts(components);
+    }
+    isLitRoute(filePath, appConfig) {
+        const litIntegration = appConfig.integrations.find((plugin) => plugin.name === LIT_PLUGIN_NAME);
+        if (!litIntegration) {
+            return false;
+        }
+        const normalizedPath = path.normalize(filePath);
+        return litIntegration.extensions.some((extension) => normalizedPath.endsWith(extension));
+    }
+}

package/src/lit-static-render-worker-client.d.ts

@@ -0,0 +1,26 @@
+import type { PageParams, PageQuery } from '@ecopages/core';
+import type { LitStaticRenderResult } from './lit-static-render-protocol.js';
+export declare class LitStaticRenderWorkerClient {
+    private readonly configModulePath;
+    private readonly runtimeOrigin;
+    private worker;
+    private workerExitPromise;
+    private workerExitCode;
+    private readyPromise;
+    private pending;
+    private nextRenderId;
+    private shutdownHandler;
+    constructor({ configModulePath, runtimeOrigin }: {
+        configModulePath: string;
+        runtimeOrigin: string;
+    });
+    private rejectPending;
+    start(): Promise<void>;
+    renderPage(input: {
+        filePath: string;
+        params: PageParams;
+        query?: PageQuery;
+    }): Promise<LitStaticRenderResult>;
+    dispose(): Promise<void>;
+}
+export declare const litStaticRenderWorkerEntryPath: string;