@nextlytics/core 0.4.1 → 0.4.2-canary.106

package/dist/anonymous-user.d.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server';
 import { RequestContext, ServerEventContext, NextlyticsConfig, AnonymousUserResult } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
+import 'next';
 
 type ResolveAnonymousUserParams = {
     ctx: RequestContext;

package/dist/api-handler.d.ts

@@ -1,12 +1,15 @@
 import { NextRequest } from 'next/server';
-import { NextlyticsEvent, RequestContext, PageViewDelivery, DispatchResult, UserContext } from './types.js';
+import { RequestContext, JavascriptTemplate, NextlyticsEvent, PageViewDelivery, DispatchResult, UserContext } from './types.js';
 import { NextlyticsConfigWithDefaults } from './config-helpers.js';
 import 'next/dist/server/web/spec-extension/cookies';
+import 'next';
 
 type DispatchEvent = (event: NextlyticsEvent, ctx: RequestContext, policyFilter?: PageViewDelivery | "client-actions") => DispatchResult;
 type UpdateEvent = (eventId: string, patch: Partial<NextlyticsEvent>, ctx: RequestContext) => Promise<void>;
+/** Collect the client-side templates from the configured backends. */
+type CollectTemplates = (ctx: RequestContext) => Record<string, JavascriptTemplate>;
 declare function getUserContext(config: NextlyticsConfigWithDefaults, ctx: RequestContext): Promise<UserContext | undefined>;
 declare function getEventProps(config: NextlyticsConfigWithDefaults, ctx: RequestContext, userContext?: UserContext): Promise<Record<string, unknown> | undefined>;
-declare function handleEventPost(request: NextRequest, config: NextlyticsConfigWithDefaults, dispatchEvent: DispatchEvent, updateEvent: UpdateEvent): Promise<Response>;
+declare function handleEventPost(request: NextRequest, config: NextlyticsConfigWithDefaults, dispatchEvent: DispatchEvent, updateEvent: UpdateEvent, collectTemplates: CollectTemplates): Promise<Response>;
 
-export { type DispatchEvent, type UpdateEvent, getEventProps, getUserContext, handleEventPost };
+export { type CollectTemplates, type DispatchEvent, type UpdateEvent, getEventProps, getUserContext, handleEventPost };

package/dist/api-handler.js

@@ -27,6 +27,14 @@ 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 newTemplatesFor(hctx) {
+  const all = hctx.collectTemplates(hctx.ctx);
+  const missing = {};
+  for (const [id, template] of Object.entries(all)) {
+    if (!hctx.knownTemplateIds.has(id)) missing[id] = template;
+  }
+  return Object.keys(missing).length > 0 ? missing : void 0;
+}
 function createRequestContext(request) {
   return {
     headers: request.headers,
@@ -110,13 +118,14 @@ async function handleClientInit(request, hctx) {
     (0, import_server.after)(() => completion2);
     return Response.json({
       ok: true,
-      items: filterScripts(actions)
+      items: filterScripts(actions),
+      templates: newTemplatesFor(hctx)
     });
   }
   const { completion } = dispatchEvent(event, ctx, "client-actions");
   (0, import_server.after)(() => completion);
   (0, import_server.after)(() => updateEvent(pageRenderId, { clientContext, userContext, anonymousUserId }, ctx));
-  return Response.json({ ok: true });
+  return Response.json({ ok: true, templates: newTemplatesFor(hctx) });
 }
 async function handleClientEvent(request, hctx) {
   const { pageRenderId, ctx, apiCallServerContext, userContext, config, dispatchEvent } = hctx;
@@ -144,9 +153,13 @@ async function handleClientEvent(request, hctx) {
   const { clientActions, completion } = dispatchEvent(event, ctx);
   const actions = await clientActions;
   (0, import_server.after)(() => completion);
-  return Response.json({ ok: true, items: filterScripts(actions) });
+  return Response.json({
+    ok: true,
+    items: filterScripts(actions),
+    templates: newTemplatesFor(hctx)
+  });
 }
-async function handleEventPost(request, config, dispatchEvent, updateEvent) {
+async function handleEventPost(request, config, dispatchEvent, updateEvent, collectTemplates) {
   const softNavHeader = request.headers.get(import_server_component_context.headerNames.isSoftNavigation);
   const isSoftNavigation = softNavHeader === "1";
   const pageRenderIdHeader = request.headers.get(import_server_component_context.headerNames.pageRenderId);
@@ -162,6 +175,10 @@ async function handleEventPost(request, config, dispatchEvent, updateEvent) {
   const ctx = createRequestContext(request);
   const apiCallServerContext = (0, import_uitils.createServerContext)(request);
   const userContext = await getUserContext(config, ctx);
+  const knownTemplatesHeader = request.headers.get(import_server_component_context.headerNames.knownTemplates);
+  const knownTemplateIds = new Set(
+    knownTemplatesHeader ? knownTemplatesHeader.split(",").map((id) => id.trim()).filter(Boolean) : []
+  );
   const cookiePageRenderId = request.cookies.get(import_server_component_context.LAST_PAGE_RENDER_ID_COOKIE)?.value;
   const pageRenderId = isSoftNavigation ? cookiePageRenderId ?? (0, import_uitils.generateId)() : pageRenderIdHeader;
   if (isSoftNavigation && !cookiePageRenderId && config.debug) {
@@ -177,7 +194,9 @@ async function handleEventPost(request, config, dispatchEvent, updateEvent) {
     userContext,
     config,
     dispatchEvent,
-    updateEvent
+    updateEvent,
+    collectTemplates,
+    knownTemplateIds
   };
   const bodyType = body.type;
   switch (bodyType) {

package/dist/backends/clickhouse.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsBackend } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 /**
  * ClickHouse backend for Nextlytics

package/dist/backends/ga.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsBackendFactory } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 type GoogleAnalyticsBackendOptions = {
     /** GA4 Measurement ID (e.g. "G-XXXXXXXXXX") */

package/dist/backends/gtm.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsBackend } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 type GoogleTagManagerBackendOptions = {
     /** GTM Container ID (e.g. "GTM-XXXXXXX") */

package/dist/backends/lib/db.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsEvent, ClientContext, ServerEventContext } from '../../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 declare const tableColumns: readonly [{
     readonly name: "timestamp";

package/dist/backends/logging.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsBackend } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 declare function loggingBackend(): NextlyticsBackend;
 

package/dist/backends/neon.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsBackend } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 type NeonBackendConfig = {
     databaseUrl: string;

package/dist/backends/postgrest.d.ts

@@ -2,6 +2,7 @@ import { NextlyticsBackend } from '../types.js';
 export { AnalyticsEventRow, generatePgCreateTableSQL } from './lib/db.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 /**
  * PostgREST backend for Nextlytics

package/dist/backends/posthog.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsBackend } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 type PosthogBackendOptions = {
     /** PostHog project API key */

package/dist/backends/segment.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsBackend } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 /**
  * Segment backend for Nextlytics

package/dist/client.d.ts

@@ -3,6 +3,7 @@ import { ReactNode } from 'react';
 import { TemplatizedScriptInsertion, JavascriptTemplate } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 /** Context object for Pages Router integration */
 type NextlyticsContext = {

package/dist/client.js

@@ -153,7 +153,11 @@ function NextlyticsScripts({
   });
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: compiled.map(({ key, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_client_utils.InjectScript, { ...props }, key)) });
 }
-async function sendEventToServer(requestId, request, { signal, isSoftNavigation } = {}) {
+async function sendEventToServer(requestId, request, {
+  signal,
+  isSoftNavigation,
+  knownTemplateIds
+} = {}) {
   try {
     const headers = {
       "Content-Type": "application/json",
@@ -162,6 +166,9 @@ async function sendEventToServer(requestId, request, { signal, isSoftNavigation
     if (isSoftNavigation) {
       headers[import_server_component_context.headerNames.isSoftNavigation] = "1";
     }
+    if (knownTemplateIds?.length) {
+      headers[import_server_component_context.headerNames.knownTemplates] = knownTemplateIds.join(",");
+    }
     const response = await fetch("/api/event", {
       method: "POST",
       headers,
@@ -175,7 +182,7 @@ async function sendEventToServer(requestId, request, { signal, isSoftNavigation
       return { ok: false };
     }
     const data = await response.json().catch(() => ({ ok: response.ok }));
-    return { ok: data.ok ?? response.ok, items: data.items };
+    return { ok: data.ok ?? response.ok, items: data.items, templates: data.templates };
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
       return { ok: false };
@@ -185,9 +192,28 @@ async function sendEventToServer(requestId, request, { signal, isSoftNavigation
   }
 }
 function NextlyticsClient(props) {
-  const { requestId, scripts: initialScripts = [], templates = {} } = props.ctx;
+  const { requestId, scripts: initialScripts = [] } = props.ctx;
   const scriptsRef = (0, import_react.useRef)([]);
   const subscribersRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+  const [templates, setTemplates] = (0, import_react.useState)(
+    () => props.ctx.templates ?? {}
+  );
+  const mergeTemplates = (0, import_react.useCallback)((incoming) => {
+    if (!incoming) return;
+    const keys = Object.keys(incoming);
+    if (keys.length === 0) return;
+    setTemplates((prev) => {
+      const hasNew = keys.some((k) => prev[k] !== incoming[k]);
+      return hasNew ? { ...prev, ...incoming } : prev;
+    });
+  }, []);
+  (0, import_react.useEffect)(() => {
+    mergeTemplates(props.ctx.templates);
+  }, [props.ctx.templates, mergeTemplates]);
+  const knownTemplateIdsRef = (0, import_react.useRef)(Object.keys(props.ctx.templates ?? {}));
+  (0, import_react.useEffect)(() => {
+    knownTemplateIdsRef.current = Object.keys(templates);
+  }, [templates]);
   const addScripts = (0, import_react.useCallback)((newScripts) => {
     (0, import_client_utils.debug)("Adding scripts", {
       newCount: newScripts.length,
@@ -197,8 +223,16 @@ function NextlyticsClient(props) {
     subscribersRef.current.forEach((cb) => cb());
   }, []);
   const contextValue = (0, import_react.useMemo)(
-    () => ({ requestId, templates, addScripts, scriptsRef, subscribersRef }),
-    [requestId, templates, addScripts]
+    () => ({
+      requestId,
+      templates,
+      addScripts,
+      scriptsRef,
+      subscribersRef,
+      mergeTemplates,
+      knownTemplateIdsRef
+    }),
+    [requestId, templates, addScripts, mergeTemplates]
   );
   (0, import_client_utils.useNavigation)(requestId, ({ softNavigation, signal }) => {
     (0, import_client_utils.debug)("Sending page-view", { requestId, softNavigation });
@@ -206,9 +240,10 @@ function NextlyticsClient(props) {
     sendEventToServer(
       requestId,
       { type: "page-view", clientContext, softNavigation: softNavigation || void 0 },
-      { signal, isSoftNavigation: softNavigation }
-    ).then(({ items }) => {
+      { signal, isSoftNavigation: softNavigation, knownTemplateIds: knownTemplateIdsRef.current }
+    ).then(({ items, templates: responseTemplates }) => {
       (0, import_client_utils.debug)("page-view response", { scriptsCount: items?.length ?? 0 });
+      mergeTemplates(responseTemplates);
       if (items?.length) addScripts(items);
     });
   });
@@ -224,22 +259,27 @@ function useNextlytics() {
       "[Nextlytics] useNextlytics() must be used within a component wrapped by <NextlyticsServer>. Add <NextlyticsServer> at the top of your layout.tsx file."
     );
   }
-  const { requestId, addScripts } = context;
+  const { requestId, addScripts, mergeTemplates, knownTemplateIdsRef } = context;
   const sendEvent = (0, import_react.useCallback)(
     async (eventName, opts) => {
-      const result = await sendEventToServer(requestId, {
-        type: "custom-event",
-        name: eventName,
-        props: opts?.props,
-        collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        clientContext: createClientContext()
-      });
+      const result = await sendEventToServer(
+        requestId,
+        {
+          type: "custom-event",
+          name: eventName,
+          props: opts?.props,
+          collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          clientContext: createClientContext()
+        },
+        { knownTemplateIds: knownTemplateIdsRef.current }
+      );
+      mergeTemplates(result.templates);
       if (result.items && result.items.length > 0) {
         addScripts(result.items);
       }
       return { ok: result.ok };
     },
-    [requestId, addScripts]
+    [requestId, addScripts, mergeTemplates, knownTemplateIdsRef]
   );
   return { sendEvent };
 }

package/dist/config-helpers.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsConfig } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 type NextlyticsConfigWithDefaults = Required<Pick<NextlyticsConfig, "excludeApiCalls" | "eventEndpoint" | "isApiPath" | "backends">> & NextlyticsConfig & {
     anonymousUsers: Required<NonNullable<NextlyticsConfig["anonymousUsers"]>>;

package/dist/index.d.ts

@@ -8,3 +8,4 @@ import 'react/jsx-runtime';
 import 'react';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';

package/dist/middleware.d.ts

@@ -1,9 +1,10 @@
 import { NextMiddleware } from 'next/server';
 import { NextlyticsConfigWithDefaults } from './config-helpers.js';
-import { DispatchEvent, UpdateEvent } from './api-handler.js';
+import { DispatchEvent, UpdateEvent, CollectTemplates } from './api-handler.js';
 import './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
+import 'next';
 
-declare function createNextlyticsMiddleware(config: NextlyticsConfigWithDefaults, dispatchEvent: DispatchEvent, updateEvent: UpdateEvent): NextMiddleware;
+declare function createNextlyticsMiddleware(config: NextlyticsConfigWithDefaults, dispatchEvent: DispatchEvent, updateEvent: UpdateEvent, collectTemplates: CollectTemplates): NextMiddleware;
 
 export { createNextlyticsMiddleware };

package/dist/middleware.js

@@ -33,7 +33,7 @@ function createRequestContext(request) {
     path: request.nextUrl.pathname
   };
 }
-function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
+function createNextlyticsMiddleware(config, dispatchEvent, updateEvent, collectTemplates) {
   const { eventEndpoint } = config;
   return async (request) => {
     const pathname = request.nextUrl.pathname;
@@ -67,7 +67,7 @@ function createNextlyticsMiddleware(config, dispatchEvent, updateEvent) {
     }
     if (pathname === eventEndpoint) {
       if (request.method === "POST") {
-        return (0, import_api_handler.handleEventPost)(request, config, dispatchEvent, updateEvent);
+        return (0, import_api_handler.handleEventPost)(request, config, dispatchEvent, updateEvent, collectTemplates);
       }
       return Response.json({ error: "Method not allowed" }, { status: 405 });
     }

package/dist/pages-router.d.ts

@@ -4,9 +4,10 @@ import 'react';
 import './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 type PagesRouterContext = {
-    req: {
+    req?: {
         headers: Record<string, string | string[] | undefined>;
         cookies?: Record<string, string>;
     };
@@ -14,6 +15,11 @@ type PagesRouterContext = {
 /**
  * Get Nextlytics props for Pages Router _app.tsx.
  * Reads context from headers set by middleware.
+ *
+ * `_app`'s getInitialProps re-runs on every client-side navigation, where there
+ * is no `req`. Return an empty context in that case rather than throwing — the
+ * client already has its scripts and templates from the initial render and the
+ * /api/event round-trip.
  */
 declare function getNextlyticsProps(ctx: PagesRouterContext): NextlyticsContext;
 

package/dist/pages-router.js

@@ -23,8 +23,12 @@ __export(pages_router_exports, {
 module.exports = __toCommonJS(pages_router_exports);
 var import_server_component_context = require("./server-component-context");
 function getNextlyticsProps(ctx) {
+  const reqHeaders = ctx?.req?.headers;
+  if (!reqHeaders) {
+    return { requestId: "" };
+  }
   const headersList = new Headers();
-  for (const [key, value] of Object.entries(ctx.req.headers)) {
+  for (const [key, value] of Object.entries(reqHeaders)) {
     if (value) {
       headersList.set(key, Array.isArray(value) ? value[0] : value);
     }

package/dist/plugins/vercel-geo.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsPlugin } from '../types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 type VercelGeoPluginOptions = {
     /** Property name to store geo data under. Default: "geo" */

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

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server';
 import { TemplatizedScriptInsertion } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
+import 'next';
 
 declare const headerNames: {
     readonly pathname: "x-nl-pathname";
@@ -9,6 +10,9 @@ declare const headerNames: {
     readonly isSoftNavigation: "x-nl-is-soft-nav";
     readonly active: "x-nl-active";
     readonly scripts: "x-nl-scripts";
+    /** Comma-separated template ids the client already holds, so the server only
+     * returns the ones it's missing (see api-handler / client templates merge). */
+    readonly knownTemplates: "x-nl-known-templates";
 };
 declare const LAST_PAGE_RENDER_ID_COOKIE = "last-page-render-id";
 /** Context passed from middleware to server components via headers */

package/dist/server-component-context.js

@@ -31,7 +31,10 @@ const headerNames = {
   pageRenderId: `${HEADER_PREFIX}page-render-id`,
   isSoftNavigation: `${HEADER_PREFIX}is-soft-nav`,
   active: `${HEADER_PREFIX}active`,
-  scripts: `${HEADER_PREFIX}scripts`
+  scripts: `${HEADER_PREFIX}scripts`,
+  /** Comma-separated template ids the client already holds, so the server only
+   * returns the ones it's missing (see api-handler / client templates merge). */
+  knownTemplates: `${HEADER_PREFIX}known-templates`
 };
 const LAST_PAGE_RENDER_ID_COOKIE = "last-page-render-id";
 function serializeServerComponentContext(response, ctx) {

package/dist/server.d.ts

@@ -1,6 +1,7 @@
 import { NextlyticsConfig, NextlyticsResult, RequestContext } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 import 'next/server';
+import 'next';
 
 declare function createRequestContext(): Promise<RequestContext>;
 declare function Nextlytics(userConfig: NextlyticsConfig): NextlyticsResult;

package/dist/server.js

@@ -174,13 +174,20 @@ function Nextlytics(userConfig) {
     const ctx = await createRequestContext();
     return updateEventInternal(eventId, patch, ctx);
   };
-  const middleware = (0, import_middleware.createNextlyticsMiddleware)(config, dispatchEventInternal, updateEventInternal);
+  const middleware = (0, import_middleware.createNextlyticsMiddleware)(
+    config,
+    dispatchEventInternal,
+    updateEventInternal,
+    (ctx) => collectTemplates(config, ctx)
+  );
   async function Server({ children }) {
     const headersList = await (0, import_headers.headers)();
     const ctx = (0, import_server_component_context.restoreServerComponentContext)(headersList);
     if (!ctx) {
       if (!headersList.get(import_server_component_context.headerNames.active)) {
-        console.warn("[Nextlytics] nextlyticsMiddleware should be added in order for Server to work");
+        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 });
     }
@@ -188,15 +195,14 @@ function Nextlytics(userConfig) {
     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.headerNames.pageRenderId);
-    const serverContext = createServerContextFromHeaders(headersList);
+  const analytics = async (req) => {
+    const source = req ? normalizeRequest(req) : await normalizeFromNextHeaders();
+    const pageRenderId = source.headers.get(import_server_component_context.headerNames.pageRenderId) || source.cookies.get(import_server_component_context.LAST_PAGE_RENDER_ID_COOKIE)?.value || void 0;
+    const serverContext = buildServerContext(source);
     const ctx = {
-      headers: headersList,
-      cookies: cookieStore,
-      path: headersList.get(import_server_component_context.headerNames.pathname) || ""
+      headers: source.headers,
+      cookies: source.cookies,
+      path: source.path
     };
     const { anonId: anonymousUserId } = await (0, import_anonymous_user.resolveAnonymousUser)({ ctx, serverContext, config });
     let userContext;
@@ -209,14 +215,14 @@ function Nextlytics(userConfig) {
     const propsFromCallback = await (0, import_api_handler.getEventProps)(config, ctx, userContext);
     return {
       sendEvent: async (eventName, opts) => {
-        if (!pageRenderId) {
+        if (!pageRenderId && !req) {
           console.error("[Nextlytics] analytics() requires nextlyticsMiddleware");
           return { ok: false };
         }
         const event = {
           origin: "server",
           eventId: (0, import_uitils.generateId)(),
-          parentEventId: pageRenderId,
+          ...pageRenderId ? { parentEventId: pageRenderId } : {},
           type: eventName,
           collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
           anonymousUserId,
@@ -237,32 +243,73 @@ function Nextlytics(userConfig) {
     NextlyticsServer: Server
   };
 }
-function createServerContextFromHeaders(headersList) {
+function searchToRecord(params) {
+  const out = {};
+  params.forEach((value, key) => {
+    (out[key] ?? (out[key] = [])).push(value);
+  });
+  return out;
+}
+function isNextApiRequest(req) {
+  return typeof req.headers?.get !== "function";
+}
+async function normalizeFromNextHeaders() {
+  const [_cookies, _headers] = await Promise.all([(0, import_headers.cookies)(), (0, import_headers.headers)()]);
+  return {
+    headers: _headers,
+    cookies: _cookies,
+    path: _headers.get(import_server_component_context.headerNames.pathname) || "",
+    search: searchToRecord(new URLSearchParams(_headers.get(import_server_component_context.headerNames.search) || "")),
+    method: "GET"
+  };
+}
+function normalizeRequest(req) {
+  if (!isNextApiRequest(req)) {
+    return {
+      headers: req.headers,
+      cookies: req.cookies,
+      path: req.nextUrl.pathname,
+      search: searchToRecord(req.nextUrl.searchParams),
+      method: req.method
+    };
+  }
+  const headersList = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value !== void 0) {
+      headersList.set(key, Array.isArray(value) ? value.join(", ") : value);
+    }
+  }
+  const cookieMap = req.cookies || {};
+  const cookieStore = {
+    get: (name) => {
+      const value = cookieMap[name];
+      return value === void 0 ? void 0 : { name, value };
+    },
+    getAll: () => Object.entries(cookieMap).map(([name, value]) => ({ name, value })),
+    has: (name) => name in cookieMap
+  };
+  const url = new URL(req.url || "/", `http://${headersList.get("host") || "localhost"}`);
+  return {
+    headers: headersList,
+    cookies: cookieStore,
+    path: url.pathname,
+    search: searchToRecord(url.searchParams),
+    method: req.method || "GET"
+  };
+}
+function buildServerContext(source) {
   const rawHeaders = {};
-  headersList.forEach((value, key) => {
+  source.headers.forEach((value, key) => {
     rawHeaders[key] = value;
   });
-  const requestHeaders = (0, import_headers2.removeSensitiveHeaders)(rawHeaders);
-  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);
-    params.forEach((value, key) => {
-      if (!searchParams[key]) {
-        searchParams[key] = [];
-      }
-      searchParams[key].push(value);
-    });
-  }
   return {
     collectedAt: /* @__PURE__ */ new Date(),
-    host: headersList.get("host") || "",
-    method: "GET",
-    path: pathname,
-    search: searchParams,
-    ip: headersList.get("x-forwarded-for")?.split(",")[0]?.trim() || "",
-    requestHeaders,
+    host: source.headers.get("host") || "",
+    method: source.method,
+    path: source.path,
+    search: source.search,
+    ip: source.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "",
+    requestHeaders: (0, import_headers2.removeSensitiveHeaders)(rawHeaders),
     responseHeaders: {}
   };
 }

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import { RequestCookies } from 'next/dist/server/web/spec-extension/cookies';
-import { NextMiddleware } from 'next/server';
+import { NextRequest, NextMiddleware } from 'next/server';
+import { NextApiRequest } from 'next';
 
 /** Server-side request context collected in middleware */
 interface ServerEventContext {
@@ -227,7 +228,7 @@ type NextlyticsBackend = {
 type NextlyticsBackendFactory = (ctx: RequestContext) => NextlyticsBackend;
 /** Server-side analytics API */
 type NextlyticsServerSide = {
-    /** Send custom event from server component/action */
+    /** Send custom event from a server component, server action, or API route */
     sendEvent: (eventName: string, opts?: {
         props?: Record<string, unknown>;
     }) => Promise<{
@@ -266,11 +267,21 @@ type ClientRequest = {
 type ClientRequestResult = {
     ok: boolean;
     items?: ClientActionItem[];
+    /** Client-side templates from the backends, so Pages Router clients (which
+     * can't read them from config) can compile the script insertions. */
+    templates?: Record<string, JavascriptTemplate>;
 };
 /** Return value from Nextlytics() */
 type NextlyticsResult = {
-    /** Get server-side analytics API */
-    analytics: () => Promise<NextlyticsServerSide>;
+    /** Get server-side analytics API.
+     *
+     * App Router (server components, server actions, route handlers): call with no
+     * argument — context is read from `next/headers`.
+     *
+     * Pages Router API routes: `next/headers` is unavailable there, so pass the
+     * request (`analytics(req)`). A NextRequest (App Router route handler) is also
+     * accepted. */
+    analytics: (req?: NextRequest | NextApiRequest) => Promise<NextlyticsServerSide>;
     /** Middleware to intercept requests */
     middleware: NextMiddleware;
     /** Manually dispatch event (returns two-phase result) */

package/dist/uitils.d.ts

@@ -1,6 +1,7 @@
 import { NextRequest } from 'next/server';
 import { ServerEventContext } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
+import 'next';
 
 /** Returns the full installed Next.js version string (e.g. "16.1.6"), or undefined. */
 declare function getNextVersion(): string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextlytics/core",
-  "version": "0.4.1",
+  "version": "0.4.2-canary.106",
   "description": "Analytics library for Next.js",
   "license": "MIT",
   "repository": {