evolit 0.3.0 → 0.4.1

package/README.md

@@ -321,6 +321,68 @@ server components and helpers that do not receive route props directly. It retur
 Reading `getRouteState().url` has the same dynamic-rendering semantics as `requestUrl()`; reading
 `params` and `searchParams` participates in the normal segment-cache key tracking.
 
+## LitSX compiler integrations
+
+`evolit.config.js` can configure the native LitSX compiler and register build-tool-neutral LitSX
+integrations. The same declaration is used by development, SSR, hydration, production builds and
+the standalone runtime:
+
+```js
+import { litsxUnoCss } from "@litsx/unocss";
+import { defineEvolitConfig } from "evolit/litsx";
+
+export default defineEvolitConfig({
+  litsx: {
+    compiler: {
+      sourceMaps: true,
+    },
+    integrations: [litsxUnoCss()],
+  },
+});
+```
+
+This is the complete Evolit + UnoCSS setup. The application does not coordinate compiler plugins,
+virtual modules, generation, finalization or global CSS links, and it does not need Vite or
+PostCSS. `@litsx/unocss` remains the owner of candidate extraction and CSS generation; Evolit only
+executes its neutral LitSX lifecycle.
+
+`compiler` accepts the public `TransformLitsxOptions` surface except the values Evolit must own for
+correct server and browser graphs. Evolit always supplies the current `filename`, selects `ssr` per
+target and forces native lowering with `reactCompat: false`; `compiler.sourceMaps` can override the
+existing per-pipeline default without changing applications that omit `litsx`.
+Authoring and output plugins contributed by the application and integrations are composed in
+declaration order rather than replacing framework invariants.
+
+An integration is a descriptor with a unique `name` and `create(context)` method. Each call to
+`create` belongs to exactly one development server, build or standalone runtime, so mutable caches
+must live on the returned instance, never on the descriptor. An instance can contribute:
+
+- `compiler`: native compiler options, including authoring and output plugins.
+- `resolveModule`: sources for integration-owned virtual modules in both server and browser graphs.
+- `processModule`: post-processing, observable dependencies and preliminary outputs for a compiled
+  module.
+- `finalize`: graph-wide assets, styles or modules after every reachable module is known.
+- `invalidate` and `forget`: configuration/dependency refresh and removal of stale module state.
+- `dispose`: idempotent cleanup when the owning server, build or runtime closes.
+
+Declared outputs use stable IDs unique within the pipeline and one of `asset`, `module` or `style`. A module
+may expose a safe `virtual:` specifier; a style with `document: true` is content-hashed, included in
+the client asset manifest and linked once in the document. Evolit publishes a generation only after
+every integration finalizes successfully, so a failed generation cannot expose a partial mix of
+old and new assets.
+
+In development, dependencies reported by compiler plugins and lifecycle hooks are watched together
+with application modules. Invalidating a dependency advances the integration generation, evicts
+affected compiled modules and calls `forget` for modules that leave the graph. Configuration reload
+therefore removes obsolete results instead of accumulating them. Hook failures identify the
+integration, lifecycle phase and relevant module in development; production errors keep the same
+context while redacting project-local absolute paths.
+
+For native Shadow DOM, `@litsx/unocss` serializes component preflight inside each Declarative Shadow
+Root, preserves authored `Component.styles` before generated utilities, and emits the document
+theme/custom-property layers once. Those document variables inherit through Shadow Roots and the
+browser hydrates the server result without switching to `react-compat`.
+
 ## Server Setup
 
 Server integrations that need one-time application setup can be registered with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolit",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A convention-driven application framework for LitSX and web components.",
   "type": "module",
   "packageManager": "yarn@4.10.3",
@@ -34,6 +34,10 @@
       "browser": "./src/extensions-client.js",
       "default": "./src/extensions.js"
     },
+    "./litsx": {
+      "types": "./src/litsx-pipeline.d.ts",
+      "default": "./src/litsx-pipeline.js"
+    },
     "./internal/development-hot": "./src/development-hot-client.js"
   },
   "scripts": {
@@ -79,8 +83,10 @@
     }
   },
   "devDependencies": {
+    "@litsx/unocss": "1.0.0-next.8",
     "@playwright/test": "^1.62.0",
     "@webcomponents/scoped-custom-element-registry": "^0.0.10",
+    "unocss": "66.8.1",
     "vite": "^8.1.5"
   }
 }

package/src/build.js

@@ -58,6 +58,7 @@ import {
   runWithOptionalSsrUrqlScope,
 } from "./urql-ssr.js";
 import { runServerSetup } from "./server-setup.js";
+import { createLitsxPipeline, mergeLitsxAssetsIntoManifest } from "./litsx-pipeline.js";
 
 const CONTENT_TYPE_BY_EXTENSION = new Map([
   [".css", "text/css; charset=utf-8"],
@@ -163,11 +164,20 @@ async function writeDeploymentRuntimeEntry(buildRoot) {
 
 export async function buildProject(projectRoot, options = {}) {
   const evolitConfig = await loadEvolitConfig(projectRoot);
-  const serverSetupCleanup = await runServerSetup({
+  const litsxPipeline = await createLitsxPipeline({
     projectRoot,
     mode: "production",
-    evolitConfig,
+    config: evolitConfig,
   });
+  let serverSetupCleanup = null;
+  let buildError = null;
+  try {
+    serverSetupCleanup = await runServerSetup({
+      projectRoot,
+      mode: "production",
+      evolitConfig,
+      litsxPipeline,
+    });
   const extensions = resolveEvolitExtensions(evolitConfig);
   const extensionClientDescriptors = getExtensionClientDescriptors(extensions);
   const packageClientSpecifiers = new Set(
@@ -194,6 +204,7 @@ export async function buildProject(projectRoot, options = {}) {
       sourceMaps: false,
       ssr: true,
       target: "server",
+      litsxPipeline,
     });
     result.packageImports.forEach((specifier) => ssrPackageImports.add(specifier));
     return result;
@@ -202,7 +213,7 @@ export async function buildProject(projectRoot, options = {}) {
   function getEntryInventory(entryPath) {
     let inventory = inventoriesBySourceEntry.get(entryPath);
     if (!inventory) {
-      inventory = collectClientGraphInventory([entryPath], { projectRoot });
+      inventory = collectClientGraphInventory([entryPath], { projectRoot, litsxPipeline });
       inventoriesBySourceEntry.set(entryPath, inventory);
     }
     return inventory;
@@ -216,6 +227,7 @@ export async function buildProject(projectRoot, options = {}) {
       mode: "production",
       sourceMaps: true,
       target: "client",
+      litsxPipeline,
     });
     clientModule = path.relative(clientBuild.outputRoot, clientBuild.entrypoint)
       .split(path.sep)
@@ -235,6 +247,7 @@ export async function buildProject(projectRoot, options = {}) {
       mode: "production",
       ssr: true,
       target: "server",
+      litsxPipeline,
     });
     const methods = Object.keys(handlerModule)
       .filter((name) => /^[A-Z]+$/.test(name) && typeof handlerModule[name] === "function")
@@ -345,18 +358,20 @@ export async function buildProject(projectRoot, options = {}) {
   }
 
   sharedVendorOptions.additionalEntrySpecifiers = [...packageClientSpecifiers].sort();
-  const clientAssets = await emitBundledClientAssets(projectRoot, {
+  let clientAssets = await emitBundledClientAssets(projectRoot, {
     entryClientModules,
     additionalVendorSpecifiers: sharedVendorOptions.additionalEntrySpecifiers,
     serverAssetImportsByEntry,
     clientBoundariesByEntry,
   });
+  const integrationOutputs = await litsxPipeline?.finalize({
+    routes,
+    routeHandlers,
+  });
+  clientAssets = mergeLitsxAssetsIntoManifest(clientAssets, integrationOutputs);
   const staticAssetPublicUrls = createStaticAssetPublicUrlMap(clientAssets);
   await rewriteServerAssetPlaceholders(projectRoot, clientAssets);
 
-  const routeResolver = await createRouteResolver(projectRoot, "production", {
-    staticAssetPublicUrls,
-  });
   const sharedRuntime = await buildSharedVendorRuntime(projectRoot, "production", sharedVendorOptions);
   clientAssets.sharedImports = { ...sharedRuntime.imports };
   const packageImports = sharedRuntime.imports;
@@ -364,6 +379,11 @@ export async function buildProject(projectRoot, options = {}) {
     assetManifest: clientAssets,
     packageImports,
   });
+  const routeResolver = await createRouteResolver(projectRoot, "production", {
+    staticAssetPublicUrls,
+    assetResolver,
+    litsxPipeline,
+  });
   const hydrationModuleUrl = await resolveSharedVendorModuleUrl(
     projectRoot,
     "production",
@@ -423,7 +443,21 @@ export async function buildProject(projectRoot, options = {}) {
           }
           continue;
         }
-        if (assetResolver(moduleId) || clientAssets.byPublicPath?.[moduleId]) continue;
+        const directPublicUrl = assetResolver(moduleId)
+          ?? (clientAssets.byPublicPath?.[moduleId] ? moduleId : null);
+        if (directPublicUrl) {
+          if (Array.isArray(result.clientImports)) {
+            result.clientImports = result.clientImports.map((value) => (
+              value === moduleId ? directPublicUrl : value
+            ));
+          }
+          if (Array.isArray(result.hydrationData?.clientImports)) {
+            result.hydrationData.clientImports = result.hydrationData.clientImports.map((value) => (
+              value === moduleId ? directPublicUrl : value
+            ));
+          }
+          continue;
+        }
         const importerPath = routeResult.boundaryModule
           ?? routeResult.route?.page
           ?? path.join(projectRoot, "app", "page.jsx");
@@ -473,6 +507,7 @@ export async function buildProject(projectRoot, options = {}) {
         ])]
         : [];
       const styleUrls = [...new Set([
+        ...(clientAssets.documentStyles ?? []),
         ...collectTransitiveStyleUrls(clientImports, clientAssets),
         ...resolveServerStyleUrls(routeResult, projectRoot, clientAssets),
       ])];
@@ -650,6 +685,11 @@ export async function buildProject(projectRoot, options = {}) {
         cache: sortedRouteCache.find((entry) => entry.pathname === artifact.routePathname)?.cache
           ?? "static",
       })),
+      ...(integrationOutputs?.assets ?? []).map((asset) => ({
+        kind: asset.kind,
+        outputPath: toBuildRelativePath(projectRoot, asset.outputPath),
+        integration: asset.integration,
+      })),
     ],
   };
   const manifestPath = path.join(buildRoot, MANIFEST_FILENAME);
@@ -676,7 +716,22 @@ export async function buildProject(projectRoot, options = {}) {
   await writeJson(path.join(buildRoot, DEPLOY_ASSETS_MANIFEST_FILENAME), deployAssets);
   await writeJson(path.join(buildRoot, DEPLOY_SERVER_MANIFEST_FILENAME), deployServer);
 
-  await serverSetupCleanup?.();
-
   return manifestPath;
+  } catch (error) {
+    buildError = error;
+    throw error;
+  } finally {
+    let cleanupError = null;
+    try {
+      await serverSetupCleanup?.();
+    } catch (error) {
+      cleanupError = error;
+    }
+    try {
+      await litsxPipeline?.dispose();
+    } catch (error) {
+      cleanupError ??= error;
+    }
+    if (!buildError && cleanupError) throw cleanupError;
+  }
 }

package/src/client-assets.js

@@ -2483,6 +2483,7 @@ export function normalizeClientAssetManifest(manifest) {
       manifest.clientBoundariesByEntry && typeof manifest.clientBoundariesByEntry === "object"
         ? manifest.clientBoundariesByEntry
         : {},
+    documentStyles: Array.isArray(manifest.documentStyles) ? manifest.documentStyles : [],
     assets: manifest.assets,
   };
 }

package/src/compiler.js

@@ -182,14 +182,28 @@ async function transformModuleSource(source, {
   sourcePath,
   sourceMaps,
   ssr = false,
+  target = ssr ? "server" : "client",
+  litsxPipeline = null,
 }) {
   if (isLitsxAuthoredModule(sourcePath, source)) {
-    const transformed = await transformLitsx(source, {
-      filename: sourcePath,
-      sourceMaps,
-      ssr,
-    });
-    return restoreSideEffectImports(source, sourcePath, transformed, sourceMaps);
+    const compilerOptions = litsxPipeline
+      ? litsxPipeline.getCompilerOptions({ filename: sourcePath, sourceMaps, ssr })
+      : { filename: sourcePath, sourceMaps, ssr };
+    const transformed = restoreSideEffectImports(
+      source,
+      sourcePath,
+      await transformLitsx(source, compilerOptions),
+      compilerOptions.sourceMaps === true,
+    );
+    return litsxPipeline
+      ? litsxPipeline.processModule(transformed, {
+        source,
+        sourcePath,
+        sourceMaps: compilerOptions.sourceMaps === true,
+        ssr: ssr === true,
+        target,
+      })
+      : transformed;
   }
 
   if (sourcePath.endsWith(".ts")) {
@@ -914,8 +928,9 @@ function getTypedOutputRoot(projectRoot, mode, target = "server") {
   );
 }
 
-function toOutputPath(projectRoot, outputRoot, sourcePath) {
-  const relativePath = toOutputRelativePath(projectRoot, sourcePath);
+function toOutputPath(projectRoot, outputRoot, sourcePath, litsxPipeline = null) {
+  const relativePath = litsxPipeline?.getOutputRelativePath?.(sourcePath)
+    ?? toOutputRelativePath(projectRoot, sourcePath);
   const extension = path.extname(relativePath);
   if (!extension) {
     return path.join(outputRoot, `${relativePath}.mjs`);
@@ -963,6 +978,7 @@ async function rewriteRelativeSpecifiers({
   serverExportsByModule,
   packageImports,
   dynamicImportDirectories,
+  litsxPipeline,
 }) {
   const magicSource = new MagicString(code);
   let didRewrite = false;
@@ -974,10 +990,19 @@ async function rewriteRelativeSpecifiers({
   for (const reference of moduleReferences.staticReferences) {
     const { specifier } = reference;
 
-    const aliasedImportPath = isBareSpecifier(specifier)
+    const virtualImportPath = litsxPipeline
+      ? await litsxPipeline.resolveModule(specifier, {
+        importer: sourcePath,
+        target,
+        ssr: target === "server",
+        sourceMaps,
+      })
+      : null;
+
+    const aliasedImportPath = !virtualImportPath && isBareSpecifier(specifier)
       ? await resolveProjectMappedImport(projectRoot, sourcePath, specifier)
       : null;
-    const packageImportPath = isBareSpecifier(specifier) && !aliasedImportPath
+    const packageImportPath = !virtualImportPath && isBareSpecifier(specifier) && !aliasedImportPath
       ? await resolveProjectPackageImport(projectRoot, sourcePath, specifier)
       : null;
     const packageAssetPath = packageImportPath && isStaticAssetPath(packageImportPath)
@@ -987,6 +1012,7 @@ async function rewriteRelativeSpecifiers({
     if (
       target === "server"
       && isBareSpecifier(specifier)
+      && !virtualImportPath
       && !aliasedImportPath
       && !packageAssetPath
     ) {
@@ -996,6 +1022,7 @@ async function rewriteRelativeSpecifiers({
     if (
       target === "client"
       && isBareSpecifier(specifier)
+      && !virtualImportPath
       && !aliasedImportPath
       && !packageAssetPath
     ) {
@@ -1010,11 +1037,12 @@ async function rewriteRelativeSpecifiers({
       continue;
     }
 
-    if (!isRelativeSpecifier(specifier) && !aliasedImportPath && !packageAssetPath) {
+    if (!virtualImportPath && !isRelativeSpecifier(specifier) && !aliasedImportPath && !packageAssetPath) {
       continue;
     }
 
-    const resolvedImportPath = packageAssetPath
+    const resolvedImportPath = virtualImportPath
+      ?? packageAssetPath
       ?? aliasedImportPath
       ?? await resolveImportPath(sourcePath, specifier);
     if (!resolvedImportPath) {
@@ -1033,6 +1061,9 @@ async function rewriteRelativeSpecifiers({
 
     if (shouldCompileModule(resolvedImportPath)) {
       compiledImportPath = await compileModule(resolvedImportPath);
+      if (virtualImportPath) {
+        litsxPipeline?.registerResolvedModule(specifier, resolvedImportPath, compiledImportPath);
+      }
       const serverExports = serverExportsByModule?.get(resolvedImportPath) ?? new Set();
       const importedNames = importedNamesBySpecifier.get(specifier) ?? new Set();
       if (
@@ -1245,6 +1276,7 @@ function getDevelopmentGraphCacheKey(entryPath, options) {
     options.target ?? "server",
     options.ssr === true ? "ssr" : "client",
     options.sourceMaps === false ? "without-maps" : "with-maps",
+    options.litsxPipeline?.identity?.id ?? "default-litsx",
   ].join("::");
 }
 
@@ -1358,6 +1390,7 @@ async function compileModuleGraphUncached(entryPath, options = {}) {
     staticAssetPublicUrls = null,
     onDevelopmentEvent,
     managedSourceRoots,
+    litsxPipeline,
   } = options;
 
   const outputRoot = getTypedOutputRoot(projectRoot, mode, target);
@@ -1384,7 +1417,7 @@ async function compileModuleGraphUncached(entryPath, options = {}) {
       return visited.get(sourcePath);
     }
 
-    const outputPath = toOutputPath(projectRoot, outputRoot, sourcePath);
+    const outputPath = toOutputPath(projectRoot, outputRoot, sourcePath, litsxPipeline);
     visited.set(sourcePath, outputPath);
 
     await ensureDirectory(path.dirname(outputPath));
@@ -1394,6 +1427,8 @@ async function compileModuleGraphUncached(entryPath, options = {}) {
       sourcePath,
       sourceMaps,
       ssr,
+      target,
+      litsxPipeline,
     });
     const isServerComponentModule = isCompiledServerComponentModule(transformed.code);
     const isMixedComponentModule = isServerComponentModule
@@ -1439,6 +1474,7 @@ async function compileModuleGraphUncached(entryPath, options = {}) {
       serverExportsByModule,
       packageImports,
       dynamicImportDirectories,
+      litsxPipeline,
     });
 
     await fs.writeFile(outputPath, rewritten.code, "utf8");
@@ -1467,7 +1503,12 @@ async function compileModuleGraphUncached(entryPath, options = {}) {
   return {
     entrypoint: await compileModule(entryPath),
     outputRoot,
-    sourceFiles: [...new Set([...visited.keys(), ...staticAssetFiles])],
+    sourceFiles: [...new Set([
+      ...visited.keys(),
+      ...staticAssetFiles,
+      ...(litsxPipeline?.dependencies ?? []),
+    ])],
+    integrationDependencies: litsxPipeline?.dependencies ?? [],
     watchedDirectories: [...dynamicImportDirectories],
     packageImports: [...packageImports].sort(),
   };
@@ -1625,6 +1666,8 @@ export async function collectClientGraphInventory(entryPaths, options = {}) {
       projectRoot,
       sourcePath,
       sourceMaps: false,
+      target: "client",
+      litsxPipeline: options.litsxPipeline,
     });
     const isServer = isCompiledServerComponentModule(transformed.code);
     const isComponent = isCompiledClientBoundaryModule(transformed.code);

package/src/deployment-runtime.js

@@ -53,6 +53,7 @@ import {
   runRequestExtensions,
 } from "./extensions.js";
 import { runServerSetup } from "./server-setup.js";
+import { createLitsxPipeline, mergeLitsxAssetsIntoManifest } from "./litsx-pipeline.js";
 
 function isBarePackageModuleId(value) {
   return typeof value === "string"
@@ -259,6 +260,7 @@ export async function createRequestRenderer({
   onDevelopmentEvent,
   managedSourceRoots,
   extensions = [],
+  litsxPipeline = null,
 }) {
   let currentAssetManifest = normalizeClientAssetManifest(assetManifest);
   const extensionClientDescriptors = getExtensionClientDescriptors(extensions);
@@ -325,7 +327,11 @@ export async function createRequestRenderer({
   function getDevelopmentEntryInventory(entryPath) {
     let inventory = devInventoryByEntry.get(entryPath);
     if (!inventory) {
-      inventory = collectClientGraphInventory([entryPath], { projectRoot, managedSourceRoots });
+      inventory = collectClientGraphInventory([entryPath], {
+        projectRoot,
+        managedSourceRoots,
+        litsxPipeline,
+      });
       devInventoryByEntry.set(entryPath, inventory);
       inventory.catch(() => {
         if (devInventoryByEntry.get(entryPath) === inventory) devInventoryByEntry.delete(entryPath);
@@ -337,6 +343,7 @@ export async function createRequestRenderer({
     const resolver = await createRouteResolver(projectRoot, mode, {
       onDevelopmentEvent,
       managedSourceRoots,
+      litsxPipeline,
       segmentRenderCache: sharedSegmentRenderCache,
       getStaticAssetPublicUrls() {
         return createStaticAssetPublicUrlMap(currentAssetManifest);
@@ -359,6 +366,7 @@ export async function createRequestRenderer({
       target: "client",
       onDevelopmentEvent,
       managedSourceRoots,
+      litsxPipeline,
     });
     devPreparedClientModules.add(clientModuleKey);
     devClientModuleDependencies.set(
@@ -387,7 +395,13 @@ export async function createRequestRenderer({
       clientBoundariesByEntry: devClientBoundariesByEntry,
       additionalVendorSpecifiers: [...packageClientSpecifiers],
     });
-    currentAssetManifest = bundledClientAssets.manifest;
+    const integrationOutputs = await litsxPipeline?.finalize({
+      assetManifest: bundledClientAssets.manifest,
+    });
+    currentAssetManifest = mergeLitsxAssetsIntoManifest(
+      bundledClientAssets.manifest,
+      integrationOutputs,
+    );
     devPreviousAssetOutputPaths = new Set();
     currentAssetResolver = createAssetResolver(projectRoot, {
       assetManifest: currentAssetManifest,
@@ -625,6 +639,7 @@ export async function createRequestRenderer({
         : [];
       const styleUrls = currentAssetManifest
         ? [...new Set([
+          ...(currentAssetManifest.documentStyles ?? []),
           ...collectTransitiveStyleUrls(clientImports, currentAssetManifest),
           ...resolveServerStyleUrls(routeResult, projectRoot, currentAssetManifest),
         ])]
@@ -857,6 +872,7 @@ export async function createRequestRenderer({
             target: "client",
             onDevelopmentEvent,
             managedSourceRoots,
+            litsxPipeline,
           });
         }
         return;
@@ -936,7 +952,10 @@ export async function createDeploymentRuntime({
   evolitConfig: configuredEvolitConfig,
 } = {}) {
   const evolitConfig = configuredEvolitConfig ?? await loadEvolitConfig(projectRoot);
-  const serverSetupCleanup = await runServerSetup({ projectRoot, mode, evolitConfig });
+  const litsxPipeline = await createLitsxPipeline({ projectRoot, mode, config: evolitConfig });
+  let serverSetupCleanup = null;
+  try {
+  serverSetupCleanup = await runServerSetup({ projectRoot, mode, evolitConfig, litsxPipeline });
   const extensions = resolveEvolitExtensions(evolitConfig);
   const extensionClientSpecifiers = getExtensionClientDescriptors(extensions).map((descriptor) => descriptor.module);
   const effectiveManagedSourceRoots = managedSourceRoots
@@ -994,18 +1013,26 @@ export async function createDeploymentRuntime({
     onDevelopmentEvent,
     managedSourceRoots: effectiveManagedSourceRoots,
     extensions,
+    litsxPipeline,
   });
+  let closed = false;
 
   return {
     assets,
     cache: renderer.responseCacheController,
     renderer,
+    get litsxDependencies() {
+      return litsxPipeline?.dependencies ?? [];
+    },
     async invalidateDevelopmentState(changedPaths = null) {
       if (mode !== "development") {
         return;
       }
 
-      const invalidationResult = await renderer.invalidateDevelopmentState(changedPaths);
+      const litsxInvalidated = await litsxPipeline?.invalidate(changedPaths);
+      const invalidationResult = await renderer.invalidateDevelopmentState(
+        litsxInvalidated ? null : changedPaths,
+      );
       if (typeof effectiveResponseCacheRuntime.store.clear === "function") {
         await effectiveResponseCacheRuntime.store.clear();
       }
@@ -1075,6 +1102,7 @@ export async function createDeploymentRuntime({
       const { routeResult, response } = await renderer.renderRoute(resolvedRequest, routePolicyResult, {
         extensionState: extensionResult,
       });
+      await litsxPipeline?.finalize({ routeResult, assetManifest: renderer.assetManifest });
       runtimeState.assetManifest = normalizeClientAssetManifest(renderer.assetManifest);
       return formatResponseForRequest(
         request,
@@ -1082,13 +1110,39 @@ export async function createDeploymentRuntime({
       );
     },
     async close() {
+      if (closed) return;
+      closed = true;
+      let cleanupError = null;
       const revalidationTasks = this.revalidationTasks;
       if (revalidationTasks) {
-        await Promise.all(revalidationTasks.values());
+        try {
+          await Promise.all(revalidationTasks.values());
+        } catch (error) {
+          cleanupError = error;
+        }
       }
-      await serverSetupCleanup?.();
+      try {
+        await serverSetupCleanup?.();
+      } catch (error) {
+        cleanupError = error;
+      }
+      try {
+        await litsxPipeline?.dispose();
+      } catch (error) {
+        cleanupError ??= error;
+      }
+      if (cleanupError) throw cleanupError;
     },
   };
+  } catch (error) {
+    try {
+      await serverSetupCleanup?.();
+    } catch {}
+    try {
+      await litsxPipeline?.dispose();
+    } catch {}
+    throw error;
+  }
 }
 
 function addNavigationVaryHeader(response) {

package/src/index.js

@@ -124,6 +124,9 @@ export { getRequestContext } from "./request-context.js";
 /** Defines an Evolit extension for use in evolit.config.js. */
 export { defineEvolitPlugin } from "./extensions.js";
 
+/** Defines a typed Evolit configuration, including the native LitSX pipeline. */
+export { defineEvolitConfig, defineLitsxIntegration } from "./litsx-pipeline.js";
+
 /**
  * Returns the incoming request URL. Reading it makes the current route dynamic.
  *