@nextlytics/core 0.3.0-canary.70 → 0.3.0-canary.80

package/dist/client.js

@@ -25,13 +25,15 @@ __export(client_exports, {
 module.exports = __toCommonJS(client_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_react = require("react");
+var import_client_utils = require("./client-utils");
 var import_server_component_context = require("./server-component-context");
 var import_template = require("./template");
+var import_stable_hash = require("./stable-hash");
 const templateFunctions = {
   q: (v) => JSON.stringify(v ?? null),
-  json: (v) => JSON.stringify(v ?? null)
+  json: (v) => JSON.stringify(v ?? null),
+  stableHash: (v) => (0, import_stable_hash.stableHash)(v)
 };
-const compiledCache = {};
 const NextlyticsContext = (0, import_react.createContext)(null);
 function createClientContext() {
   const isBrowser = typeof window !== "undefined";
@@ -55,94 +57,165 @@ function createClientContext() {
     locale: isBrowser ? navigator.language : void 0
   };
 }
-function getCompiledTemplate(templateId, itemIndex, item) {
-  const cacheKey = `${templateId}:${itemIndex}`;
-  if (!compiledCache[cacheKey]) {
-    compiledCache[cacheKey] = {
-      src: item.src ? (0, import_template.compile)(item.src) : void 0,
-      body: item.body ? (0, import_template.compile)(item.body) : void 0
-    };
-  }
-  return compiledCache[cacheKey];
-}
-function executeTemplatedScripts(scripts, templates) {
-  if (!scripts || typeof window === "undefined") return;
+function deduplicateScripts(scripts, templates) {
+  const result = [];
+  const firstSeenByDeps = /* @__PURE__ */ new Set();
   for (const script of scripts) {
-    if (script.type !== "script-template") {
-      console.warn(`[Nextlytics] unsupported script type ${script.type} `);
+    if (script.type !== "script-template") continue;
+    const template = templates[script.templateId];
+    if (!template) continue;
+    if (!template.deps) {
+      result.push(script);
       continue;
     }
+    const paramsRecord = script.params || {};
+    const deps = compileTemplateDeps(template, paramsRecord);
+    const depsKey = `${script.templateId}\0${deps.join("\0")}`;
+    if (firstSeenByDeps.has(depsKey)) continue;
+    firstSeenByDeps.add(depsKey);
+    result.push(script);
+  }
+  return result;
+}
+function compileScripts(scripts, templates) {
+  const result = [];
+  for (const [scriptIndex, script] of scripts.entries()) {
+    if (script.type !== "script-template") continue;
     const template = templates[script.templateId];
     if (!template) {
-      console.warn(`[Nextlytics] Missing template: ${script.templateId}`);
+      console.warn(`[Nextlytics] Template "${script.templateId}" not found`);
       continue;
     }
-    const params = script.params;
-    for (let i = 0; i < template.items.length; i++) {
-      const item = template.items[i];
-      const compiled = getCompiledTemplate(script.templateId, i, item);
-      const src = compiled.src ? (0, import_template.apply)(compiled.src, params, templateFunctions) : void 0;
-      if (item.singleton && src && document.querySelector(`script[src="${src}"]`)) {
+    const paramsRecord = script.params || {};
+    const deps = compileTemplateDeps(template, paramsRecord);
+    let itemIndex = 0;
+    for (const item of template.items) {
+      const keyPrefix = `${script.templateId}:${scriptIndex}:${item.src ? "ext" : "body"}:${itemIndex}`;
+      if (item.src) {
+        const compiledSrc = (0, import_template.compile)(item.src);
+        const src = (0, import_template.apply)(compiledSrc, paramsRecord, templateFunctions);
+        result.push({
+          key: keyPrefix,
+          src,
+          async: item.async,
+          deps
+        });
+        itemIndex++;
         continue;
       }
-      const el = document.createElement("script");
-      if (src) {
-        el.src = src;
-      }
-      if (compiled.body) {
-        el.textContent = (0, import_template.apply)(compiled.body, params, templateFunctions);
-      }
-      if (item.async) {
-        el.async = true;
+      if (!item.body) {
+        itemIndex++;
+        continue;
       }
-      document.head.appendChild(el);
+      const bodyText = Array.isArray(item.body) ? item.body.join("\n") : item.body;
+      const compiled = (0, import_template.compile)(bodyText);
+      const body = (0, import_template.apply)(compiled, paramsRecord, templateFunctions);
+      result.push({ key: keyPrefix, body, deps });
+      itemIndex++;
     }
   }
+  return result;
+}
+function compileTemplateDeps(template, paramsRecord) {
+  if (!template.deps) return [];
+  const rawDeps = Array.isArray(template.deps) ? template.deps : [template.deps];
+  return rawDeps.map((dep) => (0, import_template.apply)((0, import_template.compile)(dep), paramsRecord, templateFunctions));
 }
-async function sendEvent(requestId, type, payload) {
+function NextlyticsScripts({
+  initialScripts
+}) {
+  const context = (0, import_react.useContext)(NextlyticsContext);
+  if (!context) {
+    throw new Error("NextlyticsScripts should be called within NextlyticsContext");
+  }
+  const { scriptsRef, subscribersRef, templates } = context;
+  const [, forceUpdate] = (0, import_react.useReducer)((x) => x + 1, 0);
+  (0, import_react.useEffect)(() => {
+    subscribersRef.current.add(forceUpdate);
+    return () => {
+      subscribersRef.current.delete(forceUpdate);
+    };
+  }, [subscribersRef]);
+  const allScripts = [...initialScripts, ...scriptsRef.current];
+  const dedupedScripts = (0, import_react.useMemo)(
+    () => deduplicateScripts(allScripts, templates),
+    [allScripts, templates]
+  );
+  const compiled = (0, import_react.useMemo)(
+    () => compileScripts(dedupedScripts, templates),
+    [dedupedScripts, templates]
+  );
+  (0, import_client_utils.debug)("Rendering scripts", {
+    initialCount: initialScripts.length,
+    dynamicCount: scriptsRef.current.length,
+    totalCount: allScripts.length,
+    compiledCount: compiled.length
+  });
+  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 } = {}) {
   try {
+    const headers = {
+      "Content-Type": "application/json",
+      [import_server_component_context.headerNames.pageRenderId]: requestId
+    };
+    if (isSoftNavigation) {
+      headers[import_server_component_context.headerNames.isSoftNavigation] = "1";
+    }
     const response = await fetch("/api/event", {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        [import_server_component_context.headers.pageRenderId]: requestId
-      },
-      body: JSON.stringify({ type, payload })
+      headers,
+      body: JSON.stringify(request),
+      signal
     });
     if (response.status === 404) {
       console.error(
-        "[Nextlytics] In order for NextlyticsClient to work, you must mount nextlyticsRouteHandler to /api/event"
+        "[Nextlytics] In order for NextlyticsClient to work, you must install nextlytics middleware"
       );
       return { ok: false };
     }
     const data = await response.json().catch(() => ({ ok: response.ok }));
-    return { ok: data.ok ?? response.ok, scripts: data.scripts };
+    return { ok: data.ok ?? response.ok, items: data.items };
   } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return { ok: false };
+    }
     console.error("[Nextlytics] Failed to send event:", error);
     return { ok: false };
   }
 }
-const initializedRequestIds = /* @__PURE__ */ new Set();
 function NextlyticsClient(props) {
-  const requestId = props.ctx?.requestId ?? props.requestId ?? "";
-  const scripts = props.ctx?.scripts ?? props.scripts;
-  const templates = props.ctx?.templates ?? props.templates ?? {};
-  (0, import_react.useEffect)(() => {
-    if (initializedRequestIds.has(requestId)) return;
-    initializedRequestIds.add(requestId);
-    if (scripts && Object.keys(templates).length > 0) {
-      executeTemplatedScripts(scripts, templates);
-    }
+  const { requestId, scripts: initialScripts = [], templates = {} } = props.ctx;
+  const scriptsRef = (0, import_react.useRef)([]);
+  const subscribersRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+  const addScripts = (0, import_react.useCallback)((newScripts) => {
+    (0, import_client_utils.debug)("Adding scripts", {
+      newCount: newScripts.length,
+      templateIds: newScripts.map((s) => s.templateId)
+    });
+    scriptsRef.current = [...scriptsRef.current, ...newScripts];
+    subscribersRef.current.forEach((cb) => cb());
+  }, []);
+  const contextValue = (0, import_react.useMemo)(
+    () => ({ requestId, templates, addScripts, scriptsRef, subscribersRef }),
+    [requestId, templates, addScripts]
+  );
+  (0, import_client_utils.useNavigation)(requestId, ({ softNavigation, signal }) => {
+    (0, import_client_utils.debug)("Sending page-view", { requestId, softNavigation });
     const clientContext = createClientContext();
-    sendEvent(requestId, "client-init", clientContext).then(
-      ({ scripts: responseScripts }) => {
-        if (responseScripts) {
-          executeTemplatedScripts(responseScripts, templates);
-        }
-      }
-    );
-  }, [requestId, scripts, templates]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NextlyticsContext.Provider, { value: { requestId, templates }, children: props.children });
+    sendEventToServer(
+      requestId,
+      { type: "page-view", clientContext, softNavigation: softNavigation || void 0 },
+      { signal, isSoftNavigation: softNavigation }
+    ).then(({ items }) => {
+      (0, import_client_utils.debug)("page-view response", { scriptsCount: items?.length ?? 0 });
+      if (items?.length) addScripts(items);
+    });
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(NextlyticsContext.Provider, { value: contextValue, children: [
+    props.children,
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NextlyticsScripts, { initialScripts })
+  ] });
 }
 function useNextlytics() {
   const context = (0, import_react.useContext)(NextlyticsContext);
@@ -151,23 +224,24 @@ 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, templates } = context;
-  const send = (0, import_react.useCallback)(
+  const { requestId, addScripts } = context;
+  const sendEvent = (0, import_react.useCallback)(
     async (eventName, opts) => {
-      const result = await sendEvent(requestId, "client-event", {
+      const result = await sendEventToServer(requestId, {
+        type: "custom-event",
         name: eventName,
         props: opts?.props,
         collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
         clientContext: createClientContext()
       });
-      if (result.scripts) {
-        executeTemplatedScripts(result.scripts, templates);
+      if (result.items && result.items.length > 0) {
+        addScripts(result.items);
       }
       return { ok: result.ok };
     },
-    [requestId, templates]
+    [requestId, addScripts]
   );
-  return { sendEvent: send };
+  return { sendEvent };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/config-helpers.js

@@ -28,7 +28,7 @@ function withDefaults(config) {
     ...config,
     excludeApiCalls: config.excludeApiCalls ?? false,
     eventEndpoint: config.eventEndpoint ?? "/api/event",
-    isApiPath: config.isApiPath ?? (() => false),
+    isApiPath: config.isApiPath ?? ((str) => str.startsWith("/api")),
     backends: config.backends ?? [],
     anonymousUsers: {
       gdprMode: config.anonymousUsers?.gdprMode ?? true,

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { Nextlytics, NextlyticsServer } from './server.js';
-export { NextlyticsClient, NextlyticsContext, useNextlytics } from './client.js';
+export { Nextlytics } from './server.js';
 export { getNextlyticsProps } from './pages-router.js';
+export { NextlyticsClient, NextlyticsContext, useNextlytics } from './client.js';
 export { loggingBackend } from './backends/logging.js';
-export { AnonymousUserResult, BackendConfigEntry, BackendWithConfig, ClientContext, IngestPolicy, NextlyticsBackend, NextlyticsBackendFactory, NextlyticsConfig, NextlyticsEvent, NextlyticsPlugin, NextlyticsPluginFactory, NextlyticsResult, NextlyticsServerSide, RequestContext, ServerEventContext, UserContext } from './types.js';
+export { AnonymousUserResult, BackendConfigEntry, BackendWithConfig, ClientAction, ClientContext, ClientRequest, JavascriptTemplate, NextlyticsBackend, NextlyticsBackendFactory, NextlyticsClientContext, NextlyticsConfig, NextlyticsEvent, NextlyticsPlugin, NextlyticsPluginFactory, NextlyticsResult, NextlyticsServerSide, PageViewDelivery, PagesRouterContext, RequestContext, ServerEventContext, UserContext } from './types.js';
 import 'react/jsx-runtime';
 import 'react';
 import 'next/dist/server/web/spec-extension/cookies';

package/dist/index.js

@@ -20,21 +20,19 @@ var index_exports = {};
 __export(index_exports, {
   Nextlytics: () => import_server.Nextlytics,
   NextlyticsClient: () => import_client.NextlyticsClient,
-  NextlyticsServer: () => import_server.NextlyticsServer,
   getNextlyticsProps: () => import_pages_router.getNextlyticsProps,
   loggingBackend: () => import_logging.loggingBackend,
   useNextlytics: () => import_client.useNextlytics
 });
 module.exports = __toCommonJS(index_exports);
 var import_server = require("./server");
-var import_client = require("./client");
 var import_pages_router = require("./pages-router");
+var import_client = require("./client");
 var import_logging = require("./backends/logging");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Nextlytics,
   NextlyticsClient,
-  NextlyticsServer,
   getNextlyticsProps,
   loggingBackend,
   useNextlytics

package/dist/middleware.d.ts

@@ -1,10 +1,9 @@
 import { NextMiddleware } from 'next/server';
-import { NextlyticsEvent, RequestContext, IngestPolicy, DispatchResult } from './types.js';
 import { NextlyticsConfigWithDefaults } from './config-helpers.js';
+import { DispatchEvent, UpdateEvent } from './api-handler.js';
+import './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 
-type DispatchEvent = (event: NextlyticsEvent, ctx: RequestContext, policyFilter?: IngestPolicy) => DispatchResult;
-type UpdateEvent = (eventId: string, patch: Partial<NextlyticsEvent>, ctx: RequestContext) => Promise<void>;
 declare function createNextlyticsMiddleware(config: NextlyticsConfigWithDefaults, dispatchEvent: DispatchEvent, updateEvent: UpdateEvent): NextMiddleware;
 
 export { createNextlyticsMiddleware };

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 };