@nextlytics/core 0.3.0 → 0.3.1

package/dist/middleware.js

@@ -25,29 +25,7 @@ var import_server = require("next/server");
 var import_server_component_context = require("./server-component-context");
 var import_uitils = require("./uitils");
 var import_anonymous_user = require("./anonymous-user");
-function isBackendWithConfig(entry) {
-  return typeof entry === "object" && entry !== null && "backend" in entry;
-}
-function resolveBackends(config, ctx) {
-  const entries = config.backends || [];
-  return entries.map((entry) => {
-    if (isBackendWithConfig(entry)) {
-      const backend2 = typeof entry.backend === "function" ? entry.backend(ctx) : entry.backend;
-      return backend2 ? { backend: backend2, ingestPolicy: entry.ingestPolicy ?? "immediate" } : null;
-    }
-    const backend = typeof entry === "function" ? entry(ctx) : entry;
-    return backend ? { backend, ingestPolicy: "immediate" } : null;
-  }).filter((b) => b !== null);
-}
-function collectTemplates(backends) {
-  const templates = {};
-  for (const { backend } of backends) {
-    if (backend.getClientSideTemplates) {
-      Object.assign(templates, backend.getClientSideTemplates());
-    }
-  }
-  return templates;
-}
+var import_api_handler = require("./api-handler");
 function createRequestContext(request) {
   return {
     headers: request.headers,
@@ -59,29 +37,57 @@ function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
   return async (request) => {
     const pathname = request.nextUrl.pathname;
     const reqInfo = (0, import_uitils.getRequestInfo)(request);
+    const middlewareDebug = config.debug || process.env.NEXTLYTICS_MIDDLEWARE_DEBUG === "true";
+    if (middlewareDebug) {
+      const headers = request.headers;
+      const debugHeaders = {};
+      headers.forEach((value, key) => {
+        debugHeaders[key] = value;
+      });
+      console.log("[Nextlytics][middleware]", {
+        url: request.url,
+        pathname,
+        search: request.nextUrl.search,
+        method: request.method,
+        nextVersion: (0, import_uitils.getNextVersion)(),
+        destination: request.destination,
+        referrer: request.referrer,
+        mode: request.mode,
+        cache: request.cache,
+        redirect: request.redirect,
+        integrity: request.integrity,
+        isPrefetch: reqInfo.isPrefetch,
+        isRsc: reqInfo.isRsc,
+        isPageNavigation: reqInfo.isPageNavigation,
+        isStaticFile: reqInfo.isStaticFile,
+        isNextjsInternal: reqInfo.isNextjsInternal,
+        headers: debugHeaders
+      });
+    }
     if (pathname === eventEndpoint) {
       if (request.method === "POST") {
-        return handleEventPost(request, config, dispatchEvent, updateEvent);
+        return (0, import_api_handler.handleEventPost)(request, config, dispatchEvent, updateEvent);
       }
       return Response.json({ error: "Method not allowed" }, { status: 405 });
     }
     if (reqInfo.isNextjsInternal || reqInfo.isPrefetch || reqInfo.isStaticFile) {
       return import_server.NextResponse.next();
     }
+    if (!reqInfo.isPageNavigation && !config.isApiPath(pathname)) {
+      return import_server.NextResponse.next();
+    }
     const pageRenderId = (0, import_uitils.generateId)();
     const serverContext = (0, import_uitils.createServerContext)(request);
     const response = import_server.NextResponse.next();
     const ctx = createRequestContext(request);
+    response.cookies.set(import_server_component_context.LAST_PAGE_RENDER_ID_COOKIE, pageRenderId, { path: "/" });
     const { anonId } = await (0, import_anonymous_user.resolveAnonymousUser)({ ctx, serverContext, config, response });
-    const backends = resolveBackends(config, ctx);
-    const templates = collectTemplates(backends);
     if (config.excludePaths?.(pathname)) {
       (0, import_server_component_context.serializeServerComponentContext)(response, {
         pageRenderId,
         pathname: request.nextUrl.pathname,
         search: request.nextUrl.search,
-        scripts: [],
-        templates
+        scripts: []
       });
       return response;
     }
@@ -91,12 +97,11 @@ function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
         pageRenderId,
         pathname: request.nextUrl.pathname,
         search: request.nextUrl.search,
-        scripts: [],
-        templates
+        scripts: []
       });
       return response;
     }
-    const userContext = await getUserContext(config, ctx);
+    const userContext = await (0, import_api_handler.getUserContext)(config, ctx);
     const pageViewEvent = createPageViewEvent(
       pageRenderId,
       serverContext,
@@ -104,7 +109,7 @@ function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
       userContext,
       anonId
     );
-    const { clientActions, completion } = dispatchEvent(pageViewEvent, ctx, "immediate");
+    const { clientActions, completion } = dispatchEvent(pageViewEvent, ctx, "on-request");
     const actions = await clientActions;
     const scripts = actions.items.filter(
       (i) => i.type === "script-template"
@@ -114,8 +119,7 @@ function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
       pageRenderId,
       pathname: request.nextUrl.pathname,
       search: request.nextUrl.search,
-      scripts,
-      templates
+      scripts
     });
     return response;
   };
@@ -123,6 +127,7 @@ function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
 function createPageViewEvent(pageRenderId, serverContext, isApiPath, userContext, anonymousUserId) {
   const eventType = isApiPath ? "apiCall" : "pageView";
   return {
+    origin: "server",
     collectedAt: serverContext.collectedAt.toISOString(),
     eventId: pageRenderId,
     type: eventType,
@@ -132,99 +137,6 @@ function createPageViewEvent(pageRenderId, serverContext, isApiPath, userContext
     properties: {}
   };
 }
-async function getUserContext(config, ctx) {
-  if (!config.callbacks.getUser) return void 0;
-  try {
-    return await config.callbacks.getUser(ctx) || void 0;
-  } catch {
-    return void 0;
-  }
-}
-function reconstructServerContext(apiCallContext, clientInit) {
-  const searchParams = {};
-  if (clientInit.search) {
-    const params = new URLSearchParams(clientInit.search);
-    params.forEach((value, key) => {
-      if (!searchParams[key]) searchParams[key] = [];
-      searchParams[key].push(value);
-    });
-  }
-  return {
-    ...apiCallContext,
-    // Override with client-provided values
-    host: clientInit.host || apiCallContext.host,
-    path: clientInit.path || apiCallContext.path,
-    search: Object.keys(searchParams).length > 0 ? searchParams : apiCallContext.search,
-    method: "GET"
-    // Page loads are always GET
-  };
-}
-async function handleEventPost(request, config, dispatchEvent, updateEvent) {
-  const pageRenderId = request.headers.get(import_server_component_context.headers.pageRenderId);
-  if (!pageRenderId) {
-    return Response.json({ error: "Missing page render ID" }, { status: 400 });
-  }
-  let body;
-  try {
-    body = await request.json();
-  } catch {
-    return Response.json({ error: "Invalid JSON" }, { status: 400 });
-  }
-  const { type, payload } = body;
-  const ctx = createRequestContext(request);
-  const apiCallServerContext = (0, import_uitils.createServerContext)(request);
-  const userContext = await getUserContext(config, ctx);
-  if (type === "client-init") {
-    const clientContext = payload;
-    const serverContext = reconstructServerContext(apiCallServerContext, clientContext);
-    const { anonId: anonymousUserId } = await (0, import_anonymous_user.resolveAnonymousUser)({
-      ctx,
-      serverContext,
-      config
-    });
-    const event = {
-      eventId: pageRenderId,
-      type: "pageView",
-      collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      anonymousUserId,
-      serverContext,
-      clientContext,
-      userContext,
-      properties: {}
-    };
-    const { clientActions, completion } = dispatchEvent(event, ctx, "on-client-event");
-    const actions = await clientActions;
-    (0, import_server.after)(() => completion);
-    (0, import_server.after)(() => updateEvent(pageRenderId, { clientContext, userContext, anonymousUserId }, ctx));
-    const scripts = actions.items.filter((i) => i.type === "script-template");
-    return Response.json({ ok: true, scripts: scripts.length > 0 ? scripts : void 0 });
-  } else if (type === "client-event") {
-    const clientContext = payload.clientContext || void 0;
-    const serverContext = clientContext ? reconstructServerContext(apiCallServerContext, clientContext) : apiCallServerContext;
-    const { anonId: anonymousUserId } = await (0, import_anonymous_user.resolveAnonymousUser)({
-      ctx,
-      serverContext,
-      config
-    });
-    const event = {
-      eventId: (0, import_uitils.generateId)(),
-      parentEventId: pageRenderId,
-      type: payload.name || type,
-      collectedAt: payload.collectedAt || (/* @__PURE__ */ new Date()).toISOString(),
-      anonymousUserId,
-      serverContext,
-      clientContext,
-      userContext,
-      properties: payload.props || {}
-    };
-    const { clientActions, completion } = dispatchEvent(event, ctx);
-    const actions = await clientActions;
-    (0, import_server.after)(() => completion);
-    const scripts = actions.items.filter((i) => i.type === "script-template");
-    return Response.json({ ok: true, scripts: scripts.length > 0 ? scripts : void 0 });
-  }
-  return Response.json({ ok: true });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createNextlyticsMiddleware

package/dist/pages-router.d.ts

@@ -5,41 +5,16 @@ import './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
 
-type ContextWithHeaders = {
+type PagesRouterContext = {
     req: {
         headers: Record<string, string | string[] | undefined>;
+        cookies?: Record<string, string>;
     };
 };
 /**
- * Extract Nextlytics context from Pages Router context (getServerSideProps or getInitialProps).
- * Use this in _app.tsx with getInitialProps to pass context to NextlyticsClient.
- *
- * @example
- * ```tsx
- * // pages/_app.tsx
- * import type { AppContext, AppProps } from 'next/app'
- * import { NextlyticsClient, getNextlyticsProps, type NextlyticsContext } from '@nextlytics/core'
- *
- * type MyAppProps = AppProps & { nextlyticsCtx: NextlyticsContext }
- *
- * function MyApp({ Component, pageProps, nextlyticsCtx }: MyAppProps) {
- *   return (
- *     <NextlyticsClient ctx={nextlyticsCtx}>
- *       <Component {...pageProps} />
- *     </NextlyticsClient>
- *   )
- * }
- *
- * MyApp.getInitialProps = async (appContext: AppContext) => {
- *   return {
- *     pageProps: appContext.Component.getInitialProps
- *       ? await appContext.Component.getInitialProps(appContext.ctx)
- *       : {},
- *     nextlyticsCtx: getNextlyticsProps(appContext.ctx),
- *   }
- * }
- * ```
+ * Get Nextlytics props for Pages Router _app.tsx.
+ * Reads context from headers set by middleware.
  */
-declare function getNextlyticsProps(ctx: ContextWithHeaders): NextlyticsContext;
+declare function getNextlyticsProps(ctx: PagesRouterContext): NextlyticsContext;
 
-export { getNextlyticsProps };
+export { type PagesRouterContext, getNextlyticsProps };

package/dist/pages-router.js

@@ -35,8 +35,7 @@ function getNextlyticsProps(ctx) {
   }
   return {
     requestId: context.pageRenderId,
-    scripts: context.scripts,
-    templates: context.templates
+    scripts: context.scripts
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server-component-context.d.ts

@@ -1,14 +1,15 @@
 import { NextResponse } from 'next/server';
-import { TemplatizedScriptInsertion, JavascriptTemplate } from './types.js';
+import { TemplatizedScriptInsertion } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 
-declare const headerKeys: {
-    readonly pathname: "x-nc-pathname";
-    readonly search: "x-nc-search";
-    readonly pageRenderId: "x-nc-page-render-id";
-    readonly scripts: "x-nc-scripts";
-    readonly templates: "x-nc-templates";
+declare const headerNames: {
+    readonly pathname: "x-nl-pathname";
+    readonly search: "x-nl-search";
+    readonly pageRenderId: "x-nl-page-render-id";
+    readonly isSoftNavigation: "x-nl-is-soft-nav";
+    readonly scripts: "x-nl-scripts";
 };
+declare const LAST_PAGE_RENDER_ID_COOKIE = "last-page-render-id";
 /** Context passed from middleware to server components via headers */
 type ServerComponentContext = {
     /** Unique page render ID (event ID) */
@@ -17,14 +18,12 @@ type ServerComponentContext = {
     pathname: string;
     /** Query string */
     search: string;
-    /** Script actions to execute on client */
+    /** Script actions to execute on client (params only, templates come from config) */
     scripts: TemplatizedScriptInsertion<unknown>[];
-    /** Template definitions for scripts */
-    templates: Record<string, JavascriptTemplate>;
 };
 /** Serialize context to response headers (called in middleware) */
 declare function serializeServerComponentContext(response: NextResponse, ctx: ServerComponentContext): void;
 /** Restore context from request headers (called in server components) */
 declare function restoreServerComponentContext(headersList: Headers): ServerComponentContext | null;
 
-export { type ServerComponentContext, headerKeys as headers, restoreServerComponentContext, serializeServerComponentContext };
+export { LAST_PAGE_RENDER_ID_COOKIE, type ServerComponentContext, headerNames, restoreServerComponentContext, serializeServerComponentContext };

package/dist/server-component-context.js

@@ -18,32 +18,31 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_component_context_exports = {};
 __export(server_component_context_exports, {
-  headers: () => headerKeys,
+  LAST_PAGE_RENDER_ID_COOKIE: () => LAST_PAGE_RENDER_ID_COOKIE,
+  headerNames: () => headerNames,
   restoreServerComponentContext: () => restoreServerComponentContext,
   serializeServerComponentContext: () => serializeServerComponentContext
 });
 module.exports = __toCommonJS(server_component_context_exports);
-const HEADER_PREFIX = "x-nc-";
-const headerKeys = {
+const HEADER_PREFIX = "x-nl-";
+const headerNames = {
   pathname: `${HEADER_PREFIX}pathname`,
   search: `${HEADER_PREFIX}search`,
   pageRenderId: `${HEADER_PREFIX}page-render-id`,
-  scripts: `${HEADER_PREFIX}scripts`,
-  templates: `${HEADER_PREFIX}templates`
+  isSoftNavigation: `${HEADER_PREFIX}is-soft-nav`,
+  scripts: `${HEADER_PREFIX}scripts`
 };
+const LAST_PAGE_RENDER_ID_COOKIE = "last-page-render-id";
 function serializeServerComponentContext(response, ctx) {
-  response.headers.set(headerKeys.pageRenderId, ctx.pageRenderId);
-  response.headers.set(headerKeys.pathname, ctx.pathname);
-  response.headers.set(headerKeys.search, ctx.search);
+  response.headers.set(headerNames.pageRenderId, ctx.pageRenderId);
+  response.headers.set(headerNames.pathname, ctx.pathname);
+  response.headers.set(headerNames.search, ctx.search);
   if (ctx.scripts.length > 0) {
     const scriptParts = ctx.scripts.filter((item) => item.type === "script-template").map((s) => `${s.templateId}=${JSON.stringify(s.params)}`);
     if (scriptParts.length > 0) {
-      response.headers.set(headerKeys.scripts, scriptParts.join(";"));
+      response.headers.set(headerNames.scripts, scriptParts.join(";"));
     }
   }
-  if (Object.keys(ctx.templates).length > 0) {
-    response.headers.set(headerKeys.templates, JSON.stringify(ctx.templates));
-  }
 }
 function parseScriptsHeader(header) {
   const scripts = [];
@@ -62,34 +61,25 @@ function parseScriptsHeader(header) {
   return scripts;
 }
 function restoreServerComponentContext(headersList) {
-  const pageRenderId = headersList.get(headerKeys.pageRenderId);
+  const pageRenderId = headersList.get(headerNames.pageRenderId);
   if (!pageRenderId) {
     return null;
   }
-  const pathname = headersList.get(headerKeys.pathname) || "";
-  const search = headersList.get(headerKeys.search) || "";
-  const scriptsHeader = headersList.get(headerKeys.scripts);
+  const pathname = headersList.get(headerNames.pathname) || "";
+  const search = headersList.get(headerNames.search) || "";
+  const scriptsHeader = headersList.get(headerNames.scripts);
   const scripts = scriptsHeader ? parseScriptsHeader(scriptsHeader) : [];
-  let templates = {};
-  const templatesHeader = headersList.get(headerKeys.templates);
-  if (templatesHeader) {
-    try {
-      templates = JSON.parse(templatesHeader);
-    } catch {
-      console.warn("[Nextlytics] Failed to parse templates header");
-    }
-  }
   return {
     pageRenderId,
     pathname,
     search,
-    scripts,
-    templates
+    scripts
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  headers,
+  LAST_PAGE_RENDER_ID_COOKIE,
+  headerNames,
   restoreServerComponentContext,
   serializeServerComponentContext
 });

package/dist/server.d.ts

@@ -1,13 +1,8 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
 import { NextlyticsConfig, NextlyticsResult, RequestContext } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
 
 declare function createRequestContext(): Promise<RequestContext>;
-declare function NextlyticsServer({ children }: {
-    children: ReactNode;
-}): Promise<react_jsx_runtime.JSX.Element>;
 declare function Nextlytics(userConfig: NextlyticsConfig): NextlyticsResult;
 
-export { Nextlytics, NextlyticsServer, createRequestContext };
+export { Nextlytics, createRequestContext };

package/dist/server.js

@@ -19,7 +19,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   Nextlytics: () => Nextlytics,
-  NextlyticsServer: () => NextlyticsServer,
   createRequestContext: () => createRequestContext
 });
 module.exports = __toCommonJS(server_exports);
@@ -29,7 +28,6 @@ var import_headers2 = require("./headers");
 var import_server_component_context = require("./server-component-context");
 var import_anonymous_user = require("./anonymous-user");
 var import_client = require("./client");
-var import_handlers = require("./handlers");
 var import_config_helpers = require("./config-helpers");
 var import_middleware = require("./middleware");
 var import_uitils = require("./uitils");
@@ -41,11 +39,17 @@ function resolveBackends(config, ctx, policyFilter) {
   return entries.map((entry) => {
     if (isBackendWithConfig(entry)) {
       const backend2 = typeof entry.backend === "function" ? entry.backend(ctx) : entry.backend;
-      return backend2 ? { backend: backend2, ingestPolicy: entry.ingestPolicy ?? "immediate" } : null;
+      return backend2 ? { backend: backend2, pageViewDelivery: entry.pageViewDelivery ?? "on-request" } : null;
     }
     const backend = typeof entry === "function" ? entry(ctx) : entry;
-    return backend ? { backend, ingestPolicy: "immediate" } : null;
-  }).filter((b) => b !== null).filter((b) => !policyFilter || b.ingestPolicy === policyFilter);
+    return backend ? { backend, pageViewDelivery: "on-request" } : null;
+  }).filter((b) => b !== null).filter((b) => {
+    if (!policyFilter) return true;
+    if (policyFilter === "client-actions") {
+      return b.pageViewDelivery === "on-page-load" || b.backend.returnsClientActions;
+    }
+    return b.pageViewDelivery === policyFilter;
+  });
 }
 function resolvePlugins(config, ctx) {
   const plugins = config.plugins || [];
@@ -75,16 +79,15 @@ async function createRequestContext() {
     headers: _headers
   };
 }
-async function NextlyticsServer({ children }) {
-  const headersList = await (0, import_headers.headers)();
-  const ctx = (0, import_server_component_context.restoreServerComponentContext)(headersList);
-  if (!ctx) {
-    console.warn(
-      "[Nextlytics] nextlyticsMiddleware should be added in order for NextlyticsServer to work"
-    );
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+function collectTemplates(config, ctx) {
+  const templates = {};
+  const backends = resolveBackends(config, ctx);
+  for (const { backend } of backends) {
+    if (backend.getClientSideTemplates) {
+      Object.assign(templates, backend.getClientSideTemplates());
+    }
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_client.NextlyticsClient, { requestId: ctx.pageRenderId, scripts: ctx.scripts, templates: ctx.templates, children });
+  return templates;
 }
 function Nextlytics(userConfig) {
   const config = (0, import_config_helpers.withDefaults)(userConfig);
@@ -136,7 +139,7 @@ function Nextlytics(userConfig) {
     return { clientActions, completion };
   };
   const updateEventInternal = async (eventId, patch, ctx) => {
-    const resolved = resolveBackends(config, ctx, "immediate").filter(
+    const resolved = resolveBackends(config, ctx, "on-request").filter(
       ({ backend }) => backend.supportsUpdates
     );
     const results = await Promise.all(
@@ -170,11 +173,21 @@ function Nextlytics(userConfig) {
     return updateEventInternal(eventId, patch, ctx);
   };
   const middleware = (0, import_middleware.createNextlyticsMiddleware)(config, dispatchEventInternal, updateEventInternal);
-  const handlers = (0, import_handlers.createHandlers)();
+  async function Server({ children }) {
+    const headersList = await (0, import_headers.headers)();
+    const ctx = (0, import_server_component_context.restoreServerComponentContext)(headersList);
+    if (!ctx) {
+      console.warn("[Nextlytics] nextlyticsMiddleware should be added in order for Server to work");
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+    }
+    const requestCtx = await createRequestContext();
+    const templates = collectTemplates(config, requestCtx);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_client.NextlyticsClient, { ctx: { requestId: ctx.pageRenderId, scripts: ctx.scripts, templates }, children });
+  }
   const analytics = async () => {
     const headersList = await (0, import_headers.headers)();
     const cookieStore = await (0, import_headers.cookies)();
-    const pageRenderId = headersList.get(import_server_component_context.headers.pageRenderId);
+    const pageRenderId = headersList.get(import_server_component_context.headerNames.pageRenderId);
     const serverContext = createServerContextFromHeaders(headersList);
     const ctx = { headers: headersList, cookies: cookieStore };
     const { anonId: anonymousUserId } = await (0, import_anonymous_user.resolveAnonymousUser)({ ctx, serverContext, config });
@@ -192,6 +205,7 @@ function Nextlytics(userConfig) {
           return { ok: false };
         }
         const event = {
+          origin: "server",
           eventId: (0, import_uitils.generateId)(),
           parentEventId: pageRenderId,
           type: eventName,
@@ -206,7 +220,13 @@ function Nextlytics(userConfig) {
       }
     };
   };
-  return { middleware, handlers, analytics, dispatchEvent, updateEvent };
+  return {
+    middleware,
+    analytics,
+    dispatchEvent,
+    updateEvent,
+    NextlyticsServer: Server
+  };
 }
 function createServerContextFromHeaders(headersList) {
   const rawHeaders = {};
@@ -214,8 +234,8 @@ function createServerContextFromHeaders(headersList) {
     rawHeaders[key] = value;
   });
   const requestHeaders = (0, import_headers2.removeSensitiveHeaders)(rawHeaders);
-  const pathname = headersList.get(import_server_component_context.headers.pathname) || "";
-  const search = headersList.get(import_server_component_context.headers.search) || "";
+  const pathname = headersList.get(import_server_component_context.headerNames.pathname) || "";
+  const search = headersList.get(import_server_component_context.headerNames.search) || "";
   const searchParams = {};
   if (search) {
     const params = new URLSearchParams(search);
@@ -240,6 +260,5 @@ function createServerContextFromHeaders(headersList) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Nextlytics,
-  NextlyticsServer,
   createRequestContext
 });

package/dist/stable-hash.d.ts

@@ -0,0 +1,6 @@
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+declare function stableHash(value: JsonValue): string;
+
+export { type JsonValue, stableHash };

package/dist/stable-hash.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stable_hash_exports = {};
+__export(stable_hash_exports, {
+  stableHash: () => stableHash
+});
+module.exports = __toCommonJS(stable_hash_exports);
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+function stableStringify(value, seen) {
+  if (value === null) return "null";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (valueType === "boolean") return value ? "true" : "false";
+  if (valueType === "bigint") {
+    throw new TypeError("Do not know how to serialize a BigInt");
+  }
+  if (valueType === "undefined" || valueType === "function" || valueType === "symbol") {
+    return void 0;
+  }
+  if (typeof value.toJSON === "function") {
+    return stableStringify(value.toJSON(), seen);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => stableStringify(item, seen) ?? "null");
+    return `[${items.join(",")}]`;
+  }
+  const obj = value;
+  if (seen.has(obj)) {
+    throw new TypeError("Converting circular structure to JSON");
+  }
+  seen.add(obj);
+  const keys = Object.keys(obj).sort();
+  const parts = [];
+  for (const key of keys) {
+    const next = stableStringify(obj[key], seen);
+    if (next !== void 0) {
+      parts.push(`${JSON.stringify(key)}:${next}`);
+    }
+  }
+  seen.delete(obj);
+  return `{${parts.join(",")}}`;
+}
+function fnv1aHash(input) {
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, FNV_PRIME) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function stableHash(value) {
+  const stable = stableStringify(value, /* @__PURE__ */ new WeakSet()) ?? "null";
+  return fnv1aHash(stable);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stableHash
+});