hadars 0.1.35 → 0.1.37

package/dist/lambda.d.cts

@@ -0,0 +1,93 @@
+import { H as HadarsEntryModule, a as HadarsOptions } from './hadars-B3b_6sj2.cjs';
+import 'react';
+
+/**
+ * AWS Lambda adapter for hadars.
+ *
+ * After running `hadars build`, import this in your Lambda entry file:
+ *
+ *   // lambda.ts
+ *   import { createLambdaHandler } from 'hadars/lambda';
+ *   import config from './hadars.config';
+ *   export const handler = createLambdaHandler(config);
+ *
+ * The returned handler speaks the API Gateway HTTP API (v2) payload format.
+ * API Gateway REST API (v1) events are also accepted.
+ *
+ * Static assets (JS, CSS, fonts) are served directly from the bundled
+ * `.hadars/static/` directory. For production use, front the Lambda with
+ * CloudFront and route static paths to an S3 origin instead.
+ */
+
+/** API Gateway HTTP API (v2) event. */
+interface APIGatewayV2Event {
+    version: '2.0';
+    routeKey: string;
+    rawPath: string;
+    rawQueryString: string;
+    cookies?: string[];
+    headers: Record<string, string>;
+    requestContext: {
+        http: {
+            method: string;
+        };
+        domainName: string;
+    };
+    body?: string;
+    isBase64Encoded: boolean;
+}
+/** API Gateway REST API (v1) event. */
+interface APIGatewayV1Event {
+    httpMethod: string;
+    path: string;
+    queryStringParameters?: Record<string, string> | null;
+    headers?: Record<string, string> | null;
+    body?: string | null;
+    isBase64Encoded: boolean;
+}
+type APIGatewayEvent = APIGatewayV2Event | APIGatewayV1Event;
+interface LambdaResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+    isBase64Encoded: boolean;
+}
+type LambdaHandler = (event: APIGatewayEvent) => Promise<LambdaResponse>;
+/**
+ * Pre-loaded module and HTML for single-file Lambda bundles created by
+ * `hadars export lambda`. Passing this bypasses all runtime file I/O so
+ * the handler works without a `.hadars/` directory on disk.
+ */
+interface LambdaBundled {
+    /** The compiled SSR module — import it statically in your entry shim. */
+    ssrModule: HadarsEntryModule<any>;
+    /**
+     * The contents of `.hadars/static/out.html` — load it as a text string
+     * at build time (esbuild's `--loader:.html=text` does this automatically
+     * when `hadars export lambda` runs).
+     */
+    outHtml: string;
+}
+/**
+ * Creates an AWS Lambda handler from a hadars config.
+ *
+ * Must be called after `hadars build` has produced the `.hadars/` output
+ * directory. The handler is stateless — Lambda can reuse the same instance
+ * across invocations; the SSR module and HTML template are cached in memory
+ * after the first warm invocation.
+ *
+ * Pass a {@link LambdaBundled} object as the second argument when using
+ * `hadars export lambda` to produce a single-file bundle — in that mode all
+ * I/O is eliminated and the handler is fully self-contained.
+ *
+ * @example — standard (file-based) deployment
+ * export const handler = createLambdaHandler(config);
+ *
+ * @example — single-file bundle (generated entry shim)
+ * import * as ssrModule from './.hadars/index.ssr.js';
+ * import outHtml from './.hadars/static/out.html';
+ * export const handler = createLambdaHandler(config, { ssrModule, outHtml });
+ */
+declare function createLambdaHandler(options: HadarsOptions, bundled?: LambdaBundled): LambdaHandler;
+
+export { type APIGatewayEvent, type APIGatewayV1Event, type APIGatewayV2Event, type LambdaBundled, type LambdaHandler, type LambdaResponse, createLambdaHandler };

package/dist/lambda.d.ts

@@ -0,0 +1,93 @@
+import { H as HadarsEntryModule, a as HadarsOptions } from './hadars-B3b_6sj2.js';
+import 'react';
+
+/**
+ * AWS Lambda adapter for hadars.
+ *
+ * After running `hadars build`, import this in your Lambda entry file:
+ *
+ *   // lambda.ts
+ *   import { createLambdaHandler } from 'hadars/lambda';
+ *   import config from './hadars.config';
+ *   export const handler = createLambdaHandler(config);
+ *
+ * The returned handler speaks the API Gateway HTTP API (v2) payload format.
+ * API Gateway REST API (v1) events are also accepted.
+ *
+ * Static assets (JS, CSS, fonts) are served directly from the bundled
+ * `.hadars/static/` directory. For production use, front the Lambda with
+ * CloudFront and route static paths to an S3 origin instead.
+ */
+
+/** API Gateway HTTP API (v2) event. */
+interface APIGatewayV2Event {
+    version: '2.0';
+    routeKey: string;
+    rawPath: string;
+    rawQueryString: string;
+    cookies?: string[];
+    headers: Record<string, string>;
+    requestContext: {
+        http: {
+            method: string;
+        };
+        domainName: string;
+    };
+    body?: string;
+    isBase64Encoded: boolean;
+}
+/** API Gateway REST API (v1) event. */
+interface APIGatewayV1Event {
+    httpMethod: string;
+    path: string;
+    queryStringParameters?: Record<string, string> | null;
+    headers?: Record<string, string> | null;
+    body?: string | null;
+    isBase64Encoded: boolean;
+}
+type APIGatewayEvent = APIGatewayV2Event | APIGatewayV1Event;
+interface LambdaResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+    isBase64Encoded: boolean;
+}
+type LambdaHandler = (event: APIGatewayEvent) => Promise<LambdaResponse>;
+/**
+ * Pre-loaded module and HTML for single-file Lambda bundles created by
+ * `hadars export lambda`. Passing this bypasses all runtime file I/O so
+ * the handler works without a `.hadars/` directory on disk.
+ */
+interface LambdaBundled {
+    /** The compiled SSR module — import it statically in your entry shim. */
+    ssrModule: HadarsEntryModule<any>;
+    /**
+     * The contents of `.hadars/static/out.html` — load it as a text string
+     * at build time (esbuild's `--loader:.html=text` does this automatically
+     * when `hadars export lambda` runs).
+     */
+    outHtml: string;
+}
+/**
+ * Creates an AWS Lambda handler from a hadars config.
+ *
+ * Must be called after `hadars build` has produced the `.hadars/` output
+ * directory. The handler is stateless — Lambda can reuse the same instance
+ * across invocations; the SSR module and HTML template are cached in memory
+ * after the first warm invocation.
+ *
+ * Pass a {@link LambdaBundled} object as the second argument when using
+ * `hadars export lambda` to produce a single-file bundle — in that mode all
+ * I/O is eliminated and the handler is fully self-contained.
+ *
+ * @example — standard (file-based) deployment
+ * export const handler = createLambdaHandler(config);
+ *
+ * @example — single-file bundle (generated entry shim)
+ * import * as ssrModule from './.hadars/index.ssr.js';
+ * import outHtml from './.hadars/static/out.html';
+ * export const handler = createLambdaHandler(config, { ssrModule, outHtml });
+ */
+declare function createLambdaHandler(options: HadarsOptions, bundled?: LambdaBundled): LambdaHandler;
+
+export { type APIGatewayEvent, type APIGatewayV1Event, type APIGatewayV2Event, type LambdaBundled, type LambdaHandler, type LambdaResponse, createLambdaHandler };

package/dist/lambda.js

@@ -0,0 +1,499 @@
+import {
+  processSegmentCache
+} from "./chunk-UNQSQIOO.js";
+import {
+  renderToString
+} from "./chunk-F7IIMM3J.js";
+import {
+  createElement
+} from "./chunk-OS3V4CPN.js";
+
+// src/lambda.ts
+import "react";
+import pathMod from "node:path";
+import { pathToFileURL } from "node:url";
+import fs from "node:fs/promises";
+
+// src/utils/proxyHandler.tsx
+var cloneHeaders = (headers) => {
+  return new Headers(headers);
+};
+var getCORSHeaders = (req) => {
+  const origin = req.headers.get("Origin") || "*";
+  return {
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
+    "Access-Control-Allow-Headers": req.headers.get("Access-Control-Request-Headers") || "*",
+    "Access-Control-Allow-Credentials": "true"
+  };
+};
+var createProxyHandler = (options) => {
+  const { proxy, proxyCORS } = options;
+  if (!proxy) {
+    return () => void 0;
+  }
+  if (typeof proxy === "function") {
+    return async (req) => {
+      if (req.method === "OPTIONS" && options.proxyCORS) {
+        return new Response(null, {
+          status: 204,
+          headers: getCORSHeaders(req)
+        });
+      }
+      const res = await proxy(req);
+      if (res && proxyCORS) {
+        const modifiedHeaders = new Headers(res.headers);
+        Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
+          modifiedHeaders.set(key, value);
+        });
+        return new Response(res.body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: modifiedHeaders
+        });
+      }
+      return res || void 0;
+    };
+  }
+  const proxyRules = Object.entries(proxy).sort((a, b) => b[0].length - a[0].length);
+  return async (req) => {
+    for (const [path, target] of proxyRules) {
+      if (req.pathname.startsWith(path)) {
+        if (req.method === "OPTIONS" && proxyCORS) {
+          return new Response(null, {
+            status: 204,
+            headers: getCORSHeaders(req)
+          });
+        }
+        const targetURL = new URL(target);
+        targetURL.pathname = targetURL.pathname.replace(/\/$/, "") + req.pathname.slice(path.length);
+        targetURL.search = req.search;
+        const sendHeaders = cloneHeaders(req.headers);
+        sendHeaders.set("Host", targetURL.host);
+        const hasBody = !["GET", "HEAD"].includes(req.method);
+        const proxyReq = new Request(targetURL.toString(), {
+          method: req.method,
+          headers: sendHeaders,
+          body: hasBody ? req.body : void 0,
+          redirect: "follow",
+          // Node.js (undici) requires duplex:'half' when body is a ReadableStream
+          ...hasBody ? { duplex: "half" } : {}
+        });
+        const res = await fetch(proxyReq);
+        const body = await res.arrayBuffer();
+        const clonedRes = new Headers(res.headers);
+        clonedRes.delete("content-length");
+        clonedRes.delete("content-encoding");
+        if (proxyCORS) {
+          Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
+            clonedRes.set(key, value);
+          });
+        }
+        return new Response(body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: clonedRes
+        });
+      }
+    }
+    return void 0;
+  };
+};
+
+// src/utils/cookies.ts
+var parseCookies = (cookieString) => {
+  const cookies = {};
+  if (!cookieString) {
+    return cookies;
+  }
+  const pairs = cookieString.split(";");
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    if (index > -1) {
+      const key = pair.slice(0, index).trim();
+      const value = pair.slice(index + 1).trim();
+      cookies[key] = decodeURIComponent(value);
+    }
+  }
+  return cookies;
+};
+
+// src/utils/request.tsx
+var parseRequest = (request) => {
+  const url = new URL(request.url);
+  const cookies = request.headers.get("Cookie") || "";
+  const cookieRecord = parseCookies(cookies);
+  return Object.assign(request, { pathname: url.pathname, search: url.search, location: url.pathname + url.search, cookies: cookieRecord });
+};
+
+// src/utils/staticFile.ts
+import { readFile, stat } from "node:fs/promises";
+var MIME = {
+  html: "text/html; charset=utf-8",
+  htm: "text/html; charset=utf-8",
+  css: "text/css",
+  js: "application/javascript",
+  mjs: "application/javascript",
+  cjs: "application/javascript",
+  json: "application/json",
+  map: "application/json",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  txt: "text/plain",
+  xml: "application/xml",
+  pdf: "application/pdf"
+};
+async function tryServeFile(filePath) {
+  try {
+    await stat(filePath);
+  } catch {
+    return null;
+  }
+  try {
+    const data = await readFile(filePath);
+    const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+    const contentType = MIME[ext] ?? "application/octet-stream";
+    return new Response(data.buffer, { headers: { "Content-Type": contentType } });
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/response.tsx
+var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+var escAttr = (s) => s.replace(/[&<>"]/g, (c) => ESC[c] ?? c);
+var escText = (s) => s.replace(/[&<>]/g, (c) => ESC[c] ?? c);
+var ATTR = {
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv",
+  charSet: "charset",
+  crossOrigin: "crossorigin",
+  noModule: "nomodule",
+  referrerPolicy: "referrerpolicy",
+  fetchPriority: "fetchpriority"
+};
+function renderHeadTag(tag, id, opts, selfClose = false) {
+  let attrs = ` id="${escAttr(id)}"`;
+  let inner = "";
+  for (const [k, v] of Object.entries(opts)) {
+    if (k === "key" || k === "children") continue;
+    if (k === "dangerouslySetInnerHTML") {
+      inner = v.__html ?? "";
+      continue;
+    }
+    const attr = ATTR[k] ?? k;
+    if (v === true) attrs += ` ${attr}`;
+    else if (v !== false && v != null) attrs += ` ${attr}="${escAttr(String(v))}"`;
+  }
+  return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
+}
+var getHeadHtml = (seoData) => {
+  let html = `<title>${escText(seoData.title ?? "")}</title>`;
+  for (const [id, opts] of Object.entries(seoData.meta))
+    html += renderHeadTag("meta", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.link))
+    html += renderHeadTag("link", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.style))
+    html += renderHeadTag("style", id, opts);
+  for (const [id, opts] of Object.entries(seoData.script))
+    html += renderHeadTag("script", id, opts);
+  return html;
+};
+var getReactResponse = async (req, opts) => {
+  const App = opts.document.body;
+  const { getInitProps, getAfterRenderProps, getFinalProps } = opts.document;
+  const context = {
+    head: { title: "Hadars App", meta: {}, link: {}, style: {}, script: {}, status: 200 }
+  };
+  let props = {
+    ...getInitProps ? await getInitProps(req) : {},
+    location: req.location,
+    context
+  };
+  const unsuspend = { cache: /* @__PURE__ */ new Map() };
+  globalThis.__hadarsUnsuspend = unsuspend;
+  let bodyHtml;
+  try {
+    bodyHtml = await renderToString(createElement(App, props));
+    if (getAfterRenderProps) {
+      props = await getAfterRenderProps(props, bodyHtml);
+      bodyHtml = await renderToString(
+        createElement(App, { ...props, location: req.location, context })
+      );
+    }
+  } finally {
+    globalThis.__hadarsUnsuspend = null;
+  }
+  const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
+  const serverData = {};
+  for (const [key, entry] of unsuspend.cache) {
+    if (entry.status === "fulfilled") serverData[key] = entry.value;
+  }
+  const clientProps = {
+    ...restProps,
+    location: req.location,
+    ...Object.keys(serverData).length > 0 ? { __serverData: serverData } : {}
+  };
+  return {
+    bodyHtml: processSegmentCache(bodyHtml),
+    clientProps,
+    status: context.head.status,
+    headHtml: getHeadHtml(context.head)
+  };
+};
+
+// src/utils/ssrHandler.ts
+var HEAD_MARKER = '<meta name="HADARS_HEAD">';
+var BODY_MARKER = '<meta name="HADARS_BODY">';
+var encoder = new TextEncoder();
+async function buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml) {
+  const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
+  const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
+  return precontentHtml + `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` + postContent;
+}
+var makePrecontentHtmlGetter = (htmlFilePromise) => {
+  let preHead = null;
+  let postHead = null;
+  let postContent = null;
+  return async (headHtml) => {
+    if (preHead === null || postHead === null || postContent === null) {
+      const html = await htmlFilePromise;
+      const headEnd = html.indexOf(HEAD_MARKER);
+      const contentStart = html.indexOf(BODY_MARKER);
+      preHead = html.slice(0, headEnd);
+      postHead = html.slice(headEnd + HEAD_MARKER.length, contentStart);
+      postContent = html.slice(contentStart + BODY_MARKER.length);
+    }
+    return [preHead + headHtml + postHead, postContent];
+  };
+};
+async function transformStream(data, stream) {
+  const writer = stream.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+var gzipCompress = (d) => transformStream(d, new globalThis.CompressionStream("gzip"));
+var gzipDecompress = (d) => transformStream(d, new globalThis.DecompressionStream("gzip"));
+async function buildCacheEntry(res, ttl) {
+  const buf = await res.arrayBuffer();
+  const body = await gzipCompress(new Uint8Array(buf));
+  const headers = [];
+  res.headers.forEach((v, k) => {
+    if (k.toLowerCase() !== "content-encoding" && k.toLowerCase() !== "content-length") {
+      headers.push([k, v]);
+    }
+  });
+  headers.push(["content-encoding", "gzip"]);
+  return { body, status: res.status, headers, expiresAt: ttl != null ? Date.now() + ttl : null };
+}
+async function serveFromEntry(entry, req) {
+  const accept = req.headers.get("Accept-Encoding") ?? "";
+  if (accept.includes("gzip")) {
+    return new Response(entry.body.buffer, { status: entry.status, headers: entry.headers });
+  }
+  const plain = await gzipDecompress(entry.body);
+  const headers = entry.headers.filter(([k]) => k.toLowerCase() !== "content-encoding");
+  return new Response(plain.buffer, { status: entry.status, headers });
+}
+function createRenderCache(opts, handler) {
+  const store = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  return async (req, ctx) => {
+    const hadarsReq = parseRequest(req);
+    const cacheOpts = await opts(hadarsReq);
+    const key = cacheOpts?.key ?? null;
+    if (key != null) {
+      const entry = store.get(key);
+      if (entry) {
+        const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
+        if (!expired) return serveFromEntry(entry, req);
+        store.delete(key);
+      }
+      let flight = inFlight.get(key);
+      if (!flight) {
+        const ttl = cacheOpts?.ttl;
+        flight = handler(new Request(req), ctx).then(async (res) => {
+          if (!res || res.status < 200 || res.status >= 300 || res.headers.has("set-cookie")) {
+            return null;
+          }
+          const newEntry2 = await buildCacheEntry(res, ttl);
+          store.set(key, newEntry2);
+          return newEntry2;
+        }).catch(() => null).finally(() => inFlight.delete(key));
+        inFlight.set(key, flight);
+      }
+      const newEntry = await flight;
+      if (newEntry) return serveFromEntry(newEntry, req);
+    }
+    return handler(req, ctx);
+  };
+}
+
+// src/lambda.ts
+function eventToRequest(event) {
+  let method;
+  let path;
+  let queryString;
+  let headers;
+  let rawBody;
+  let isBase64;
+  let host;
+  if ("version" in event && event.version === "2.0") {
+    method = event.requestContext.http.method;
+    path = event.rawPath;
+    queryString = event.rawQueryString;
+    headers = { ...event.headers };
+    if (event.cookies?.length) headers["cookie"] = event.cookies.join("; ");
+    rawBody = event.body;
+    isBase64 = event.isBase64Encoded;
+    host = event.requestContext.domainName;
+  } else {
+    const e = event;
+    method = e.httpMethod;
+    path = e.path;
+    const qs = e.queryStringParameters;
+    queryString = qs ? new URLSearchParams(qs).toString() : "";
+    headers = e.headers ?? {};
+    rawBody = e.body;
+    isBase64 = e.isBase64Encoded;
+    host = headers["host"] ?? "lambda";
+  }
+  const url = `https://${host}${path}${queryString ? "?" + queryString : ""}`;
+  let body;
+  if (rawBody) body = isBase64 ? Buffer.from(rawBody, "base64") : rawBody;
+  return new Request(url, {
+    method,
+    headers,
+    body: ["GET", "HEAD"].includes(method) ? void 0 : body
+  });
+}
+var TEXT_RE = /\b(?:text\/|application\/(?:json|javascript|xml)|image\/svg\+xml)/;
+async function responseToLambda(response) {
+  const headers = {};
+  response.headers.forEach((v, k) => {
+    headers[k] = v;
+  });
+  const contentType = response.headers.get("Content-Type") ?? "";
+  if (TEXT_RE.test(contentType)) {
+    return {
+      statusCode: response.status,
+      headers,
+      body: await response.text(),
+      isBase64Encoded: false
+    };
+  }
+  return {
+    statusCode: response.status,
+    headers,
+    body: Buffer.from(await response.arrayBuffer()).toString("base64"),
+    isBase64Encoded: true
+  };
+}
+var HadarsFolder = "./.hadars";
+var StaticPath = `${HadarsFolder}/static`;
+var SSR_FILENAME = "index.ssr.js";
+var noopCtx = { upgrade: () => false };
+function createLambdaHandler(options, bundled) {
+  const cwd = process.cwd();
+  const fetchHandler = options.fetch;
+  const handleProxy = createProxyHandler(options);
+  const getPrecontentHtml = bundled ? makePrecontentHtmlGetter(Promise.resolve(bundled.outHtml)) : makePrecontentHtmlGetter(fs.readFile(pathMod.join(cwd, StaticPath, "out.html"), "utf-8"));
+  let ssrModulePromise = null;
+  const getSsrModule = () => {
+    if (bundled) return Promise.resolve(bundled.ssrModule);
+    if (!ssrModulePromise) {
+      ssrModulePromise = import(pathToFileURL(pathMod.resolve(cwd, HadarsFolder, SSR_FILENAME)).href);
+    }
+    return ssrModulePromise;
+  };
+  const runHandler = async (req) => {
+    const request = parseRequest(req);
+    if (fetchHandler) {
+      const res = await fetchHandler(request);
+      if (res) return res;
+    }
+    const proxied = await handleProxy(request);
+    if (proxied) return proxied;
+    const urlPath = new URL(request.url).pathname;
+    if (!bundled) {
+      const staticRes = await tryServeFile(pathMod.join(cwd, StaticPath, urlPath));
+      if (staticRes) return staticRes;
+      const projectStaticPath = pathMod.resolve(cwd, "static");
+      const projectRes = await tryServeFile(pathMod.join(projectStaticPath, urlPath));
+      if (projectRes) return projectRes;
+      const routeClean = urlPath.replace(/(^\/|\/$)/g, "");
+      if (routeClean) {
+        const routeRes = await tryServeFile(
+          pathMod.join(cwd, StaticPath, routeClean, "index.html")
+        );
+        if (routeRes) return routeRes;
+      }
+    }
+    try {
+      const {
+        default: Component,
+        getInitProps,
+        getAfterRenderProps,
+        getFinalProps
+      } = await getSsrModule();
+      const { bodyHtml, clientProps, status, headHtml } = await getReactResponse(request, {
+        document: {
+          body: Component,
+          lang: "en",
+          getInitProps,
+          getAfterRenderProps,
+          getFinalProps
+        }
+      });
+      if (request.headers.get("Accept") === "application/json") {
+        const serverData = clientProps.__serverData ?? {};
+        return new Response(JSON.stringify({ serverData }), {
+          status,
+          headers: { "Content-Type": "application/json; charset=utf-8" }
+        });
+      }
+      const html = await buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml);
+      return new Response(html, {
+        status,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } catch (err) {
+      console.error("[hadars] SSR render error:", err);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  };
+  const finalHandler = options.cache ? createRenderCache(options.cache, (req) => runHandler(req)) : (req) => runHandler(req);
+  return async (event) => {
+    const req = eventToRequest(event);
+    const response = await finalHandler(req, noopCtx) ?? new Response("Not Found", { status: 404 });
+    return responseToLambda(response);
+  };
+}
+export {
+  createLambdaHandler
+};