@nextlytics/core 0.3.0-canary.80 → 0.3.0

package/dist/backends/ga.d.ts

@@ -15,11 +15,6 @@ type GoogleAnalyticsBackendOptions = {
      * - "anonymousUserId": Always use Nextlytics anonymousUserId
      */
     clientIdSource?: "gaCookie" | "anonymousUserId";
-    /**
-     * Prefer sending client-origin events from the browser (gtag) instead of Measurement Protocol.
-     * Default: true. Set to false to force Measurement Protocol when apiSecret is provided.
-     */
-    preferClientSideForClientEvents?: boolean;
 };
 declare function googleAnalyticsBackend(opts: GoogleAnalyticsBackendOptions): NextlyticsBackendFactory;
 

package/dist/backends/ga.js

@@ -21,9 +21,7 @@ __export(ga_exports, {
   googleAnalyticsBackend: () => googleAnalyticsBackend
 });
 module.exports = __toCommonJS(ga_exports);
-const GA_INIT_TEMPLATE = "ga-gtag";
-const GA_PROPERTIES_TEMPLATE = "ga-properties";
-const GA_EVENT_TEMPLATE = "ga-event";
+const GA_TEMPLATE_ID = "ga-gtag";
 function parseGaCookie(cookieValue) {
   const match = cookieValue.match(/^GA\d+\.\d+\.(.+)$/);
   return match ? match[1] : null;
@@ -120,51 +118,27 @@ function googleAnalyticsBackend(opts) {
   return (ctx) => {
     const gaCookie = ctx.cookies.get("_ga");
     const gaCookieClientId = gaCookie ? parseGaCookie(gaCookie.value) : null;
-    const preferClientSideForClientEvents = opts.preferClientSideForClientEvents ?? true;
     return {
       name: "google-analytics",
       returnsClientActions: true,
       supportsUpdates: false,
       getClientSideTemplates() {
         return {
-          [GA_EVENT_TEMPLATE]: {
-            deps: "{{eventId}}",
+          [GA_TEMPLATE_ID]: {
             items: [
-              // Update user properties for this event (if provided)
-              {
-                body: [
-                  "gtag('set', {{json(properties)}});",
-                  "gtag('event', '{{eventName}}', {{json(eventParams)}});"
-                ]
-              }
-            ]
-          },
-          [GA_INIT_TEMPLATE]: {
-            deps: "{{measurementId}}{{json(initial_config)}}",
-            items: [
-              // External gtag.js - load once
               {
+                async: "true",
                 src: "https://www.googletagmanager.com/gtag/js?id={{measurementId}}",
-                async: true
+                singleton: true
               },
-              // gtag definition and initialization - run once
               {
                 body: [
                   "window.dataLayer = window.dataLayer || [];",
-                  opts.debugMode ? "function gtag(){ console.log('[gtag() call]', arguments); dataLayer.push(arguments); }" : "function gtag(){dataLayer.push(arguments);}",
-                  "window.gtag = gtag;",
+                  "function gtag(){dataLayer.push(arguments);}",
                   "gtag('js', new Date());",
-                  "gtag('config', '{{measurementId}}', {{json(initial_config)}});"
-                ]
-              }
-            ]
-          },
-          [GA_PROPERTIES_TEMPLATE]: {
-            deps: "{{json(properties)}}",
-            items: [
-              // Updates that should NOT trigger page_view (e.g., user_id, user_properties)
-              {
-                body: "gtag('set', {{json(properties)}});"
+                  "gtag('config', '{{measurementId}}', {{json(config)}});",
+                  "gtag('event', 'page_view');"
+                ].join("\n")
               }
             ]
           }
@@ -181,66 +155,33 @@ function googleAnalyticsBackend(opts) {
         } = event.userContext?.traits ?? {};
         const userProperties = Object.keys(customTraits).length > 0 ? customTraits : void 0;
         if (event.type === "pageView") {
-          const initial_config = {
-            // Rely on GA auto page_view (including SPA history changes).
-            send_page_view: true,
+          const config = {
+            send_page_view: false,
             client_id: clientId
           };
           if (debugMode) {
-            initial_config.debug_mode = true;
+            config.debug_mode = true;
           }
-          const properties2 = {};
           if (userId) {
-            properties2.user_id = userId;
+            config.user_id = userId;
           }
           if (userProperties) {
-            properties2.user_properties = userProperties;
+            config.user_properties = userProperties;
           }
           return {
             items: [
               {
                 type: "script-template",
-                templateId: GA_INIT_TEMPLATE,
+                templateId: GA_TEMPLATE_ID,
                 params: {
                   measurementId,
-                  initial_config
-                }
-              },
-              {
-                type: "script-template",
-                templateId: GA_PROPERTIES_TEMPLATE,
-                params: {
-                  properties: properties2
+                  config
                 }
               }
             ]
           };
         }
-        const eventParams = buildEventParams(event);
-        const properties = {};
-        if (userId) {
-          properties.user_id = userId;
-        }
-        if (userProperties) {
-          properties.user_properties = userProperties;
-        }
-        if (event.origin === "client") {
-          if (preferClientSideForClientEvents || !apiSecret) {
-            return {
-              items: [
-                {
-                  type: "script-template",
-                  templateId: GA_EVENT_TEMPLATE,
-                  params: {
-                    eventId: event.eventId,
-                    eventName: toGA4EventName(event.type),
-                    eventParams,
-                    properties
-                  }
-                }
-              ]
-            };
-          }
+        if (apiSecret) {
           await sendToMeasurementProtocol({
             measurementId,
             apiSecret,
@@ -248,29 +189,12 @@ function googleAnalyticsBackend(opts) {
             userId,
             userProperties,
             eventName: toGA4EventName(event.type),
-            eventParams,
+            eventParams: buildEventParams(event),
             userAgent: getUserAgent(event),
             clientIp: getClientIp(event),
             debugMode
           });
-          return void 0;
-        }
-        if (!apiSecret) {
-          return void 0;
         }
-        await sendToMeasurementProtocol({
-          measurementId,
-          apiSecret,
-          clientId,
-          userId,
-          userProperties,
-          eventName: toGA4EventName(event.type),
-          eventParams,
-          userAgent: getUserAgent(event),
-          clientIp: getClientIp(event),
-          debugMode
-        });
-        return void 0;
       },
       updateEvent() {
       }

package/dist/backends/gtm.js

@@ -22,7 +22,6 @@ __export(gtm_exports, {
 });
 module.exports = __toCommonJS(gtm_exports);
 const GTM_INIT_TEMPLATE_ID = "gtm-init";
-const GTM_INIT_DATA_TEMPLATE_ID = "gtm-init-data";
 const GTM_PAGEVIEW_TEMPLATE_ID = "gtm-pageview";
 const GTM_EVENT_TEMPLATE_ID = "gtm-event";
 function toSnakeCase(str) {
@@ -38,27 +37,21 @@ function googleTagManagerBackend(opts) {
       return {
         [GTM_INIT_TEMPLATE_ID]: {
           items: [
-            // GTM script loader - run once
             {
               body: [
                 "window.dataLayer = window.dataLayer || [];",
-                "(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':",
-                "new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],",
-                "j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=",
-                "'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);",
-                "})(window,document,'script','dataLayer','{{containerId}}');"
+                "dataLayer.push({{json(initialData)}});",
+                "if (!window.google_tag_manager || !window.google_tag_manager['{{containerId}}']) {",
+                "  (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':",
+                "  new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],",
+                "  j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=",
+                "  'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);",
+                "  })(window,document,'script','dataLayer','{{containerId}}');",
+                "}"
               ].join("\n")
             }
           ]
         },
-        [GTM_INIT_DATA_TEMPLATE_ID]: {
-          items: [
-            // Initial data push - run when params change (e.g., user logs in)
-            {
-              body: "dataLayer.push({{json(initialData)}});"
-            }
-          ]
-        },
         [GTM_PAGEVIEW_TEMPLATE_ID]: {
           items: [
             {
@@ -129,11 +122,6 @@ function googleTagManagerBackend(opts) {
       if (event.clientContext) {
         return {
           items: [
-            {
-              type: "script-template",
-              templateId: GTM_INIT_DATA_TEMPLATE_ID,
-              params: { initialData }
-            },
             {
               type: "script-template",
               templateId: GTM_PAGEVIEW_TEMPLATE_ID,
@@ -149,11 +137,6 @@ function googleTagManagerBackend(opts) {
             templateId: GTM_INIT_TEMPLATE_ID,
             params: { containerId, initialData }
           },
-          {
-            type: "script-template",
-            templateId: GTM_INIT_DATA_TEMPLATE_ID,
-            params: { initialData }
-          },
           {
             type: "script-template",
             templateId: GTM_PAGEVIEW_TEMPLATE_ID,

package/dist/backends/logging.js

@@ -21,24 +21,10 @@ __export(logging_exports, {
   loggingBackend: () => loggingBackend
 });
 module.exports = __toCommonJS(logging_exports);
-const LOG_TEMPLATE_ID = "log-console";
 function loggingBackend() {
   return {
     name: "logging",
     supportsUpdates: true,
-    returnsClientActions: true,
-    getClientSideTemplates() {
-      return {
-        [LOG_TEMPLATE_ID]: {
-          deps: "{{eventId}}",
-          items: [
-            {
-              body: "console.log('[Nextlytics Log][client]', {{json(event)}});"
-            }
-          ]
-        }
-      };
-    },
     async onEvent(event) {
       const { type, eventId, serverContext, ...rest } = event;
       const method = serverContext?.method || "";
@@ -46,25 +32,6 @@ function loggingBackend() {
       const route = method && path ? `${method} ${path}` : "";
       console.log(`[Nextlytics Log] ${type}${route ? ` ${route}` : ""} (${eventId})`);
       console.log(JSON.stringify({ serverContext, ...rest }, null, 2));
-      if (event.origin === "client") {
-        return {
-          items: [
-            {
-              type: "script-template",
-              templateId: LOG_TEMPLATE_ID,
-              params: {
-                eventId: event.eventId,
-                event: {
-                  type: event.type,
-                  eventProps: event.properties,
-                  userProps: event.userContext
-                }
-              }
-            }
-          ]
-        };
-      }
-      return void 0;
     },
     updateEvent(eventId, patch) {
       console.log(`[Nextlytics Log] Update ${eventId}`);

package/dist/backends/segment.js

@@ -124,7 +124,6 @@ function segmentBackend(config) {
       } else {
         await send([{ type: "track", event: event.type, ...basePayload }]);
       }
-      return void 0;
     },
     updateEvent() {
     }

package/dist/client.d.ts

@@ -11,7 +11,10 @@ type NextlyticsContext = {
     templates?: Record<string, JavascriptTemplate>;
 };
 declare function NextlyticsClient(props: {
-    ctx: NextlyticsContext;
+    ctx?: NextlyticsContext;
+    requestId?: string;
+    scripts?: TemplatizedScriptInsertion<unknown>[];
+    templates?: Record<string, JavascriptTemplate>;
     children?: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 type NextlyticsClientApi = {

package/dist/client.js

@@ -25,15 +25,13 @@ __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),
-  stableHash: (v) => (0, import_stable_hash.stableHash)(v)
+  json: (v) => JSON.stringify(v ?? null)
 };
+const compiledCache = {};
 const NextlyticsContext = (0, import_react.createContext)(null);
 function createClientContext() {
   const isBrowser = typeof window !== "undefined";
@@ -57,165 +55,94 @@ function createClientContext() {
     locale: isBrowser ? navigator.language : void 0
   };
 }
-function deduplicateScripts(scripts, templates) {
-  const result = [];
-  const firstSeenByDeps = /* @__PURE__ */ new Set();
+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;
   for (const script of scripts) {
-    if (script.type !== "script-template") continue;
-    const template = templates[script.templateId];
-    if (!template) continue;
-    if (!template.deps) {
-      result.push(script);
+    if (script.type !== "script-template") {
+      console.warn(`[Nextlytics] unsupported script type ${script.type} `);
       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] Template "${script.templateId}" not found`);
+      console.warn(`[Nextlytics] Missing template: ${script.templateId}`);
       continue;
     }
-    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++;
+    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}"]`)) {
         continue;
       }
-      if (!item.body) {
-        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);
       }
-      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++;
+      if (item.async) {
+        el.async = true;
+      }
+      document.head.appendChild(el);
     }
   }
-  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));
 }
-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 } = {}) {
+async function sendEvent(requestId, type, payload) {
   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,
-      body: JSON.stringify(request),
-      signal
+      headers: {
+        "Content-Type": "application/json",
+        [import_server_component_context.headers.pageRenderId]: requestId
+      },
+      body: JSON.stringify({ type, payload })
     });
     if (response.status === 404) {
       console.error(
-        "[Nextlytics] In order for NextlyticsClient to work, you must install nextlytics middleware"
+        "[Nextlytics] In order for NextlyticsClient to work, you must mount nextlyticsRouteHandler to /api/event"
       );
       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, scripts: data.scripts };
   } 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, 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 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 clientContext = createClientContext();
-    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 })
-  ] });
+    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 });
 }
 function useNextlytics() {
   const context = (0, import_react.useContext)(NextlyticsContext);
@@ -224,24 +151,23 @@ 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 sendEvent = (0, import_react.useCallback)(
+  const { requestId, templates } = context;
+  const send = (0, import_react.useCallback)(
     async (eventName, opts) => {
-      const result = await sendEventToServer(requestId, {
-        type: "custom-event",
+      const result = await sendEvent(requestId, "client-event", {
         name: eventName,
         props: opts?.props,
         collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
         clientContext: createClientContext()
       });
-      if (result.items && result.items.length > 0) {
-        addScripts(result.items);
+      if (result.scripts) {
+        executeTemplatedScripts(result.scripts, templates);
       }
       return { ok: result.ok };
     },
-    [requestId, addScripts]
+    [requestId, templates]
   );
-  return { sendEvent };
+  return { sendEvent: send };
 }
 // 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 ?? ((str) => str.startsWith("/api")),
+    isApiPath: config.isApiPath ?? (() => false),
     backends: config.backends ?? [],
     anonymousUsers: {
       gdprMode: config.anonymousUsers?.gdprMode ?? true,

package/dist/handlers.d.ts

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,40 @@
+"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
+});