apptvty 0.1.2

package/dist/middleware/nextjs.js

@@ -0,0 +1,658 @@
+"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);
+
+// src/middleware/nextjs.ts
+var nextjs_exports = {};
+__export(nextjs_exports, {
+  createNextjsQueryHandler: () => createNextjsQueryHandler,
+  withApptvty: () => withApptvty
+});
+module.exports = __toCommonJS(nextjs_exports);
+var import_server = require("next/server");
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.apptvty.com";
+function resolveBaseUrl(config) {
+  const raw = config.baseUrl ?? (typeof process !== "undefined" ? process.env?.APPTVTY_API_URL : void 0) ?? DEFAULT_BASE_URL;
+  return raw.replace(/\/$/, "");
+}
+var ApptvtyClient = class {
+  constructor(config) {
+    this.baseUrl = resolveBaseUrl(config);
+    this.apiKey = config.apiKey;
+    this.siteId = config.siteId;
+    this.debug = config.debug ?? false;
+  }
+  /**
+   * Send a batch of request log entries to the Apptvty ingestion API.
+   * Called by the logger's auto-flush — not called directly by user code.
+   */
+  async sendLogs(logs) {
+    if (logs.length === 0) return;
+    try {
+      await this.post("/v1/logs/batch", { logs });
+      this.log(`Flushed ${logs.length} log(s)`);
+    } catch (err) {
+      if (err instanceof ApptvtyTrialExpiredError) {
+        console.warn(
+          `
+[apptvty] \u26A0  FREE TRIAL EXPIRED
+[apptvty]    Log in and upgrade to keep receiving agent analytics.
+[apptvty]    Dashboard: ${err.dashboardUrl}
+`
+        );
+        return;
+      }
+      this.warn("Failed to send logs:", err);
+    }
+  }
+  /**
+   * Send a query to the Apptvty backend.
+   * The backend runs RAG against the site's indexed content and,
+   * if ads are enabled for the site, attaches a relevant sponsored ad.
+   *
+   * @throws on non-retryable errors (network errors, 5xx) — callers should catch
+   */
+  async query(req) {
+    const response = await this.post("/v1/query", req);
+    return response;
+  }
+  /**
+   * Get relevant ads for a page (for HTML injection when crawler is detected).
+   * Used by middleware to inject ads into HTML responses.
+   */
+  async getAdsForPage(req) {
+    const response = await this.post("/v1/ads/for-page", req);
+    return response;
+  }
+  /**
+   * Log an ad impression back to Apptvty.
+   *
+   * Called after returning a query response that contains a `sponsored` block.
+   * This is what triggers the billing cycle:
+   *   - Advertiser gets charged (debited from their USDC ad budget)
+   *   - Publisher (the website) gets credited in USDC
+   *
+   * This call is fire-and-forget. The SDK logs a warning on failure
+   * but does not throw — a missed impression log is better than
+   * breaking the query response.
+   */
+  async logImpression(impression) {
+    try {
+      await this.post("/v1/impressions", impression);
+      this.log(`Impression logged: ${impression.impression_id}`);
+    } catch (err) {
+      this.warn("Failed to log impression (billing may be delayed):", err);
+    }
+  }
+  // ─── Analytics (for coding agents) ───────────────────────────────────────────
+  // These allow agents to check activity, logs, and errors without a human.
+  /** Get 30-day traffic overview (requests, AI %, crawlers, queries). */
+  async getSiteStats() {
+    return this.get(`/v1/sites/${this.siteId}/stats`);
+  }
+  /** Get day-by-day stats (default 30 days, max 90). */
+  async getSiteDailyStats(days = 30) {
+    return this.get(`/v1/sites/${this.siteId}/stats/daily`, { days: String(days) });
+  }
+  /** Get crawler breakdown by type (default 30 days). */
+  async getSiteCrawlers(days = 30) {
+    return this.get(`/v1/sites/${this.siteId}/crawlers`, { days: String(days) });
+  }
+  /** Get recent activity feed (last hour, default 50 items, max 200). */
+  async getSiteActivity(limit = 50) {
+    return this.get(`/v1/sites/${this.siteId}/activity`, { limit: String(limit) });
+  }
+  /** Get recent agent queries (default 50, max 200). */
+  async getSiteQueries(limit = 50) {
+    return this.get(`/v1/sites/${this.siteId}/queries`, { limit: String(limit) });
+  }
+  /** Get wallet balance and earnings. */
+  async getSiteWallet() {
+    return this.get(`/v1/sites/${this.siteId}/wallet`);
+  }
+  async get(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "User-Agent": "apptvty-sdk/0.1.0"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new ApptvtyApiError(response.status, path, text);
+    }
+    return response.json();
+  }
+  async post(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": "apptvty-sdk/0.1.0"
+      },
+      body: JSON.stringify(body),
+      // Node 18+ fetch: set a reasonable timeout via AbortSignal
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      if (response.status === 402) {
+        let dashboardUrl = "https://dashboard.apptvty.com/login";
+        try {
+          const json = JSON.parse(text);
+          dashboardUrl = json?.error?.details?.dashboard_url ?? dashboardUrl;
+        } catch {
+        }
+        throw new ApptvtyTrialExpiredError(dashboardUrl);
+      }
+      throw new ApptvtyApiError(response.status, path, text);
+    }
+    return response.json();
+  }
+  log(...args) {
+    if (this.debug) console.log("[apptvty]", ...args);
+  }
+  warn(...args) {
+    if (this.debug) console.warn("[apptvty]", ...args);
+  }
+};
+var ApptvtyApiError = class extends Error {
+  constructor(statusCode, path, body) {
+    super(`Apptvty API error ${statusCode} at ${path}: ${body}`);
+    this.statusCode = statusCode;
+    this.path = path;
+    this.body = body;
+    this.name = "ApptvtyApiError";
+  }
+};
+var ApptvtyTrialExpiredError = class extends Error {
+  constructor(dashboardUrl) {
+    super(`Apptvty free trial has expired. Log in to continue: ${dashboardUrl}`);
+    this.dashboardUrl = dashboardUrl;
+    this.name = "ApptvtyTrialExpiredError";
+  }
+};
+
+// src/crawler.ts
+var KNOWN_CRAWLERS = [
+  // OpenAI
+  { name: "GPTBot", organization: "OpenAI", patterns: [/GPTBot/i, /ChatGPT-User/i] },
+  { name: "OpenAI-SearchBot", organization: "OpenAI", patterns: [/OpenAI-SearchBot/i] },
+  // Anthropic
+  { name: "ClaudeBot", organization: "Anthropic", patterns: [/ClaudeBot/i, /Claude-Web/i, /Anthropic-AI/i] },
+  // Google
+  { name: "Google-Extended", organization: "Google AI", patterns: [/Google-Extended/i] },
+  { name: "GoogleOther", organization: "Google AI", patterns: [/GoogleOther/i] },
+  { name: "Googlebot", organization: "Google", patterns: [/Googlebot/i] },
+  // Microsoft
+  { name: "Bingbot", organization: "Microsoft", patterns: [/bingbot/i, /BingPreview/i] },
+  // Perplexity
+  { name: "PerplexityBot", organization: "Perplexity", patterns: [/PerplexityBot/i] },
+  // You.com
+  { name: "YouBot", organization: "You.com", patterns: [/YouBot/i] },
+  // Meta
+  { name: "Meta-ExternalAgent", organization: "Meta", patterns: [/Meta-ExternalAgent/i] },
+  { name: "FacebookBot", organization: "Meta", patterns: [/facebookexternalhit/i, /FacebookBot/i] },
+  // Apple
+  { name: "AppleBot", organization: "Apple", patterns: [/Applebot/i] },
+  // Twitter/X
+  { name: "TwitterBot", organization: "Twitter/X", patterns: [/Twitterbot/i] },
+  // LinkedIn
+  { name: "LinkedInBot", organization: "LinkedIn", patterns: [/LinkedInBot/i] },
+  // DuckDuckGo
+  { name: "DuckDuckBot", organization: "DuckDuckGo", patterns: [/DuckDuckBot/i] },
+  // Cohere
+  { name: "Cohere-AI", organization: "Cohere", patterns: [/Cohere-AI/i, /cohere-ai/i] },
+  // Allen Institute
+  { name: "AI2Bot", organization: "Allen Institute for AI", patterns: [/AI2Bot/i] },
+  // Mistral
+  { name: "MistralBot", organization: "Mistral AI", patterns: [/MistralBot/i] }
+];
+var AI_PATTERN_MATCHES = [
+  [/openai/i, 0.9],
+  [/anthropic/i, 0.9],
+  [/gpt|chatgpt/i, 0.85],
+  [/claude/i, 0.85],
+  [/perplexity/i, 0.85],
+  [/llm|language[- ]model/i, 0.75],
+  [/bot.*ai|ai.*bot/i, 0.75],
+  [/search.*ai|ai.*search/i, 0.7]
+];
+var HUMAN_SIGNALS = [
+  /Mozilla\/5\.0.*\(Windows NT.*\) AppleWebKit.*Chrome.*Safari/i,
+  /Mozilla\/5\.0.*\(Macintosh.*\) AppleWebKit.*Version.*Safari/i
+];
+function detectCrawler(userAgent) {
+  if (!userAgent || userAgent.length < 4) {
+    return { isAi: false, name: null, organization: null, confidence: 0.3, detectionMethod: "heuristic" };
+  }
+  for (const crawler of KNOWN_CRAWLERS) {
+    for (const pattern of crawler.patterns) {
+      if (pattern.test(userAgent)) {
+        return {
+          isAi: true,
+          name: crawler.name,
+          organization: crawler.organization,
+          confidence: 0.95,
+          detectionMethod: "exact_match"
+        };
+      }
+    }
+  }
+  for (const pattern of HUMAN_SIGNALS) {
+    if (pattern.test(userAgent)) {
+      return { isAi: false, name: null, organization: null, confidence: 0.85, detectionMethod: "heuristic" };
+    }
+  }
+  for (const [pattern, confidence] of AI_PATTERN_MATCHES) {
+    if (pattern.test(userAgent)) {
+      return {
+        isAi: true,
+        name: extractBotName(userAgent),
+        organization: null,
+        confidence,
+        detectionMethod: "pattern_match"
+      };
+    }
+  }
+  let score = 0;
+  if (/bot|crawler|spider|scraper/i.test(userAgent)) score += 0.4;
+  if (/python-requests|curl\/|wget\/|scrapy|go-http-client/i.test(userAgent)) score += 0.3;
+  if (!userAgent.includes("Mozilla")) score += 0.2;
+  if (userAgent.length < 20) score += 0.2;
+  if (score >= 0.5) {
+    return {
+      isAi: false,
+      // Generic bot — not classified as AI
+      name: "unknown_bot",
+      organization: null,
+      confidence: Math.min(score, 0.8),
+      detectionMethod: "heuristic"
+    };
+  }
+  return { isAi: false, name: null, organization: null, confidence: 0.1, detectionMethod: "none" };
+}
+function extractBotName(userAgent) {
+  const parts = userAgent.split(/[\s/;(]+/);
+  for (const part of parts) {
+    if (/bot|agent|crawler|ai/i.test(part) && part.length > 2) {
+      return part.replace(/[^a-zA-Z0-9-_]/g, "");
+    }
+  }
+  return "unknown_ai_bot";
+}
+
+// src/logger.ts
+var RequestLogger = class {
+  constructor(client, config) {
+    this.client = client;
+    this.queue = [];
+    this.timer = null;
+    this.flushing = false;
+    this.batchSize = config.batchSize ?? 50;
+    this.debug = config.debug ?? false;
+    const interval = config.flushInterval ?? 5e3;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, interval);
+    if (this.timer.unref) this.timer.unref();
+    const handleExit = () => {
+      void this.flushSync();
+    };
+    process.once("SIGTERM", handleExit);
+    process.once("SIGINT", handleExit);
+    process.once("beforeExit", handleExit);
+  }
+  /** Enqueue a single log entry. Non-blocking. */
+  enqueue(entry) {
+    this.queue.push(entry);
+    if (this.queue.length >= this.batchSize) {
+      void this.flush();
+    }
+  }
+  /** Flush the current queue to the API. */
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0, this.batchSize);
+    try {
+      await this.client.sendLogs(batch);
+    } catch {
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /**
+   * Synchronous-ish flush for process shutdown.
+   * Fires the fetch and doesn't await to avoid blocking exit handlers.
+   */
+  flushSync() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue.splice(0);
+    void this.client.sendLogs(batch);
+  }
+  /** Stop the interval timer. Call when you want to fully tear down the SDK. */
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    void this.flush();
+  }
+  log(...args) {
+    if (this.debug) console.log("[apptvty:logger]", ...args);
+  }
+};
+function getClientIp(headers) {
+  const forwarded = headers["x-forwarded-for"];
+  if (forwarded) {
+    const first = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+    return first.split(",")[0].trim();
+  }
+  return headers["x-real-ip"] ?? "unknown";
+}
+
+// src/query-handler.ts
+var RESPONSE_HEADERS = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store",
+  "X-Robots-Tag": "noindex"
+  // Don't index the query endpoint itself
+};
+function createQueryHandler(client, config) {
+  const queryPath = config.queryPath ?? "/query";
+  return async function handleQuery(req) {
+    if (!req.query || req.query.trim() === "") {
+      const origin = getOrigin(req.requestUrl);
+      const discovery = {
+        version: "1.0",
+        endpoint: `${origin}${queryPath}`,
+        description: "Query this site's content directly. Submit a question and receive a structured JSON response with an AI-generated answer, source citations, and confidence score. Ideal for AI agents, search engines, and automated systems seeking direct answers.",
+        crawl_policy: "Do not crawl this entire site unnecessarily. Use this query endpoint with ?q=your_question to get the relevant information you need. Full-site crawling is discouraged.",
+        usage: {
+          method: "GET",
+          parameters: {
+            q: {
+              type: "string",
+              required: true,
+              description: "Your question or search query (max 500 characters)"
+            },
+            lang: {
+              type: "string",
+              required: false,
+              description: "Preferred response language (ISO 639-1 code, default: en)"
+            },
+            surface_ads: {
+              type: "boolean",
+              required: false,
+              description: "Include sponsored ads in response (1 = yes, default; 0 = no). When crawling, use ai_crawler=1 to signal you want ads."
+            },
+            ai_crawler: {
+              type: "boolean",
+              required: false,
+              description: "Set to 1 when you are an AI agent/crawler. Signals the server to surface ads. Use with ?q=... for targeted answers + ads."
+            }
+          },
+          example: `${origin}${queryPath}?q=what+features+do+you+offer&ai_crawler=1`,
+          response_format: "application/json"
+        },
+        capabilities: [
+          "Natural language question answering",
+          "Source citations with relevance scores",
+          "Structured JSON for easy parsing",
+          "Supports follow-up context via session continuity",
+          "Query-preferred: use ?q= instead of full-site crawl"
+        ],
+        rate_limit: "100 requests per hour per IP"
+      };
+      return { status: 200, body: discovery, headers: RESPONSE_HEADERS };
+    }
+    const trimmedQuery = req.query.trim();
+    if (trimmedQuery.length > 500) {
+      return errorResponse(400, "QUERY_TOO_LONG", "Query must be 500 characters or fewer");
+    }
+    const requestId = crypto.randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const startMs = Date.now();
+    const surfaceAds = req.surface_ads !== false;
+    const aiCrawler = req.ai_crawler === true;
+    let backendResponse;
+    try {
+      backendResponse = await client.query({
+        site_id: config.siteId,
+        query: trimmedQuery,
+        agent_ua: req.userAgent,
+        agent_ip: req.ipAddress,
+        request_id: requestId,
+        timestamp,
+        surface_ads: surfaceAds,
+        ai_crawler: aiCrawler
+      });
+    } catch (err) {
+      if (err instanceof ApptvtyTrialExpiredError) {
+        return errorResponse(
+          402,
+          "TRIAL_EXPIRED",
+          `Apptvty free trial has expired. The site owner must log in and upgrade to continue. Dashboard: ${err.dashboardUrl}`
+        );
+      }
+      return errorResponse(502, "UPSTREAM_ERROR", "Could not retrieve an answer at this time");
+    }
+    const responseTimeMs = Date.now() - startMs;
+    const ads = backendResponse.sponsored ? Array.isArray(backendResponse.sponsored) ? backendResponse.sponsored : [backendResponse.sponsored] : [];
+    for (const ad of ads) {
+      void client.logImpression({
+        impression_id: ad.impression_id,
+        site_id: config.siteId,
+        query: trimmedQuery,
+        agent_ua: req.userAgent,
+        agent_ip: req.ipAddress,
+        timestamp
+      });
+    }
+    const agentResponse = {
+      success: true,
+      version: "1.0",
+      query: trimmedQuery,
+      answer: backendResponse.answer,
+      sources: backendResponse.sources,
+      confidence: backendResponse.confidence,
+      ...backendResponse.sponsored && { sponsored: backendResponse.sponsored },
+      metadata: {
+        request_id: requestId,
+        response_time_ms: responseTimeMs,
+        tokens_used: backendResponse.tokens_used,
+        site_id: config.siteId,
+        timestamp
+      }
+    };
+    return { status: 200, body: agentResponse, headers: RESPONSE_HEADERS };
+  };
+}
+function errorResponse(status, code, message) {
+  const body = {
+    success: false,
+    error: {
+      code,
+      message,
+      request_id: crypto.randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  return { status, body, headers: RESPONSE_HEADERS };
+}
+function getOrigin(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.origin;
+  } catch {
+    return "";
+  }
+}
+
+// src/middleware/nextjs.ts
+function headersToRecord(h) {
+  const entries = h.entries();
+  return Object.fromEntries(Array.from(entries));
+}
+var instances = /* @__PURE__ */ new Map();
+function getInstance(config) {
+  const key = config.apiKey;
+  if (!instances.has(key)) {
+    const client = new ApptvtyClient(config);
+    const logger = new RequestLogger(client, config);
+    instances.set(key, { client, logger });
+  }
+  return instances.get(key);
+}
+function withApptvty(config, next) {
+  const { client, logger } = getInstance(config);
+  const queryPath = config.queryPath ?? "/query";
+  return async function apptvtyMiddleware(request) {
+    const startMs = Date.now();
+    const userAgent = request.headers.get("user-agent") ?? "";
+    const crawlerInfo = detectCrawler(userAgent);
+    const aiCrawlerParam = parseBoolParam(request.nextUrl.searchParams.get("ai_crawler"), false);
+    const isCrawler = crawlerInfo.isAi || aiCrawlerParam;
+    let response;
+    try {
+      response = next ? await next(request) : import_server.NextResponse.next();
+    } catch (err) {
+      throw err;
+    }
+    const responseTimeMs = Date.now() - startMs;
+    const { pathname } = request.nextUrl;
+    if (shouldSkip(pathname)) {
+      return response;
+    }
+    const headers = headersToRecord(request.headers);
+    const entry = {
+      site_id: config.siteId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      method: request.method,
+      path: pathname,
+      status_code: response.status,
+      response_time_ms: responseTimeMs,
+      ip_address: getClientIp(headers),
+      user_agent: userAgent,
+      referer: request.headers.get("referer"),
+      is_ai_crawler: crawlerInfo.isAi,
+      crawler_type: crawlerInfo.name,
+      crawler_organization: crawlerInfo.organization,
+      confidence_score: crawlerInfo.confidence
+    };
+    logger.enqueue(entry);
+    if (isCrawler && response.ok && !pathname.startsWith(queryPath)) {
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("text/html")) {
+        try {
+          const modified = await injectAdsIntoHtml(response, client, config.siteId, pathname);
+          if (modified) return modified;
+        } catch (err) {
+          if (config.debug) console.warn("[apptvty] Ad injection failed:", err);
+        }
+      }
+    }
+    return response;
+  };
+}
+function createNextjsQueryHandler(config) {
+  const { client } = getInstance(config);
+  const handleQuery = createQueryHandler(client, config);
+  return async function GET(request) {
+    const { searchParams } = request.nextUrl;
+    const q = searchParams.get("q");
+    const lang = searchParams.get("lang");
+    const surfaceAds = parseBoolParam(searchParams.get("surface_ads"), true);
+    const aiCrawler = parseBoolParam(searchParams.get("ai_crawler"), false);
+    const userAgent = request.headers.get("user-agent") ?? "";
+    const headers = headersToRecord(request.headers);
+    const result = await handleQuery({
+      query: q,
+      lang,
+      surface_ads: surfaceAds,
+      ai_crawler: aiCrawler,
+      userAgent,
+      ipAddress: getClientIp(headers),
+      requestUrl: request.url
+    });
+    return import_server.NextResponse.json(result.body, {
+      status: result.status,
+      headers: result.headers
+    });
+  };
+}
+var AD_INJECTION_MARKER = "<!-- apptvty-sponsored -->";
+function buildAdBlock(ads) {
+  const items = ads.map(
+    (ad) => `<li><a href="${escapeHtml(ad.url)}" rel="nofollow">${escapeHtml(ad.text)}</a> <small>\u2014 ${escapeHtml(ad.advertiser)}</small></li>`
+  ).join("\n");
+  return `
+<section aria-label="Sponsored" data-sponsored ${AD_INJECTION_MARKER}>
+  <h3>Sponsored</h3>
+  <ul>${items}</ul>
+</section>`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+async function injectAdsIntoHtml(response, client, siteId, pathname) {
+  const html = await response.text();
+  if (!html || html.includes(AD_INJECTION_MARKER)) return null;
+  const pageAds = await client.getAdsForPage({ site_id: siteId, page_path: pathname });
+  if (!pageAds.ads || pageAds.ads.length === 0) return null;
+  const adBlock = buildAdBlock(pageAds.ads);
+  let modified;
+  if (html.includes("</body>")) {
+    modified = html.replace("</body>", `${adBlock}
+</body>`);
+  } else if (html.includes("</html>")) {
+    modified = html.replace("</html>", `${adBlock}
+</html>`);
+  } else {
+    modified = html + adBlock;
+  }
+  return new import_server.NextResponse(modified, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: new Headers(response.headers)
+  });
+}
+function parseBoolParam(value, defaultValue) {
+  if (value === null) return defaultValue;
+  return value === "1" || value === "true" || value === "yes";
+}
+function shouldSkip(pathname) {
+  return pathname.startsWith("/_next/") || pathname.startsWith("/api/_") || pathname === "/favicon.ico" || /\.(svg|png|jpg|jpeg|gif|webp|ico|woff2?|ttf|css|js\.map)$/.test(pathname);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNextjsQueryHandler,
+  withApptvty
+});
+//# sourceMappingURL=nextjs.js.map