@oneclick.dev/cms-core-modules 0.0.108 → 0.0.110

package/dist/server-handlers.mjs

@@ -1,1057 +1,1004 @@
-import { createError as e, createRouter as t, defineEventHandler as n, getQuery as r, getRouterParam as i } from "h3";
+import { createRouter as v, defineEventHandler as w, createError as y, getRouterParam as q, getQuery as C } from "h3";
 import "vue";
-//#region src/products/server.ts
-function a(a) {
-	let { initFirebase: o, normalizeTimestamps: s } = a, c = t();
-	async function l(t) {
-		let { supabase: n, instanceId: r } = t.context.module, { data: i, error: a } = await n.from("project_modules").select("config").eq("id", r).single();
-		if (a || !i?.config) throw e({
-			statusCode: 500,
-			statusMessage: "Failed to load module config."
-		});
-		let s = i.config, c = s.project, l = s.productCollection || "products";
-		if (!c) throw e({
-			statusCode: 400,
-			statusMessage: "Products module has no Firebase integration configured."
-		});
-		return {
-			firebase: await o(t, c),
-			collection: l
-		};
-	}
-	return c.get("/products", n(async (t) => {
-		try {
-			let { firebase: e, collection: n } = await l(t);
-			return (await e.firestore().collection(n).get()).docs.map((e) => s({
-				id: e.id,
-				...e.data()
-			}));
-		} catch (t) {
-			throw console.error("Products handler — list error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to list products"
-			});
-		}
-	})), c.get("/products/:productId", n(async (t) => {
-		let n = i(t, "productId");
-		if (!n) throw e({
-			statusCode: 400,
-			statusMessage: "Product ID is required."
-		});
-		try {
-			let { firebase: r, collection: i } = await l(t), a = await r.firestore().collection(i).doc(n).get();
-			if (!a.exists) throw e({
-				statusCode: 404,
-				statusMessage: "Product not found."
-			});
-			return s({
-				id: a.id,
-				...a.data()
-			});
-		} catch (t) {
-			throw console.error("Products handler — get error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to get product"
-			});
-		}
-	})), c.get("/empty-stock", n(async (t) => {
-		let n = r(t).category;
-		try {
-			let { firebase: e, collection: r } = await l(t), i = e.firestore().collection(r).where("stock", "==", 0);
-			n && (i = i.where("collections", "array-contains", n));
-			let a = (await i.get()).docs.map((e) => s({
-				id: e.id,
-				...e.data()
-			}));
-			return {
-				count: a.length,
-				products: a.map((e) => ({
-					id: e.id,
-					title: e.title,
-					slug: e.slug,
-					stock: e.stock,
-					price: e.price,
-					currency: e.currency,
-					status: e.status
-				}))
-			};
-		} catch (t) {
-			throw console.error("Products handler — empty-stock error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to query empty stock"
-			});
-		}
-	})), c.handler;
+function $(h) {
+  const { initFirebase: P, normalizeTimestamps: A } = h, g = v();
+  async function m(u) {
+    const { supabase: i, instanceId: d } = u.context.module, { data: e, error: o } = await i.from("project_modules").select("config").eq("id", d).single();
+    if (o || !e?.config)
+      throw y({ statusCode: 500, statusMessage: "Failed to load module config." });
+    const s = e.config, t = s.project, a = s.productCollection || "products";
+    if (!t)
+      throw y({ statusCode: 400, statusMessage: "Products module has no Firebase integration configured." });
+    return { firebase: await P(u, t), collection: a };
+  }
+  return g.get("/products", w(async (u) => {
+    try {
+      const { firebase: i, collection: d } = await m(u);
+      return (await i.firestore().collection(d).get()).docs.map((o) => A({
+        id: o.id,
+        ...o.data()
+      }));
+    } catch (i) {
+      throw console.error("Products handler — list error:", i), y({
+        statusCode: i.statusCode || 500,
+        statusMessage: i.statusMessage || "Failed to list products"
+      });
+    }
+  })), g.get("/products/:productId", w(async (u) => {
+    const i = q(u, "productId");
+    if (!i)
+      throw y({ statusCode: 400, statusMessage: "Product ID is required." });
+    try {
+      const { firebase: d, collection: e } = await m(u), o = await d.firestore().collection(e).doc(i).get();
+      if (!o.exists)
+        throw y({ statusCode: 404, statusMessage: "Product not found." });
+      return A({
+        id: o.id,
+        ...o.data()
+      });
+    } catch (d) {
+      throw console.error("Products handler — get error:", d), y({
+        statusCode: d.statusCode || 500,
+        statusMessage: d.statusMessage || "Failed to get product"
+      });
+    }
+  })), g.get("/empty-stock", w(async (u) => {
+    const d = C(u).category;
+    try {
+      const { firebase: e, collection: o } = await m(u);
+      let s = e.firestore().collection(o).where("stock", "==", 0);
+      d && (s = s.where("collections", "array-contains", d));
+      const a = (await s.get()).docs.map((n) => A({
+        id: n.id,
+        ...n.data()
+      }));
+      return {
+        count: a.length,
+        products: a.map((n) => ({
+          id: n.id,
+          title: n.title,
+          slug: n.slug,
+          stock: n.stock,
+          price: n.price,
+          currency: n.currency,
+          status: n.status
+        }))
+      };
+    } catch (e) {
+      throw console.error("Products handler — empty-stock error:", e), y({
+        statusCode: e.statusCode || 500,
+        statusMessage: e.statusMessage || "Failed to query empty stock"
+      });
+    }
+  })), g.handler;
 }
-//#endregion
-//#region src/appointments/server.ts
-function o(a) {
-	let { initFirebase: o, normalizeTimestamps: s } = a, c = t();
-	async function l(t) {
-		let { supabase: n, instanceId: r } = t.context.module, { data: i, error: a } = await n.from("project_modules").select("config").eq("id", r).single();
-		if (a || !i?.config) throw e({
-			statusCode: 500,
-			statusMessage: "Failed to load module config."
-		});
-		let s = i.config, c = s.project, l = s.reservationsCollection || "bookings_orders", u = s.agendaCollection || "agendas";
-		if (!c) throw e({
-			statusCode: 400,
-			statusMessage: "Appointments module has no Firebase integration configured."
-		});
-		return {
-			firebase: await o(t, c),
-			reservationsCollection: l,
-			agendaCollection: u
-		};
-	}
-	function u(e) {
-		return (e.reservations || []).map((t) => ({
-			orderId: e.id,
-			reservationId: t.id,
-			customerInfo: e.customerInfo,
-			date: t.date,
-			startTime: t.timeslot?.startTime,
-			endTime: t.timeslot?.endTime,
-			spots: t.spots,
-			status: e.status,
-			reservationStatus: t.status,
-			resourceId: t.resourceId,
-			reservationPrice: t.totalPrice,
-			reservationBasePrice: t.basePrice,
-			reservationAddOnsPrice: t.addOnsPrice,
-			pricingOption: t.pricingOption,
-			amountDue: e.amountDue,
-			amountPaid: e.amountPaid,
-			createdAt: e.createdAt,
-			metadata: e.metadata || {},
-			reservationMetadata: t.metadata || {}
-		}));
-	}
-	return c.get("/agendas", n(async (t) => {
-		try {
-			let { firebase: e, agendaCollection: n } = await l(t), r = (await e.firestore().collection(n).get()).docs.map((e) => {
-				let t = e.data();
-				return {
-					id: e.id,
-					serviceName: t.serviceName || "",
-					type: t.type || "regular"
-				};
-			});
-			return {
-				count: r.length,
-				agendas: r
-			};
-		} catch (t) {
-			throw console.error("Appointments handler — list agendas error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to list agendas"
-			});
-		}
-	})), c.get("/agendas/:agendaId/opening-hours", n(async (t) => {
-		let n = i(t, "agendaId"), a = r(t).date;
-		if (!n) throw e({
-			statusCode: 400,
-			statusMessage: "Agenda ID is required."
-		});
-		if (!a) throw e({
-			statusCode: 400,
-			statusMessage: "Date is required (YYYY-MM-DD)."
-		});
-		try {
-			let { firebase: r, agendaCollection: i } = await l(t), o = await r.firestore().collection(i).doc(n).get();
-			if (!o.exists) throw e({
-				statusCode: 404,
-				statusMessage: "Agenda not found."
-			});
-			let s = o.data(), c = (s.resources || []).filter((e) => e.isActive), u = s.exceptions || [], d = (/* @__PURE__ */ new Date(a + "T00:00:00")).getDay(), f = c.map((e) => {
-				let t = e.openingHours?.[d] || [], n = u.find((t) => {
-					let n = a >= t.startDate && a <= t.endDate, r = !t.resourceIds || t.resourceIds.length === 0 || t.resourceIds.includes(e.id);
-					return n && r;
-				});
-				return n ? {
-					resourceId: e.id,
-					resourceName: e.name,
-					date: a,
-					dayOfWeek: d,
-					isClosed: n.isClosed,
-					hours: n.isClosed ? [] : (n.timeslots || []).map((e) => ({
-						start: e.startTime,
-						end: e.endTime
-					})),
-					isException: !0
-				} : {
-					resourceId: e.id,
-					resourceName: e.name,
-					date: a,
-					dayOfWeek: d,
-					isClosed: t.length === 0,
-					hours: t,
-					isException: !1
-				};
-			});
-			return {
-				agendaId: n,
-				serviceName: s.serviceName || "",
-				date: a,
-				resources: f
-			};
-		} catch (t) {
-			throw console.error("Appointments handler — opening hours error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to get opening hours"
-			});
-		}
-	})), c.get("/appointments", n(async (t) => {
-		let n = r(t), i = Math.min(Number(n.quantity) || 20, 100), a = n.status || "confirmed";
-		try {
-			let { firebase: e, reservationsCollection: n } = await l(t), r = (await e.firestore().collection(n).orderBy("createdAt", "desc").where("status", "==", a).limit(i).get()).docs.flatMap((e) => u(s({
-				id: e.id,
-				...e.data()
-			})));
-			return {
-				count: r.length,
-				appointments: r
-			};
-		} catch (t) {
-			throw console.error("Appointments handler — list error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to list appointments"
-			});
-		}
-	})), c.get("/appointments/find", n(async (t) => {
-		let n = r(t), i = (n.name || "").toLowerCase().trim(), a = (n.email || "").toLowerCase().trim(), o = n.date;
-		try {
-			let { firebase: e, reservationsCollection: n } = await l(t), r = e.firestore().collection(n);
-			a && (r = r.where("customerInfo.email", "==", a));
-			let c = (await r.orderBy("createdAt", "desc").limit(200).get()).docs.flatMap((e) => u(s({
-				id: e.id,
-				...e.data()
-			})));
-			return o && (c = c.filter((e) => e.date === o)), i && (c = c.filter((e) => {
-				let t = (e.customerInfo?.firstName || "").toLowerCase(), n = (e.customerInfo?.lastName || "").toLowerCase();
-				return t.includes(i) || n.includes(i) || `${t} ${n}`.includes(i);
-			})), {
-				count: c.length,
-				appointments: c
-			};
-		} catch (t) {
-			throw console.error("Appointments handler — find error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to find appointments"
-			});
-		}
-	})), c.get("/appointments/:appointmentId", n(async (t) => {
-		let n = i(t, "appointmentId");
-		if (!n) throw e({
-			statusCode: 400,
-			statusMessage: "Appointment ID is required."
-		});
-		try {
-			let { firebase: r, reservationsCollection: i } = await l(t), a = await r.firestore().collection(i).doc(n).get();
-			if (!a.exists) throw e({
-				statusCode: 404,
-				statusMessage: "Appointment not found."
-			});
-			let o = s({
-				id: a.id,
-				...a.data()
-			});
-			return {
-				...o,
-				reservations: u(o)
-			};
-		} catch (t) {
-			throw console.error("Appointments handler — get error:", t), e({
-				statusCode: t.statusCode || 500,
-				statusMessage: t.statusMessage || "Failed to get appointment"
-			});
-		}
-	})), c.handler;
+function x(h) {
+  const { initFirebase: P, normalizeTimestamps: A } = h, g = v();
+  async function m(i) {
+    const { supabase: d, instanceId: e } = i.context.module, { data: o, error: s } = await d.from("project_modules").select("config").eq("id", e).single();
+    if (s || !o?.config)
+      throw y({ statusCode: 500, statusMessage: "Failed to load module config." });
+    const t = o.config, a = t.project, n = t.reservationsCollection || "bookings_orders", r = t.agendaCollection || "agendas";
+    if (!a)
+      throw y({ statusCode: 400, statusMessage: "Appointments module has no Firebase integration configured." });
+    return { firebase: await P(i, a), reservationsCollection: n, agendaCollection: r };
+  }
+  function u(i) {
+    return (i.reservations || []).map((e) => ({
+      orderId: i.id,
+      reservationId: e.id,
+      customerInfo: i.customerInfo,
+      date: e.date,
+      startTime: e.timeslot?.startTime,
+      endTime: e.timeslot?.endTime,
+      spots: e.spots,
+      status: i.status,
+      reservationStatus: e.status,
+      resourceId: e.resourceId,
+      reservationPrice: e.totalPrice,
+      reservationBasePrice: e.basePrice,
+      reservationAddOnsPrice: e.addOnsPrice,
+      pricingOption: e.pricingOption,
+      amountDue: i.amountDue,
+      amountPaid: i.amountPaid,
+      createdAt: i.createdAt,
+      metadata: i.metadata || {},
+      reservationMetadata: e.metadata || {}
+    }));
+  }
+  return g.get("/agendas", w(async (i) => {
+    try {
+      const { firebase: d, agendaCollection: e } = await m(i), s = (await d.firestore().collection(e).get()).docs.map((t) => {
+        const a = t.data();
+        return {
+          id: t.id,
+          serviceName: a.serviceName || "",
+          type: a.type || "regular"
+        };
+      });
+      return {
+        count: s.length,
+        agendas: s
+      };
+    } catch (d) {
+      throw console.error("Appointments handler — list agendas error:", d), y({
+        statusCode: d.statusCode || 500,
+        statusMessage: d.statusMessage || "Failed to list agendas"
+      });
+    }
+  })), g.get("/agendas/:agendaId/opening-hours", w(async (i) => {
+    const d = q(i, "agendaId"), o = C(i).date;
+    if (!d)
+      throw y({ statusCode: 400, statusMessage: "Agenda ID is required." });
+    if (!o)
+      throw y({ statusCode: 400, statusMessage: "Date is required (YYYY-MM-DD)." });
+    try {
+      const { firebase: s, agendaCollection: t } = await m(i), a = await s.firestore().collection(t).doc(d).get();
+      if (!a.exists)
+        throw y({ statusCode: 404, statusMessage: "Agenda not found." });
+      const n = a.data(), r = (n.resources || []).filter((f) => f.isActive), c = n.exceptions || [], p = (/* @__PURE__ */ new Date(o + "T00:00:00")).getDay(), D = r.map((f) => {
+        const R = f.openingHours?.[p] || [], I = c.find((S) => {
+          const b = o >= S.startDate && o <= S.endDate, M = !S.resourceIds || S.resourceIds.length === 0 || S.resourceIds.includes(f.id);
+          return b && M;
+        });
+        return I ? {
+          resourceId: f.id,
+          resourceName: f.name,
+          date: o,
+          dayOfWeek: p,
+          isClosed: I.isClosed,
+          hours: I.isClosed ? [] : (I.timeslots || []).map((S) => ({
+            start: S.startTime,
+            end: S.endTime
+          })),
+          isException: !0
+        } : {
+          resourceId: f.id,
+          resourceName: f.name,
+          date: o,
+          dayOfWeek: p,
+          isClosed: R.length === 0,
+          hours: R,
+          isException: !1
+        };
+      });
+      return {
+        agendaId: d,
+        serviceName: n.serviceName || "",
+        date: o,
+        resources: D
+      };
+    } catch (s) {
+      throw console.error("Appointments handler — opening hours error:", s), y({
+        statusCode: s.statusCode || 500,
+        statusMessage: s.statusMessage || "Failed to get opening hours"
+      });
+    }
+  })), g.get("/appointments", w(async (i) => {
+    const d = C(i), e = Math.min(Number(d.quantity) || 20, 100), o = d.status || "confirmed";
+    try {
+      const { firebase: s, reservationsCollection: t } = await m(i), n = (await s.firestore().collection(t).orderBy("createdAt", "desc").where("status", "==", o).limit(e).get()).docs.flatMap(
+        (r) => u(A({ id: r.id, ...r.data() }))
+      );
+      return {
+        count: n.length,
+        appointments: n
+      };
+    } catch (s) {
+      throw console.error("Appointments handler — list error:", s), y({
+        statusCode: s.statusCode || 500,
+        statusMessage: s.statusMessage || "Failed to list appointments"
+      });
+    }
+  })), g.get("/appointments/find", w(async (i) => {
+    const d = C(i), e = (d.name || "").toLowerCase().trim(), o = (d.email || "").toLowerCase().trim(), s = d.date;
+    try {
+      const { firebase: t, reservationsCollection: a } = await m(i);
+      let n = t.firestore().collection(a);
+      o && (n = n.where("customerInfo.email", "==", o));
+      let c = (await n.orderBy("createdAt", "desc").limit(200).get()).docs.flatMap(
+        (l) => u(A({ id: l.id, ...l.data() }))
+      );
+      return s && (c = c.filter((l) => l.date === s)), e && (c = c.filter((l) => {
+        const p = (l.customerInfo?.firstName || "").toLowerCase(), D = (l.customerInfo?.lastName || "").toLowerCase();
+        return p.includes(e) || D.includes(e) || `${p} ${D}`.includes(e);
+      })), {
+        count: c.length,
+        appointments: c
+      };
+    } catch (t) {
+      throw console.error("Appointments handler — find error:", t), y({
+        statusCode: t.statusCode || 500,
+        statusMessage: t.statusMessage || "Failed to find appointments"
+      });
+    }
+  })), g.get("/appointments/:appointmentId", w(async (i) => {
+    const d = q(i, "appointmentId");
+    if (!d)
+      throw y({ statusCode: 400, statusMessage: "Appointment ID is required." });
+    try {
+      const { firebase: e, reservationsCollection: o } = await m(i), s = await e.firestore().collection(o).doc(d).get();
+      if (!s.exists)
+        throw y({ statusCode: 404, statusMessage: "Appointment not found." });
+      const t = A({ id: s.id, ...s.data() });
+      return {
+        ...t,
+        reservations: u(t)
+      };
+    } catch (e) {
+      throw console.error("Appointments handler — get error:", e), y({
+        statusCode: e.statusCode || 500,
+        statusMessage: e.statusMessage || "Failed to get appointment"
+      });
+    }
+  })), g.handler;
 }
-//#endregion
-//#region src/googleAnalytics/server.ts
-var s = "https://analyticsdata.googleapis.com/v1beta", c = ["https://www.googleapis.com/auth/analytics.readonly", "https://www.googleapis.com/auth/webmasters.readonly"], l = "https://searchconsole.googleapis.com/webmasters/v3";
-function u(i) {
-	let { decrypt: a, getGoogleAccessToken: o } = i, u = t();
-	async function m(t) {
-		let { supabase: n, instanceId: r } = t.context.module, { data: i, error: s } = await n.from("project_modules").select("config").eq("id", r).single();
-		if (s || !i?.config) throw e({
-			statusCode: 500,
-			statusMessage: "Failed to load module config."
-		});
-		let l = i.config, u = l.propertyId, d = l.serviceAccount, f = l.siteUrl || "";
-		if (!d) throw e({
-			statusCode: 400,
-			statusMessage: "No Google Service Account configured for this module."
-		});
-		if (!u) throw e({
-			statusCode: 400,
-			statusMessage: "No GA4 Property ID configured for this module."
-		});
-		let { data: p, error: m } = await n.from("integrations").select("config").eq("id", d).single(), h = p?.config;
-		if (m || !h) {
-			let { data: t, error: r } = await n.from("agency_integrations").select("config").eq("id", d).single();
-			if (r || !t?.config) throw e({
-				statusCode: 500,
-				statusMessage: "Failed to load Google Service Account credentials."
-			});
-			h = t.config;
-		}
-		return {
-			accessToken: await o({
-				clientEmail: a(h.clientEmail),
-				privateKey: a(h.privateKey),
-				projectId: a(h.projectId)
-			}, c),
-			propertyId: u,
-			siteUrl: f
-		};
-	}
-	async function h(t, n, r) {
-		let i = await fetch(`${s}/properties/${n}:runReport`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${t}`,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify(r)
-		});
-		if (!i.ok) {
-			let t = await i.json().catch(() => ({}));
-			throw console.error("GA4 runReport failed:", t), e({
-				statusCode: i.status,
-				statusMessage: t?.error?.message || "GA4 API request failed"
-			});
-		}
-		return i.json();
-	}
-	u.get("/report", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e), a = i.startDate || "30daysAgo", o = i.endDate || "today", s = a.match(/^(\d+)daysAgo$/), c = s ? parseInt(s[1], 10) : 30, l = `${c * 2}daysAgo`, u = `${c + 1}daysAgo`, f = [
-			{ name: "sessions" },
-			{ name: "totalUsers" },
-			{ name: "screenPageViews" },
-			{ name: "bounceRate" },
-			{ name: "averageSessionDuration" },
-			{ name: "newUsers" },
-			{ name: "engagementRate" },
-			{ name: "sessionsPerUser" },
-			{ name: "screenPageViewsPerSession" }
-		], p, g = !0;
-		try {
-			p = await h(t, n, {
-				dateRanges: [{
-					startDate: a,
-					endDate: o,
-					name: "current"
-				}, {
-					startDate: l,
-					endDate: u,
-					name: "previous"
-				}],
-				dimensions: [{ name: "date" }],
-				metrics: f,
-				metricAggregations: ["TOTAL"],
-				orderBys: [{ dimension: { dimensionName: "date" } }]
-			});
-		} catch {
-			g = !1, p = await h(t, n, {
-				dateRanges: [{
-					startDate: a,
-					endDate: o
-				}],
-				dimensions: [{ name: "date" }],
-				metrics: f,
-				metricAggregations: ["TOTAL"],
-				orderBys: [{ dimension: { dimensionName: "date" } }]
-			});
-		}
-		return d(p, g);
-	})), u.get("/realtime", n(async (t) => {
-		let { accessToken: n, propertyId: r } = await m(t), i = await fetch(`${s}/properties/${r}:runRealtimeReport`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${n}`,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({
-				dimensions: [{ name: "unifiedScreenName" }],
-				metrics: [{ name: "activeUsers" }],
-				orderBys: [{
-					metric: { metricName: "activeUsers" },
-					desc: !0
-				}],
-				limit: 5
-			})
-		});
-		if (!i.ok) {
-			let t = await i.json().catch(() => ({}));
-			throw e({
-				statusCode: i.status,
-				statusMessage: t?.error?.message || "Realtime API failed"
-			});
-		}
-		let a = await i.json();
-		return {
-			activeUsers: (a?.rows || []).reduce((e, t) => e + parseInt(t.metricValues?.[0]?.value || "0", 10), 0),
-			activePages: (a?.rows || []).map((e) => ({
-				page: e.dimensionValues?.[0]?.value || "(not set)",
-				activeUsers: parseInt(e.metricValues?.[0]?.value || "0", 10)
-			}))
-		};
-	})), u.get("/top-pages", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e), a = i.startDate || "30daysAgo", o = i.endDate || "today", s = parseInt(i.limit || "10", 10), c = f(await h(t, n, {
-			dateRanges: [{
-				startDate: a,
-				endDate: o
-			}],
-			dimensions: [{ name: "pagePath" }],
-			metrics: [
-				{ name: "screenPageViews" },
-				{ name: "totalUsers" },
-				{ name: "averageSessionDuration" }
-			],
-			orderBys: [{
-				metric: { metricName: "screenPageViews" },
-				desc: !0
-			}],
-			limit: s * 2
-		}), "pagePath"), l = /* @__PURE__ */ new Map();
-		for (let e of c.rows) {
-			let t = e.pagePath.toLowerCase().replace(/\/+$/, ""), n = l.get(t);
-			if (n) {
-				n.screenPageViews += e.screenPageViews || 0, n.totalUsers += e.totalUsers || 0;
-				let t = n.screenPageViews;
-				t > 0 && (n.averageSessionDuration = (n.averageSessionDuration * (t - (e.screenPageViews || 0)) + (e.averageSessionDuration || 0) * (e.screenPageViews || 0)) / t);
-			} else l.set(t, { ...e });
-		}
-		return {
-			rows: [...l.values()].sort((e, t) => (t.screenPageViews || 0) - (e.screenPageViews || 0)).slice(0, s),
-			rowCount: c.rowCount
-		};
-	})), u.get("/top-sources", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "sessionSource" }],
-			metrics: [{ name: "sessions" }, { name: "totalUsers" }],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}],
-			limit: 10
-		}), "sessionSource");
-	})), u.get("/devices", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "deviceCategory" }],
-			metrics: [{ name: "sessions" }, { name: "totalUsers" }],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}]
-		}), "deviceCategory");
-	})), u.get("/countries", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "country" }],
-			metrics: [{ name: "sessions" }, { name: "totalUsers" }],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}],
-			limit: 10
-		}), "country");
-	})), u.get("/acquisition/channels", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "sessionDefaultChannelGroup" }],
-			metrics: [
-				{ name: "sessions" },
-				{ name: "totalUsers" },
-				{ name: "newUsers" },
-				{ name: "engagementRate" },
-				{ name: "averageSessionDuration" },
-				{ name: "screenPageViewsPerSession" },
-				{ name: "conversions" }
-			],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}],
-			limit: 15
-		}), "sessionDefaultChannelGroup");
-	})), u.get("/acquisition/source-medium", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "sessionSourceMedium" }],
-			metrics: [
-				{ name: "sessions" },
-				{ name: "totalUsers" },
-				{ name: "newUsers" },
-				{ name: "bounceRate" },
-				{ name: "averageSessionDuration" },
-				{ name: "conversions" }
-			],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}],
-			limit: 20
-		}), "sessionSourceMedium");
-	})), u.get("/acquisition/referrals", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "sessionSource" }],
-			dimensionFilter: { filter: {
-				fieldName: "sessionMedium",
-				stringFilter: { value: "referral" }
-			} },
-			metrics: [
-				{ name: "sessions" },
-				{ name: "totalUsers" },
-				{ name: "engagementRate" },
-				{ name: "averageSessionDuration" }
-			],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}],
-			limit: 20
-		}), "sessionSource");
-	})), u.get("/acquisition/campaigns", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "sessionCampaignName" }],
-			dimensionFilter: { notExpression: { filter: {
-				fieldName: "sessionCampaignName",
-				stringFilter: { value: "(not set)" }
-			} } },
-			metrics: [
-				{ name: "sessions" },
-				{ name: "totalUsers" },
-				{ name: "conversions" },
-				{ name: "engagementRate" }
-			],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}],
-			limit: 20
-		}), "sessionCampaignName");
-	})), u.get("/content/all-pages", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e), a = i.startDate || "30daysAgo", o = i.endDate || "today", s = parseInt(i.limit || "50", 10);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: a,
-				endDate: o
-			}],
-			dimensions: [{ name: "pagePath" }],
-			metrics: [
-				{ name: "screenPageViews" },
-				{ name: "totalUsers" },
-				{ name: "averageSessionDuration" },
-				{ name: "bounceRate" },
-				{ name: "engagementRate" },
-				{ name: "sessions" },
-				{ name: "userEngagementDuration" }
-			],
-			orderBys: [{
-				metric: { metricName: "screenPageViews" },
-				desc: !0
-			}],
-			limit: s
-		}), "pagePath");
-	})), u.get("/content/landing-pages", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "landingPagePlusQueryString" }],
-			metrics: [
-				{ name: "sessions" },
-				{ name: "totalUsers" },
-				{ name: "bounceRate" },
-				{ name: "averageSessionDuration" },
-				{ name: "screenPageViews" },
-				{ name: "engagementRate" }
-			],
-			orderBys: [{
-				metric: { metricName: "sessions" },
-				desc: !0
-			}],
-			limit: 30
-		}), "landingPagePlusQueryString");
-	})), u.get("/content/exit-pages", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e), a = f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "pagePath" }],
-			metrics: [
-				{ name: "sessions" },
-				{ name: "screenPageViews" },
-				{ name: "totalUsers" },
-				{ name: "bounceRate" }
-			],
-			orderBys: [{
-				metric: { metricName: "screenPageViews" },
-				desc: !0
-			}],
-			limit: 20
-		}), "pagePath");
-		return a.rows = a.rows.map((e) => ({
-			...e,
-			exitRate: e.bounceRate || 0
-		})), a;
-	})), u.get("/content/search-terms", n(async (e) => {
-		let { accessToken: t, propertyId: n, siteUrl: i } = await m(e), a = r(e), o = a.startDate || "30daysAgo", s = a.endDate || "today";
-		if (i) try {
-			let e = `${l}/sites/${encodeURIComponent(i)}/searchAnalytics/query`, n = await fetch(e, {
-				method: "POST",
-				headers: {
-					Authorization: `Bearer ${t}`,
-					"Content-Type": "application/json"
-				},
-				body: JSON.stringify({
-					startDate: g(o),
-					endDate: g(s),
-					dimensions: ["query"],
-					rowLimit: 30
-				})
-			});
-			if (n.ok) {
-				let e = ((await n.json()).rows || []).map((e) => ({
-					query: e.keys[0],
-					clicks: e.clicks,
-					impressions: e.impressions,
-					ctr: e.ctr,
-					position: e.position
-				}));
-				if (e.length > 0) return {
-					rows: e,
-					rowCount: e.length,
-					source: "search_console"
-				};
-			} else {
-				let e = await n.text().catch(() => "");
-				console.error(`[GA Module] Search Console API error (${n.status}):`, e);
-			}
-		} catch (e) {
-			console.error("[GA Module] Search Console request failed:", e?.message || e);
-		}
-		else console.log("[GA Module] No siteUrl configured, skipping Search Console");
-		try {
-			let e = f(await h(t, n, {
-				dateRanges: [{
-					startDate: o,
-					endDate: s
-				}],
-				dimensions: [{ name: "sessionGoogleAdsQuery" }],
-				metrics: [
-					{ name: "sessions" },
-					{ name: "totalUsers" },
-					{ name: "engagementRate" }
-				],
-				dimensionFilter: { andGroup: { expressions: [{ notExpression: { filter: {
-					fieldName: "sessionGoogleAdsQuery",
-					stringFilter: { value: "(not set)" }
-				} } }, { notExpression: { filter: {
-					fieldName: "sessionGoogleAdsQuery",
-					stringFilter: { value: "(not provided)" }
-				} } }] } },
-				orderBys: [{
-					metric: { metricName: "sessions" },
-					desc: !0
-				}],
-				limit: 30
-			}), "sessionGoogleAdsQuery");
-			if (e.rows.length > 0) return {
-				...e,
-				source: "google_ads"
-			};
-		} catch {}
-		return {
-			...f(await h(t, n, {
-				dateRanges: [{
-					startDate: o,
-					endDate: s
-				}],
-				dimensions: [{ name: "landingPagePlusQueryString" }],
-				metrics: [
-					{ name: "sessions" },
-					{ name: "totalUsers" },
-					{ name: "engagementRate" }
-				],
-				dimensionFilter: { andGroup: { expressions: [{ filter: {
-					fieldName: "sessionMedium",
-					stringFilter: {
-						matchType: "EXACT",
-						value: "organic"
-					}
-				} }, { notExpression: { filter: {
-					fieldName: "landingPagePlusQueryString",
-					stringFilter: { value: "(not set)" }
-				} } }] } },
-				orderBys: [{
-					metric: { metricName: "sessions" },
-					desc: !0
-				}],
-				limit: 30
-			}), "landingPagePlusQueryString"),
-			source: "organic_landing_pages"
-		};
-	})), u.get("/audience/overview", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "newVsReturning" }],
-			metrics: [
-				{ name: "totalUsers" },
-				{ name: "sessions" },
-				{ name: "engagementRate" },
-				{ name: "averageSessionDuration" },
-				{ name: "screenPageViewsPerSession" }
-			],
-			metricAggregations: ["TOTAL"]
-		}), "newVsReturning");
-	})), u.get("/audience/technology", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e), a = i.startDate || "30daysAgo", o = i.endDate || "today", s = i.dimension || "browser", c = [
-			"browser",
-			"operatingSystem",
-			"screenResolution"
-		].includes(s) ? s : "browser";
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: a,
-				endDate: o
-			}],
-			dimensions: [{ name: c }],
-			metrics: [
-				{ name: "totalUsers" },
-				{ name: "sessions" },
-				{ name: "engagementRate" }
-			],
-			orderBys: [{
-				metric: { metricName: "totalUsers" },
-				desc: !0
-			}],
-			limit: 10
-		}), c);
-	})), u.get("/audience/languages", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return f(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "language" }],
-			metrics: [{ name: "totalUsers" }, { name: "sessions" }],
-			orderBys: [{
-				metric: { metricName: "totalUsers" },
-				desc: !0
-			}],
-			limit: 15
-		}), "language");
-	})), u.get("/audience/hours", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return p(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "dayOfWeekName" }, { name: "hour" }],
-			metrics: [{ name: "sessions" }],
-			orderBys: [{ dimension: { dimensionName: "dayOfWeekName" } }, { dimension: { dimensionName: "hour" } }],
-			limit: 168
-		}), ["dayOfWeekName", "hour"]);
-	})), u.get("/audience/cities", n(async (e) => {
-		let { accessToken: t, propertyId: n } = await m(e), i = r(e);
-		return p(await h(t, n, {
-			dateRanges: [{
-				startDate: i.startDate || "30daysAgo",
-				endDate: i.endDate || "today"
-			}],
-			dimensions: [{ name: "city" }, { name: "country" }],
-			metrics: [{ name: "totalUsers" }, { name: "sessions" }],
-			dimensionFilter: { notExpression: { filter: {
-				fieldName: "city",
-				stringFilter: { value: "(not set)" }
-			} } },
-			orderBys: [{
-				metric: { metricName: "totalUsers" },
-				desc: !0
-			}],
-			limit: 20
-		}), ["city", "country"]);
-	}));
-	function g(e) {
-		let t = e.match(/^(\d+)daysAgo$/);
-		if (t) {
-			let e = /* @__PURE__ */ new Date();
-			return e.setDate(e.getDate() - parseInt(t[1], 10)), e.toISOString().slice(0, 10);
-		}
-		if (e === "today") return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-		if (e === "yesterday") {
-			let e = /* @__PURE__ */ new Date();
-			return e.setDate(e.getDate() - 1), e.toISOString().slice(0, 10);
-		}
-		return e;
-	}
-	async function _(t, n, r) {
-		let i = `${l}/sites/${encodeURIComponent(n)}/searchAnalytics/query`, a = await fetch(i, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${t}`,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify(r)
-		});
-		if (!a.ok) {
-			let t = await a.json().catch(() => ({}));
-			throw e({
-				statusCode: a.status,
-				statusMessage: t?.error?.message || "Search Console API request failed"
-			});
-		}
-		return a.json();
-	}
-	return u.get("/seo/keywords", n(async (t) => {
-		let { accessToken: n, siteUrl: i } = await m(t);
-		if (!i) throw e({
-			statusCode: 400,
-			statusMessage: "Search Console Site URL is not configured. Add it in module settings."
-		});
-		let a = r(t), o = await _(n, i, {
-			startDate: g(a.startDate || "30daysAgo"),
-			endDate: g(a.endDate || "today"),
-			dimensions: ["query"],
-			rowLimit: Math.min(parseInt(a.limit) || 50, 100)
-		});
-		return {
-			rows: (o.rows || []).map((e) => ({
-				query: e.keys[0],
-				clicks: e.clicks,
-				impressions: e.impressions,
-				ctr: e.ctr,
-				position: e.position
-			})),
-			rowCount: o.rows?.length || 0
-		};
-	})), u.get("/seo/pages", n(async (t) => {
-		let { accessToken: n, siteUrl: i } = await m(t);
-		if (!i) throw e({
-			statusCode: 400,
-			statusMessage: "Search Console Site URL is not configured."
-		});
-		let a = r(t), o = await _(n, i, {
-			startDate: g(a.startDate || "30daysAgo"),
-			endDate: g(a.endDate || "today"),
-			dimensions: ["page"],
-			rowLimit: Math.min(parseInt(a.limit) || 50, 100)
-		});
-		return {
-			rows: (o.rows || []).map((e) => ({
-				page: e.keys[0],
-				clicks: e.clicks,
-				impressions: e.impressions,
-				ctr: e.ctr,
-				position: e.position
-			})),
-			rowCount: o.rows?.length || 0
-		};
-	})), u.get("/seo/trends", n(async (t) => {
-		let { accessToken: n, siteUrl: i } = await m(t);
-		if (!i) throw e({
-			statusCode: 400,
-			statusMessage: "Search Console Site URL is not configured."
-		});
-		let a = r(t), o = ((await _(n, i, {
-			startDate: g(a.startDate || "30daysAgo"),
-			endDate: g(a.endDate || "today"),
-			dimensions: ["date"],
-			rowLimit: 500
-		})).rows || []).map((e) => ({
-			date: e.keys[0],
-			clicks: e.clicks,
-			impressions: e.impressions,
-			ctr: e.ctr,
-			position: e.position
-		})).sort((e, t) => e.date.localeCompare(t.date)), s = o.reduce((e, t) => ({
-			clicks: e.clicks + t.clicks,
-			impressions: e.impressions + t.impressions
-		}), {
-			clicks: 0,
-			impressions: 0
-		});
-		return s.ctr = s.impressions > 0 ? s.clicks / s.impressions : 0, s.avgPosition = o.length > 0 ? o.reduce((e, t) => e + t.position, 0) / o.length : 0, {
-			rows: o,
-			totals: s,
-			rowCount: o.length
-		};
-	})), u.get("/seo/query-pages", n(async (t) => {
-		let { accessToken: n, siteUrl: i } = await m(t);
-		if (!i) throw e({
-			statusCode: 400,
-			statusMessage: "Search Console Site URL is not configured."
-		});
-		let a = r(t), o = await _(n, i, {
-			startDate: g(a.startDate || "30daysAgo"),
-			endDate: g(a.endDate || "today"),
-			dimensions: ["query", "page"],
-			rowLimit: 100
-		});
-		return {
-			rows: (o.rows || []).map((e) => ({
-				query: e.keys[0],
-				page: e.keys[1],
-				clicks: e.clicks,
-				impressions: e.impressions,
-				ctr: e.ctr,
-				position: e.position
-			})),
-			rowCount: o.rows?.length || 0
-		};
-	})), u.handler;
+const T = "https://analyticsdata.googleapis.com/v1beta", V = [
+  "https://www.googleapis.com/auth/analytics.readonly",
+  "https://www.googleapis.com/auth/webmasters.readonly"
+], N = "https://searchconsole.googleapis.com/webmasters/v3";
+function G(h) {
+  const { decrypt: P, getGoogleAccessToken: A } = h, g = v();
+  async function m(e) {
+    const { supabase: o, instanceId: s } = e.context.module, { data: t, error: a } = await o.from("project_modules").select("config").eq("id", s).single();
+    if (a || !t?.config)
+      throw y({ statusCode: 500, statusMessage: "Failed to load module config." });
+    const n = t.config, r = n.propertyId, c = n.serviceAccount, l = n.siteUrl || "";
+    if (!c)
+      throw y({ statusCode: 400, statusMessage: "No Google Service Account configured for this module." });
+    if (!r)
+      throw y({ statusCode: 400, statusMessage: "No GA4 Property ID configured for this module." });
+    const { data: p, error: D } = await o.from("integrations").select("config").eq("id", c).single();
+    let f = p?.config;
+    if (D || !f) {
+      const { data: M, error: F } = await o.from("agency_integrations").select("config").eq("id", c).single();
+      if (F || !M?.config)
+        throw y({ statusCode: 500, statusMessage: "Failed to load Google Service Account credentials." });
+      f = M.config;
+    }
+    const R = P(f.clientEmail), I = P(f.privateKey), S = P(f.projectId);
+    return { accessToken: await A(
+      { clientEmail: R, privateKey: I, projectId: S },
+      V
+    ), propertyId: r, siteUrl: l };
+  }
+  async function u(e, o, s) {
+    const t = await fetch(`${T}/properties/${o}:runReport`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${e}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(s)
+    });
+    if (!t.ok) {
+      const a = await t.json().catch(() => ({}));
+      throw console.error("GA4 runReport failed:", a), y({
+        statusCode: t.status,
+        statusMessage: a?.error?.message || "GA4 API request failed"
+      });
+    }
+    return t.json();
+  }
+  g.get(
+    "/report",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = a.match(/^(\d+)daysAgo$/), c = r ? parseInt(r[1], 10) : 30, l = `${c * 2}daysAgo`, p = `${c + 1}daysAgo`, D = [
+        { name: "sessions" },
+        { name: "totalUsers" },
+        { name: "screenPageViews" },
+        { name: "bounceRate" },
+        { name: "averageSessionDuration" },
+        { name: "newUsers" },
+        { name: "engagementRate" },
+        { name: "sessionsPerUser" },
+        { name: "screenPageViewsPerSession" }
+      ];
+      let f, R = !0;
+      try {
+        f = await u(o, s, {
+          dateRanges: [
+            { startDate: a, endDate: n, name: "current" },
+            { startDate: l, endDate: p, name: "previous" }
+          ],
+          dimensions: [{ name: "date" }],
+          metrics: D,
+          metricAggregations: ["TOTAL"],
+          orderBys: [{ dimension: { dimensionName: "date" } }]
+        });
+      } catch {
+        R = !1, f = await u(o, s, {
+          dateRanges: [{ startDate: a, endDate: n }],
+          dimensions: [{ name: "date" }],
+          metrics: D,
+          metricAggregations: ["TOTAL"],
+          orderBys: [{ dimension: { dimensionName: "date" } }]
+        });
+      }
+      return E(f, R);
+    })
+  ), g.get(
+    "/realtime",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = await fetch(
+        `${T}/properties/${s}:runRealtimeReport`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${o}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            dimensions: [{ name: "unifiedScreenName" }],
+            metrics: [{ name: "activeUsers" }],
+            orderBys: [{ metric: { metricName: "activeUsers" }, desc: !0 }],
+            limit: 5
+          })
+        }
+      );
+      if (!t.ok) {
+        const c = await t.json().catch(() => ({}));
+        throw y({ statusCode: t.status, statusMessage: c?.error?.message || "Realtime API failed" });
+      }
+      const a = await t.json(), n = (a?.rows || []).reduce(
+        (c, l) => c + parseInt(l.metricValues?.[0]?.value || "0", 10),
+        0
+      ), r = (a?.rows || []).map((c) => ({
+        page: c.dimensionValues?.[0]?.value || "(not set)",
+        activeUsers: parseInt(c.metricValues?.[0]?.value || "0", 10)
+      }));
+      return { activeUsers: n, activePages: r };
+    })
+  ), g.get(
+    "/top-pages",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = parseInt(t.limit || "10", 10), c = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "pagePath" }],
+        metrics: [
+          { name: "screenPageViews" },
+          { name: "totalUsers" },
+          { name: "averageSessionDuration" }
+        ],
+        orderBys: [{ metric: { metricName: "screenPageViews" }, desc: !0 }],
+        limit: r * 2
+        // fetch extra to account for duplicates before aggregation
+      }), l = k(c, "pagePath"), p = /* @__PURE__ */ new Map();
+      for (const f of l.rows) {
+        const R = f.pagePath.toLowerCase().replace(/\/+$/, ""), I = p.get(R);
+        if (I) {
+          I.screenPageViews += f.screenPageViews || 0, I.totalUsers += f.totalUsers || 0;
+          const S = I.screenPageViews;
+          S > 0 && (I.averageSessionDuration = (I.averageSessionDuration * (S - (f.screenPageViews || 0)) + (f.averageSessionDuration || 0) * (f.screenPageViews || 0)) / S);
+        } else
+          p.set(R, { ...f });
+      }
+      return { rows: [...p.values()].sort((f, R) => (R.screenPageViews || 0) - (f.screenPageViews || 0)).slice(0, r), rowCount: l.rowCount };
+    })
+  ), g.get(
+    "/top-sources",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "sessionSource" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 10
+      });
+      return k(r, "sessionSource");
+    })
+  ), g.get(
+    "/devices",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "deviceCategory" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }]
+      });
+      return k(r, "deviceCategory");
+    })
+  ), g.get(
+    "/countries",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "country" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 10
+      });
+      return k(r, "country");
+    })
+  ), g.get(
+    "/acquisition/channels",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "sessionDefaultChannelGroup" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "newUsers" },
+          { name: "engagementRate" },
+          { name: "averageSessionDuration" },
+          { name: "screenPageViewsPerSession" },
+          { name: "conversions" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 15
+      });
+      return k(r, "sessionDefaultChannelGroup");
+    })
+  ), g.get(
+    "/acquisition/source-medium",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "sessionSourceMedium" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "newUsers" },
+          { name: "bounceRate" },
+          { name: "averageSessionDuration" },
+          { name: "conversions" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 20
+      });
+      return k(r, "sessionSourceMedium");
+    })
+  ), g.get(
+    "/acquisition/referrals",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "sessionSource" }],
+        dimensionFilter: {
+          filter: {
+            fieldName: "sessionMedium",
+            stringFilter: { value: "referral" }
+          }
+        },
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "engagementRate" },
+          { name: "averageSessionDuration" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 20
+      });
+      return k(r, "sessionSource");
+    })
+  ), g.get(
+    "/acquisition/campaigns",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "sessionCampaignName" }],
+        dimensionFilter: {
+          notExpression: {
+            filter: {
+              fieldName: "sessionCampaignName",
+              stringFilter: { value: "(not set)" }
+            }
+          }
+        },
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "conversions" },
+          { name: "engagementRate" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 20
+      });
+      return k(r, "sessionCampaignName");
+    })
+  ), g.get(
+    "/content/all-pages",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = parseInt(t.limit || "50", 10), c = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "pagePath" }],
+        metrics: [
+          { name: "screenPageViews" },
+          { name: "totalUsers" },
+          { name: "averageSessionDuration" },
+          { name: "bounceRate" },
+          { name: "engagementRate" },
+          { name: "sessions" },
+          { name: "userEngagementDuration" }
+        ],
+        orderBys: [{ metric: { metricName: "screenPageViews" }, desc: !0 }],
+        limit: r
+      });
+      return k(c, "pagePath");
+    })
+  ), g.get(
+    "/content/landing-pages",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "landingPagePlusQueryString" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "bounceRate" },
+          { name: "averageSessionDuration" },
+          { name: "screenPageViews" },
+          { name: "engagementRate" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 30
+      });
+      return k(r, "landingPagePlusQueryString");
+    })
+  ), g.get(
+    "/content/exit-pages",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "pagePath" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "screenPageViews" },
+          { name: "totalUsers" },
+          { name: "bounceRate" }
+        ],
+        orderBys: [{ metric: { metricName: "screenPageViews" }, desc: !0 }],
+        limit: 20
+      }), c = k(r, "pagePath");
+      return c.rows = c.rows.map((l) => ({
+        ...l,
+        exitRate: l.bounceRate || 0
+      })), c;
+    })
+  ), g.get(
+    "/content/search-terms",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s, siteUrl: t } = await m(e), a = C(e), n = a.startDate || "30daysAgo", r = a.endDate || "today";
+      if (t)
+        try {
+          const p = `${N}/sites/${encodeURIComponent(t)}/searchAnalytics/query`, D = await fetch(
+            p,
+            {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${o}`,
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                startDate: i(n),
+                endDate: i(r),
+                dimensions: ["query"],
+                rowLimit: 30
+              })
+            }
+          );
+          if (D.ok) {
+            const R = ((await D.json()).rows || []).map((I) => ({
+              query: I.keys[0],
+              clicks: I.clicks,
+              impressions: I.impressions,
+              ctr: I.ctr,
+              position: I.position
+            }));
+            if (R.length > 0)
+              return {
+                rows: R,
+                rowCount: R.length,
+                source: "search_console"
+              };
+          } else {
+            const f = await D.text().catch(() => "");
+            console.error(`[GA Module] Search Console API error (${D.status}):`, f);
+          }
+        } catch (p) {
+          console.error("[GA Module] Search Console request failed:", p?.message || p);
+        }
+      else
+        console.log("[GA Module] No siteUrl configured, skipping Search Console");
+      try {
+        const p = await u(o, s, {
+          dateRanges: [{ startDate: n, endDate: r }],
+          dimensions: [{ name: "sessionGoogleAdsQuery" }],
+          metrics: [
+            { name: "sessions" },
+            { name: "totalUsers" },
+            { name: "engagementRate" }
+          ],
+          dimensionFilter: {
+            andGroup: {
+              expressions: [
+                {
+                  notExpression: {
+                    filter: {
+                      fieldName: "sessionGoogleAdsQuery",
+                      stringFilter: { value: "(not set)" }
+                    }
+                  }
+                },
+                {
+                  notExpression: {
+                    filter: {
+                      fieldName: "sessionGoogleAdsQuery",
+                      stringFilter: { value: "(not provided)" }
+                    }
+                  }
+                }
+              ]
+            }
+          },
+          orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+          limit: 30
+        }), D = k(p, "sessionGoogleAdsQuery");
+        if (D.rows.length > 0)
+          return { ...D, source: "google_ads" };
+      } catch {
+      }
+      const c = await u(o, s, {
+        dateRanges: [{ startDate: n, endDate: r }],
+        dimensions: [{ name: "landingPagePlusQueryString" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "engagementRate" }
+        ],
+        dimensionFilter: {
+          andGroup: {
+            expressions: [
+              {
+                filter: {
+                  fieldName: "sessionMedium",
+                  stringFilter: {
+                    matchType: "EXACT",
+                    value: "organic"
+                  }
+                }
+              },
+              {
+                notExpression: {
+                  filter: {
+                    fieldName: "landingPagePlusQueryString",
+                    stringFilter: { value: "(not set)" }
+                  }
+                }
+              }
+            ]
+          }
+        },
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 30
+      });
+      return { ...k(c, "landingPagePlusQueryString"), source: "organic_landing_pages" };
+    })
+  ), g.get(
+    "/audience/overview",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "newVsReturning" }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" },
+          { name: "engagementRate" },
+          { name: "averageSessionDuration" },
+          { name: "screenPageViewsPerSession" }
+        ],
+        metricAggregations: ["TOTAL"]
+      });
+      return k(r, "newVsReturning");
+    })
+  ), g.get(
+    "/audience/technology",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = t.dimension || "browser", l = ["browser", "operatingSystem", "screenResolution"].includes(r) ? r : "browser", p = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: l }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" },
+          { name: "engagementRate" }
+        ],
+        orderBys: [{ metric: { metricName: "totalUsers" }, desc: !0 }],
+        limit: 10
+      });
+      return k(p, l);
+    })
+  ), g.get(
+    "/audience/languages",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "language" }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" }
+        ],
+        orderBys: [{ metric: { metricName: "totalUsers" }, desc: !0 }],
+        limit: 15
+      });
+      return k(r, "language");
+    })
+  ), g.get(
+    "/audience/hours",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "dayOfWeekName" }, { name: "hour" }],
+        metrics: [{ name: "sessions" }],
+        orderBys: [
+          { dimension: { dimensionName: "dayOfWeekName" } },
+          { dimension: { dimensionName: "hour" } }
+        ],
+        limit: 168
+        // 7 days × 24 hours
+      });
+      return U(r, ["dayOfWeekName", "hour"]);
+    })
+  ), g.get(
+    "/audience/cities",
+    w(async (e) => {
+      const { accessToken: o, propertyId: s } = await m(e), t = C(e), a = t.startDate || "30daysAgo", n = t.endDate || "today", r = await u(o, s, {
+        dateRanges: [{ startDate: a, endDate: n }],
+        dimensions: [{ name: "city" }, { name: "country" }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" }
+        ],
+        dimensionFilter: {
+          notExpression: {
+            filter: {
+              fieldName: "city",
+              stringFilter: { value: "(not set)" }
+            }
+          }
+        },
+        orderBys: [{ metric: { metricName: "totalUsers" }, desc: !0 }],
+        limit: 20
+      });
+      return U(r, ["city", "country"]);
+    })
+  );
+  function i(e) {
+    const o = e.match(/^(\d+)daysAgo$/);
+    if (o) {
+      const s = /* @__PURE__ */ new Date();
+      return s.setDate(s.getDate() - parseInt(o[1], 10)), s.toISOString().slice(0, 10);
+    }
+    if (e === "today") return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (e === "yesterday") {
+      const s = /* @__PURE__ */ new Date();
+      return s.setDate(s.getDate() - 1), s.toISOString().slice(0, 10);
+    }
+    return e;
+  }
+  async function d(e, o, s) {
+    const t = `${N}/sites/${encodeURIComponent(o)}/searchAnalytics/query`, a = await fetch(t, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${e}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(s)
+    });
+    if (!a.ok) {
+      const n = await a.json().catch(() => ({}));
+      throw y({
+        statusCode: a.status,
+        statusMessage: n?.error?.message || "Search Console API request failed"
+      });
+    }
+    return a.json();
+  }
+  return g.get(
+    "/seo/keywords",
+    w(async (e) => {
+      const { accessToken: o, siteUrl: s } = await m(e);
+      if (!s)
+        throw y({ statusCode: 400, statusMessage: "Search Console Site URL is not configured. Add it in module settings." });
+      const t = C(e), a = i(t.startDate || "30daysAgo"), n = i(t.endDate || "today"), r = Math.min(parseInt(t.limit) || 50, 100), c = await d(o, s, {
+        startDate: a,
+        endDate: n,
+        dimensions: ["query"],
+        rowLimit: r
+      });
+      return {
+        rows: (c.rows || []).map((l) => ({
+          query: l.keys[0],
+          clicks: l.clicks,
+          impressions: l.impressions,
+          ctr: l.ctr,
+          position: l.position
+        })),
+        rowCount: c.rows?.length || 0
+      };
+    })
+  ), g.get(
+    "/seo/pages",
+    w(async (e) => {
+      const { accessToken: o, siteUrl: s } = await m(e);
+      if (!s)
+        throw y({ statusCode: 400, statusMessage: "Search Console Site URL is not configured." });
+      const t = C(e), a = i(t.startDate || "30daysAgo"), n = i(t.endDate || "today"), r = Math.min(parseInt(t.limit) || 50, 100), c = await d(o, s, {
+        startDate: a,
+        endDate: n,
+        dimensions: ["page"],
+        rowLimit: r
+      });
+      return {
+        rows: (c.rows || []).map((l) => ({
+          page: l.keys[0],
+          clicks: l.clicks,
+          impressions: l.impressions,
+          ctr: l.ctr,
+          position: l.position
+        })),
+        rowCount: c.rows?.length || 0
+      };
+    })
+  ), g.get(
+    "/seo/trends",
+    w(async (e) => {
+      const { accessToken: o, siteUrl: s } = await m(e);
+      if (!s)
+        throw y({ statusCode: 400, statusMessage: "Search Console Site URL is not configured." });
+      const t = C(e), a = i(t.startDate || "30daysAgo"), n = i(t.endDate || "today"), c = ((await d(o, s, {
+        startDate: a,
+        endDate: n,
+        dimensions: ["date"],
+        rowLimit: 500
+      })).rows || []).map((p) => ({
+        date: p.keys[0],
+        clicks: p.clicks,
+        impressions: p.impressions,
+        ctr: p.ctr,
+        position: p.position
+      })).sort((p, D) => p.date.localeCompare(D.date)), l = c.reduce(
+        (p, D) => ({
+          clicks: p.clicks + D.clicks,
+          impressions: p.impressions + D.impressions
+        }),
+        { clicks: 0, impressions: 0 }
+      );
+      return l.ctr = l.impressions > 0 ? l.clicks / l.impressions : 0, l.avgPosition = c.length > 0 ? c.reduce((p, D) => p + D.position, 0) / c.length : 0, { rows: c, totals: l, rowCount: c.length };
+    })
+  ), g.get(
+    "/seo/query-pages",
+    w(async (e) => {
+      const { accessToken: o, siteUrl: s } = await m(e);
+      if (!s)
+        throw y({ statusCode: 400, statusMessage: "Search Console Site URL is not configured." });
+      const t = C(e), a = i(t.startDate || "30daysAgo"), n = i(t.endDate || "today"), r = await d(o, s, {
+        startDate: a,
+        endDate: n,
+        dimensions: ["query", "page"],
+        rowLimit: 100
+      });
+      return {
+        rows: (r.rows || []).map((c) => ({
+          query: c.keys[0],
+          page: c.keys[1],
+          clicks: c.clicks,
+          impressions: c.impressions,
+          ctr: c.ctr,
+          position: c.position
+        })),
+        rowCount: r.rows?.length || 0
+      };
+    })
+  ), g.handler;
 }
-function d(e, t = !0) {
-	let n = (e.metricHeaders || []).map((e) => e.name), r = (e.dimensionHeaders || []).map((e) => e.name).indexOf("date"), i = [];
-	(e.rows || []).forEach((e) => {
-		let t = r >= 0 ? e.dimensionValues[r]?.value : e.dimensionValues[0]?.value;
-		if (!t || t.length < 8) return;
-		let a = { date: `${t.slice(0, 4)}-${t.slice(4, 6)}-${t.slice(6, 8)}` };
-		n.forEach((t, n) => {
-			a[t] = parseFloat(e.metricValues[n]?.value || "0");
-		}), i.push(a);
-	});
-	let a = {}, o = {};
-	e.totals && e.totals.length >= 2 ? n.forEach((t, n) => {
-		a[t] = parseFloat(e.totals[0]?.metricValues?.[n]?.value || "0"), o[t] = parseFloat(e.totals[1]?.metricValues?.[n]?.value || "0");
-	}) : e.totals && e.totals.length === 1 && n.forEach((t, n) => {
-		a[t] = parseFloat(e.totals[0]?.metricValues?.[n]?.value || "0");
-	});
-	let s = {};
-	n.forEach((e) => {
-		let t = a[e] || 0, n = o[e];
-		n !== void 0 && n !== 0 ? s[e] = (t - n) / n * 100 : s[e] = null;
-	});
-	let c = /* @__PURE__ */ new Map();
-	for (let e of i) c.has(e.date) || c.set(e.date, e);
-	let l = Array.from(c.values()).sort((e, t) => e.date.localeCompare(t.date)), u = t && e.totals && e.totals.length >= 2 ? l.slice(-Math.ceil(l.length / 2)) : l;
-	return {
-		rows: u,
-		totals: a,
-		previousTotals: o,
-		changes: s,
-		rowCount: u.length
-	};
+function E(h, P = !0) {
+  const A = (h.metricHeaders || []).map((a) => a.name), m = (h.dimensionHeaders || []).map((a) => a.name).indexOf("date"), u = [];
+  (h.rows || []).forEach((a) => {
+    const n = m >= 0 ? a.dimensionValues[m]?.value : a.dimensionValues[0]?.value;
+    if (!n || n.length < 8) return;
+    const c = { date: `${n.slice(0, 4)}-${n.slice(4, 6)}-${n.slice(6, 8)}` };
+    A.forEach((l, p) => {
+      c[l] = parseFloat(a.metricValues[p]?.value || "0");
+    }), u.push(c);
+  });
+  const i = {}, d = {};
+  h.totals && h.totals.length >= 2 ? A.forEach((a, n) => {
+    i[a] = parseFloat(h.totals[0]?.metricValues?.[n]?.value || "0"), d[a] = parseFloat(h.totals[1]?.metricValues?.[n]?.value || "0");
+  }) : h.totals && h.totals.length === 1 && A.forEach((a, n) => {
+    i[a] = parseFloat(h.totals[0]?.metricValues?.[n]?.value || "0");
+  });
+  const e = {};
+  A.forEach((a) => {
+    const n = i[a] || 0, r = d[a];
+    r !== void 0 && r !== 0 ? e[a] = (n - r) / r * 100 : e[a] = null;
+  });
+  const o = /* @__PURE__ */ new Map();
+  for (const a of u)
+    o.has(a.date) || o.set(a.date, a);
+  const s = Array.from(o.values()).sort((a, n) => a.date.localeCompare(n.date)), t = P && h.totals && h.totals.length >= 2 ? s.slice(-Math.ceil(s.length / 2)) : s;
+  return {
+    rows: t,
+    totals: i,
+    previousTotals: d,
+    changes: e,
+    rowCount: t.length
+  };
 }
-function f(e, t) {
-	let n = (e.metricHeaders || []).map((e) => e.name), r = (e.rows || []).map((e) => {
-		let r = { [t]: e.dimensionValues[0].value };
-		return n.forEach((t, n) => {
-			r[t] = parseFloat(e.metricValues[n].value);
-		}), r;
-	});
-	return {
-		rows: r,
-		rowCount: e.rowCount || r.length
-	};
+function k(h, P) {
+  const A = (h.metricHeaders || []).map((m) => m.name), g = (h.rows || []).map((m) => {
+    const u = {
+      [P]: m.dimensionValues[0].value
+    };
+    return A.forEach((i, d) => {
+      u[i] = parseFloat(m.metricValues[d].value);
+    }), u;
+  });
+  return { rows: g, rowCount: h.rowCount || g.length };
 }
-function p(e, t) {
-	let n = (e.metricHeaders || []).map((e) => e.name), r = (e.rows || []).map((e) => {
-		let r = {};
-		return t.forEach((t, n) => {
-			r[t] = e.dimensionValues[n]?.value || "";
-		}), n.forEach((t, n) => {
-			r[t] = parseFloat(e.metricValues[n].value);
-		}), r;
-	});
-	return {
-		rows: r,
-		rowCount: e.rowCount || r.length
-	};
+function U(h, P) {
+  const A = (h.metricHeaders || []).map((m) => m.name), g = (h.rows || []).map((m) => {
+    const u = {};
+    return P.forEach((i, d) => {
+      u[i] = m.dimensionValues[d]?.value || "";
+    }), A.forEach((i, d) => {
+      u[i] = parseFloat(m.metricValues[d].value);
+    }), u;
+  });
+  return { rows: g, rowCount: h.rowCount || g.length };
 }
-//#endregion
-//#region src/contentManager/server.ts
-function m(r) {
-	let { decrypt: i } = r, a = t();
-	async function o(t) {
-		let { supabase: n, instanceId: r } = t.context.module, { data: a, error: o } = await n.from("project_modules").select("config").eq("id", r).single();
-		if (o || !a?.config) throw e({
-			statusCode: 500,
-			statusMessage: "Failed to load module config."
-		});
-		let s = a.config, c = s.githubIntegration, l = s.githubRepo, u = s.githubOwner;
-		if (!c || !l || !u) throw e({
-			statusCode: 400,
-			statusMessage: "No GitHub integration configured for this module."
-		});
-		let { data: d, error: f } = await n.from("integrations").select("config").eq("id", c).single(), p = d?.config;
-		if (f || !p) {
-			let { data: t, error: r } = await n.from("agency_integrations").select("config").eq("id", c).single();
-			if (r || !t?.config) throw e({
-				statusCode: 500,
-				statusMessage: "Failed to load Github credentials."
-			});
-			p = t.config;
-		}
-		return {
-			token: i(p.token),
-			repo: l,
-			owner: u
-		};
-	}
-	return a.post("/github/deploy", n(async (t) => {
-		try {
-			let { token: e, repo: n, owner: r } = await o(t);
-			await fetch(`https://api.github.com/repos/${r}/${n}/dispatches`, {
-				method: "POST",
-				headers: {
-					Authorization: `Bearer ${e}`,
-					Accept: "application/vnd.github+json"
-				},
-				body: JSON.stringify({ event_type: "deploy-site" })
-			});
-		} catch (t) {
-			throw console.error("Error triggering GitHub deployment:", t), e({
-				statusCode: 500,
-				statusMessage: "Failed to trigger deployment."
-			});
-		}
-	})), a.handler;
+function j(h) {
+  const { decrypt: P } = h, A = v();
+  async function g(m) {
+    const { supabase: u, instanceId: i } = m.context.module, { data: d, error: e } = await u.from("project_modules").select("config").eq("id", i).single();
+    if (e || !d?.config)
+      throw y({ statusCode: 500, statusMessage: "Failed to load module config." });
+    const o = d.config, s = o.githubIntegration, t = o.githubRepo, a = o.githubOwner;
+    if (!s || !t || !a)
+      throw y({ statusCode: 400, statusMessage: "No GitHub integration configured for this module." });
+    const { data: n, error: r } = await u.from("integrations").select("config").eq("id", s).single();
+    let c = n?.config;
+    if (r || !c) {
+      const { data: p, error: D } = await u.from("agency_integrations").select("config").eq("id", s).single();
+      if (D || !p?.config)
+        throw y({ statusCode: 500, statusMessage: "Failed to load Github credentials." });
+      c = p.config;
+    }
+    return { token: P(c.token), repo: t, owner: a };
+  }
+  return A.post(
+    "/github/deploy",
+    w(async (m) => {
+      try {
+        const { token: u, repo: i, owner: d } = await g(m);
+        await fetch(`https://api.github.com/repos/${d}/${i}/dispatches`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${u}`,
+            Accept: "application/vnd.github+json"
+          },
+          body: JSON.stringify({
+            event_type: "deploy-site"
+          })
+        });
+      } catch (u) {
+        throw console.error("Error triggering GitHub deployment:", u), y({ statusCode: 500, statusMessage: "Failed to trigger deployment." });
+      }
+    })
+  ), A.handler;
 }
-//#endregion
-export { o as appointments, m as contentManager, u as googleAnalytics, a as products };
+export {
+  x as appointments,
+  j as contentManager,
+  G as googleAnalytics,
+  $ as products
+};