mcp-scraper 0.4.3 → 0.4.5

package/dist/{server-LBEYRKM2.js → server-XCDFHHLE.js}

@@ -31,7 +31,7 @@ import {
   registerSerpIntelligenceCaptureTools,
   sanitizeAttempts,
   sanitizeHarvestResult
-} from "./chunk-BAMVP57P.js";
+} from "./chunk-WI4A3KFQ.js";
 import {
   auditImages,
   getBlobStore
@@ -65,7 +65,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-XGIPATLV.js";
-import "./chunk-SRMGSCC3.js";
+import "./chunk-UGQC2FOX.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -76,7 +76,7 @@ import {
   saveExtractPages,
   setExtractJobTotal,
   settleExtractJob
-} from "./chunk-NVUBFCJK.js";
+} from "./chunk-4ZZWFI6L.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -95,7 +95,7 @@ import {
   browserActiveCostMc,
   concurrencySlotBillingInfo,
   insufficientBalanceResponse
-} from "./chunk-4MFYMUIF.js";
+} from "./chunk-5LO6EHEH.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -5274,7 +5274,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono21 } from "hono";
+import { Hono as Hono22 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -11935,23 +11935,8 @@ async function provisionMemoryForUser(user) {
   } catch {
   }
 }
-function memoryPlanForUser(user) {
-  switch (user.subscription_tier) {
-    case "starter":
-      return "pro";
-    case "growth":
-      return "team";
-    case "scale":
-      return "enterprise";
-    default:
-      return "free";
-  }
-}
-var MEMORY_PLAN_RANK = { free: 0, pro: 1, team: 2, enterprise: 3 };
 function resolveEffectiveMemoryPlan(user) {
-  const tierPlan = memoryPlanForUser(user);
-  const memoryProPlan = user.memory_plan === "pro" || user.memory_plan === "team" ? user.memory_plan : "free";
-  return MEMORY_PLAN_RANK[tierPlan] >= MEMORY_PLAN_RANK[memoryProPlan] ? tierPlan : memoryProPlan;
+  return user.memory_plan === "pro" || user.memory_plan === "team" ? user.memory_plan : "free";
 }
 async function getOrCreateUserMemoryKey(user) {
   const creds = await getUserMemoryCreds(user.id);
@@ -13310,13 +13295,219 @@ trustpilotApp.post("/reviews", createApiKeyAuth(), async (c) => {
   }
 });
 
-// src/api/directory-routes.ts
+// src/api/g2-routes.ts
 import { Hono as Hono12 } from "hono";
+import { z as z20 } from "zod";
+var G2ReviewsBodySchema = z20.object({
+  product: z20.string().trim().min(1, "product is required"),
+  maxPages: z20.number().int().min(1).max(50).default(5)
+});
+function invalidRequest7(message) {
+  return { error_code: "invalid_request", message };
+}
+function normalizeProductSlug(input) {
+  return input.trim().replace(/^https?:\/\/(www\.)?g2\.com\/products\//i, "").replace(/\/.*$/, "").replace(/\s+/g, "-").toLowerCase();
+}
+function reviewPageUrl2(product, page) {
+  const base = `https://www.g2.com/products/${encodeURIComponent(product)}/reviews`;
+  return page <= 1 ? base : `${base}?page=${page}`;
+}
+async function residentialProxyId2(attemptIndex) {
+  try {
+    const r = await resolveKernelProxyId({
+      kernelApiKey: browserServiceApiKey(),
+      proxyMode: "location",
+      location: "Austin, TX",
+      gl: "us",
+      attemptIndex,
+      fresh: true
+    });
+    return r.kernelProxyId;
+  } catch {
+    return void 0;
+  }
+}
+async function extractG2ReviewCards(page) {
+  return page.evaluate(() => {
+    const cards = Array.from(document.querySelectorAll("article[data-track-in-viewport-options]"));
+    return cards.map((card) => {
+      let meta = {};
+      try {
+        meta = JSON.parse(card.getAttribute("data-track-in-viewport-options") ?? "{}");
+      } catch {
+        meta = {};
+      }
+      const reviewId = meta.survey_response_id != null ? String(meta.survey_response_id) : null;
+      const publishedDateRaw = typeof meta.published_date === "string" ? meta.published_date : null;
+      const date = publishedDateRaw && /^\d{8}$/.test(publishedDateRaw) ? `${publishedDateRaw.slice(0, 4)}-${publishedDateRaw.slice(4, 6)}-${publishedDateRaw.slice(6, 8)}` : null;
+      const profileLink = card.querySelector('a[href*="/users/"]');
+      const profileHref = profileLink?.getAttribute("href") ?? "";
+      const profileMatch = profileHref.match(/\/users\/([a-f0-9-]+)/i);
+      const profileId = profileMatch ? profileMatch[1] : null;
+      const infoWrapper = profileLink?.parentElement;
+      const infoDiv = infoWrapper ? Array.from(infoWrapper.children).find((el2) => el2 !== profileLink) : null;
+      const name = infoDiv?.querySelector('div[class*="font-bold"]')?.textContent?.trim() ?? null;
+      const subtleDivs = infoDiv ? Array.from(infoDiv.querySelectorAll('div[class*="text-subtle"]')) : [];
+      const reviewerTitle = subtleDivs[0]?.textContent?.trim() ?? null;
+      const companySegment = subtleDivs[1]?.textContent?.trim() ?? null;
+      const ratingEl = card.querySelector('[class*="star-wrapper__desc__rating"]');
+      const ratingText = ratingEl?.textContent?.trim() ?? "";
+      const ratingParts = ratingText.split("/");
+      const rating = ratingParts[0] ? parseFloat(ratingParts[0]) : null;
+      const ratingScale = ratingParts[1] ? parseFloat(ratingParts[1]) : 5;
+      const titleEl = card.querySelector('div[class*="text-lg"][class*="font-bold"]');
+      const title = titleEl?.textContent?.trim().replace(/^["“]+|["”]+$/g, "") ?? null;
+      const sections = Array.from(card.querySelectorAll("section"));
+      const body = sections.map((sec) => {
+        const question = sec.querySelector('div[class*="font-bold"]')?.textContent?.trim() ?? null;
+        const paragraphs = Array.from(sec.querySelectorAll("p")).map((p) => p.textContent?.trim() ?? "");
+        const answer = paragraphs.join("\n\n").replace(/Review collected by and hosted on G2\.com\.\s*$/, "").trim();
+        return { question, answer };
+      }).filter((b) => b.answer.length > 0);
+      const flagButtons = Array.from(card.querySelectorAll("button[title]"));
+      let currentUser = false;
+      let validated = false;
+      let incentivized = false;
+      let origin = null;
+      for (const btn of flagButtons) {
+        const label = btn.querySelector("label")?.textContent?.trim() ?? "";
+        if (/current user/i.test(label)) currentUser = true;
+        else if (/validated/i.test(label)) validated = true;
+        else if (/^incentivized$/i.test(label)) incentivized = true;
+        else if (/^source:/i.test(label)) origin = label.replace(/^source:\s*/i, "").trim();
+      }
+      const copyBtn = card.querySelector('[data-clipboard-text*="/reviews/"]');
+      const reviewUrl = copyBtn?.getAttribute("data-clipboard-text") ?? null;
+      return {
+        source: "g2",
+        sourceReviewId: reviewId,
+        reviewUrl,
+        reviewer: {
+          name,
+          profileId,
+          title: reviewerTitle,
+          companySegment
+        },
+        rating,
+        ratingScale,
+        title,
+        date,
+        body: body.length > 0 ? body : [{ question: null, answer: "" }],
+        truncated: false,
+        flags: {
+          origin,
+          incentivized,
+          validated,
+          currentUser,
+          companyReplied: null
+        }
+      };
+    });
+  });
+}
+var g2App = new Hono12();
+g2App.post("/reviews", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = G2ReviewsBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest7(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  const product = normalizeProductSlug(body.product);
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "g2_reviews", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { product, maxPages: body.maxPages }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
+  let reviewDebitMc = 0;
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.g2_reviews, LedgerOperation.G2_REVIEWS, product);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.g2_reviews), 402);
+    debited = true;
+    const startMs = Date.now();
+    const allReviews = [];
+    let pagesFetched = 0;
+    let blocked = false;
+    for (let attempt = 0; attempt < 3 && pagesFetched === 0; attempt++) {
+      const proxyId = await residentialProxyId2(attempt);
+      const driver = new BrowserDriver();
+      try {
+        await driver.launch({
+          headless: true,
+          kernelApiKey: browserServiceApiKey(),
+          kernelProxyId: proxyId,
+          viewport: { width: 1280, height: 900 },
+          locale: "en-US"
+        });
+        const page = driver.getPage();
+        for (let pageNum = 1; pageNum <= body.maxPages; pageNum++) {
+          const url = reviewPageUrl2(product, pageNum);
+          await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45e3 });
+          await page.waitForTimeout(5e3);
+          await page.evaluate(() => window.scrollTo(0, 1200)).catch(() => {
+          });
+          await page.waitForTimeout(3e3);
+          let cards;
+          try {
+            cards = await extractG2ReviewCards(page);
+          } catch {
+            await page.waitForTimeout(3e3);
+            cards = await extractG2ReviewCards(page);
+          }
+          if (cards.length === 0) break;
+          allReviews.push(...cards);
+          pagesFetched = pageNum;
+        }
+      } catch {
+        blocked = true;
+      } finally {
+        await driver.close();
+      }
+    }
+    if (pagesFetched === 0 || allReviews.length === 0) {
+      await creditMc(user.id, MC_COSTS.g2_reviews, LedgerOperation.G2_REVIEWS_REFUND, blocked ? "blocked after retries" : "no reviews found");
+      await logRequestEvent({ userId: user.id, source: "g2_reviews", status: "failed", query: product, error: blocked ? "blocked after retries" : "no reviews found" });
+      return c.json({ error: "No reviews found for this product (refunded)", product }, 404);
+    }
+    reviewDebitMc = allReviews.length * MC_COSTS.g2_review;
+    if (reviewDebitMc > 0) {
+      const reviewDebit = await debitMc(user.id, reviewDebitMc, LedgerOperation.G2_REVIEW, product);
+      if (!reviewDebit.ok) {
+        allReviews.length = Math.floor((reviewDebit.balance_mc ?? 0) / MC_COSTS.g2_review);
+        reviewDebitMc = allReviews.length * MC_COSTS.g2_review;
+        if (reviewDebitMc > 0) await debitMc(user.id, reviewDebitMc, LedgerOperation.G2_REVIEW, product);
+      }
+    }
+    const result = {
+      product,
+      reviewUrl: reviewPageUrl2(product, 1),
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      requestedMaxPages: body.maxPages,
+      pagesFetched,
+      reviewCount: allReviews.length,
+      reviews: allReviews,
+      durationMs: Date.now() - startMs
+    };
+    await logRequestEvent({ userId: user.id, source: "g2_reviews", status: "done", query: product, resultCount: allReviews.length, result });
+    return c.json(result);
+  } catch (err) {
+    if (debited) await creditMc(user.id, MC_COSTS.g2_reviews, LedgerOperation.G2_REVIEWS_REFUND, "failed call");
+    if (reviewDebitMc > 0) await creditMc(user.id, reviewDebitMc, LedgerOperation.G2_REVIEW_REFUND, "failed call");
+    const msg = err instanceof Error ? err.message : String(err);
+    await logRequestEvent({ userId: user.id, source: "g2_reviews", status: "failed", query: product, error: msg });
+    return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
+
+// src/api/directory-routes.ts
+import { Hono as Hono13 } from "hono";
 
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { join as join5 } from "path";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -13477,24 +13668,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z20.object({
-  query: z20.string().min(1),
-  state: z20.string().min(2).default("TN"),
-  minPopulation: z20.number().int().min(0).default(1e5),
-  populationYear: z20.union(POPULATION_YEARS.map((year) => z20.literal(year))).default(2025),
-  maxCities: z20.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z20.number().int().min(1).max(50).default(50),
-  concurrency: z20.number().int().min(1).max(5).default(5),
-  includeZipGroups: z20.boolean().default(true),
-  usZipsCsvPath: z20.string().optional(),
-  saveCsv: z20.boolean().default(true),
-  gl: z20.string().length(2).default("us"),
-  hl: z20.string().length(2).default("en"),
-  proxyMode: z20.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z20.string().regex(/^\d{5}$/).optional(),
-  debug: z20.boolean().default(false),
-  headless: z20.boolean().default(true),
-  kernelApiKey: z20.string().optional()
+var DirectoryWorkflowOptionsSchema = z21.object({
+  query: z21.string().min(1),
+  state: z21.string().min(2).default("TN"),
+  minPopulation: z21.number().int().min(0).default(1e5),
+  populationYear: z21.union(POPULATION_YEARS.map((year) => z21.literal(year))).default(2025),
+  maxCities: z21.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z21.number().int().min(1).max(50).default(50),
+  concurrency: z21.number().int().min(1).max(5).default(5),
+  includeZipGroups: z21.boolean().default(true),
+  usZipsCsvPath: z21.string().optional(),
+  saveCsv: z21.boolean().default(true),
+  gl: z21.string().length(2).default("us"),
+  hl: z21.string().length(2).default("en"),
+  proxyMode: z21.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  proxyZip: z21.string().regex(/^\d{5}$/).optional(),
+  debug: z21.boolean().default(false),
+  headless: z21.boolean().default(true),
+  kernelApiKey: z21.string().optional()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -13715,7 +13906,7 @@ async function runDirectoryWorkflowFromPlan(options, plan) {
 }
 
 // src/api/directory-routes.ts
-var directoryApp = new Hono12();
+var directoryApp = new Hono13();
 directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -13788,35 +13979,35 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 // src/api/workflow-routes.ts
 import { createHmac as createHmac2 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { Hono as Hono13 } from "hono";
-import { z as z21 } from "zod";
-var workflowApp = new Hono13();
-var WorkflowInputSchema = z21.record(z21.unknown()).default({});
-var WorkflowIdSchema = z21.string().min(1);
-var CadenceSchema = z21.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z21.enum(["active", "paused"]);
-var RunBodySchema = z21.object({
+import { Hono as Hono14 } from "hono";
+import { z as z22 } from "zod";
+var workflowApp = new Hono14();
+var WorkflowInputSchema = z22.record(z22.unknown()).default({});
+var WorkflowIdSchema = z22.string().min(1);
+var CadenceSchema = z22.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z22.enum(["active", "paused"]);
+var RunBodySchema = z22.object({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z21.string().url().optional()
+  webhookUrl: z22.string().url().optional()
 });
-var ScheduleCreateSchema = z21.object({
+var ScheduleCreateSchema = z22.object({
   workflowId: WorkflowIdSchema,
-  name: z21.string().min(1).max(120).optional(),
+  name: z22.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z21.string().min(1).max(64).default("UTC"),
-  webhookUrl: z21.string().url().optional(),
-  nextRunAt: z21.string().datetime().optional()
+  timezone: z22.string().min(1).max(64).default("UTC"),
+  webhookUrl: z22.string().url().optional(),
+  nextRunAt: z22.string().datetime().optional()
 });
-var SchedulePatchSchema = z21.object({
-  name: z21.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z22.object({
+  name: z22.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z21.string().min(1).max(64).optional(),
-  webhookUrl: z21.string().url().nullable().optional(),
-  nextRunAt: z21.string().datetime().nullable().optional()
+  timezone: z22.string().min(1).max(64).optional(),
+  webhookUrl: z22.string().url().nullable().optional(),
+  nextRunAt: z22.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -14320,7 +14511,7 @@ workflowApp.post("/cron/dispatch", async (c) => {
 });
 
 // src/api/serp-intelligence-routes.ts
-import { Hono as Hono14 } from "hono";
+import { Hono as Hono15 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash as createHash2 } from "crypto";
@@ -14632,7 +14823,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -14694,171 +14885,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z22.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z22.object({
-  query: z22.string().trim().min(1, "query is required"),
-  location: z22.string().trim().min(1).optional(),
-  gl: z22.string().trim().length(2).default("us"),
-  hl: z22.string().trim().length(2).default("en"),
-  device: z22.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z22.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z22.string().regex(/^\d{5}$/).optional(),
-  pages: z22.number().int().min(1).max(2).default(1),
-  debug: z22.boolean().default(false),
-  includePageSnapshots: z22.boolean().default(false),
-  pageSnapshotLimit: z22.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z23.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z23.object({
+  query: z23.string().trim().min(1, "query is required"),
+  location: z23.string().trim().min(1).optional(),
+  gl: z23.string().trim().length(2).default("us"),
+  hl: z23.string().trim().length(2).default("en"),
+  device: z23.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z23.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
+  proxyZip: z23.string().regex(/^\d{5}$/).optional(),
+  pages: z23.number().int().min(1).max(2).default(1),
+  debug: z23.boolean().default(false),
+  includePageSnapshots: z23.boolean().default(false),
+  pageSnapshotLimit: z23.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z22.object({
+var SerpIntelligencePageSnapshotRequestSchema = z23.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z22.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z22.number().int().min(1).optional()
+  sourceKind: z23.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z23.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z22.object({
-  urls: z22.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z22.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z22.number().int().min(1).max(5).default(2),
-  timeoutMs: z22.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z22.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z23.object({
+  urls: z23.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  targets: z23.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z23.number().int().min(1).max(5).default(2),
+  timeoutMs: z23.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z23.boolean().default(false)
 }).strict();
-var SerpIntelligenceAICitationSchema = z22.object({
-  text: z22.string(),
-  href: z22.string()
+var SerpIntelligenceAICitationSchema = z23.object({
+  text: z23.string(),
+  href: z23.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z22.object({
-  position: z22.number().int().min(1),
-  title: z22.string(),
-  url: z22.string(),
-  domain: z22.string(),
-  cite: z22.string().nullable(),
-  snippet: z22.string().nullable(),
-  isRedditStyle: z22.boolean(),
-  inlineRating: z22.object({
-    value: z22.string(),
-    count: z22.string()
+var SerpIntelligenceOrganicResultSchema = z23.object({
+  position: z23.number().int().min(1),
+  title: z23.string(),
+  url: z23.string(),
+  domain: z23.string(),
+  cite: z23.string().nullable(),
+  snippet: z23.string().nullable(),
+  isRedditStyle: z23.boolean(),
+  inlineRating: z23.object({
+    value: z23.string(),
+    count: z23.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z22.object({
-  status: z22.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z22.object({
-    city: z22.string(),
-    regionCode: z22.string().nullable(),
-    canonicalLocation: z22.string()
+var SerpIntelligenceLocationEvidenceSchema = z23.object({
+  status: z23.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z23.object({
+    city: z23.string(),
+    regionCode: z23.string().nullable(),
+    canonicalLocation: z23.string()
   }).strict().nullable(),
-  candidates: z22.array(z22.object({
-    city: z22.string(),
-    regionCode: z22.string(),
-    count: z22.number().int().min(0),
-    examples: z22.array(z22.string())
+  candidates: z23.array(z23.object({
+    city: z23.string(),
+    regionCode: z23.string(),
+    count: z23.number().int().min(0),
+    examples: z23.array(z23.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z22.object({
-  seed: z22.string(),
-  location: z22.string().nullable(),
-  extractedAt: z22.string(),
-  totalQuestions: z22.number().int().min(0),
-  surface: z22.enum(["web", "aim", "unknown"]),
-  aiOverview: z22.object({
-    detected: z22.boolean(),
-    text: z22.string().nullable(),
-    citations: z22.array(SerpIntelligenceAICitationSchema),
-    expanded: z22.boolean().optional(),
-    fullyExpanded: z22.boolean().optional(),
-    sections: z22.array(z22.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z23.object({
+  seed: z23.string(),
+  location: z23.string().nullable(),
+  extractedAt: z23.string(),
+  totalQuestions: z23.number().int().min(0),
+  surface: z23.enum(["web", "aim", "unknown"]),
+  aiOverview: z23.object({
+    detected: z23.boolean(),
+    text: z23.string().nullable(),
+    citations: z23.array(SerpIntelligenceAICitationSchema),
+    expanded: z23.boolean().optional(),
+    fullyExpanded: z23.boolean().optional(),
+    sections: z23.array(z23.string()).optional()
   }).strict(),
-  aiMode: z22.object({
-    detected: z22.boolean(),
-    text: z22.string().nullable(),
-    citations: z22.array(SerpIntelligenceAICitationSchema)
+  aiMode: z23.object({
+    detected: z23.boolean(),
+    text: z23.string().nullable(),
+    citations: z23.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z22.array(z22.unknown()),
-  flat: z22.array(z22.unknown()),
-  videos: z22.array(z22.unknown()),
-  forums: z22.array(z22.unknown()),
-  organicResults: z22.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z22.array(z22.unknown()),
-  entityIds: z22.object({
-    entities: z22.array(z22.object({
-      name: z22.string(),
-      kgId: z22.string().nullable(),
-      cid: z22.string().nullable(),
-      gcid: z22.string().nullable()
+  tree: z23.array(z23.unknown()),
+  flat: z23.array(z23.unknown()),
+  videos: z23.array(z23.unknown()),
+  forums: z23.array(z23.unknown()),
+  organicResults: z23.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z23.array(z23.unknown()),
+  entityIds: z23.object({
+    entities: z23.array(z23.object({
+      name: z23.string(),
+      kgId: z23.string().nullable(),
+      cid: z23.string().nullable(),
+      gcid: z23.string().nullable()
     }).strict()),
-    kgIds: z22.array(z22.string()),
-    cids: z22.array(z22.string()),
-    gcids: z22.array(z22.string())
+    kgIds: z23.array(z23.string()),
+    cids: z23.array(z23.string()),
+    gcids: z23.array(z23.string())
   }).strict(),
-  stats: z22.object({
-    seed: z22.string(),
-    totalQuestions: z22.number().int().min(0),
-    maxDepthReached: z22.number().int().min(0),
-    durationMs: z22.number().min(0),
-    errorCount: z22.number().int().min(0)
+  stats: z23.object({
+    seed: z23.string(),
+    totalQuestions: z23.number().int().min(0),
+    maxDepthReached: z23.number().int().min(0),
+    durationMs: z23.number().min(0),
+    errorCount: z23.number().int().min(0)
   }).strict(),
-  diagnostics: z22.object({
-    completionStatus: z22.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z22.null(),
-    warnings: z22.array(z22.unknown()).optional(),
-    debug: z22.object({
+  diagnostics: z23.object({
+    completionStatus: z23.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z23.null(),
+    warnings: z23.array(z23.unknown()).optional(),
+    debug: z23.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z22.array(z22.unknown())
+  whatPeopleSaying: z23.array(z23.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z22.object({
-  attemptNumber: z22.number().int().min(1),
-  outcome: z22.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z22.string().optional(),
-  completedAt: z22.string().optional(),
-  durationMs: z22.number().min(0).optional(),
-  problemCode: z22.string().optional(),
-  message: z22.string().optional(),
-  kernelSessionId: z22.string().nullable().optional(),
-  cleanupSucceeded: z22.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z23.object({
+  attemptNumber: z23.number().int().min(1),
+  outcome: z23.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z23.string().optional(),
+  completedAt: z23.string().optional(),
+  durationMs: z23.number().min(0).optional(),
+  problemCode: z23.string().optional(),
+  message: z23.string().optional(),
+  kernelSessionId: z23.string().nullable().optional(),
+  cleanupSucceeded: z23.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z22.object({
+var SerpPageSnapshotCaptureSchema = z23.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z22.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z22.number().int().min(1).nullable(),
-  status: z22.enum(SerpPageFetchStatusValues),
-  fetchedVia: z22.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z22.number().int().min(100).max(599).nullable(),
-  contentType: z22.string().nullable(),
-  title: z22.string().nullable(),
+  sourceKind: z23.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z23.number().int().min(1).nullable(),
+  status: z23.enum(SerpPageFetchStatusValues),
+  fetchedVia: z23.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z23.number().int().min(100).max(599).nullable(),
+  contentType: z23.string().nullable(),
+  title: z23.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z22.string().nullable(),
-  headings: z22.array(z22.object({
-    level: z22.number().int().min(1).max(6),
-    text: z22.string()
+  metaDescription: z23.string().nullable(),
+  headings: z23.array(z23.object({
+    level: z23.number().int().min(1).max(6),
+    text: z23.string()
   }).strict()).default([]),
-  artifact: z22.object({
-    htmlBlobUrl: z22.string().url().nullable(),
-    textBlobUrl: z22.string().url().nullable(),
-    markdownBlobUrl: z22.string().url().nullable(),
-    screenshotBlobUrl: z22.string().url().nullable(),
-    contentSha256: z22.string().nullable(),
-    capturedAt: z22.string().nullable()
+  artifact: z23.object({
+    htmlBlobUrl: z23.string().url().nullable(),
+    textBlobUrl: z23.string().url().nullable(),
+    markdownBlobUrl: z23.string().url().nullable(),
+    screenshotBlobUrl: z23.string().url().nullable(),
+    contentSha256: z23.string().nullable(),
+    capturedAt: z23.string().nullable()
   }).strict(),
-  error: z22.object({
-    code: z22.string(),
-    message: z22.string()
+  error: z23.object({
+    code: z23.string(),
+    message: z23.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z22.object({
+var SerpIntelligenceCaptureResponseSchema = z23.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z22.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z23.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z22.array(SerpPageSnapshotCaptureSchema),
-  billing: z22.object({
-    creditsUsed: z22.number().min(0).optional(),
-    requestId: z22.string().optional(),
-    jobId: z22.string().optional()
+  pageSnapshotArtifacts: z23.array(SerpPageSnapshotCaptureSchema),
+  billing: z23.object({
+    creditsUsed: z23.number().min(0).optional(),
+    requestId: z23.string().optional(),
+    jobId: z23.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z22.object({
-  pageSnapshotArtifacts: z22.array(SerpPageSnapshotCaptureSchema),
-  attempts: z22.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z23.object({
+  pageSnapshotArtifacts: z23.array(SerpPageSnapshotCaptureSchema),
+  attempts: z23.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -15030,7 +15221,7 @@ var SERP_INTELLIGENCE_RATE_LIMIT = 60;
 var SERP_INTELLIGENCE_RATE_WINDOW_SECONDS = 60;
 var POST_CAPTURE_ROUTE_LABEL = "POST /capture";
 var POST_PAGE_SNAPSHOTS_ROUTE_LABEL = "POST /page-snapshots";
-var serpIntelligenceApp = new Hono14();
+var serpIntelligenceApp = new Hono15();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -15199,7 +15390,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono16 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
 // src/mcp/memory-inprocess-executor.ts
@@ -15726,7 +15917,7 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return { key: callerKey, user };
 }
-var mcpApp = new Hono15();
+var mcpApp = new Hono16();
 mcpApp.all("/", async (c) => {
   try {
     const keyOrError = await requireMcpCallerKey(c);
@@ -15752,7 +15943,8 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono16 } from "hono";
+import { randomUUID as randomUUID3 } from "crypto";
+import { Hono as Hono17 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -15840,8 +16032,58 @@ async function migrateBrowserAgent() {
   } catch {
   }
   await db.execute(`CREATE INDEX IF NOT EXISTS browser_auth_connections_profile ON browser_auth_connections(profile)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS browser_agent_extensions (
+      id           TEXT PRIMARY KEY,
+      user_id      INTEGER NOT NULL,
+      name         TEXT NOT NULL,
+      backend_id   TEXT NOT NULL,
+      backend_name TEXT NOT NULL,
+      source       TEXT NOT NULL DEFAULT 'store',
+      source_url   TEXT,
+      size_bytes   INTEGER,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE UNIQUE INDEX IF NOT EXISTS browser_agent_extensions_user_name ON browser_agent_extensions(user_id, name)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS browser_agent_extensions_user ON browser_agent_extensions(user_id)`);
   _ready = true;
 }
+async function createExtensionRow(input) {
+  const db = getDb();
+  const id = `bext_${randomUUID2().replace(/-/g, "").slice(0, 20)}`;
+  await db.execute({
+    sql: `INSERT INTO browser_agent_extensions (id, user_id, name, backend_id, backend_name, source, source_url, size_bytes)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [id, input.userId, input.name, input.backendId, input.backendName, input.source, input.sourceUrl, input.sizeBytes]
+  });
+  const row = await getExtensionRow(input.userId, input.name);
+  if (!row) throw new Error("extension insert failed");
+  return row;
+}
+async function getExtensionRow(userId, name) {
+  const db = getDb();
+  const res = await db.execute({
+    sql: `SELECT * FROM browser_agent_extensions WHERE user_id = ? AND name = ?`,
+    args: [userId, name]
+  });
+  return res.rows[0] ?? null;
+}
+async function listExtensionRows(userId) {
+  const db = getDb();
+  const res = await db.execute({
+    sql: `SELECT * FROM browser_agent_extensions WHERE user_id = ? ORDER BY created_at DESC`,
+    args: [userId]
+  });
+  return res.rows;
+}
+async function deleteExtensionRow(userId, name) {
+  const db = getDb();
+  await db.execute({
+    sql: `DELETE FROM browser_agent_extensions WHERE user_id = ? AND name = ?`,
+    args: [userId, name]
+  });
+}
 async function createAuthConnectionRow(input) {
   const db = getDb();
   const connectionId = `authc_${randomUUID2().replace(/-/g, "").slice(0, 20)}`;
@@ -16698,6 +16940,28 @@ function isProfileConflict(err) {
   const message = err instanceof Error ? err.message : String(err);
   return /\b409\b|conflict|already exists/i.test(message);
 }
+function isNotFound(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /\b404\b|not found/i.test(message);
+}
+async function importExtensionFromStore(storeUrl, backendName) {
+  const k = client();
+  const archive = await k.extensions.downloadFromChromeStore({ url: storeUrl });
+  const uploaded = await k.extensions.upload({ file: archive, name: backendName });
+  return {
+    backendId: uploaded.id,
+    backendName: uploaded.name ?? backendName,
+    sizeBytes: typeof uploaded.size_bytes === "number" ? uploaded.size_bytes : null
+  };
+}
+async function deleteExtensionBackend(backendName) {
+  const k = client();
+  try {
+    await k.extensions.delete(backendName);
+  } catch (err) {
+    if (!isNotFound(err)) throw err;
+  }
+}
 async function ensureProfile(k, name) {
   try {
     await k.profiles.create({ name });
@@ -16716,6 +16980,7 @@ async function createSession(opts = {}) {
   const resolvedSaveProfileChanges = opts.saveProfileChanges ?? browserServiceProfileSaveChanges();
   const disableDefaultProxy = opts.disableDefaultProxy ?? !resolvedProxyId;
   const startUrl = opts.startUrl?.trim();
+  const extensionNames = (opts.extensionNames ?? []).map((name) => name.trim()).filter(Boolean);
   if (resolvedProfileName && resolvedSaveProfileChanges === true) {
     await ensureProfile(k, resolvedProfileName);
   }
@@ -16729,7 +16994,8 @@ async function createSession(opts = {}) {
         name: resolvedProfileName,
         ...typeof resolvedSaveProfileChanges === "boolean" ? { save_changes: resolvedSaveProfileChanges } : {}
       }
-    } : {}
+    } : {},
+    ...extensionNames.length ? { extensions: extensionNames.map((name) => ({ name })) } : {}
   };
   const browser = await k.browsers.create(createPayload);
   const runtimeSessionId = browser.session_id;
@@ -17117,6 +17383,16 @@ function parseAgentDate(value) {
   const legacyParsed = Date.parse(`${value.replace(" ", "T")}Z`);
   return Number.isFinite(legacyParsed) ? legacyParsed : null;
 }
+var EXTENSION_NAME_RE = /^[\w .-]{1,64}$/;
+function publicExtension(row) {
+  return {
+    name: row.name,
+    source: row.source,
+    source_url: row.source_url,
+    size_bytes: row.size_bytes,
+    created_at: row.created_at
+  };
+}
 function replayClock(row) {
   if (!row) return null;
   const startedAtMs = parseAgentDate(row.started_at);
@@ -17143,7 +17419,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono16();
+  const app2 = new Hono17();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -17263,6 +17539,15 @@ function buildBrowserAgentRoutes() {
     const body = await c.req.json().catch(() => ({}));
     const timeoutSeconds = typeof body.timeout_seconds === "number" ? body.timeout_seconds : void 0;
     const startUrl = typeof body.url === "string" ? body.url : void 0;
+    const extensionNames = Array.isArray(body.extension_names) ? body.extension_names.filter((v) => typeof v === "string") : void 0;
+    let resolvedExtensionBackendNames;
+    if (extensionNames && extensionNames.length) {
+      const names = extensionNames;
+      const rows = await Promise.all(names.map((name) => getExtensionRow(user.id, name)));
+      const missing = names.filter((_, i) => !rows[i]);
+      if (missing.length) return c.json({ error: `extension(s) not found: ${missing.join(", ")}` }, 400);
+      resolvedExtensionBackendNames = rows.map((row) => row.backend_name);
+    }
     const gate = await acquireConcurrencyGate(user, "browser_agent_session", {
       ttlSeconds: browserSessionLockTtlSeconds(timeoutSeconds),
       metadata: { label: typeof body.label === "string" ? body.label : null }
@@ -17277,7 +17562,8 @@ function buildBrowserAgentRoutes() {
         saveProfileChanges: typeof body.save_profile_changes === "boolean" ? body.save_profile_changes : void 0,
         startUrl,
         disableDefaultProxy: typeof body.disable_default_proxy === "boolean" ? body.disable_default_proxy : void 0,
-        viewport: body.viewport && typeof body.viewport === "object" ? body.viewport : void 0
+        viewport: body.viewport && typeof body.viewport === "object" ? body.viewport : void 0,
+        extensionNames: resolvedExtensionBackendNames
       });
       runtimeSessionId = created.runtimeSessionId;
       const row = await createSessionRow({
@@ -17580,6 +17866,52 @@ function buildBrowserAgentRoutes() {
       }))
     });
   });
+  app2.post("/extensions/import", async (c) => {
+    const user = c.get("user");
+    const body = await c.req.json().catch(() => ({}));
+    const storeUrl = typeof body.store_url === "string" ? body.store_url.trim() : "";
+    const name = typeof body.name === "string" ? body.name.trim() : "";
+    if (!storeUrl) return c.json({ error: "store_url is required" }, 400);
+    if (!name || !EXTENSION_NAME_RE.test(name)) {
+      return c.json({ error: "name is required (1-64 characters: letters, numbers, spaces, dots, underscores, hyphens)" }, 400);
+    }
+    const existing = await getExtensionRow(user.id, name);
+    if (existing) return c.json({ error: `an extension named "${name}" already exists \u2014 delete it first or pick another name` }, 409);
+    const backendName = `u${user.id}_${randomUUID3().replace(/-/g, "")}`;
+    try {
+      const imported = await importExtensionFromStore(storeUrl, backendName);
+      const row = await createExtensionRow({
+        userId: user.id,
+        name,
+        backendId: imported.backendId,
+        backendName: imported.backendName,
+        source: "store",
+        sourceUrl: storeUrl,
+        sizeBytes: imported.sizeBytes
+      });
+      return c.json(publicExtension(row));
+    } catch (err) {
+      return c.json(failure(err), 502);
+    }
+  });
+  app2.get("/extensions", async (c) => {
+    const user = c.get("user");
+    const rows = await listExtensionRows(user.id);
+    return c.json({ extensions: rows.map(publicExtension) });
+  });
+  app2.delete("/extensions/:name", async (c) => {
+    const user = c.get("user");
+    const name = c.req.param("name");
+    const row = await getExtensionRow(user.id, name);
+    if (!row) return c.json({ error: "not found" }, 404);
+    try {
+      await deleteExtensionBackend(row.backend_name);
+    } catch (err) {
+      return c.json(failure(err), 502);
+    }
+    await deleteExtensionRow(user.id, name);
+    return c.json({ ok: true });
+  });
   app2.get("/sessions/:id/replays/:replayId/download", async (c) => {
     const user = c.get("user");
     const row = await loadOpenSession(c.req.param("id"), user.id);
@@ -17877,9 +18209,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono18 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono17();
+var stripeApp = new Hono18();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -17935,7 +18267,6 @@ stripeApp.post("/webhooks", async (c) => {
       const live = sub.status === "active" || sub.status === "trialing";
       const newTier = live ? tier.tier : null;
       await setSubscriptionTier(user.id, newTier, live ? tier.concurrency : 0, live ? sub.id : null);
-      await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, subscription_tier: newTier }));
     } else if (priceId === CONCURRENCY_PRICE_ID && event.type === "customer.subscription.created") {
       await setExtraConcurrencySlots(user.id, user.extra_concurrency_slots + 1);
       await setConcurrencySubId(user.id, sub.id);
@@ -17961,7 +18292,6 @@ stripeApp.post("/webhooks", async (c) => {
     if (!user) return c.json({ received: true });
     if (priceId && priceId in SUBSCRIPTION_TIERS) {
       await setSubscriptionTier(user.id, null, 0, null);
-      await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, subscription_tier: null }));
     } else if (priceId === CONCURRENCY_PRICE_ID) {
       await setExtraConcurrencySlots(user.id, Math.max(0, user.extra_concurrency_slots - 1));
       await setConcurrencySubId(user.id, null);
@@ -17983,9 +18313,9 @@ async function resolveUser(customerId, emailFallback) {
 }
 
 // src/api/oauth-routes.ts
-import { Hono as Hono18 } from "hono";
+import { Hono as Hono19 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
-import { createHash as createHash3, randomBytes as randomBytes2, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash3, randomBytes as randomBytes2, randomUUID as randomUUID4 } from "crypto";
 import { importPKCS8, exportJWK, SignJWT } from "jose";
 var ISSUER = "https://mcpscraper.dev";
 var RESOURCE = () => process.env.MCP_MEMORY_RESOURCE_URL ?? "https://memory.mcpscraper.dev/mcp";
@@ -18152,7 +18482,7 @@ function redirectWithError(redirectUri, state, error) {
   if (state) u.searchParams.set("state", state);
   return new Response(null, { status: 302, headers: { Location: u.toString() } });
 }
-var oauthApp = new Hono18();
+var oauthApp = new Hono19();
 oauthApp.use("*", async (c, next) => {
   c.header("Access-Control-Allow-Origin", "*");
   c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -18333,7 +18663,7 @@ function pkceMatches(verifier, challenge) {
 }
 async function mintAccessToken(identity, scope, plan, audience) {
   const { privateKey, kid } = await getKeys();
-  return new SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti(randomUUID3()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
+  return new SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti(randomUUID4()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
 }
 function tokenErrorResponse(c, error, description, status) {
   return c.json({ error, error_description: description }, status);
@@ -18406,8 +18736,8 @@ oauthApp.post("/oauth/token", async (c) => {
 });
 
 // src/api/chat-routes.ts
-import { Hono as Hono19 } from "hono";
-var chatApp = new Hono19();
+import { Hono as Hono20 } from "hono";
+var chatApp = new Hono20();
 function tokenOk(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -19077,8 +19407,8 @@ loadChannels();
 }
 
 // src/api/schedule-routes.ts
-import { Hono as Hono20 } from "hono";
-var scheduleApp = new Hono20();
+import { Hono as Hono21 } from "hono";
+var scheduleApp = new Hono21();
 function tokenOk2(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -19833,7 +20163,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono21();
+var app = new Hono22();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -21194,7 +21524,7 @@ app.get("/cron/tick", async (c) => {
   if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
     return c.json({ error: "Unauthorized" }, 401);
   }
-  const { drainQueue } = await import("./worker-7XRZNLKB.js");
+  const { drainQueue } = await import("./worker-YHKUJR5P.js");
   const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
   const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
   const [results, sweepResult, reapResult, expiredResult, blobCleanup] = await Promise.all([
@@ -21212,7 +21542,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     return c.json({ error: "Unauthorized" }, 401);
   }
   const jobId = c.req.param("id");
-  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-4NVO5KQA.js");
+  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-THBVEXMP.js");
   const { assembleExtractArtifacts } = await import("./extract-bundle-UKE273TV.js");
   const job = await getExtractJob2(jobId);
   if (!job) return c.json({ error: "job not found" }, 404);
@@ -21220,7 +21550,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   await completeExtractJob2(jobId, stored);
   let settlement = "already_settled_or_refunded";
   if (job.billedMc == null && job.userId != null) {
-    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-4NVO5KQA.js");
+    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-THBVEXMP.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -21247,6 +21577,7 @@ app.route("/reddit", redditApp);
 app.route("/video", videoApp);
 app.route("/maps", mapsApp);
 app.route("/trustpilot", trustpilotApp);
+app.route("/g2", g2App);
 app.route("/directory", directoryApp);
 app.route("/workflows", workflowApp);
 app.route("/serp-intelligence", serpIntelligenceApp);
@@ -21383,4 +21714,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-LBEYRKM2.js.map
+//# sourceMappingURL=server-XCDFHHLE.js.map