@ecopages/lit 0.2.0-beta.26 → 0.2.0-beta.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/lit",
-  "version": "0.2.0-beta.26",
+  "version": "0.2.0-beta.28",
   "description": "Ecopages lit integration",
   "keywords": [
     "ecopages",
@@ -39,7 +39,7 @@
     "directory": "packages/integrations/lit"
   },
   "peerDependencies": {
-    "@ecopages/core": "0.2.0-beta.26",
+    "@ecopages/core": "0.2.0-beta.28",
     "@lit-labs/ssr": "^3.3.0",
     "@lit-labs/ssr-client": "^1.1.7",
     "lit": "^3.2.1"

package/src/STATIC_RENDER.md

@@ -11,37 +11,59 @@ LitPlugin.setup()
   └─ LitStaticRenderSession.ensureWorker()
        └─ LitStaticRenderWorkerClient.start()
             └─ postMessage(init) ──► setupAppRuntimePlugins()
-                                     installAppRuntimeBuildExecutor()
+                                     installBuildRuntime()
                                      RouteRendererFactory
 
+LitPlugin.initializeRenderer()
+  └─ LitRenderer({ getRenderSession })   lazy accessor (not constructor snapshot)
+
 LitRenderer.execute() (main)
-  └─ session.renderPageInWorker()
-       └─ postMessage(render) ─────► RouteRendererFactory.execute()
-                                     (no active session in worker)
+  └─ ensureIntegrationRuntimeActivated()
+  └─ getRenderSession()
+       ├─ locals present ──────────► super.execute() (in-process)
+       └─ session.renderPageInWorker()
+            └─ postMessage(render) ─────► RouteRendererFactory.execute()
+                                          (no active session in worker)
 
 beforeStaticExport
+  └─ ensureWorker() only when `renderSession` is still null
   └─ preloadStaticRoutes()
        └─ preload SSR lazy scripts for Lit pages
 ```
 
 `ECOPAGES_LIT_STATIC_RENDER_WORKER=true` in the worker environment prevents nested worker creation during `LitPlugin.setup()` and skips processor `.setup()` inside `setupAppRuntimePlugins` (main thread already prepared artifacts).
 
+## Ownership
+
+| Concern                    | Owner                                                                                                                                                                  |
+| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Session + worker lifecycle | `LitPlugin` (`renderSession`)                                                                                                                                          |
+| Lazy session lookup        | `LitRenderer` via `getRenderSession`                                                                                                                                   |
+| Worker identity            | First `{ configModulePath, runtimeOrigin }` passed to `ensureWorker`; same identity is sticky; a later `ensureWorker` with a different identity disposes and recreates |
+
+Renderers created before plugin `setup()` still use the worker after setup assigns the session, because `execute` activates the integration runtime then reads the accessor.
+
+`beforeStaticExport` does not re-call `ensureWorker` when setup already created the session, so a different `context.baseUrl` at export time will not recreate an existing worker.
+
+## Locals policy
+
+When `RouteRendererOptions.locals` is present, `LitRenderer.execute` forces the in-process path (`super.execute`). Request locals are not sent through the worker protocol (structured-clone risk and request-scoped data). Static export and routes without locals continue through the worker.
+
 ## Files
 
 | File                                 | Role                                                            |
 | ------------------------------------ | --------------------------------------------------------------- |
-| `lit-static-render-session.ts`       | Build-scoped session: worker lifecycle + SSR preload            |
+| `lit-static-render-session.ts`       | Plugin-runtime-scoped session: worker lifecycle + SSR preload   |
 | `lit-static-render-worker-client.ts` | Message protocol client                                         |
 | `lit-static-render-worker.ts`        | Worker entry (exported as `@ecopages/lit/static-render-worker`) |
 | `lit-static-render-protocol.ts`      | Request/response message types                                  |
-| `lit-static-render-coordinator.ts`   | Active session pointer for `LitRenderer`                        |
 
 ## Protocol
 
-| Message            | Direction     | Purpose                                 |
-| ------------------ | ------------- | --------------------------------------- |
-| `init`             | main → worker | Load `eco.config.ts`, bootstrap runtime |
-| `ready`            | worker → main | Worker initialized                      |
-| `render`           | main → worker | Render one Lit page route to HTML       |
-| `result` / `error` | worker → main | Render outcome                          |
-| `shutdown`         | main → worker | Exit worker thread                      |
+| Message            | Direction     | Purpose                                                                       |
+| ------------------ | ------------- | ----------------------------------------------------------------------------- |
+| `init`             | main → worker | Load `eco.config.ts`, bootstrap runtime (`configModulePath`, `runtimeOrigin`) |
+| `ready`            | worker → main | Worker initialized                                                            |
+| `render`           | main → worker | Render one Lit page route (`filePath`, `PageParams`, optional `PageQuery`)    |
+| `result` / `error` | worker → main | HTML body plus optional `cacheStrategy`, or an error message                  |
+| `shutdown`         | main → worker | Exit worker thread                                                            |

package/src/lit-renderer.d.ts

@@ -4,18 +4,39 @@
  */
 import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoPagesElement, IntegrationRendererRenderOptions, RouteRenderResult, RouteRendererBody, RouteRendererOptions } from '@ecopages/core';
 import './dom-shim.js';
-import { IntegrationRenderer, type RenderToResponseContext } from '@ecopages/core/route-renderer/integration-renderer';
+import { IntegrationRenderer, type RenderToResponseContext } from '@ecopages/core/route-renderer/orchestration/integration-renderer';
+import type { LitStaticRenderSession } from './lit-static-render-session.js';
+export type LitRendererOptions = ConstructorParameters<typeof IntegrationRenderer>[0] & {
+    /**
+     * Lazy session lookup owned by {@link LitPlugin}.
+     *
+     * @remarks
+     * Must not snapshot the session at construction time. Plugin `setup()` may
+     * assign the session after the renderer is created; `execute` activates the
+     * integration runtime then reads this accessor so worker dispatch still works.
+     */
+    getRenderSession?: () => LitStaticRenderSession | undefined;
+};
 /**
  * A renderer for the Lit integration.
  */
 export declare class LitRenderer extends IntegrationRenderer<EcoPagesElement> {
     name: string;
+    private readonly getRenderSession?;
+    constructor(options: LitRendererOptions);
+    /**
+     * Renders a Lit page route, preferring the plugin worker when available.
+     *
+     * @remarks
+     * Activates the integration runtime before reading {@link getRenderSession}
+     * so a renderer constructed before plugin setup still sees the session.
+     * When `options.locals` is present, rendering stays in-process: request locals
+     * are not structured-cloned across the worker boundary.
+     */
     execute(options: RouteRendererOptions): Promise<RouteRenderResult>;
     private isFunctionComponent;
     private resolveQueuedForeignSubtreeChildren;
     private renderLitQueuedForeignSubtreeChildren;
-    protected shouldRenderPageComponent(): boolean;
-    private isLitManagedComponent;
     /**
      * Renders a Lit component for component-level orchestration.
      *

package/src/lit-renderer.js

@@ -1,6 +1,11 @@
 import "./dom-shim.js";
-import { IntegrationRenderer } from "@ecopages/core/route-renderer/integration-renderer";
-import { getActiveLitStaticRenderSession } from "./lit-static-render-coordinator.js";
+import {
+  IntegrationRenderer
+} from "@ecopages/core/route-renderer/orchestration/integration-renderer";
+import {
+  getForeignSubtreeResolutionContextKey,
+  resolveOwningIntegrationRenderer
+} from "@ecopages/core/route-renderer/orchestration/foreign-child/owning-renderer-resolution";
 import { LitSsrLazyPreloader } from "./lit-ssr-lazy-preloader.js";
 import { LIT_PLUGIN_NAME } from "./lit.constants.js";
 import {
@@ -11,15 +16,34 @@ import {
 } from "./utils/lit-html-rendering.js";
 class LitRenderer extends IntegrationRenderer {
   name = LIT_PLUGIN_NAME;
+  getRenderSession;
+  constructor(options) {
+    const { getRenderSession, ...rendererOptions } = options;
+    super(rendererOptions);
+    this.getRenderSession = getRenderSession;
+  }
+  /**
+   * Renders a Lit page route, preferring the plugin worker when available.
+   *
+   * @remarks
+   * Activates the integration runtime before reading {@link getRenderSession}
+   * so a renderer constructed before plugin setup still sees the session.
+   * When `options.locals` is present, rendering stays in-process: request locals
+   * are not structured-cloned across the worker boundary.
+   */
   async execute(options) {
-    const session = getActiveLitStaticRenderSession();
-    if (session) {
-      const html = await session.renderPageInWorker({
+    await this.ensureIntegrationRuntimeActivated();
+    const renderSession = this.getRenderSession?.();
+    if (renderSession && options.locals === void 0) {
+      const params = options.params ?? {};
+      const result = await renderSession.renderPageInWorker({
         filePath: options.file,
-        params: options.params ?? {}
+        params,
+        query: options.query
       });
       return {
-        body: html
+        body: result.html,
+        cacheStrategy: result.cacheStrategy
       };
     }
     return super.execute(options);
@@ -59,12 +83,6 @@ class LitRenderer extends IntegrationRenderer {
       html: renderedChildren
     };
   }
-  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.
    *
@@ -94,12 +112,26 @@ class LitRenderer extends IntegrationRenderer {
     const content = await component(props);
     const renderedHtml = await renderLitValueToString(content);
     const html = renderedChildren === void 0 ? renderedHtml : injectLitRenderedChildren(renderedHtml, renderedChildren);
-    const queuedForeignSubtreeResolution = await this.resolveQueuedForeignSubtreeHtml(
+    const queuedForeignSubtreeResolution = await this.foreignSubtreeExecutionService.resolveQueuedHtml({
+      currentIntegrationName: this.name,
       html,
-      this.getQueuedForeignSubtreeResolutionContext(input),
-      (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => this.renderLitQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken),
-      "Lit"
-    );
+      runtimeContext: this.foreignSubtreeExecutionService.getQueuedRuntimeContext(
+        input,
+        getForeignSubtreeResolutionContextKey(this.name)
+      ),
+      queueLabel: "Lit",
+      getOwningRenderer: (integrationName, rendererCache) => resolveOwningIntegrationRenderer({
+        appConfig: this.appConfig,
+        runtimeOrigin: this.runtimeOrigin,
+        currentIntegrationName: this.name,
+        currentRenderer: this,
+        integrationName,
+        cache: rendererCache
+      }),
+      applyAttributesToFirstElement: (resolvedHtml, attributes) => this.htmlTransformer.applyAttributesToFirstElement(resolvedHtml, attributes),
+      dedupeProcessedAssets: (assets2) => this.htmlTransformer.dedupeProcessedAssets(assets2),
+      renderQueuedChildren: (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => this.renderLitQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken)
+    });
     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;
@@ -141,9 +173,9 @@ class LitRenderer extends IntegrationRenderer {
    * Preloads SSR-eligible lazy scripts to register custom elements before render.
    */
   async preloadSsrLazyScripts(components) {
-    const session = getActiveLitStaticRenderSession();
-    if (session) {
-      await session.preloadSsrLazyScripts(components);
+    const renderSession = this.getRenderSession?.();
+    if (renderSession) {
+      await renderSession.preloadSsrLazyScripts(components);
       return;
     }
     await this.ssrLazyPreloader.preloadSsrLazyScripts(components);
@@ -194,45 +226,16 @@ class LitRenderer extends IntegrationRenderer {
   }
   async renderToResponse(view, props, ctx) {
     try {
-      if (ctx.partial) {
-        return this.renderPartialViewResponse({
-          view,
-          props,
-          ctx,
-          transformHtml: normalizeLitHtml
-        });
-      }
-      const viewConfig = view.config;
-      const layouts = viewConfig?.layouts;
+      const layouts = view.config?.layouts;
       const Layout = layouts?.[layouts.length - 1];
-      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 await this.renderViewWithDocumentShell({
+        view,
+        props,
+        ctx,
+        layout: Layout,
+        transformDocumentHtml: normalizeLitHtml
       });
-      return this.createHtmlResponse(body, ctx);
     } catch (error) {
       throw this.createRenderError("Error rendering view", error);
     }

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

@@ -1,3 +1,5 @@
+import type { PageParams, PageQuery, RouteRenderResult } from '@ecopages/core';
+export type LitStaticRenderCacheStrategy = RouteRenderResult['cacheStrategy'];
 export type LitStaticRenderWorkerInitMessage = {
     type: 'init';
     configModulePath: string;
@@ -7,7 +9,10 @@ export type LitStaticRenderWorkerRenderMessage = {
     type: 'render';
     id: string;
     filePath: string;
-    params: Record<string, 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';
@@ -20,6 +25,7 @@ export type LitStaticRenderWorkerResultMessage = {
     type: 'result';
     id: string;
     html: string;
+    cacheStrategy?: LitStaticRenderCacheStrategy;
 };
 export type LitStaticRenderWorkerErrorMessage = {
     type: 'error';

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

@@ -1,23 +1,45 @@
-import type { EcoComponent } from '@ecopages/core';
+import type { EcoComponent, PageParams, PageQuery } from '@ecopages/core';
 import type { StaticExportContext } from '@ecopages/core/plugins/integration-plugin';
 import type { AssetDefinition } from '@ecopages/core/services/asset-processing-service';
+import { LitStaticRenderWorkerClient } from './lit-static-render-worker-client.js';
+import type { LitStaticRenderCacheStrategy } from './lit-static-render-protocol.js';
+type LitStaticRenderWorkerClientContract = Pick<LitStaticRenderWorkerClient, 'start' | 'renderPage' | 'dispose'>;
 type LitStaticRenderSessionOptions = {
     resolveDependencyPath: (componentDir: string, sourcePath: string) => string;
     processDependencies?: (dependencies: AssetDefinition[], integrationName: string) => Promise<Array<{
         filepath?: string;
     }>>;
     preferSourceImports?: boolean;
+    createWorkerClient?: (input: {
+        configModulePath: string;
+        runtimeOrigin: string;
+    }) => LitStaticRenderWorkerClientContract;
 };
 /**
- * Build-scoped Lit server render session.
+ * 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.
  *
- * Preloads SSR-eligible lazy scripts and renders Lit page routes through a
- * dedicated worker thread for both static export and runtime/dev requests.
+ * 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;
     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;
@@ -27,8 +49,12 @@ export declare class LitStaticRenderSession {
     collectSsrPreloadScripts(components: Array<EcoComponent | undefined>): string[];
     renderPageInWorker(input: {
         filePath: string;
-        params: Record<string, string>;
-    }): Promise<string>;
+        params: PageParams;
+        query?: PageQuery;
+    }): Promise<{
+        html: string;
+        cacheStrategy?: LitStaticRenderCacheStrategy;
+    }>;
     isExpectedSsrPreloadError(error: unknown): boolean;
     dispose(): Promise<void>;
     private preloadLitRoutes;

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

@@ -4,19 +4,39 @@ import { LIT_PLUGIN_NAME } from "./lit.constants.js";
 import { LitStaticRenderWorkerClient } from "./lit-static-render-worker-client.js";
 class LitStaticRenderSession {
   preloader;
+  createWorkerClient;
   workerClient = null;
+  workerIdentity = null;
   constructor(options) {
     this.preloader = new LitSsrLazyPreloader({
       resolveDependencyPath: options.resolveDependencyPath,
       processDependencies: options.processDependencies,
       preferSourceImports: options.preferSourceImports
     });
+    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) {
+    if (this.workerClient && this.workerIdentity && this.workerIdentity.configModulePath === input.configModulePath && this.workerIdentity.runtimeOrigin === input.runtimeOrigin) {
       return;
     }
-    this.workerClient = new LitStaticRenderWorkerClient({
+    if (this.workerClient) {
+      await this.dispose();
+    }
+    this.workerIdentity = {
+      configModulePath: input.configModulePath,
+      runtimeOrigin: input.runtimeOrigin
+    };
+    this.workerClient = this.createWorkerClient({
       configModulePath: input.configModulePath,
       runtimeOrigin: input.runtimeOrigin
     });
@@ -43,6 +63,7 @@ class LitStaticRenderSession {
   async dispose() {
     await this.workerClient?.dispose();
     this.workerClient = null;
+    this.workerIdentity = null;
   }
   async preloadLitRoutes(context) {
     if (!context.routeRendererFactory) {

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

@@ -1,3 +1,5 @@
+import type { PageParams, PageQuery } from '@ecopages/core';
+import type { LitStaticRenderCacheStrategy } from './lit-static-render-protocol.js';
 export declare class LitStaticRenderWorkerClient {
     private readonly configModulePath;
     private readonly runtimeOrigin;
@@ -13,8 +15,12 @@ export declare class LitStaticRenderWorkerClient {
     start(): Promise<void>;
     renderPage(input: {
         filePath: string;
-        params: Record<string, string>;
-    }): Promise<string>;
+        params: PageParams;
+        query?: PageQuery;
+    }): Promise<{
+        html: string;
+        cacheStrategy?: LitStaticRenderCacheStrategy;
+    }>;
     dispose(): Promise<void>;
 }
 export declare const litStaticRenderWorkerEntryPath: string;

package/src/lit-static-render-worker-client.js

@@ -51,7 +51,7 @@ class LitStaticRenderWorkerClient {
             return;
           }
           this.pending.delete(message.id);
-          pending.resolve(message.html);
+          pending.resolve({ html: message.html, cacheStrategy: message.cacheStrategy });
         }
       });
       worker.on("error", (error) => {
@@ -88,7 +88,8 @@ class LitStaticRenderWorkerClient {
         type: "render",
         id,
         filePath: input.filePath,
-        params: input.params
+        params: input.params,
+        query: input.query
       };
       worker.postMessage(renderMessage);
     });

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

@@ -1,7 +1,7 @@
 import { parentPort } from "node:worker_threads";
 import { pathToFileURL } from "node:url";
 import { setupAppRuntimePlugins } from "@ecopages/core/build/build-adapter";
-import { installAppRuntimeBuildExecutor } from "@ecopages/core/build/runtime-build-executor";
+import { installBuildRuntime } from "@ecopages/core/build/build-runtime";
 import { RouteRendererFactory } from "@ecopages/core/route-renderer/route-renderer";
 import "./dom-shim.js";
 let appConfig = null;
@@ -16,29 +16,30 @@ async function initializeWorker(configModulePath, runtimeOrigin) {
     appConfig,
     runtimeOrigin
   });
-  installAppRuntimeBuildExecutor(appConfig);
+  installBuildRuntime(appConfig);
   routeRendererFactory = new RouteRendererFactory({
     appConfig,
     runtimeOrigin
   });
 }
-async function renderPage(filePath, params) {
+async function renderPage(filePath, params, query) {
   if (!routeRendererFactory) {
     throw new Error("Lit static render worker is not initialized");
   }
   const result = await routeRendererFactory.getPageRenderer(filePath).execute({
     file: filePath,
-    params
+    params,
+    query
   });
   const body = result.body;
   if (typeof body === "string") {
-    return body;
+    return { html: body, cacheStrategy: result.cacheStrategy };
   }
   if (Buffer.isBuffer(body)) {
-    return body.toString("utf8");
+    return { html: body.toString("utf8"), cacheStrategy: result.cacheStrategy };
   }
   if (body instanceof ReadableStream) {
-    return new Response(body).text();
+    return { html: await new Response(body).text(), cacheStrategy: result.cacheStrategy };
   }
   throw new TypeError(`Unsupported Lit static render body type: ${typeof body}`);
 }
@@ -60,8 +61,8 @@ parentPort.on("message", async (message) => {
       return;
     }
     if (message.type === "render") {
-      const html = await renderPage(message.filePath, message.params);
-      postMessage({ type: "result", id: message.id, html });
+      const result = await renderPage(message.filePath, message.params, message.query);
+      postMessage({ type: "result", id: message.id, ...result });
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);

package/src/lit.plugin.d.ts

@@ -13,6 +13,11 @@ export declare const PLUGIN_NAME = "lit";
 /**
  * The Lit plugin class
  * This plugin provides support for Lit components in Ecopages
+ *
+ * @remarks
+ * Owns the {@link LitStaticRenderSession} for worker SSR. Renderers receive a
+ * lazy `getRenderSession` accessor so construction before {@link setup} still
+ * observes the session once setup assigns it.
  */
 export declare class LitPlugin extends IntegrationPlugin {
     renderer: typeof LitRenderer;
@@ -20,6 +25,9 @@ export declare class LitPlugin extends IntegrationPlugin {
     constructor(options?: Omit<IntegrationPluginConfig, 'name'>);
     getDependencies(): AssetDefinition[];
     private createRenderSession;
+    initializeRenderer(options?: {
+        rendererModules?: unknown;
+    }): LitRenderer;
     setup(): Promise<void>;
     teardown(): Promise<void>;
     beforeStaticExport(context: StaticExportContext): Promise<void>;

package/src/lit.plugin.js

@@ -8,7 +8,6 @@ import { AssetFactory } from "@ecopages/core/services/asset-processing-service";
 import { litElementHydrateScript } from "./lit-element-hydrate.js";
 import { LIT_PLUGIN_NAME } from "./lit.constants.js";
 import { LitRenderer } from "./lit-renderer.js";
-import { setActiveLitStaticRenderSession } from "./lit-static-render-coordinator.js";
 import { LitStaticRenderSession } from "./lit-static-render-session.js";
 const PLUGIN_NAME = LIT_PLUGIN_NAME;
 class LitPlugin extends IntegrationPlugin {
@@ -56,6 +55,13 @@ class LitPlugin extends IntegrationPlugin {
       preferSourceImports: typeof Bun !== "undefined"
     });
   }
+  initializeRenderer(options) {
+    const renderer = new this.renderer({
+      ...this.createRendererOptions(options),
+      getRenderSession: () => this.renderSession ?? void 0
+    });
+    return this.attachRendererRuntimeServices(renderer);
+  }
   async setup() {
     await super.setup();
     if (!this.appConfig?.absolutePaths?.config) {
@@ -69,12 +75,10 @@ class LitPlugin extends IntegrationPlugin {
       configModulePath: this.appConfig.absolutePaths.config,
       runtimeOrigin: this.runtimeOrigin
     });
-    setActiveLitStaticRenderSession(this.renderSession);
   }
   async teardown() {
     await this.renderSession?.dispose();
     this.renderSession = null;
-    setActiveLitStaticRenderSession(null);
     await super.teardown();
   }
   async beforeStaticExport(context) {
@@ -84,7 +88,6 @@ class LitPlugin extends IntegrationPlugin {
         configModulePath: context.appConfig.absolutePaths.config,
         runtimeOrigin: context.baseUrl
       });
-      setActiveLitStaticRenderSession(this.renderSession);
     }
     await this.renderSession.preloadStaticRoutes(context);
   }

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

@@ -1,3 +0,0 @@
-import type { LitStaticRenderSession } from './lit-static-render-session.js';
-export declare function setActiveLitStaticRenderSession(session: LitStaticRenderSession | null): void;
-export declare function getActiveLitStaticRenderSession(): LitStaticRenderSession | null;

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

@@ -1,11 +0,0 @@
-let activeSession = null;
-function setActiveLitStaticRenderSession(session) {
-  activeSession = session;
-}
-function getActiveLitStaticRenderSession() {
-  return activeSession;
-}
-export {
-  getActiveLitStaticRenderSession,
-  setActiveLitStaticRenderSession
-};