@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

package/src/adapters/shared/fs-server-response-factory.js

@@ -1,81 +0,0 @@
-import { STATUS_MESSAGE } from "../../config/constants.js";
-import { appLogger } from "../../global/app-logger.js";
-import { fileSystem } from "@ecopages/file-system";
-class FileSystemServerResponseFactory {
-  options;
-  constructor({ options }) {
-    this.options = options;
-  }
-  isHtml(contentType) {
-    return contentType === "text/html";
-  }
-  shouldEnableGzip(contentType) {
-    if (this.options.watchMode) return false;
-    const gzipEnabledExtensions = ["text/javascript", "text/css"];
-    return gzipEnabledExtensions.includes(contentType);
-  }
-  async createResponseWithBody(body, init = {
-    headers: {
-      "Content-Type": "text/html"
-    }
-  }) {
-    return new Response(body, init);
-  }
-  async createDefaultNotFoundResponse() {
-    return new Response(STATUS_MESSAGE[404], {
-      status: 404
-    });
-  }
-  /**
-   * Wraps already-rendered HTML in a 404 response envelope.
-   */
-  async createHtmlNotFoundResponse(body) {
-    return await this.createResponseWithBody(body, {
-      status: 404,
-      statusText: STATUS_MESSAGE[404],
-      headers: {
-        "Content-Type": "text/html"
-      }
-    });
-  }
-  /**
-   * Reads a static file response, returning `null` when the file is missing.
-   */
-  async createFileResponse(filePath, contentType) {
-    try {
-      let file;
-      const contentEncodingHeader = {};
-      if (this.shouldEnableGzip(contentType)) {
-        const gzipPath = `${filePath}.gz`;
-        if (fileSystem.exists(gzipPath)) {
-          file = fileSystem.readFileAsBuffer(gzipPath);
-          contentEncodingHeader["Content-Encoding"] = "gzip";
-          contentEncodingHeader["Vary"] = "Accept-Encoding";
-        } else {
-          appLogger.debug("Gzip file not found, serving uncompressed", gzipPath);
-          file = fileSystem.readFileAsBuffer(filePath);
-        }
-      } else {
-        file = fileSystem.readFileAsBuffer(filePath);
-      }
-      return await this.createResponseWithBody(file, {
-        headers: {
-          "Content-Type": contentType,
-          ...contentEncodingHeader
-        }
-      });
-    } catch (error) {
-      const err = error;
-      const code = err.code || err.cause?.code;
-      if (code === "ENOENT") {
-        appLogger.debug("File not found", filePath);
-      } else {
-        appLogger.error("Error reading file", filePath, err);
-      }
-      return null;
-    }
-  }
-}
-export {
-  FileSystemServerResponseFactory
-};

package/src/adapters/shared/fs-server-response-matcher.js

@@ -1,186 +0,0 @@
-import path from "node:path";
-import { appLogger } from "../../global/app-logger.js";
-import { PageRequestCacheCoordinator } from "../../services/cache/page-request-cache-coordinator.service.js";
-import { ServerUtils } from "../../utils/server-utils.module.js";
-import { FileRouteMiddlewarePipeline } from "./file-route-middleware-pipeline.js";
-import { LocalsAccessError } from "../../errors/locals-access-error.js";
-import { isDevelopmentRuntime } from "../../utils/runtime.js";
-class FileSystemResponseMatcher {
-  appConfig;
-  assetPrefix;
-  router;
-  routeRendererFactory;
-  fileSystemResponseFactory;
-  pageRequestCacheCoordinator;
-  fileRouteMiddlewarePipeline;
-  constructor({
-    appConfig,
-    assetPrefix,
-    router,
-    routeRendererFactory,
-    fileSystemResponseFactory,
-    cacheService = null,
-    defaultCacheStrategy = "static"
-  }) {
-    this.appConfig = appConfig;
-    this.assetPrefix = assetPrefix;
-    this.router = router;
-    this.routeRendererFactory = routeRendererFactory;
-    this.fileSystemResponseFactory = fileSystemResponseFactory;
-    this.pageRequestCacheCoordinator = new PageRequestCacheCoordinator(cacheService, defaultCacheStrategy);
-    this.fileRouteMiddlewarePipeline = new FileRouteMiddlewarePipeline(cacheService);
-  }
-  /**
-   * Resolves unmatched paths either as static asset requests or as the custom
-   * not-found page.
-   * @param requestUrl Incoming pathname.
-   * @returns Static file response or rendered 404 response.
-   */
-  async handleNoMatch(requestUrl) {
-    const isStaticFileRequest = ServerUtils.hasKnownExtension(requestUrl);
-    if (!isStaticFileRequest) {
-      return this.renderCustomNotFoundResponse();
-    }
-    const relativeUrl = requestUrl.startsWith("/") ? requestUrl.slice(1) : requestUrl;
-    const filePath = path.join(this.assetPrefix, relativeUrl);
-    const contentType = ServerUtils.getContentType(filePath);
-    const response = await this.fileSystemResponseFactory.createFileResponse(filePath, contentType);
-    return response ?? this.renderCustomNotFoundResponse();
-  }
-  /**
-   * Handles a matched file-system page route.
-   *
-   * The method inspects page metadata needed for request-time execution,
-   * prepares the renderer invocation, validates middleware/cache constraints,
-   * and delegates caching plus middleware execution to dedicated collaborators.
-   *
-   * @param match Router match result.
-   * @param request Optional incoming request. A synthetic GET request is created when omitted.
-   * @returns Final response for the matched route.
-   */
-  async handleMatch(match, request) {
-    try {
-      const executionPlan = await this.createExecutionPlan(match, request);
-      this.fileRouteMiddlewarePipeline.assertValidConfiguration({
-        middleware: executionPlan.pageMiddleware,
-        pageCacheStrategy: executionPlan.pageCacheStrategy,
-        filePath: executionPlan.pageFilePath
-      });
-      const routeRenderer = this.routeRendererFactory.getPageRenderer(executionPlan.pageFilePath);
-      const middlewareContext = this.fileRouteMiddlewarePipeline.createContext({
-        request: executionPlan.request,
-        params: match.params,
-        locals: executionPlan.localsStore
-      });
-      const renderFn = async () => {
-        const result = await routeRenderer.execute({
-          file: executionPlan.pageFilePath,
-          params: match.params,
-          query: match.query,
-          locals: executionPlan.localsForRender
-        });
-        const html = await this.pageRequestCacheCoordinator.bodyToString(result.body);
-        const strategy = result.cacheStrategy ?? this.pageRequestCacheCoordinator.getDefaultCacheStrategy();
-        return { html, strategy };
-      };
-      const renderResponse = async () => {
-        return this.pageRequestCacheCoordinator.render({
-          cacheKey: executionPlan.cacheKey,
-          pageCacheStrategy: executionPlan.pageCacheStrategy,
-          renderFn
-        });
-      };
-      return await this.fileRouteMiddlewarePipeline.run({
-        middleware: executionPlan.pageMiddleware,
-        context: middlewareContext,
-        renderResponse
-      });
-    } catch (error) {
-      if (error instanceof Response) {
-        return error;
-      }
-      if (error instanceof LocalsAccessError) {
-        return new Response(error.message, {
-          status: 500,
-          headers: { "Content-Type": "text/plain; charset=utf-8" }
-        });
-      }
-      if (error instanceof Error) {
-        if (isDevelopmentRuntime() || appLogger.isDebugEnabled()) {
-          appLogger.error(`[FileSystemResponseMatcher] ${error.message} at ${match.requestedPathname}`);
-        }
-      }
-      return this.renderCustomNotFoundResponse();
-    }
-  }
-  /**
-   * Renders the app-owned custom 404 page, falling back to the default text 404
-   * when the page template cannot be resolved.
-   */
-  async renderCustomNotFoundResponse() {
-    const error404TemplatePath = this.appConfig.absolutePaths.error404TemplatePath;
-    try {
-      const routeRenderer = this.routeRendererFactory.getPageRenderer(error404TemplatePath);
-      const result = await routeRenderer.execute({
-        file: error404TemplatePath
-      });
-      return this.fileSystemResponseFactory.createHtmlNotFoundResponse(result.body);
-    } catch {
-      appLogger.debug(
-        "Custom 404 template not found, falling back to default 404 response",
-        error404TemplatePath
-      );
-      return this.fileSystemResponseFactory.createDefaultNotFoundResponse();
-    }
-  }
-  async createExecutionPlan(match, request) {
-    const cacheKey = this.pageRequestCacheCoordinator.buildCacheKey({
-      pathname: match.requestedPathname,
-      query: match.query
-    });
-    const resolvedRequest = request ?? new Request(new URL(cacheKey, this.router.origin).toString(), {
-      method: "GET"
-    });
-    const localsStore = {};
-    const pageFilePath = match.templateRoute.filePath;
-    const pageModule = await this.importPageModule(pageFilePath);
-    const Page = pageModule?.default;
-    const pageMiddleware = Page?.middleware ?? [];
-    const pageCacheStrategy = Page?.cache ?? this.pageRequestCacheCoordinator.getDefaultCacheStrategy();
-    return {
-      cacheKey,
-      request: resolvedRequest,
-      pageFilePath,
-      pageMiddleware,
-      pageCacheStrategy,
-      localsStore,
-      localsForRender: pageCacheStrategy === "dynamic" ? localsStore : void 0
-    };
-  }
-  /**
-   * Loads the matched page module for request-time inspection.
-   *
-   * The matcher needs access to page-level metadata such as `cache` and
-   * `middleware` before full rendering starts, so it asks the owning route
-   * renderer to load the page module. That preserves integration-specific page
-   * import setup for request-time inspection as well as for full rendering.
-   *
-   * @param filePath Absolute page module path.
-   * @returns Imported page module.
-   */
-  async importPageModule(filePath) {
-    const routeRenderer = this.routeRendererFactory.getPageRenderer(filePath);
-    return routeRenderer.loadPageModule(filePath, {
-      cacheScope: "request-metadata"
-    });
-  }
-  /**
-   * Get the underlying cache service for external invalidation.
-   */
-  getCacheService() {
-    return this.pageRequestCacheCoordinator.getCacheService();
-  }
-}
-export {
-  FileSystemResponseMatcher
-};

package/src/adapters/shared/hmr-entrypoint-registrar.d.ts

@@ -1,55 +0,0 @@
-/**
- * Shared runtime state used while registering HMR-owned entrypoints.
- */
-export interface HmrEntrypointRegistrarOptions {
-    /** Absolute source directory used to derive the emitted HMR path. */
-    srcDir: string;
-    /** Absolute distribution directory where HMR outputs are written. */
-    distDir: string;
-    /** In-flight registrations keyed by normalized absolute entrypoint path. */
-    entrypointRegistrations: Map<string, Promise<string>>;
-    /** Stable entrypoint-to-output mapping retained once an entrypoint is registered. */
-    watchedFiles: Map<string, string>;
-    /** Runtime-specific cleanup invoked when an entrypoint registration fails. */
-    clearFailedRegistration?: (entrypointPath: string) => void;
-    /** Development-only guardrail for integrations that never finish producing output. */
-    registrationTimeoutMs: number;
-}
-/**
- * Runtime-specific hooks required to materialize a single HMR entrypoint.
- */
-export interface HmrEntrypointRegistrationOptions {
-    /**
-     * Emits the browser-consumable HMR artifact for an entrypoint.
-     */
-    emit(entrypointPath: string, outputPath: string): Promise<void>;
-    /**
-     * Creates the runtime-specific error raised when the emit hook completes without producing output.
-     */
-    getMissingOutputError(entrypointPath: string, outputPath: string): Error;
-}
-/**
- * Coordinates the shared HMR entrypoint registration lifecycle for both Node and Bun managers.
- *
- * The registrar owns the cross-runtime policy: normalize entrypoint identities, dedupe concurrent
- * registrations, derive the emitted `_hmr` output path, clear stale output before rebuilding, and
- * apply the development timeout that prevents unresolved registrations from hanging navigation.
- * Runtime-specific managers remain responsible for the actual emit step and any cleanup outside
- * this shared registration flow.
- */
-export declare class HmrEntrypointRegistrar {
-    private readonly options;
-    constructor(options: HmrEntrypointRegistrarOptions);
-    /**
-     * Registers a single source entrypoint and returns the browser URL for its emitted HMR module.
-     *
-     * Concurrent requests for the same normalized entrypoint share the same in-flight promise so the
-     * integration only builds once per registration cycle.
-     */
-    registerEntrypoint(entrypointPath: string, registrationOptions: HmrEntrypointRegistrationOptions): Promise<string>;
-    private registerEntrypointInternal;
-    private awaitEntrypointRegistration;
-    private getEntrypointOutput;
-    private removeStaleEntrypointOutput;
-    private encodeDynamicSegments;
-}

package/src/adapters/shared/hmr-entrypoint-registrar.js

@@ -1,87 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { appLogger } from "../../global/app-logger.js";
-import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
-class HmrEntrypointRegistrar {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Registers a single source entrypoint and returns the browser URL for its emitted HMR module.
-   *
-   * Concurrent requests for the same normalized entrypoint share the same in-flight promise so the
-   * integration only builds once per registration cycle.
-   */
-  async registerEntrypoint(entrypointPath, registrationOptions) {
-    const normalizedEntrypoint = path.resolve(entrypointPath);
-    const existingRegistration = this.options.entrypointRegistrations.get(normalizedEntrypoint);
-    if (existingRegistration) {
-      return await this.awaitEntrypointRegistration(existingRegistration, normalizedEntrypoint);
-    }
-    const registration = this.registerEntrypointInternal(normalizedEntrypoint, registrationOptions);
-    this.options.entrypointRegistrations.set(normalizedEntrypoint, registration);
-    try {
-      return await this.awaitEntrypointRegistration(registration, normalizedEntrypoint);
-    } catch (error) {
-      this.options.clearFailedRegistration?.(normalizedEntrypoint);
-      throw error;
-    } finally {
-      this.options.entrypointRegistrations.delete(normalizedEntrypoint);
-    }
-  }
-  async registerEntrypointInternal(entrypointPath, registrationOptions) {
-    if (this.options.watchedFiles.has(entrypointPath)) {
-      return this.options.watchedFiles.get(entrypointPath);
-    }
-    const { outputPath, outputUrl } = this.getEntrypointOutput(entrypointPath);
-    this.options.watchedFiles.set(entrypointPath, outputUrl);
-    this.removeStaleEntrypointOutput(outputPath);
-    await registrationOptions.emit(entrypointPath, outputPath);
-    if (!fileSystem.exists(outputPath)) {
-      throw registrationOptions.getMissingOutputError(entrypointPath, outputPath);
-    }
-    return outputUrl;
-  }
-  async awaitEntrypointRegistration(registration, entrypointPath) {
-    if (process.env.NODE_ENV !== "development") {
-      return await registration;
-    }
-    return await Promise.race([
-      registration,
-      new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`[HMR] Timed out registering entrypoint: ${entrypointPath}`));
-        }, this.options.registrationTimeoutMs);
-      })
-    ]);
-  }
-  getEntrypointOutput(entrypointPath) {
-    const relativePath = path.relative(this.options.srcDir, entrypointPath);
-    const relativePathJs = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, ".js");
-    const encodedPathJs = this.encodeDynamicSegments(relativePathJs);
-    const urlPath = encodedPathJs.split(path.sep).join("/");
-    return {
-      outputUrl: `/${path.join(RESOLVED_ASSETS_DIR, "_hmr", urlPath)}`,
-      outputPath: path.join(this.options.distDir, urlPath)
-    };
-  }
-  removeStaleEntrypointOutput(outputPath) {
-    if (!fileSystem.exists(outputPath)) {
-      return;
-    }
-    try {
-      fileSystem.remove(outputPath);
-    } catch (error) {
-      appLogger.warn(
-        `[HMR] Failed to remove stale entrypoint output ${outputPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  encodeDynamicSegments(filepath) {
-    return filepath.replace(/\[([^\]]+)\]/g, "_$1_");
-  }
-}
-export {
-  HmrEntrypointRegistrar
-};

package/src/adapters/shared/hmr-html-response.js

@@ -1,33 +0,0 @@
-const HMR_RUNTIME_IMPORT = "import '/_hmr_runtime.js'";
-const HMR_RUNTIME_SCRIPT = `<script type="module">${HMR_RUNTIME_IMPORT};<\/script>`;
-function isHtmlResponse(response) {
-  const contentType = response.headers.get("Content-Type");
-  return contentType !== null && contentType.startsWith("text/html");
-}
-function shouldInjectHmrHtmlResponse(watch, hmrManager) {
-  return watch && hmrManager?.isEnabled() === true;
-}
-async function injectHmrRuntimeIntoHtmlResponse(response) {
-  const html = await response.text();
-  const headers = new Headers(response.headers);
-  headers.set("Cache-Control", "no-store, must-revalidate");
-  headers.delete("Content-Length");
-  if (html.includes(HMR_RUNTIME_IMPORT)) {
-    return new Response(html, {
-      status: response.status,
-      statusText: response.statusText,
-      headers
-    });
-  }
-  const updatedHtml = html.replace(/<\/html>/i, `${HMR_RUNTIME_SCRIPT}</html>`);
-  return new Response(updatedHtml, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-export {
-  injectHmrRuntimeIntoHtmlResponse,
-  isHtmlResponse,
-  shouldInjectHmrHtmlResponse
-};

package/src/adapters/shared/node-http-websocket-upgrades.js

@@ -1,125 +0,0 @@
-import { WebSocketServer } from "ws";
-import { appLogger } from "../../global/app-logger.js";
-import { findWebSocketRoute } from "../abstract/ws-pattern-matcher.js";
-import { invokeWebSocketHandlerHook, toWebSocketCloseInfo } from "./websocket-lifecycle.js";
-const attachedUpgradeServers = /* @__PURE__ */ new WeakSet();
-function adaptNodeWebSocket(ws, kind, params, search, context) {
-  return {
-    kind,
-    params,
-    search,
-    context,
-    send: (message) => {
-      if (typeof message === "string") {
-        ws.send(message);
-      } else if (message instanceof Blob) {
-        void message.arrayBuffer().then((buf) => ws.send(new Uint8Array(buf)));
-      } else if (message instanceof ArrayBuffer) {
-        ws.send(new Uint8Array(message));
-      } else if (ArrayBuffer.isView(message)) {
-        ws.send(new Uint8Array(message.buffer, message.byteOffset, message.byteLength));
-      } else {
-        ws.send(message);
-      }
-    },
-    sendStream: async (stream) => {
-      const reader = stream.getReader();
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          if (value) ws.send(value);
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    },
-    close: (code, reason) => ws.close(code, reason)
-  };
-}
-function toUpgradeRequest(runtimeOrigin, req) {
-  const upgradeUrl = new URL(req.url ?? "/", runtimeOrigin);
-  return new Request(upgradeUrl, {
-    method: req.method,
-    headers: req.headers
-  });
-}
-async function resolveNodeContext(request, handler, kind, params, search) {
-  if (!handler.context) {
-    return void 0;
-  }
-  try {
-    return await handler.context({ request, kind, params, search });
-  } catch (error) {
-    appLogger.error(`[WS:${kind}] context() failed; closing connection.`, error);
-    throw error;
-  }
-}
-async function setupNodeWebSocketConnection(ws, wsMatch, req, runtimeOrigin, search) {
-  const handler = wsMatch.handler;
-  const baseRequest = toUpgradeRequest(runtimeOrigin, req);
-  let context;
-  try {
-    context = await resolveNodeContext(baseRequest, handler, wsMatch.kind, wsMatch.params, search);
-  } catch {
-    ws.close(1011, "context initialization failed");
-    return;
-  }
-  const socket = adaptNodeWebSocket(ws, wsMatch.kind, wsMatch.params, search, context);
-  try {
-    await handler.onConnect?.(socket);
-  } catch (error) {
-    appLogger.error(`[WS:${wsMatch.kind}] onConnect failed:`, error);
-    ws.close(1011, "onConnect failed");
-    return;
-  }
-  ws.on("message", (msg, isBinary) => {
-    const message = isBinary ? {
-      kind: "binary",
-      data: msg instanceof ArrayBuffer ? new Uint8Array(msg) : Array.isArray(msg) ? new Uint8Array(Buffer.concat(msg)) : new Uint8Array(msg)
-    } : { kind: "text", text: msg.toString() };
-    invokeWebSocketHandlerHook(wsMatch.kind, "onMessage", handler.onMessage?.(socket, message));
-  });
-  ws.on("close", (code, reason) => {
-    const event = toWebSocketCloseInfo(code, reason.toString());
-    invokeWebSocketHandlerHook(wsMatch.kind, "onClose", handler.onClose?.(socket, event));
-  });
-  ws.on("error", (err) => {
-    appLogger.error(`[WS:${wsMatch.kind}] error:`, err);
-    invokeWebSocketHandlerHook(wsMatch.kind, "onError", handler.onError?.(socket, err));
-  });
-}
-function attachNodeHttpWebSocketUpgrades(server, options) {
-  if (options.websocketHandlers.size === 0) {
-    return;
-  }
-  if (attachedUpgradeServers.has(server)) {
-    appLogger.warn("[WS] WebSocket upgrades already attached to this HTTP server; skipping duplicate attach.");
-    return;
-  }
-  attachedUpgradeServers.add(server);
-  const userWss = new WebSocketServer({ noServer: true });
-  server.on("upgrade", (req, socket, head) => {
-    if (options.preflight?.(req, socket, head)) {
-      return;
-    }
-    const url = new URL(req.url ?? "/", options.runtimeOrigin);
-    const wsMatch = findWebSocketRoute(options.websocketHandlers, url.pathname);
-    if (!wsMatch) {
-      if (!options.passthroughUnmatched) {
-        socket.destroy();
-      }
-      return;
-    }
-    userWss.handleUpgrade(req, socket, head, (ws) => {
-      const search = Object.fromEntries(url.searchParams.entries());
-      void setupNodeWebSocketConnection(ws, wsMatch, req, options.runtimeOrigin, search).catch((error) => {
-        appLogger.error(`[WS:${wsMatch.kind}] unexpected error:`, error);
-        ws.close(1011, "internal error");
-      });
-    });
-  });
-}
-export {
-  attachNodeHttpWebSocketUpgrades
-};

package/src/adapters/shared/render-context.js

@@ -1,93 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { invariant } from "../../utils/invariant.js";
-function resolveServerModulePath(filePath) {
-  return filePath instanceof URL ? fileURLToPath(filePath) : filePath;
-}
-function mergePropsWithLocals(props, locals) {
-  if (!locals || typeof props !== "object" || props === null) {
-    return props;
-  }
-  return { ...props, locals };
-}
-function createRenderContext(options) {
-  const { integrations } = options;
-  const getRendererForView = (view) => {
-    const integrationName = view.config?.integration ?? view.config?.__eco?.integration;
-    invariant(
-      !!integrationName,
-      "Cannot determine integration for view. Set view.config.integration explicitly or ensure the view is defined with eco.page() in a file with a recognized extension."
-    );
-    const integration = integrations.find((i) => i.name === integrationName);
-    invariant(!!integration, `No integration found for: ${integrationName}`);
-    return integration.initializeRenderer({
-      rendererModules: options.rendererModules
-    });
-  };
-  const renderContext = {
-    importServerModule: async (filePath) => {
-      invariant(!!options.importServerModule, "Server module importing is not available in this render context.");
-      return await options.importServerModule(resolveServerModulePath(filePath));
-    },
-    async renderServerModule(filePath, props, renderOptions) {
-      const module = await renderContext.importServerModule(filePath);
-      const view = module.default;
-      const locals = this?.locals;
-      const mergedProps = mergePropsWithLocals(props ?? {}, locals);
-      const renderer = getRendererForView(view);
-      const ctx = {
-        partial: false,
-        status: renderOptions?.status,
-        headers: renderOptions?.headers
-      };
-      return await renderer.renderToResponse(view, mergedProps, ctx);
-    },
-    async render(view, props, renderOptions) {
-      const locals = this?.locals;
-      const mergedProps = mergePropsWithLocals(props ?? {}, locals);
-      const renderer = getRendererForView(view);
-      const ctx = {
-        partial: false,
-        status: renderOptions?.status,
-        headers: renderOptions?.headers
-      };
-      return renderer.renderToResponse(view, mergedProps, ctx);
-    },
-    async renderPartial(view, props, renderOptions) {
-      const locals = this?.locals;
-      const mergedProps = mergePropsWithLocals(props, locals);
-      const renderer = getRendererForView(view);
-      const ctx = {
-        partial: true,
-        status: renderOptions?.status,
-        headers: renderOptions?.headers
-      };
-      return renderer.renderToResponse(view, mergedProps, ctx);
-    },
-    json(data, responseOptions) {
-      const headers = new Headers({ "Content-Type": "application/json; charset=utf-8" });
-      if (responseOptions?.headers) {
-        const incomingHeaders = new Headers(responseOptions.headers);
-        incomingHeaders.forEach((value, key) => headers.set(key, value));
-      }
-      return new Response(JSON.stringify(data), {
-        status: responseOptions?.status ?? 200,
-        headers
-      });
-    },
-    html(content, responseOptions) {
-      const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
-      if (responseOptions?.headers) {
-        const incomingHeaders = new Headers(responseOptions.headers);
-        incomingHeaders.forEach((value, key) => headers.set(key, value));
-      }
-      return new Response(content, {
-        status: responseOptions?.status ?? 200,
-        headers
-      });
-    }
-  };
-  return renderContext;
-}
-export {
-  createRenderContext
-};