@ecopages/lit 0.2.0-rc.7 → 0.2.0-rc.8

package/README.md

@@ -72,4 +72,4 @@ Important:
 
 A Lit Component can import a relative stylesheet with `import './counter.css'`; core extracts it into the shared asset pipeline. Direct local imports of that Component make its Dependencies available to the Lit SSR preloader, including through Foreign Child rendering.
 
-Keep custom-element registration explicit with `scripts: [{ src: './counter.script.ts', ssr: true, lazy: { 'on:visible': true } }]`. The module executes before server rendering and loads in the browser on visibility. `ssr: true` no longer emits an additional eager browser script. Omit `lazy` when eager browser loading is intended. SSR preload artifacts are excluded from HTML, and hydration support must be available before the browser registers the element.
+Keep custom-element registration explicit with `scripts: [{ src: './counter.script.ts', ssr: true, lazy: { 'on:visible': true } }]`. Entries with `ssr: true` execute on the server before rendering (eager or lazy) and load in the browser according to `lazy`. `ssr: true` does not emit an additional eager browser script. Omit `lazy` when eager browser loading is intended. SSR preload artifacts are excluded from HTML, and hydration support must be available before the browser registers the element. Lit-owned page routes preload those scripts in the static-render worker through the app module loader so `@lit-labs/ssr` sees the registered custom element.

package/package.json

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

package/src/STATIC_RENDER.md

@@ -24,6 +24,8 @@ LitRenderer.execute() (main)
        └─ session.renderPageInWorker()
             └─ postMessage(render) ─────► RouteRendererFactory.execute()
                                           (no active session in worker)
+                                          LitRenderer.ssrScriptPreloader uses
+                                          importServerModule (no entrypoint resolver)
 
 beforeStaticExport
   └─ ensureWorker() only when `renderSession` is still null

package/src/dom-shim.js

@@ -2,15 +2,49 @@ import { installWindowOnGlobal } from '@lit-labs/ssr/lib/dom-shim.js';
 import '@lit-labs/ssr/lib/install-global-dom-shim.js';
 /** Repairs the minimal Lit DOM surface after another Integration installs its SSR globals. */
 export function ensureLitDomShim() {
-    if (typeof globalThis.document?.createTreeWalker !== 'function') {
-        if (typeof globalThis.window === 'undefined') {
-            installWindowOnGlobal();
+    if (typeof globalThis.window === 'undefined') {
+        installWindowOnGlobal();
+    }
+    if (typeof globalThis.document !== 'undefined' && typeof globalThis.document.createTreeWalker !== 'function') {
+        Object.defineProperty(globalThis.document, 'createTreeWalker', {
+            configurable: true,
+            writable: true,
+            value: () => ({}),
+        });
+    }
+    for (const target of [globalThis.Element, globalThis.HTMLElement]) {
+        if (typeof target === 'undefined' || !target?.prototype) {
+            continue;
+        }
+        if (!('attributes' in target.prototype)) {
+            Object.defineProperty(target.prototype, 'attributes', {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    if (typeof this.getAttributeNames === 'function') {
+                        return this.getAttributeNames().map((name) => ({
+                            name,
+                            value: this.getAttribute(name),
+                        }));
+                    }
+                    return [];
+                },
+            });
         }
-        else {
-            Object.defineProperty(globalThis.document, 'createTreeWalker', {
+        if (typeof target.prototype.attachShadow !== 'function') {
+            Object.defineProperty(target.prototype, 'attachShadow', {
                 configurable: true,
                 writable: true,
-                value: () => ({}),
+                value: function attachShadow(init = { mode: 'open' }) {
+                    const shadowRoot = {
+                        mode: init?.mode ?? 'open',
+                        host: this,
+                        children: [],
+                        childNodes: [],
+                    };
+                    this.shadowRoot = shadowRoot;
+                    return shadowRoot;
+                },
             });
         }
     }

package/src/lit-renderer.d.ts

@@ -3,9 +3,8 @@
  * @module
  */
 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/orchestration/integration-renderer';
-import { type LitSsrPreloadComponent } from './lit-ssr-lazy-preloader.js';
+import { type CustomElementSsrPreloadComponent } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-script-preloader';
 import type { LitStaticRenderSession } from './lit-static-render-session.js';
 export type LitRendererOptions = ConstructorParameters<typeof IntegrationRenderer>[0] & {
     /**
@@ -24,6 +23,7 @@ export type LitRendererOptions = ConstructorParameters<typeof IntegrationRendere
 export declare class LitRenderer extends IntegrationRenderer<EcoPagesElement> {
     name: string;
     private readonly getRenderSession?;
+    private readonly ssrScriptPreloader;
     constructor(options: LitRendererOptions);
     /**
      * Renders a Lit page route, preferring the plugin worker when available.
@@ -41,14 +41,13 @@ export declare class LitRenderer extends IntegrationRenderer<EcoPagesElement> {
     /**
      * Renders a Lit component for component-level orchestration.
      *
-     * SSR-eligible lazy scripts are preloaded first so custom elements registered
+     * SSR-eligible 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.
      */
     renderComponent(input: ComponentRenderInput): Promise<ComponentRenderResult>;
-    private readonly ssrLazyPreloader;
     /**
      * Detects preload failures that are expected for browser-only modules.
      *
@@ -57,24 +56,24 @@ export declare class LitRenderer extends IntegrationRenderer<EcoPagesElement> {
      */
     protected isExpectedSsrPreloadError(error: unknown): boolean;
     /**
-     * Collects lazy script file paths eligible for SSR preloading.
+     * Collects script file paths eligible for SSR preloading.
      *
-     * Only per-entry lazy script dependencies with `ssr: true` are collected.
+     * Per-entry script dependencies with `ssr: true` are collected (eager or lazy).
      * File-backed entries are required (`src` must be present);
      * inline content lazy entries are intentionally skipped.
      */
-    protected collectSsrPreloadScripts(components: Array<LitSsrPreloadComponent | undefined>): string[];
+    protected collectSsrPreloadScripts(components: Array<CustomElementSsrPreloadComponent | undefined>): string[];
     /**
-     * Preloads SSR-eligible lazy scripts to register custom elements before render.
-     */
-    protected preloadSsrLazyScripts(components: Array<LitSsrPreloadComponent | undefined>): Promise<void>;
-    /**
-     * Resolves the concrete JS entrypoint used for SSR preloading.
+     * Preloads SSR-eligible scripts to register custom elements before render.
      *
-     * Scripts are passed through the asset pipeline so preload imports can use
-     * the same processed output shape as runtime dependencies.
+     * @remarks
+     * When a render session exists (main thread), preload uses the session so
+     * Bun source imports and the Node asset pipeline stay on that isolate.
+     * With no session (static-render worker), preload uses this renderer's
+     * app-module importer. A native source import in the worker leaves custom
+     * elements undefined for `@lit-labs/ssr`.
      */
-    protected resolveSsrPreloadEntrypoint(scriptPath: string): Promise<string | null>;
+    protected preloadSsrScripts(components: Array<CustomElementSsrPreloadComponent | undefined>): Promise<void>;
     render({ params, query, props, locals, metadata, Page, Layout, layoutEntries, HtmlTemplate, resolvedPageDependencyComponents, }: IntegrationRendererRenderOptions): Promise<RouteRendererBody>;
     renderToResponse<P = Record<string, unknown>>(view: EcoComponent<P>, props: P, ctx: RenderToResponseContext): Promise<Response>;
 }

package/src/lit-renderer.js

@@ -1,9 +1,13 @@
-import { createLitServerModuleImporter } from './lit-server-module-loader.js';
-import './dom-shim.js';
+/**
+ * This module contains the Lit renderer
+ * @module
+ */
 import { IntegrationRenderer, } from '@ecopages/core/route-renderer/orchestration/integration-renderer';
 import { resolveDocumentShellLayouts } from '@ecopages/core/route-renderer/orchestration/document-shell/layout-shell-props.service';
 import { getForeignSubtreeResolutionContextKey, resolveOwningIntegrationRenderer, } from '@ecopages/core/route-renderer/orchestration/foreign-child/owning-renderer-resolution';
-import { LitSsrLazyPreloader } from './lit-ssr-lazy-preloader.js';
+import { ensureLitDomShim } from './dom-shim.js';
+import { CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES, CustomElementScriptPreloader, } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-script-preloader';
+import { createCustomElementServerModuleImporter } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-server-module-importer';
 import { LIT_PLUGIN_NAME } from './lit.constants.js';
 import { injectLitRenderedChildren, LIT_COMPONENT_CHILDREN_SLOT_MARKER, normalizeLitHtml, renderLitValueToString, } from './utils/lit-html-rendering.js';
 /**
@@ -12,10 +16,18 @@ import { injectLitRenderedChildren, LIT_COMPONENT_CHILDREN_SLOT_MARKER, normaliz
 export class LitRenderer extends IntegrationRenderer {
     name = LIT_PLUGIN_NAME;
     getRenderSession;
+    ssrScriptPreloader;
     constructor(options) {
         const { getRenderSession, ...rendererOptions } = options;
         super(rendererOptions);
         this.getRenderSession = getRenderSession;
+        this.ssrScriptPreloader = new CustomElementScriptPreloader({
+            cacheScope: CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.lit,
+            logLabel: 'lit',
+            requireLazyScriptEntry: true,
+            resolveDependencyPath: this.resolveDependencyPath.bind(this),
+            importServerModule: createCustomElementServerModuleImporter(this.appConfig, '.lit-ssr'),
+        });
     }
     /**
      * Renders a Lit page route, preferring the plugin worker when available.
@@ -73,14 +85,14 @@ export class LitRenderer extends IntegrationRenderer {
     /**
      * Renders a Lit component for component-level orchestration.
      *
-     * SSR-eligible lazy scripts are preloaded first so custom elements registered
+     * SSR-eligible 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]);
+        await this.preloadSsrScripts([input.component]);
         if (!this.isFunctionComponent(input.component)) {
             throw new TypeError('Lit renderer expected a callable component.');
         }
@@ -133,11 +145,6 @@ export class LitRenderer extends IntegrationRenderer {
             ]),
         });
     }
-    ssrLazyPreloader = new LitSsrLazyPreloader({
-        importServerModule: createLitServerModuleImporter(this.appConfig),
-        resolveDependencyPath: this.resolveDependencyPath.bind(this),
-        processDependencies: this.assetProcessingService?.processDependencies?.bind(this.assetProcessingService),
-    });
     /**
      * Detects preload failures that are expected for browser-only modules.
      *
@@ -145,41 +152,40 @@ export class LitRenderer extends IntegrationRenderer {
      * lazy client scripts intentionally depend on browser globals.
      */
     isExpectedSsrPreloadError(error) {
-        return this.ssrLazyPreloader.isExpectedSsrPreloadError(error);
+        return this.ssrScriptPreloader.isExpectedSsrPreloadError(error);
     }
     /**
-     * Collects lazy script file paths eligible for SSR preloading.
+     * Collects script file paths eligible for SSR preloading.
      *
-     * Only per-entry lazy script dependencies with `ssr: true` are collected.
+     * Per-entry script dependencies with `ssr: true` are collected (eager or lazy).
      * File-backed entries are required (`src` must be present);
      * inline content lazy entries are intentionally skipped.
      */
     collectSsrPreloadScripts(components) {
-        return this.ssrLazyPreloader.collectSsrPreloadScripts(components);
+        return this.ssrScriptPreloader.collectSsrPreloadScripts(components);
     }
     /**
-     * Preloads SSR-eligible lazy scripts to register custom elements before render.
+     * Preloads SSR-eligible scripts to register custom elements before render.
+     *
+     * @remarks
+     * When a render session exists (main thread), preload uses the session so
+     * Bun source imports and the Node asset pipeline stay on that isolate.
+     * With no session (static-render worker), preload uses this renderer's
+     * app-module importer. A native source import in the worker leaves custom
+     * elements undefined for `@lit-labs/ssr`.
      */
-    async preloadSsrLazyScripts(components) {
+    async preloadSsrScripts(components) {
+        ensureLitDomShim();
         const renderSession = this.getRenderSession?.();
         if (renderSession) {
-            await renderSession.preloadSsrLazyScripts(components);
+            await renderSession.preloadSsrScripts(components);
             return;
         }
-        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);
+        await this.ssrScriptPreloader.preloadSsrScripts(components);
     }
     async render({ params, query, props, locals, metadata, Page, Layout, layoutEntries, HtmlTemplate, resolvedPageDependencyComponents, }) {
         try {
-            await this.preloadSsrLazyScripts([Page, Layout, ...(resolvedPageDependencyComponents ?? [])]);
+            await this.preloadSsrScripts([Page, Layout, ...(resolvedPageDependencyComponents ?? [])]);
             return await this.renderPageWithDocumentShell({
                 page: {
                     component: Page,
@@ -212,7 +218,7 @@ export class LitRenderer extends IntegrationRenderer {
         try {
             const layouts = view.config?.layouts;
             const Layout = layouts?.[layouts.length - 1];
-            await this.preloadSsrLazyScripts([view, Layout]);
+            await this.preloadSsrScripts([view, Layout]);
             return await this.renderViewWithDocumentShell({
                 view,
                 props,

package/src/lit-ssr-preload-entrypoint.d.ts

@@ -0,0 +1 @@
+export { createCustomElementSsrPreloadEntrypointResolver as createLitSsrPreloadEntrypointResolver, type CustomElementSsrPreloadEntrypointResolverOptions as LitSsrPreloadEntrypointResolverOptions, } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-ssr-preload-entrypoint';

package/src/lit-ssr-preload-entrypoint.js

@@ -0,0 +1 @@
+export { createCustomElementSsrPreloadEntrypointResolver as createLitSsrPreloadEntrypointResolver, } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-ssr-preload-entrypoint';

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

@@ -1,17 +1,15 @@
 import type { 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 { type LitSsrLazyPreloaderOptions, type LitSsrPreloadComponent } from './lit-ssr-lazy-preloader.js';
+import { type CustomElementScriptPreloaderOptions, type CustomElementSsrPreloadComponent } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-script-preloader';
 import { LitStaticRenderWorkerClient } from './lit-static-render-worker-client.js';
 import type { LitStaticRenderCacheStrategy } from './lit-static-render-protocol.js';
+import type { AssetDefinition, ProcessedAsset } from '@ecopages/core/services/asset-processing-service';
 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;
-    importServerModule?: LitSsrLazyPreloaderOptions['importServerModule'];
+    processDependencies?: (dependencies: AssetDefinition[], integrationName: string) => Promise<ProcessedAsset[]>;
+    importServerModule?: CustomElementScriptPreloaderOptions['importServerModule'];
     getInvalidationVersion?: () => number;
     createWorkerClient?: (input: {
         configModulePath: string;
@@ -51,8 +49,8 @@ export declare class LitStaticRenderSession {
         runtimeOrigin: string;
     }): Promise<void>;
     preloadStaticRoutes(context: StaticExportContext): Promise<void>;
-    preloadSsrLazyScripts(components: Array<LitSsrPreloadComponent | undefined>): Promise<void>;
-    collectSsrPreloadScripts(components: Array<LitSsrPreloadComponent | undefined>): string[];
+    preloadSsrScripts(components: Array<CustomElementSsrPreloadComponent | undefined>): Promise<void>;
+    collectSsrPreloadScripts(components: Array<CustomElementSsrPreloadComponent | undefined>): string[];
     renderPageInWorker(input: {
         filePath: string;
         params: PageParams;

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

@@ -1,6 +1,8 @@
 import path from 'node:path';
-import { LitSsrLazyPreloader, } from './lit-ssr-lazy-preloader.js';
+import { ensureLitDomShim } from './dom-shim.js';
+import { CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES, CustomElementScriptPreloader, } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-script-preloader';
 import { LIT_PLUGIN_NAME } from './lit.constants.js';
+import { createLitSsrPreloadEntrypointResolver } from './lit-ssr-preload-entrypoint.js';
 import { LitStaticRenderWorkerClient } from './lit-static-render-worker-client.js';
 /**
  * Plugin-runtime-scoped Lit server render session.
@@ -24,10 +26,17 @@ export class LitStaticRenderSession {
     renderChain = Promise.resolve();
     constructor(options) {
         this.getInvalidationVersion = options.getInvalidationVersion ?? (() => 0);
-        this.preloader = new LitSsrLazyPreloader({
+        const preferSourceImports = options.preferSourceImports ?? typeof Bun !== 'undefined';
+        this.preloader = new CustomElementScriptPreloader({
+            cacheScope: CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.lit,
+            logLabel: 'lit',
+            requireLazyScriptEntry: true,
             resolveDependencyPath: options.resolveDependencyPath,
-            processDependencies: options.processDependencies,
-            preferSourceImports: options.preferSourceImports,
+            preferSourceImports,
+            resolvePreloadEntrypoint: createLitSsrPreloadEntrypointResolver({
+                preferSourceImports,
+                processDependencies: options.processDependencies,
+            }),
             importServerModule: options.importServerModule,
         });
         this.createWorkerClient =
@@ -68,8 +77,9 @@ export class LitStaticRenderSession {
     async preloadStaticRoutes(context) {
         await this.preloadLitRoutes(context);
     }
-    async preloadSsrLazyScripts(components) {
-        await this.preloader.preloadSsrLazyScripts(components);
+    async preloadSsrScripts(components) {
+        ensureLitDomShim();
+        await this.preloader.preloadSsrScripts(components);
     }
     collectSsrPreloadScripts(components) {
         return this.preloader.collectSsrPreloadScripts(components);
@@ -124,7 +134,7 @@ export class LitStaticRenderSession {
                 }
             }
         }
-        await this.preloadSsrLazyScripts(components);
+        await this.preloadSsrScripts(components);
     }
     isLitRoute(filePath, appConfig) {
         const litIntegration = appConfig.integrations.find((plugin) => plugin.name === LIT_PLUGIN_NAME);

package/src/lit.plugin.d.ts

@@ -1,3 +1,4 @@
+import type { IHmrManager } from '@ecopages/core';
 /**
  * This module contains the Lit plugin
  * @module
@@ -38,6 +39,7 @@ export declare class LitPlugin extends IntegrationPlugin {
     initializeRenderer(options?: {
         rendererModules?: unknown;
     }): LitRenderer;
+    setHmrManager(hmrManager: IHmrManager): void;
     setup(): Promise<void>;
     teardown(): Promise<void>;
     beforeStaticExport(context: StaticExportContext): Promise<void>;

package/src/lit.plugin.js

@@ -1,4 +1,5 @@
-import { createLitServerModuleImporter } from './lit-server-module-loader.js';
+import { createCustomElementServerModuleImporter } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-server-module-importer';
+import { CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES, invalidateCustomElementScriptPreload, } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-script-preloader';
 /**
  * This module contains the Lit plugin
  * @module
@@ -66,7 +67,7 @@ export class LitPlugin extends IntegrationPlugin {
             resolveDependencyPath: (componentDir, sourcePath) => path.join(componentDir, sourcePath),
             processDependencies: this.assetProcessingService.processDependencies.bind(this.assetProcessingService),
             getInvalidationVersion: () => this.appConfig?.runtime?.serverInvalidationState?.getServerInvalidationVersion() ?? 0,
-            importServerModule: createLitServerModuleImporter(this.appConfig),
+            importServerModule: createCustomElementServerModuleImporter(this.appConfig, '.lit-ssr'),
             preferSourceImports: typeof Bun !== 'undefined',
         });
     }
@@ -77,6 +78,18 @@ export class LitPlugin extends IntegrationPlugin {
         });
         return this.attachRendererRuntimeServices(renderer);
     }
+    setHmrManager(hmrManager) {
+        super.setHmrManager(hmrManager);
+        if (!this.appConfig) {
+            return;
+        }
+        const runtime = this.appConfig.runtime ?? {};
+        this.appConfig.runtime = runtime;
+        runtime.registeredScriptEntrypointChangeHandlers ??= [];
+        runtime.registeredScriptEntrypointChangeHandlers.push((scriptPath) => {
+            invalidateCustomElementScriptPreload(scriptPath, CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.lit);
+        });
+    }
     async setup() {
         await super.setup();
         if (!this.appConfig?.absolutePaths?.config) {

package/src/lit-server-module-loader.d.ts

@@ -1,6 +0,0 @@
-import type { EcoPagesAppConfig } from '@ecopages/core';
-/**
- * Uses server export conditions and isolates module evaluation by custom-element
- * registry. Browser asset output must never be evaluated as the SSR implementation.
- */
-export declare function createLitServerModuleImporter(appConfig: EcoPagesAppConfig): (filePath: string, registryKey: string) => Promise<unknown>;

package/src/lit-server-module-loader.js

@@ -1,18 +0,0 @@
-import path from 'node:path';
-/**
- * Uses server export conditions and isolates module evaluation by custom-element
- * registry. Browser asset output must never be evaluated as the SSR implementation.
- */
-export function createLitServerModuleImporter(appConfig) {
-    return async (filePath, registryKey) => {
-        const loader = appConfig.runtime?.appModuleLoader;
-        if (!loader)
-            throw new Error('Lit SSR requires the app server module loader');
-        return loader.importModule({
-            filePath,
-            rootDir: appConfig.rootDir,
-            outdir: path.join(appConfig.absolutePaths.workDir, '.lit-ssr', registryKey),
-            forceBuild: true,
-        });
-    };
-}

package/src/lit-ssr-lazy-preloader.d.ts

@@ -1,48 +0,0 @@
-import { type EcoComponent } from '@ecopages/core';
-import type { AssetDefinition } from '@ecopages/core/services/asset-processing-service';
-export type LitSsrPreloadComponent = EcoComponent | Partial<EcoComponent>;
-type ProcessDependencies = (dependencies: AssetDefinition[], integrationName: string) => Promise<Array<{
-    filepath?: string;
-}>>;
-export interface LitSsrLazyPreloaderOptions {
-    resolveDependencyPath: (componentDir: string, sourcePath: string) => string;
-    processDependencies?: ProcessDependencies;
-    preferSourceImports?: boolean;
-    importServerModule?: (scriptPath: string, registryKey: string) => Promise<unknown>;
-}
-/**
- * Encapsulates SSR lazy script preload behavior for Lit components.
- *
- * Collects `dependencies.scripts` lazy entries with `ssr: true`, resolves the
- * processed entrypoint through the asset pipeline, and imports the module so
- * custom elements are registered before SSR rendering.
- */
-export declare class LitSsrLazyPreloader {
-    private readonly resolveDependencyPath;
-    private readonly processDependencies?;
-    private readonly preferSourceImports;
-    private readonly importServerModule?;
-    private activeRegistry;
-    private readonly ssrPreloadedScripts;
-    private readonly ssrPreloadFailedScripts;
-    private readonly ssrPreloadEntrypointCache;
-    constructor({ resolveDependencyPath, processDependencies, preferSourceImports, importServerModule, }: LitSsrLazyPreloaderOptions);
-    private getErrorCode;
-    /**
-     * Detects preload failures that are expected for browser-only modules.
-     */
-    isExpectedSsrPreloadError(error: unknown): boolean;
-    /**
-     * Collects lazy script file paths eligible for SSR preloading.
-     */
-    collectSsrPreloadScripts(components: Array<LitSsrPreloadComponent | undefined>): string[];
-    /**
-     * Preloads SSR-eligible lazy scripts to register custom elements before render.
-     */
-    preloadSsrLazyScripts(components: Array<LitSsrPreloadComponent | undefined>): Promise<void>;
-    /**
-     * Resolves the concrete JS entrypoint used for SSR preloading.
-     */
-    resolveSsrPreloadEntrypoint(scriptPath: string): Promise<string | null>;
-}
-export {};

package/src/lit-ssr-lazy-preloader.js

@@ -1,198 +0,0 @@
-import { ensureLitDomShim } from './dom-shim.js';
-import { getComponentIdentity } from '@ecopages/core';
-import { AssetFactory } from '@ecopages/core/services/asset-processing-service';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { randomUUID } from 'node:crypto';
-const registryKeys = new WeakMap();
-function getRegistryKey(registry) {
-    let key = registryKeys.get(registry);
-    if (!key) {
-        key = randomUUID();
-        registryKeys.set(registry, key);
-    }
-    return key;
-}
-/**
- * Encapsulates SSR lazy script preload behavior for Lit components.
- *
- * Collects `dependencies.scripts` lazy entries with `ssr: true`, resolves the
- * processed entrypoint through the asset pipeline, and imports the module so
- * custom elements are registered before SSR rendering.
- */
-export class LitSsrLazyPreloader {
-    resolveDependencyPath;
-    processDependencies;
-    preferSourceImports;
-    importServerModule;
-    activeRegistry;
-    ssrPreloadedScripts = new Set();
-    ssrPreloadFailedScripts = new Set();
-    ssrPreloadEntrypointCache = new Map();
-    constructor({ resolveDependencyPath, processDependencies, preferSourceImports, importServerModule, }) {
-        this.importServerModule = importServerModule;
-        this.resolveDependencyPath = resolveDependencyPath;
-        this.processDependencies = processDependencies;
-        this.preferSourceImports = preferSourceImports ?? typeof Bun !== 'undefined';
-    }
-    getErrorCode(error) {
-        if (typeof error !== 'object' || error === null) {
-            return '';
-        }
-        const code = Reflect.get(error, 'code');
-        return code === undefined ? '' : String(code);
-    }
-    /**
-     * Detects preload failures that are expected for browser-only modules.
-     */
-    isExpectedSsrPreloadError(error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorCode = this.getErrorCode(error);
-        if (errorCode === 'ERR_UNKNOWN_FILE_EXTENSION') {
-            return true;
-        }
-        return (errorMessage.includes(`reading 'Element'`) ||
-            errorMessage.includes('window is not defined') ||
-            errorMessage.includes('document is not defined') ||
-            errorMessage.includes('navigator is not defined'));
-    }
-    /**
-     * Collects lazy script file paths eligible for SSR preloading.
-     */
-    collectSsrPreloadScripts(components) {
-        const scriptPaths = new Set();
-        const visitedConfigs = new Set();
-        const collect = (component) => {
-            const config = component?.config;
-            if (!config || visitedConfigs.has(config)) {
-                return;
-            }
-            visitedConfigs.add(config);
-            const scriptEntries = config.dependencies?.scripts ?? [];
-            const componentFile = getComponentIdentity(component?.config)?.file;
-            if (componentFile) {
-                const componentDir = path.dirname(componentFile);
-                for (const script of scriptEntries) {
-                    if (typeof script === 'string') {
-                        continue;
-                    }
-                    if (!script.lazy || script.ssr !== true) {
-                        continue;
-                    }
-                    if (!script.src) {
-                        continue;
-                    }
-                    scriptPaths.add(this.resolveDependencyPath(componentDir, script.src));
-                }
-            }
-            for (const layout of config.layouts ?? []) {
-                collect(layout);
-            }
-            for (const nestedComponent of config.dependencies?.components || []) {
-                collect(nestedComponent);
-            }
-        };
-        for (const component of components) {
-            collect(component);
-        }
-        return Array.from(scriptPaths);
-    }
-    /**
-     * Preloads SSR-eligible lazy scripts to register custom elements before render.
-     */
-    async preloadSsrLazyScripts(components) {
-        ensureLitDomShim();
-        const registry = globalThis.customElements;
-        if (this.activeRegistry !== registry) {
-            this.ssrPreloadedScripts.clear();
-            this.ssrPreloadFailedScripts.clear();
-            this.activeRegistry = registry;
-        }
-        const scripts = this.collectSsrPreloadScripts(components);
-        if (scripts.length === 0) {
-            return;
-        }
-        await Promise.all(scripts
-            .filter((scriptPath) => {
-            if (this.ssrPreloadedScripts.has(scriptPath)) {
-                return false;
-            }
-            if (this.ssrPreloadFailedScripts.has(scriptPath)) {
-                return false;
-            }
-            return true;
-        })
-            .map(async (scriptPath) => {
-            try {
-                const registryKey = registry ? getRegistryKey(registry) : 'default';
-                if (this.importServerModule) {
-                    await this.importServerModule(scriptPath, registryKey);
-                }
-                else {
-                    const preloadEntrypoint = await this.resolveSsrPreloadEntrypoint(scriptPath);
-                    if (!preloadEntrypoint)
-                        throw new Error(`Cannot resolve SSR entry ${scriptPath}`);
-                    const importUrl = pathToFileURL(preloadEntrypoint);
-                    if (registry && typeof Bun === 'undefined')
-                        importUrl.searchParams.set('eco-ssr-registry', registryKey);
-                    await import(/* @vite-ignore */ importUrl.href);
-                }
-                this.ssrPreloadedScripts.add(scriptPath);
-            }
-            catch (error) {
-                this.ssrPreloadFailedScripts.add(scriptPath);
-                if (this.isExpectedSsrPreloadError(error)) {
-                    if (process.env.ECOPAGES_DEBUG === 'true') {
-                        console.warn(`[ecopages][lit] Skipping SSR preload for browser-only lazy script: ${scriptPath}`);
-                    }
-                    return;
-                }
-                console.warn(`[ecopages][lit] Failed to preload lazy SSR script: ${scriptPath}`, error);
-            }
-        }));
-    }
-    /**
-     * Resolves the concrete JS entrypoint used for SSR preloading.
-     */
-    async resolveSsrPreloadEntrypoint(scriptPath) {
-        const cachedEntrypoint = this.ssrPreloadEntrypointCache.get(scriptPath);
-        if (cachedEntrypoint) {
-            return cachedEntrypoint;
-        }
-        if (this.preferSourceImports) {
-            this.ssrPreloadEntrypointCache.set(scriptPath, scriptPath);
-            return scriptPath;
-        }
-        if (!this.processDependencies) {
-            this.ssrPreloadEntrypointCache.set(scriptPath, scriptPath);
-            return scriptPath;
-        }
-        try {
-            const processed = await this.processDependencies([
-                AssetFactory.createInlineFileScript({
-                    filepath: scriptPath,
-                    excludeFromHtml: true,
-                    position: 'head',
-                    bundle: true,
-                    attributes: {
-                        type: 'module',
-                        defer: '',
-                    },
-                }),
-            ], `lit-ssr-preload:${scriptPath}`);
-            const entrypoint = processed[0]?.filepath;
-            if (!entrypoint) {
-                return scriptPath;
-            }
-            this.ssrPreloadEntrypointCache.set(scriptPath, entrypoint);
-            return entrypoint;
-        }
-        catch (error) {
-            if (process.env.ECOPAGES_DEBUG === 'true') {
-                console.warn(`[ecopages][lit] Failed to resolve SSR preload entrypoint for: ${scriptPath}`, error);
-            }
-            this.ssrPreloadEntrypointCache.set(scriptPath, scriptPath);
-            return scriptPath;
-        }
-    }
-}