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

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

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { RequestCookies } from 'next/dist/server/web/spec-extension/cookies';
-import { NextRequest, NextMiddleware } from 'next/server';
+import { NextMiddleware } from 'next/server';
 
 /** Server-side request context collected in middleware */
 interface ServerEventContext {
@@ -69,6 +69,12 @@ interface UserContext {
 }
 /** Analytics event sent to backends */
 interface NextlyticsEvent {
+    /**
+     * Where the event was triggered?
+     *  - server — on server, e.g in route or server side component
+     *  - client — on client
+     */
+    origin: "server" | "client";
     /** ISO timestamp when event was collected */
     collectedAt: string;
     /** Unique event ID */
@@ -109,17 +115,17 @@ type NextlyticsPlugin = {
 };
 /** Factory to create plugin per-request (for request-scoped plugins) */
 type NextlyticsPluginFactory = (ctx: RequestContext) => NextlyticsPlugin;
-/** When to ingest events for a backend */
-type IngestPolicy = 
-/** Dispatch immediately in middleware (default) - faster but no client context */
-"immediate"
-/** Dispatch when client-init is received - has full client context (title, screen, etc) */
- | "on-client-event";
+/** When to deliver page view events for a backend */
+type PageViewDelivery = 
+/** Dispatch on server request in middleware (default) - faster but no client context */
+"on-request"
+/** Dispatch on page load (client-side) - has full client context (title, screen, etc) */
+ | "on-page-load";
 /** Backend with configuration options */
 type BackendWithConfig = {
     backend: NextlyticsBackend | NextlyticsBackendFactory;
-    /** When to send events. Default: "immediate" */
-    ingestPolicy?: IngestPolicy;
+    /** When to send events. Default: "on-request" */
+    pageViewDelivery?: PageViewDelivery;
 };
 /** Backend config entry - either a backend directly or with config */
 type BackendConfigEntry = NextlyticsBackend | NextlyticsBackendFactory | BackendWithConfig;
@@ -181,13 +187,16 @@ type DispatchResult = {
 };
 type JavascriptTemplate = {
     items: ScriptElement[];
+    /**
+     * Optional dependency key template. When this value changes, the script re-injects.
+     * If omitted, the template is treated as "once".
+     */
+    deps?: string | string[];
 };
 type ScriptElement = {
-    async?: string;
-    body?: string;
+    async?: boolean;
+    body?: string | string[];
     src?: string;
-    /** If true, skip insertion if script with same src already exists */
-    singleton?: boolean;
 };
 /** Backend that receives analytics events */
 type NextlyticsBackend = {
@@ -201,7 +210,7 @@ type NextlyticsBackend = {
     returnsClientActions?: boolean;
     getClientSideTemplates?: () => Record<string, JavascriptTemplate>;
     /** Handle new event */
-    onEvent(event: NextlyticsEvent): Promise<void | ClientAction>;
+    onEvent(event: NextlyticsEvent): Promise<ClientAction | void | undefined>;
     /** Update existing event (e.g. add client context to server pageView) */
     updateEvent(eventId: string, patch: Partial<NextlyticsEvent>): Promise<void> | void;
 };
@@ -216,11 +225,41 @@ type NextlyticsServerSide = {
         ok: boolean;
     }>;
 };
-type AppRouteHandlers = Record<"GET" | "POST", (req: NextRequest) => Promise<Response>>;
+/** Context for Pages Router _app.tsx */
+type PagesRouterContext = {
+    req: {
+        headers: Record<string, string | string[] | undefined>;
+        cookies?: Record<string, string>;
+    };
+};
+/** Context passed to NextlyticsClient */
+type NextlyticsClientContext = {
+    requestId: string;
+    scripts?: TemplatizedScriptInsertion<unknown>[];
+    templates?: Record<string, JavascriptTemplate>;
+};
+/** Client-to-server request types (discriminated union) */
+type ClientRequest = {
+    type: "page-view";
+    clientContext: ClientContext;
+    /** If true, only update existing event (soft navigation - no dispatch, no scripts) */
+    softNavigation?: boolean;
+} | {
+    type: "custom-event";
+    name: string;
+    props?: Record<string, unknown>;
+    collectedAt: string;
+    clientContext: ClientContext;
+};
+/**
+ * Result of any /api/event call
+ */
+type ClientRequestResult = {
+    ok: boolean;
+    items?: ClientActionItem[];
+};
 /** Return value from Nextlytics() */
 type NextlyticsResult = {
-    /** Route handlers for /api/event */
-    handlers: AppRouteHandlers;
     /** Get server-side analytics API */
     analytics: () => Promise<NextlyticsServerSide>;
     /** Middleware to intercept requests */
@@ -229,6 +268,10 @@ type NextlyticsResult = {
     dispatchEvent: (event: NextlyticsEvent) => Promise<DispatchResult>;
     /** Manually update existing event */
     updateEvent: (eventId: string, patch: Partial<NextlyticsEvent>) => Promise<void>;
+    /** Server component that wraps your app to provide analytics context (App Router) */
+    NextlyticsServer: (props: {
+        children: React.ReactNode;
+    }) => Promise<React.ReactElement>;
 };
 
-export type { AnonymousUserResult, BackendConfigEntry, BackendWithConfig, ClientAction, ClientActionItem, ClientContext, DispatchResult, IngestPolicy, JavascriptTemplate, NextlyticsBackend, NextlyticsBackendFactory, NextlyticsConfig, NextlyticsEvent, NextlyticsPlugin, NextlyticsPluginFactory, NextlyticsResult, NextlyticsServerSide, RequestContext, ScriptElement, ServerEventContext, TemplatizedScriptInsertion, UserContext };
+export type { AnonymousUserResult, BackendConfigEntry, BackendWithConfig, ClientAction, ClientActionItem, ClientContext, ClientRequest, ClientRequestResult, DispatchResult, JavascriptTemplate, NextlyticsBackend, NextlyticsBackendFactory, NextlyticsClientContext, NextlyticsConfig, NextlyticsEvent, NextlyticsPlugin, NextlyticsPluginFactory, NextlyticsResult, NextlyticsServerSide, PageViewDelivery, PagesRouterContext, RequestContext, ScriptElement, ServerEventContext, TemplatizedScriptInsertion, UserContext };

package/dist/uitils.d.ts

@@ -2,6 +2,12 @@ import { NextRequest } from 'next/server';
 import { ServerEventContext } from './types.js';
 import 'next/dist/server/web/spec-extension/cookies';
 
+/** Returns the full installed Next.js version string (e.g. "16.1.6"), or undefined. */
+declare function getNextVersion(): string | undefined;
+/** True if the installed Next.js major version is 15. */
+declare function isNext15(): boolean;
+/** True if the installed Next.js major version is 16. */
+declare function isNext16(): boolean;
 /** Generate a random base62 ID (16 chars = 62^16 ≈ 4.7 × 10^28 combinations) */
 declare function generateId(): string;
 type RequestInfo = {
@@ -19,4 +25,4 @@ type RequestInfo = {
 declare function getRequestInfo(request: NextRequest): RequestInfo;
 declare function createServerContext(request: NextRequest): ServerEventContext;
 
-export { type RequestInfo, createServerContext, generateId, getRequestInfo };
+export { type RequestInfo, createServerContext, generateId, getNextVersion, getRequestInfo, isNext15, isNext16 };

package/dist/uitils.js

@@ -20,10 +20,41 @@ var uitils_exports = {};
 __export(uitils_exports, {
   createServerContext: () => createServerContext,
   generateId: () => generateId,
-  getRequestInfo: () => getRequestInfo
+  getNextVersion: () => getNextVersion,
+  getRequestInfo: () => getRequestInfo,
+  isNext15: () => isNext15,
+  isNext16: () => isNext16
 });
 module.exports = __toCommonJS(uitils_exports);
 var import_headers = require("./headers");
+let _nextVersion;
+function detectNextVersion() {
+  if (_nextVersion !== void 0) return _nextVersion;
+  try {
+    const pkg = require("next/package.json");
+    _nextVersion = pkg.version;
+  } catch {
+    console.warn(
+      "[Nextlytics] Could not read Next.js version from next/package.json.\nThis can happen if your bundler does not support JSON imports from\nnode_modules. Ensure `resolveJsonModule: true` is set in tsconfig\nand your bundler can resolve peer-dependency subpath imports.\nTurbopack and webpack (default Next.js bundlers) both support this."
+    );
+    _nextVersion = "";
+  }
+  return _nextVersion || void 0;
+}
+function parseMajor(version) {
+  if (!version) return void 0;
+  const major = parseInt(version.split(".")[0], 10);
+  return Number.isFinite(major) ? major : void 0;
+}
+function getNextVersion() {
+  return detectNextVersion();
+}
+function isNext15() {
+  return parseMajor(detectNextVersion()) === 15;
+}
+function isNext16() {
+  return parseMajor(detectNextVersion()) === 16;
+}
 const BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function generateId() {
   const length = 16;
@@ -45,15 +76,15 @@ function getRequestInfo(request) {
   );
   const hasStandardPrefetchHeader = headers.get("next-router-prefetch") === "1" || headers.get("purpose") === "prefetch" || headers.get("sec-purpose") === "prefetch";
   const nextUrl = headers.get("next-url");
-  const isRscPrefetch = nextUrl !== null && nextUrl !== pathname;
-  const isPrefetch = hasStandardPrefetchHeader || isRscPrefetch;
   const isRsc = !!(nextUrl || headers.get("rsc"));
   const secFetchDest = headers.get("sec-fetch-dest");
   const secFetchMode = headers.get("sec-fetch-mode");
   const accept = headers.get("accept") || "";
   const isDocumentRequest = secFetchDest === "document" || secFetchMode === "navigate";
   const acceptsHtml = accept.includes("text/html");
-  const isPageNavigation = isRsc || isDocumentRequest || acceptsHtml;
+  const isPageNavigation = isDocumentRequest || acceptsHtml;
+  const isRscPrefetch = nextUrl !== null && nextUrl !== pathname;
+  const isPrefetch = hasStandardPrefetchHeader || isRscPrefetch && !isPageNavigation;
   return {
     isPrefetch,
     isRsc,
@@ -90,5 +121,8 @@ function createServerContext(request) {
 0 && (module.exports = {
   createServerContext,
   generateId,
-  getRequestInfo
+  getNextVersion,
+  getRequestInfo,
+  isNext15,
+  isNext16
 });

package/package.json

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

package/dist/handlers.d.ts

@@ -1,12 +0,0 @@
-import { NextRequest } from 'next/server';
-
-type AppRouteHandlers = Record<"GET" | "POST", (req: NextRequest) => Promise<Response>>;
-/**
- * Route handlers for /api/event (deprecated - middleware handles this now)
- *
- * Kept for backward compatibility. If you have mounted these handlers at /api/event,
- * the middleware will intercept the request first, so these won't be called.
- */
-declare function createHandlers(): AppRouteHandlers;
-
-export { createHandlers };

package/dist/handlers.js

@@ -1,40 +0,0 @@
-"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 handlers_exports = {};
-__export(handlers_exports, {
-  createHandlers: () => createHandlers
-});
-module.exports = __toCommonJS(handlers_exports);
-function createHandlers() {
-  return {
-    GET: async () => {
-      return Response.json({ status: "ok" });
-    },
-    POST: async () => {
-      return Response.json(
-        { error: "Middleware not configured. Events are handled by nextlyticsMiddleware." },
-        { status: 500 }
-      );
-    }
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createHandlers
-});