@nextlytics/core 0.1.0-canary-1

package/dist/server.js

@@ -0,0 +1,213 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { headers, cookies } from "next/headers";
+import { removeSensitiveHeaders } from "./headers";
+import {
+  headers as analyticsHeaders,
+  restoreServerComponentContext
+} from "./server-component-context";
+import { resolveAnonymousUser } from "./anonymous-user";
+import { NextlyticsClient } from "./client";
+import { createHandlers } from "./handlers";
+import { logConfigWarnings, validateConfig, withDefaults } from "./config-helpers";
+import { createNextlyticsMiddleware } from "./middleware";
+import { generateId } from "./uitils";
+function resolveBackends(config, ctx) {
+  const backends = config.backends || [];
+  return backends.map((backend) => {
+    if (typeof backend === "function") {
+      return backend(ctx);
+    }
+    return backend;
+  }).filter((b) => b !== null);
+}
+function resolvePlugins(config, ctx) {
+  const plugins = config.plugins || [];
+  return plugins.map((plugin) => {
+    if (typeof plugin === "function") {
+      if (!ctx) {
+        return null;
+      }
+      return plugin(ctx);
+    }
+    return plugin;
+  }).filter((p) => p !== null);
+}
+function mergeClientActions(actions) {
+  const items = [];
+  for (const action of actions) {
+    if (action?.items) {
+      items.push(...action.items);
+    }
+  }
+  return { items };
+}
+async function createRequestContext() {
+  const [_cookies, _headers] = await Promise.all([cookies(), headers()]);
+  return {
+    cookies: _cookies,
+    headers: _headers
+  };
+}
+async function NextlyticsServer({ children }) {
+  const headersList = await headers();
+  const ctx = restoreServerComponentContext(headersList);
+  if (!ctx) {
+    console.warn(
+      "[Nextlytics] nextlyticsMiddleware should be added in order for NextlyticsServer to work"
+    );
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsx(NextlyticsClient, { requestId: ctx.pageRenderId, scripts: ctx.scripts, templates: ctx.templates, children });
+}
+function Nextlytics(userConfig) {
+  const config = withDefaults(userConfig);
+  const validationResult = validateConfig(config);
+  logConfigWarnings(validationResult);
+  const dispatchEventInternal = (event, ctx) => {
+    const plugins = resolvePlugins(config, ctx);
+    const backends = resolveBackends(config, ctx);
+    const pluginsDone = (async () => {
+      for (const plugin of plugins) {
+        try {
+          await plugin.onDispatch(event);
+        } catch (err) {
+          console.warn("[Nextlytics] Plugin failed on onDispatch:", err);
+        }
+      }
+    })();
+    const backendResults = pluginsDone.then(() => {
+      return backends.map((backend) => {
+        const start = Date.now();
+        const promise = backend.onEvent(event).then((result) => ({ ok: true, ms: Date.now() - start, result })).catch((err) => {
+          console.warn(`[Nextlytics] Backend "${backend.name}" failed on onEvent:`, err);
+          return { ok: false, ms: Date.now() - start, result: void 0 };
+        });
+        return { backend, promise };
+      });
+    });
+    const clientActions = backendResults.then(async (results) => {
+      const actionResults = results.filter((r) => r.backend.returnsClientActions);
+      const actions = await Promise.all(actionResults.map((r) => r.promise));
+      return mergeClientActions(actions.map((a) => a.result));
+    });
+    const completion = backendResults.then(async (results) => {
+      const settled = await Promise.all(results.map((r) => r.promise));
+      if (config.debug) {
+        const nameWidth = Math.max(...results.map((r) => r.backend.name.length));
+        console.log(
+          `[Nextlytics] dispatchEvent ${event.type} ${event.eventId} (${results.length} backends)`
+        );
+        results.forEach((r, i) => {
+          const s = settled[i];
+          const status = s.ok ? "ok" : "fail";
+          console.log(`  ${r.backend.name.padEnd(nameWidth)}  ${status.padEnd(4)}  ${s.ms}ms`);
+        });
+      }
+    }).then(() => {
+    });
+    return { clientActions, completion };
+  };
+  const updateEventInternal = async (eventId, patch, ctx) => {
+    const backends = resolveBackends(config, ctx).filter((backend) => backend.supportsUpdates);
+    const results = await Promise.all(
+      backends.map(async (backend) => {
+        const start = Date.now();
+        try {
+          await backend.updateEvent(eventId, patch);
+          return { backend, ok: true, ms: Date.now() - start };
+        } catch (err) {
+          console.warn(`[Nextlytics] Backend "${backend.name}" failed on updateEvent:`, err);
+          return { backend, ok: false, ms: Date.now() - start };
+        }
+      })
+    );
+    if (config.debug && backends.length > 0) {
+      const nameWidth = Math.max(...backends.map((b) => b.name.length));
+      console.log(`[Nextlytics] updateEvent ${eventId} (${backends.length} backends)`);
+      results.forEach((r) => {
+        const status = r.ok ? "ok" : "fail";
+        console.log(`  ${r.backend.name.padEnd(nameWidth)}  ${status.padEnd(4)}  ${r.ms}ms`);
+      });
+    }
+  };
+  const dispatchEvent = async (event) => {
+    const ctx = await createRequestContext();
+    return dispatchEventInternal(event, ctx);
+  };
+  const updateEvent = async (eventId, patch) => {
+    const ctx = await createRequestContext();
+    return updateEventInternal(eventId, patch, ctx);
+  };
+  const middleware = createNextlyticsMiddleware(config, dispatchEventInternal, updateEventInternal);
+  const handlers = createHandlers(config, dispatchEventInternal, updateEventInternal);
+  const analytics = async () => {
+    const headersList = await headers();
+    const cookieStore = await cookies();
+    const pageRenderId = headersList.get(analyticsHeaders.pageRenderId);
+    const serverContext = createServerContextFromHeaders(headersList);
+    const ctx = { headers: headersList, cookies: cookieStore };
+    const { anonId: anonymousUserId } = await resolveAnonymousUser({ ctx, serverContext, config });
+    let userContext;
+    if (config.callbacks.getUser) {
+      try {
+        userContext = await config.callbacks.getUser(ctx) || void 0;
+      } catch {
+      }
+    }
+    return {
+      sendEvent: async (eventName, opts) => {
+        if (!pageRenderId) {
+          console.error("[Nextlytics] analytics() requires nextlyticsMiddleware");
+          return { ok: false };
+        }
+        const event = {
+          eventId: generateId(),
+          parentEventId: pageRenderId,
+          type: eventName,
+          collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          anonymousUserId,
+          serverContext,
+          userContext,
+          properties: opts?.props || {}
+        };
+        await dispatchEventInternal(event, ctx);
+        return { ok: true };
+      }
+    };
+  };
+  return { middleware, handlers, analytics, dispatchEvent, updateEvent };
+}
+function createServerContextFromHeaders(headersList) {
+  const rawHeaders = {};
+  headersList.forEach((value, key) => {
+    rawHeaders[key] = value;
+  });
+  const requestHeaders = removeSensitiveHeaders(rawHeaders);
+  const pathname = headersList.get(analyticsHeaders.pathname) || "";
+  const search = headersList.get(analyticsHeaders.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,
+    responseHeaders: {}
+  };
+}
+export {
+  Nextlytics,
+  NextlyticsServer,
+  createRequestContext
+};

package/dist/template.cjs

@@ -0,0 +1,108 @@
+"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 template_exports = {};
+__export(template_exports, {
+  apply: () => apply,
+  compile: () => compile
+});
+module.exports = __toCommonJS(template_exports);
+function compile(template) {
+  const result = [];
+  let i = 0, text = "";
+  while (i < template.length) {
+    if (template[i] === "\\" && "{}".includes(template[i + 1]) && template[i + 1] === template[i + 2]) {
+      text += template.slice(i + 1, i + 3);
+      i += 3;
+    } else if (template.slice(i, i + 2) === "{{") {
+      if (text) {
+        result.push({ type: "text", value: text });
+        text = "";
+      }
+      const end = template.indexOf("}}", i + 2);
+      if (end === -1) throw new Error(`Unclosed {{ at position ${i}`);
+      result.push({ type: "expr", expr: parseExpr(template.slice(i + 2, end).trim()) });
+      i = end + 2;
+    } else {
+      text += template[i++];
+    }
+  }
+  if (text) result.push({ type: "text", value: text });
+  return result;
+}
+function apply(tpl, params, fns) {
+  return tpl.map((p) => p.type === "text" ? p.value : evalExpr(p.expr, params, fns)).join("");
+}
+function parseExpr(s) {
+  if ((s[0] === '"' || s[0] === "'") && s[0] === s[s.length - 1]) {
+    const esc = { n: "\n", t: "	", r: "\r" };
+    return {
+      type: "string",
+      value: s.slice(1, -1).replace(/\\(.)/g, (_, c) => esc[c] ?? c)
+    };
+  }
+  if (/^-?\d+(\.\d+)?$/.test(s)) return { type: "number", value: +s };
+  const m = s.match(/^(\w+)\(/);
+  if (m && s.endsWith(")"))
+    return { type: "call", func: m[1], args: splitArgs(s.slice(m[0].length, -1)).map(parseExpr) };
+  return { type: "path", parts: s.split(".") };
+}
+function splitArgs(s) {
+  const args = [];
+  let cur = "", depth = 0, quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if ((c === '"' || c === "'") && s[i - 1] !== "\\") quote = quote === c ? null : quote ?? c;
+    if (!quote) {
+      if (c === "(") depth++;
+      if (c === ")") depth--;
+      if (c === "," && depth === 0) {
+        args.push(cur.trim());
+        cur = "";
+        continue;
+      }
+    }
+    cur += c;
+  }
+  if (cur.trim()) args.push(cur.trim());
+  return args;
+}
+function resolve(parts, obj) {
+  for (const p of parts) {
+    if (obj == null || typeof obj !== "object") return void 0;
+    obj = obj[p];
+  }
+  return obj;
+}
+function evalExpr(e, params, fns) {
+  if (e.type === "string") return e.value;
+  if (e.type === "number") return String(e.value);
+  if (e.type === "path") return String(resolve(e.parts, params) ?? "");
+  const fn = fns[e.func];
+  if (!fn) throw new Error(`Unknown function: ${e.func}`);
+  return fn(
+    ...e.args.map(
+      (a) => a.type === "path" ? resolve(a.parts, params) : a.type === "call" ? evalExpr(a, params, fns) : a.value
+    )
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  apply,
+  compile
+});

package/dist/template.d.mts

@@ -0,0 +1,27 @@
+type Expr = {
+    type: "path";
+    parts: string[];
+} | {
+    type: "call";
+    func: string;
+    args: Expr[];
+} | {
+    type: "string";
+    value: string;
+} | {
+    type: "number";
+    value: number;
+};
+type CompiledTemplate = Array<{
+    type: "text";
+    value: string;
+} | {
+    type: "expr";
+    expr: Expr;
+}>;
+type TemplateFunction = (...values: unknown[]) => string;
+type TemplateFunctions = Record<string, TemplateFunction>;
+declare function compile(template: string): CompiledTemplate;
+declare function apply(tpl: CompiledTemplate, params: Record<string, unknown>, fns: TemplateFunctions): string;
+
+export { type CompiledTemplate, type TemplateFunction, type TemplateFunctions, apply, compile };

package/dist/template.d.ts

@@ -0,0 +1,27 @@
+type Expr = {
+    type: "path";
+    parts: string[];
+} | {
+    type: "call";
+    func: string;
+    args: Expr[];
+} | {
+    type: "string";
+    value: string;
+} | {
+    type: "number";
+    value: number;
+};
+type CompiledTemplate = Array<{
+    type: "text";
+    value: string;
+} | {
+    type: "expr";
+    expr: Expr;
+}>;
+type TemplateFunction = (...values: unknown[]) => string;
+type TemplateFunctions = Record<string, TemplateFunction>;
+declare function compile(template: string): CompiledTemplate;
+declare function apply(tpl: CompiledTemplate, params: Record<string, unknown>, fns: TemplateFunctions): string;
+
+export { type CompiledTemplate, type TemplateFunction, type TemplateFunctions, apply, compile };

package/dist/template.js

@@ -0,0 +1,83 @@
+function compile(template) {
+  const result = [];
+  let i = 0, text = "";
+  while (i < template.length) {
+    if (template[i] === "\\" && "{}".includes(template[i + 1]) && template[i + 1] === template[i + 2]) {
+      text += template.slice(i + 1, i + 3);
+      i += 3;
+    } else if (template.slice(i, i + 2) === "{{") {
+      if (text) {
+        result.push({ type: "text", value: text });
+        text = "";
+      }
+      const end = template.indexOf("}}", i + 2);
+      if (end === -1) throw new Error(`Unclosed {{ at position ${i}`);
+      result.push({ type: "expr", expr: parseExpr(template.slice(i + 2, end).trim()) });
+      i = end + 2;
+    } else {
+      text += template[i++];
+    }
+  }
+  if (text) result.push({ type: "text", value: text });
+  return result;
+}
+function apply(tpl, params, fns) {
+  return tpl.map((p) => p.type === "text" ? p.value : evalExpr(p.expr, params, fns)).join("");
+}
+function parseExpr(s) {
+  if ((s[0] === '"' || s[0] === "'") && s[0] === s[s.length - 1]) {
+    const esc = { n: "\n", t: "	", r: "\r" };
+    return {
+      type: "string",
+      value: s.slice(1, -1).replace(/\\(.)/g, (_, c) => esc[c] ?? c)
+    };
+  }
+  if (/^-?\d+(\.\d+)?$/.test(s)) return { type: "number", value: +s };
+  const m = s.match(/^(\w+)\(/);
+  if (m && s.endsWith(")"))
+    return { type: "call", func: m[1], args: splitArgs(s.slice(m[0].length, -1)).map(parseExpr) };
+  return { type: "path", parts: s.split(".") };
+}
+function splitArgs(s) {
+  const args = [];
+  let cur = "", depth = 0, quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if ((c === '"' || c === "'") && s[i - 1] !== "\\") quote = quote === c ? null : quote ?? c;
+    if (!quote) {
+      if (c === "(") depth++;
+      if (c === ")") depth--;
+      if (c === "," && depth === 0) {
+        args.push(cur.trim());
+        cur = "";
+        continue;
+      }
+    }
+    cur += c;
+  }
+  if (cur.trim()) args.push(cur.trim());
+  return args;
+}
+function resolve(parts, obj) {
+  for (const p of parts) {
+    if (obj == null || typeof obj !== "object") return void 0;
+    obj = obj[p];
+  }
+  return obj;
+}
+function evalExpr(e, params, fns) {
+  if (e.type === "string") return e.value;
+  if (e.type === "number") return String(e.value);
+  if (e.type === "path") return String(resolve(e.parts, params) ?? "");
+  const fn = fns[e.func];
+  if (!fn) throw new Error(`Unknown function: ${e.func}`);
+  return fn(
+    ...e.args.map(
+      (a) => a.type === "path" ? resolve(a.parts, params) : a.type === "call" ? evalExpr(a, params, fns) : a.value
+    )
+  );
+}
+export {
+  apply,
+  compile
+};

package/dist/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/types.d.mts

@@ -0,0 +1,216 @@
+import { RequestCookies } from 'next/dist/server/web/spec-extension/cookies';
+import { NextRequest, NextMiddleware } from 'next/server';
+
+/** Server-side request context collected in middleware */
+interface ServerEventContext {
+    /** When the event was collected on server */
+    collectedAt: Date;
+    /** Request host (e.g. "example.com") */
+    host: string;
+    /** HTTP method (GET, POST, etc.) */
+    method: string;
+    /** URL pathname (e.g. "/products/123") */
+    path: string;
+    /** Query parameters as key -> values[] */
+    search: Record<string, string[]>;
+    /** Client IP from x-forwarded-for or direct connection */
+    ip: string;
+    /** Request headers (sensitive ones removed) */
+    requestHeaders: Record<string, string>;
+    /** Response headers */
+    responseHeaders: Record<string, string>;
+}
+/** Client-side context collected in browser */
+interface ClientContext {
+    /** When the event was collected on client */
+    collectedAt: Date;
+    /** document.referrer */
+    referer?: string;
+    /** window.location.pathname - may differ from server path in SPAs */
+    path?: string;
+    /** Screen and viewport dimensions */
+    screen: {
+        /** screen.width */
+        width?: number;
+        /** screen.height */
+        height?: number;
+        /** window.innerWidth (viewport) */
+        innerWidth?: number;
+        /** window.innerHeight (viewport) */
+        innerHeight?: number;
+        /** window.devicePixelRatio */
+        density?: number;
+    };
+    /** navigator.userAgent */
+    userAgent?: string;
+    /** navigator.language */
+    locale?: string;
+}
+/** Identified user context */
+interface UserContext {
+    /** Unique user identifier */
+    userId: string;
+    /** User traits for identification */
+    traits: {
+        email?: string;
+        name?: string;
+        phone?: string;
+    } & Record<string, unknown>;
+}
+/** Analytics event sent to backends */
+interface NextlyticsEvent {
+    /** ISO timestamp when event was collected */
+    collectedAt: string;
+    /** Unique event ID */
+    eventId: string;
+    /** Parent event ID (e.g. pageView for client events) */
+    parentEventId?: string;
+    /** Event type (e.g. "pageView", "apiCall", custom events) */
+    type: "pageView" | "apiCall" | string;
+    /** Anonymous user identifier (GDPR-compliant hash or cookie-based) */
+    anonymousUserId?: string;
+    /** Server-side request context */
+    serverContext: ServerEventContext;
+    /** Identified user context */
+    userContext?: UserContext;
+    /** Client-side browser context */
+    clientContext?: ClientContext;
+    /** Custom event properties */
+    properties: Record<string, unknown>;
+}
+
+type AnonymousUserResult = {
+    /** Anonymous user identifier */
+    anonId: string;
+};
+/** Headers and cookies context for backend/plugin factories. Uses Pick for compatibility with both
+ * middleware (RequestCookies) and server components (ReadonlyRequestCookies) */
+type RequestContext = {
+    headers: Headers;
+    cookies: Pick<RequestCookies, "get" | "getAll" | "has">;
+};
+type NextlyticsPlugin = {
+    /**
+     * Called right after event is created but before it's sent to backends.
+     * Plugin can mutate the event to add/modify properties.
+     * @param event - The event to process (can be mutated)
+     */
+    onDispatch(event: NextlyticsEvent): Promise<void>;
+};
+/** Factory to create plugin per-request (for request-scoped plugins) */
+type NextlyticsPluginFactory = (ctx: RequestContext) => NextlyticsPlugin;
+type NextlyticsConfig = {
+    /** Enable debug logging (shows backend stats for each event) */
+    debug?: boolean;
+    anonymousUsers?: {
+        /** Store anonymous ID in cookies */
+        useCookies?: boolean;
+        /** Use hash-based IDs for GDPR compliance (default: true) */
+        gdprMode?: boolean;
+        /** Rotate hash salt daily for shorter-lived IDs (default: true) */
+        dailySalt?: boolean;
+        /** Cookie name when useCookies=true (default: "__nextlytics_anon") */
+        cookieName?: string;
+        /** Cookie max age in seconds (default: 2 years) */
+        cookieMaxAge?: number;
+    };
+    /**
+     * When to record pageView:
+     * - "server": in middleware (default, more reliable)
+     * - "client-init": when JS loads (has client context) - NOT SUPPORTED CURRENTLU
+     */
+    pageViewMode?: "server" | "client-init";
+    /** Skip tracking for API routes */
+    excludeApiCalls?: boolean;
+    /** Skip tracking for specific paths */
+    excludePaths?: (path: string) => boolean;
+    /** Determine if path is API route. Default: () => false */
+    isApiPath?: (path: string) => boolean;
+    /** Endpoint for client events. Default: "/api/event" */
+    eventEndpoint?: string;
+    callbacks: {
+        /** Resolve authenticated user from request context */
+        getUser?: (ctx: RequestContext) => Promise<UserContext | undefined>;
+        /** Override anonymous user ID generation */
+        getAnonymousUserId?: (opts: {
+            ctx: RequestContext;
+            originalAnonymousUserId?: string;
+        }) => Promise<AnonymousUserResult>;
+    };
+    /** Analytics backends to send events to */
+    backends?: (NextlyticsBackend | NextlyticsBackendFactory)[];
+    plugins?: (NextlyticsPlugin | NextlyticsPluginFactory)[];
+};
+type ClientAction = {
+    items: ClientActionItem[];
+};
+type ClientActionItem = TemplatizedScriptInsertion<unknown>;
+/**
+ * Inserts scripts to a page as
+ * `<script scr={src}></script>` or <script>{body}</script>
+ */
+type TemplatizedScriptInsertion<T> = {
+    type: "script-template";
+    params: T;
+    templateId: string;
+};
+/** Result of dispatching an event (two-phase) */
+type DispatchResult = {
+    /** Resolves quickly with actions from backends with returnsClientActions=true */
+    clientActions: Promise<ClientAction>;
+    /** Resolves when ALL backends complete processing */
+    completion: Promise<void>;
+};
+type JavascriptTemplate = {
+    items: ScriptElement[];
+};
+type ScriptElement = {
+    async?: string;
+    body?: string;
+    src?: string;
+    /** If true, skip insertion if script with same src already exists */
+    singleton?: boolean;
+};
+/** Backend that receives analytics events */
+type NextlyticsBackend = {
+    /** Backend name for logging */
+    name: string;
+    /** Whether backend supports updating existing events */
+    supportsUpdates?: boolean;
+    /**
+     * If onEvent can return client actions
+     */
+    returnsClientActions?: boolean;
+    getClientSideTemplates?: () => Record<string, JavascriptTemplate>;
+    /** Handle new event */
+    onEvent(event: NextlyticsEvent): Promise<void | ClientAction>;
+    /** Update existing event (e.g. add client context to server pageView) */
+    updateEvent(eventId: string, patch: Partial<NextlyticsEvent>): Promise<void> | void;
+};
+/** Factory to create backend per-request (for request-scoped backends) */
+type NextlyticsBackendFactory = (ctx: RequestContext) => NextlyticsBackend;
+/** Server-side analytics API */
+type NextlyticsServerSide = {
+    /** Send custom event from server component/action */
+    sendEvent: (eventName: string, opts?: {
+        props?: Record<string, unknown>;
+    }) => Promise<{
+        ok: boolean;
+    }>;
+};
+type AppRouteHandlers = Record<"GET" | "POST", (req: NextRequest) => Promise<Response>>;
+/** 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 */
+    middleware: NextMiddleware;
+    /** Manually dispatch event (returns two-phase result) */
+    dispatchEvent: (event: NextlyticsEvent) => Promise<DispatchResult>;
+    /** Manually update existing event */
+    updateEvent: (eventId: string, patch: Partial<NextlyticsEvent>) => Promise<void>;
+};
+
+export type { AnonymousUserResult, ClientAction, ClientActionItem, ClientContext, DispatchResult, JavascriptTemplate, NextlyticsBackend, NextlyticsBackendFactory, NextlyticsConfig, NextlyticsEvent, NextlyticsPlugin, NextlyticsPluginFactory, NextlyticsResult, NextlyticsServerSide, RequestContext, ScriptElement, ServerEventContext, TemplatizedScriptInsertion, UserContext };