evaldoc 1.0.0

package/public/app/app.js

@@ -0,0 +1,1754 @@
+const TOPICS = [
+  "medication_info_safety",
+  "appointments_preparation",
+  "general_health_info",
+  "clinic_services_hours",
+  "insurance_billing_faq",
+  "post_procedure_guidance"
+];
+
+const waitlistPanel = document.getElementById("waitlistPanel");
+const authPanel = document.getElementById("authPanel");
+const onboardingPanel = document.getElementById("onboardingPanel");
+const billingSetupPanel = document.getElementById("billingSetupPanel");
+const dashboardPanel = document.getElementById("dashboardPanel");
+const signOutBtn = document.getElementById("signOutBtn");
+const authError = document.getElementById("authError");
+const onboardingError = document.getElementById("onboardingError");
+
+const loginEmail = document.getElementById("loginEmail");
+const loginPassword = document.getElementById("loginPassword");
+const signupEmail = document.getElementById("signupEmail");
+const signupPassword = document.getElementById("signupPassword");
+const loginBtn = document.getElementById("loginBtn");
+const signupBtn = document.getElementById("signupBtn");
+
+const onboardingForm = document.getElementById("onboardingForm");
+const handleInput = document.getElementById("handleInput");
+const displayNameInput = document.getElementById("displayNameInput");
+const specialtyInput = document.getElementById("specialtyInput");
+const countryInput = document.getElementById("countryInput");
+const primaryColorInput = document.getElementById("primaryColorInput");
+const secondaryColorInput = document.getElementById("secondaryColorInput");
+const welcomeInput = document.getElementById("welcomeInput");
+const topicsList = document.getElementById("topicsList");
+
+const statMonthly = document.getElementById("statMonthly");
+const statEscalations = document.getElementById("statEscalations");
+const statLimit = document.getElementById("statLimit");
+const refreshAnalyticsBtn = document.getElementById("refreshAnalyticsBtn");
+const shareLink = document.getElementById("shareLink");
+const copyLinkBtn = document.getElementById("copyLinkBtn");
+const downloadQRBtn = document.getElementById("downloadQRBtn");
+const previewChatBtn = document.getElementById("previewChatBtn");
+const qrCanvas = document.getElementById("qrCanvas");
+
+const topicsManage = document.getElementById("topicsManage");
+const saveTopicsBtn = document.getElementById("saveTopicsBtn");
+const welcomeUpdate = document.getElementById("welcomeUpdate");
+const statusSelect = document.getElementById("statusSelect");
+const saveSettingsBtn = document.getElementById("saveSettingsBtn");
+const conversationsEl = document.getElementById("conversations");
+
+let currentProvider = null;
+
+function setVisible(element, visible) {
+  element.classList.toggle("hidden", !visible);
+}
+
+function setError(element, message) {
+  element.textContent = message || "";
+}
+
+function renderTopicCheckboxes(container, selected = []) {
+  container.innerHTML = "";
+  TOPICS.forEach((topic) => {
+    const label = document.createElement("label");
+    label.className = "topic-chip";
+    const checkbox = document.createElement("input");
+    checkbox.type = "checkbox";
+    checkbox.value = topic;
+    checkbox.checked = selected.includes(topic);
+    checkbox.addEventListener("change", () => {
+      label.classList.toggle("topic-active", checkbox.checked);
+    });
+    if (checkbox.checked) label.classList.add("topic-active");
+    label.appendChild(checkbox);
+    label.appendChild(document.createTextNode(topic.replace(/_/g, " ")));
+    container.appendChild(label);
+  });
+}
+
+async function fetchWithAuth(path, options = {}) {
+  const user = firebase.auth().currentUser;
+  console.log('[FETCH] Current user:', user ? user.email : 'None');
+
+  if (!user) {
+    console.error('[FETCH] ❌ No authenticated user');
+    throw new Error('Not authenticated');
+  }
+
+  const token = await user.getIdToken();
+  console.log('[FETCH] Got ID token, length:', token.length);
+  console.log('[FETCH] Making request to:', path);
+
+  const headers = Object.assign({}, options.headers || {}, {
+    Authorization: `Bearer ${token}`
+  });
+  return fetch(path, { ...options, headers });
+}
+
+async function loadProvider() {
+  const res = await fetchWithAuth("/api/me");
+  if (res.status === 404) {
+    currentProvider = null;
+    return null;
+  }
+  if (!res.ok) {
+    throw new Error("Unable to load provider");
+  }
+  const provider = await res.json();
+  currentProvider = provider;
+  return provider;
+}
+
+async function loadAnalytics() {
+  if (!currentProvider) return;
+  const statEls = [statMonthly, statEscalations, statLimit];
+  var skeletonHtml = '<span class="skeleton-stat"></span>';
+  statEls.forEach(el => { if (el) el.innerHTML = skeletonHtml; });
+  const refreshBtn = document.getElementById("refreshAnalyticsBtn");
+  if (refreshBtn) refreshBtn.disabled = true;
+
+  try {
+    const res = await fetchWithAuth("/api/analytics");
+    if (!res.ok) {
+      statEls.forEach(el => { if (el) el.innerHTML = '<span style="cursor:pointer;color:var(--accent);" onclick="loadAnalytics()">⟳ Retry</span>'; });
+      return;
+    }
+    const data = await res.json();
+    const chats = data.provider.monthlyChatCount || 0;
+    const escalations = data.provider.totalEscalationCount || 0;
+    statMonthly.textContent = chats;
+    statEscalations.textContent = escalations;
+    const limitValue = data.provider.monthlyChatLimit || 0;
+    statLimit.textContent = limitValue <= 0 ? "∞" : limitValue;
+    const rateEl = document.getElementById("statEscalationRate");
+    if (rateEl) {
+      rateEl.textContent = (data.escalationRate != null ? data.escalationRate : 0) + "%";
+    }
+    const resRateEl = document.getElementById("statResolutionRate");
+    if (resRateEl) {
+      resRateEl.textContent = data.resolutionRate != null ? data.resolutionRate + "%" : "—";
+    }
+    const satEl = document.getElementById("statSatisfaction");
+    if (satEl && data.satisfaction) {
+      satEl.textContent = data.satisfaction.average
+        ? `${data.satisfaction.average}/5 (${data.satisfaction.count})`
+        : "—";
+    }
+
+    const totalConvEl = document.getElementById("statTotalConversations");
+    if (totalConvEl) {
+      totalConvEl.textContent = data.totalConversations || 0;
+    }
+    const uniquePatientsEl = document.getElementById("statUniquePatients");
+    if (uniquePatientsEl) {
+      uniquePatientsEl.textContent = data.uniquePatients || 0;
+    }
+
+    const topicsListEl = document.getElementById("topTopicsList");
+    if (topicsListEl && Array.isArray(data.topTopics) && data.topTopics.length) {
+      topicsListEl.innerHTML = data.topTopics.map(t =>
+        `<div style="display:flex;justify-content:space-between;padding:0.2rem 0;"><span>${formatTopicName(t.topic)}</span><strong>${t.count}</strong></div>`
+      ).join("");
+    }
+    const questionsListEl = document.getElementById("topQuestionsList");
+    if (questionsListEl && Array.isArray(data.topQuestions) && data.topQuestions.length) {
+      questionsListEl.innerHTML = data.topQuestions.map(q =>
+        `<div style="display:flex;justify-content:space-between;padding:0.2rem 0;"><span>${escapeHtml(q.question)}</span><strong>${q.count}</strong></div>`
+      ).join("");
+    }
+
+    const draftEl = document.getElementById("draftMetricsBreakdown");
+    if (draftEl && data.draftMetrics) {
+      const dm = data.draftMetrics;
+      const total = dm.accepted + dm.edited + dm.rejected;
+      if (total > 0) {
+        const pct = (v) => Math.round((v / total) * 100);
+        draftEl.innerHTML = `
+          <div style="display:flex;gap:4px;height:8px;border-radius:4px;overflow:hidden;margin-bottom:0.5rem;">
+            <div style="flex:${dm.accepted};background:#10b981;" title="Accepted ${pct(dm.accepted)}%"></div>
+            <div style="flex:${dm.edited};background:#f59e0b;" title="Edited ${pct(dm.edited)}%"></div>
+            <div style="flex:${dm.rejected};background:#ef4444;" title="Rejected ${pct(dm.rejected)}%"></div>
+          </div>
+          <div style="display:flex;justify-content:space-between;font-size:0.75rem;color:#6b7280;">
+            <span>✓ ${dm.accepted} accepted</span>
+            <span>✎ ${dm.edited} edited</span>
+            <span>✕ ${dm.rejected} rejected</span>
+          </div>`;
+      } else {
+        draftEl.textContent = "No drafts yet";
+      }
+    }
+
+    const updatedEl = document.getElementById("analyticsLastUpdated");
+    if (updatedEl) {
+      updatedEl.textContent = "Updated " + new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+    }
+  } catch (err) {
+    statEls.forEach(el => { if (el) el.innerHTML = '<span style="cursor:pointer;color:var(--accent);" onclick="loadAnalytics()">⟳ Retry</span>'; });
+  } finally {
+    if (refreshBtn) refreshBtn.disabled = false;
+  }
+}
+
+function formatTopicName(key) {
+  return escapeHtml((key || "").replace(/_/g, " ").replace(/\b\w/g, c => c.toUpperCase()));
+}
+
+function escapeHtml(text) {
+  const d = document.createElement("div");
+  d.textContent = text;
+  return d.innerHTML;
+}
+
+let conversationOffset = 0;
+const CONV_PAGE_SIZE = 20;
+
+async function loadConversations(append) {
+  if (!currentProvider) return;
+  if (!append) conversationOffset = 0;
+  const searchEl = document.getElementById("conversationSearch");
+  const filterEl = document.getElementById("conversationFilter");
+  const q = searchEl ? searchEl.value.trim() : "";
+  const filter = filterEl ? filterEl.value : "";
+  let url = `/api/conversations?limit=${CONV_PAGE_SIZE}&offset=${conversationOffset}`;
+  if (q) url += `&q=${encodeURIComponent(q)}`;
+  if (filter === "escalated") url += `&escalated=true`;
+  if (filter === "high-satisfaction") url += `&satisfaction=high`;
+  if (filter === "low-satisfaction") url += `&satisfaction=low`;
+  if (filter === "unrated") url += `&satisfaction=none`;
+  if (!append) conversationsEl.innerHTML = '<div class="loading-skeleton"><div class="skeleton-line"></div><div class="skeleton-line short"></div><div class="skeleton-line"></div></div>';
+  const res = await fetchWithAuth(url);
+  if (!res.ok) { conversationsEl.innerHTML = '<p style="color:#999;">Failed to load conversations.</p>'; return; }
+  const data = await res.json();
+  if (!append) conversationsEl.innerHTML = "";
+  if (!data.conversations.length && !append) {
+    conversationsEl.textContent = "No conversations yet.";
+    return;
+  }
+  data.conversations.forEach((conversation) => {
+    const item = document.createElement("div");
+    item.className = "conversation-item";
+    item.style.cursor = "pointer";
+    const contentArea = document.createElement("div");
+    contentArea.style.flex = "1";
+    contentArea.addEventListener("click", () => viewTranscript(conversation.id));
+    const title = document.createElement("div");
+    title.textContent = conversation.lastUserMessage || "(no message)";
+    const meta = document.createElement("div");
+    meta.className = "conversation-meta";
+    const tag = conversation.isEscalated ? "⚠ Escalated" : "OK";
+    const time = conversation.createdAt ? new Date(conversation.createdAt).toLocaleDateString() : "";
+    meta.textContent = `${conversation.topic || "general"} · ${tag} · ${time}`;
+    contentArea.appendChild(title);
+    contentArea.appendChild(meta);
+    item.appendChild(contentArea);
+
+    const deleteBtn = document.createElement("button");
+    deleteBtn.className = "conversation-delete-btn";
+    deleteBtn.textContent = "✕";
+    deleteBtn.title = "Delete conversation";
+    deleteBtn.addEventListener("click", async (e) => {
+      e.stopPropagation();
+      if (!confirm("Delete this conversation? This cannot be undone.")) return;
+      const res = await fetchWithAuth(`/api/conversations/${conversation.id}`, { method: "DELETE" });
+      if (res.ok) {
+        item.remove();
+      } else {
+        alert("Failed to delete conversation.");
+      }
+    });
+    item.appendChild(deleteBtn);
+    conversationsEl.appendChild(item);
+  });
+  conversationOffset += data.conversations.length;
+  // Remove existing load-more button
+  const existing = conversationsEl.parentElement.querySelector(".load-more-btn");
+  if (existing) existing.remove();
+  if (data.conversations.length >= CONV_PAGE_SIZE) {
+    const btn = document.createElement("button");
+    btn.className = "load-more-btn";
+    btn.textContent = "Load more";
+    btn.addEventListener("click", () => loadConversations(true));
+    conversationsEl.parentElement.appendChild(btn);
+  }
+}
+
+function scrubPII(text) {
+  if (!text) return text;
+  return text
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[email]")
+    .replace(/\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b/g, "[phone]")
+    .replace(/\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g, "[ssn]")
+    .replace(/\b(?:\d[ -]*?){13,19}\b/g, "[card]");
+}
+
+async function viewTranscript(conversationId) {
+  const res = await fetchWithAuth(`/api/conversation/${conversationId}`);
+  if (!res.ok) return;
+  const data = await res.json();
+  const modal = document.createElement("div");
+  modal.className = "transcript-modal";
+  const content = document.createElement("div");
+  content.className = "transcript-content";
+  const header = document.createElement("div");
+  header.className = "transcript-header";
+  header.innerHTML = '<h3>Conversation Transcript</h3><button class="transcript-close">&times;</button>';
+  content.appendChild(header);
+  const body = document.createElement("div");
+  body.className = "transcript-body";
+  (data.messages || []).forEach((msg) => {
+    const line = document.createElement("div");
+    line.className = `transcript-msg transcript-${msg.role}`;
+    const label = document.createElement("strong");
+    label.textContent = msg.role === "user" ? "Patient" : "AI";
+    const text = document.createElement("span");
+    text.textContent = " " + scrubPII(msg.content || msg.message || "");
+    line.appendChild(label);
+    line.appendChild(text);
+    if (msg.createdAt) {
+      const ts = document.createElement("div");
+      ts.className = "transcript-time";
+      const d = msg.createdAt._seconds ? new Date(msg.createdAt._seconds * 1000) : new Date(msg.createdAt);
+      ts.textContent = d.toLocaleString();
+      line.appendChild(ts);
+    }
+    body.appendChild(line);
+  });
+  if (!data.messages || !data.messages.length) {
+    body.textContent = "No messages in this conversation.";
+  }
+  content.appendChild(body);
+  modal.appendChild(content);
+  document.body.appendChild(modal);
+  modal.addEventListener("click", (e) => {
+    if (e.target === modal || e.target.classList.contains("transcript-close")) modal.remove();
+  });
+}
+
+function updateShareKit(provider) {
+  const link = `${window.location.origin}/${provider.handle}`;
+  shareLink.textContent = link;
+  if (window.QRCode) {
+    QRCode.toCanvas(qrCanvas, link, {
+      width: 160,
+      margin: 2,
+      color: {
+        dark: '#000000',
+        light: '#FFFFFF'
+      }
+    }, () => {});
+  }
+}
+
+async function handleOnboardingSubmit(event) {
+  event.preventDefault();
+  setError(onboardingError, "");
+
+  // Get certificate file
+  const certificateFile = document.getElementById('certificateInput').files[0];
+  const licenseNumber = document.getElementById('licenseNumberInput').value.trim();
+
+  if (!certificateFile) {
+    setError(onboardingError, "Please upload your doctor certificate");
+    return;
+  }
+
+  // Validate file size (5MB max)
+  if (certificateFile.size > 5 * 1024 * 1024) {
+    setError(onboardingError, "Certificate file must be less than 5MB");
+    return;
+  }
+
+  // Show uploading message
+  setError(onboardingError, "Uploading certificate...");
+
+  try {
+    // Upload certificate to Firebase Storage
+    const user = firebase.auth().currentUser;
+    if (!user) {
+      setError(onboardingError, "Please wait, authenticating...");
+      // Wait a bit for auth to settle
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      const retryUser = firebase.auth().currentUser;
+      if (!retryUser) {
+        setError(onboardingError, "Authentication error. Please refresh and try again.");
+        return;
+      }
+    }
+
+    // Force refresh the token to ensure it's valid
+    await user.getIdToken(true);
+
+    const storage = firebase.storage();
+    const storageRef = storage.ref();
+    const certificateRef = storageRef.child(`certificates/${user.uid}/${certificateFile.name}`);
+
+    await certificateRef.put(certificateFile);
+    const certificateUrl = await certificateRef.getDownloadURL();
+
+    let logoUrl = null;
+    let photoUrl = null;
+    const logoFile = document.getElementById("logoInput")?.files[0];
+    const photoFile = document.getElementById("photoInput")?.files[0];
+
+    if (logoFile) {
+      if (logoFile.size > 2 * 1024 * 1024) { setError(onboardingError, "Logo must be under 2MB"); return; }
+      setError(onboardingError, "Uploading logo...");
+      const logoRef = storageRef.child(`logos/${user.uid}/${logoFile.name}`);
+      await logoRef.put(logoFile);
+      logoUrl = await logoRef.getDownloadURL();
+    }
+    if (photoFile) {
+      if (photoFile.size > 2 * 1024 * 1024) { setError(onboardingError, "Photo must be under 2MB"); return; }
+      setError(onboardingError, "Uploading photo...");
+      const photoRef = storageRef.child(`photos/${user.uid}/${photoFile.name}`);
+      await photoRef.put(photoFile);
+      photoUrl = await photoRef.getDownloadURL();
+    }
+
+    setError(onboardingError, "Creating provider profile...");
+
+    const selectedTopics = Array.from(topicsList.querySelectorAll("input[type=checkbox]"))
+      .filter((input) => input.checked)
+      .map((input) => input.value);
+
+    const payload = {
+      handle: handleInput.value.trim(),
+      displayName: displayNameInput.value.trim(),
+      specialty: specialtyInput.value.trim(),
+      country: countryInput.value.trim(),
+      licenseNumber: licenseNumber,
+      certificateUrl: certificateUrl,
+      certificateFileName: certificateFile.name,
+      logoUrl: logoUrl,
+      photoUrl: photoUrl,
+      brandPrimaryColor: primaryColorInput.value.trim(),
+      brandSecondaryColor: secondaryColorInput.value.trim(),
+      welcomeMessage: welcomeInput.value.trim(),
+      enabledTopics: selectedTopics,
+      verificationStatus: 'pending'
+    };
+
+    const res = await fetchWithAuth("/api/provider", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      if (data.code === 'WAITLIST_REQUIRED') {
+        // Not yet approved — switch back to waitlist panel
+        setVisible(onboardingPanel, false);
+        setVisible(waitlistPanel, true);
+        const msg = document.getElementById('waitlistMessage');
+        if (msg) msg.textContent = 'Your account is pending approval. We will notify you at launch.';
+        return;
+      }
+      setError(onboardingError, data.error || "Unable to create provider");
+      return;
+    }
+
+    const provider = await res.json();
+    currentProvider = provider;
+
+    // After provider creation, move to billing setup
+    setVisible(onboardingPanel, false);
+    setVisible(billingSetupPanel, true);
+    await renderBillingSetup(provider);
+  } catch (error) {
+    console.error('Error during onboarding:', error);
+    setError(onboardingError, "Error uploading certificate: " + error.message);
+  }
+}
+
+async function renderBillingSetup(provider) {
+  currentProvider = provider;
+  setVisible(authPanel, false);
+  setVisible(onboardingPanel, false);
+  setVisible(billingSetupPanel, true);
+  setVisible(dashboardPanel, false);
+  setVisible(signOutBtn, true);
+
+  // Check Stripe connection status
+  const billingStatus = document.getElementById('billingStatus');
+  const stripeNotConnected = document.getElementById('stripeNotConnected');
+  const stripeOnboarding = document.getElementById('stripeOnboarding');
+  const stripeConnected = document.getElementById('stripeConnected');
+
+  if (!provider.stripeAccountId) {
+    // No Stripe account - show create button
+    setVisible(billingStatus, false);
+    setVisible(stripeNotConnected, true);
+    setVisible(stripeOnboarding, false);
+    setVisible(stripeConnected, false);
+  } else if (!provider.stripeOnboardingComplete) {
+    // Stripe account exists but onboarding not complete
+    setVisible(billingStatus, false);
+    setVisible(stripeNotConnected, false);
+    setVisible(stripeOnboarding, true);
+    setVisible(stripeConnected, false);
+  } else {
+    // Stripe fully connected - show pricing form
+    setVisible(billingStatus, false);
+    setVisible(stripeNotConnected, false);
+    setVisible(stripeOnboarding, false);
+    setVisible(stripeConnected, true);
+
+    // Pre-fill pricing if it exists
+    const billingPricingModel = document.getElementById('billingPricingModel');
+    const billingSubscriptionPrice = document.getElementById('billingSubscriptionPrice');
+    const billingPerChatPrice = document.getElementById('billingPerChatPrice');
+
+    if (provider.pricingModel) {
+      billingPricingModel.value = provider.pricingModel;
+      if (provider.pricingModel === 'subscription' && provider.subscriptionPrice) {
+        billingSubscriptionPrice.value = provider.subscriptionPrice;
+      }
+      if (provider.pricingModel === 'per-chat' && provider.perChatPrice) {
+        billingPerChatPrice.value = provider.perChatPrice;
+      }
+    }
+  }
+}
+
+function showDashboardSkeletons() {
+  var skeletonHtml = '<span class="skeleton-stat"></span>';
+  var statIds = [
+    "statMonthly", "statEscalations", "statLimit", "statEscalationRate",
+    "statSatisfaction", "statResolutionRate", "statTotalConversations", "statUniquePatients"
+  ];
+  statIds.forEach(function(id) {
+    var el = document.getElementById(id);
+    if (el) el.innerHTML = skeletonHtml;
+  });
+  var convEl = document.getElementById("conversations");
+  if (convEl) {
+    convEl.innerHTML = '<div class="loading-skeleton">' +
+      '<div class="skeleton-line"></div>' +
+      '<div class="skeleton-line short"></div>' +
+      '<div class="skeleton-line"></div>' +
+      '</div>';
+  }
+}
+
+async function renderDashboard(provider) {
+  currentProvider = provider;
+  setVisible(authPanel, false);
+  setVisible(onboardingPanel, false);
+  setVisible(dashboardPanel, true);
+  setVisible(signOutBtn, true);
+
+  // Show loading skeletons immediately while data loads
+  showDashboardSkeletons();
+
+  // Show navigation links
+  const navLinks = document.getElementById('navLinks');
+  if (navLinks) navLinks.style.display = 'flex';
+
+  renderTopicCheckboxes(topicsManage, provider.enabledTopics || []);
+  welcomeUpdate.value = provider.welcomeMessage || "";
+  statusSelect.value = provider.status || "draft";
+
+  const ci = provider.contactInfo || {};
+  const bh = provider.businessHours || {};
+  const el = (id) => document.getElementById(id);
+  if (el("brandPrimaryUpdate")) el("brandPrimaryUpdate").value = provider.brandPrimaryColor || "";
+  if (el("brandSecondaryUpdate")) el("brandSecondaryUpdate").value = provider.brandSecondaryColor || "";
+  if (el("contactPhone")) el("contactPhone").value = ci.phone || "";
+  if (el("contactEmail")) el("contactEmail").value = ci.email || "";
+  if (el("contactAddress")) el("contactAddress").value = ci.address || "";
+  if (el("hoursOpen")) el("hoursOpen").value = bh.open || "";
+  if (el("hoursClose")) el("hoursClose").value = bh.close || "";
+  if (el("hoursSummary")) el("hoursSummary").value = bh.summary || "";
+
+  const np = provider.notificationPreferences || {};
+  if (el("notifEscalation")) el("notifEscalation").checked = np.escalationNotify !== false;
+  if (el("notifUnread")) el("notifUnread").checked = np.unreadNotify !== false;
+  if (el("notifDigest")) el("notifDigest").checked = np.dailyDigestEnabled === true;
+
+  updateShareKit(provider);
+  updatePreviewCallout(provider);
+  loadOnboardingStatus();
+  loadVerificationStatus();
+  await loadAnalytics();
+  await loadConversations();
+
+  // Load payment data
+  await loadPricingConfig();
+  await loadRevenueAnalytics();
+  loadNotifications();
+  updatePlanCard(provider);
+  loadSafetyEvents();
+}
+
+function updatePlanCard(provider) {
+  const plan = provider.plan || "free";
+  const limit = provider.monthlyChatLimit || 50;
+  const used = provider.monthlyChatCount || 0;
+  const pct = limit > 0 ? Math.min((used / limit) * 100, 100) : 0;
+
+  const badge = document.getElementById("planBadge");
+  const bar = document.getElementById("usageBar");
+  const text = document.getElementById("usageText");
+
+  if (badge) {
+    badge.textContent = plan.charAt(0).toUpperCase() + plan.slice(1);
+    badge.className = "plan-badge plan-" + plan;
+  }
+  if (bar) {
+    bar.style.width = pct + "%";
+    bar.className = "usage-bar" + (pct >= 90 ? " danger" : pct >= 70 ? " warn" : "");
+  }
+  if (text) {
+    text.textContent = limit >= 999999
+      ? `${used} chats this month (unlimited)`
+      : `${used} / ${limit} chats this month`;
+  }
+
+  const warningEl = document.getElementById("usageWarning");
+  if (warningEl && limit < 999999) {
+    if (pct >= 100) {
+      warningEl.className = "usage-warning danger";
+      warningEl.textContent = "Monthly limit reached. Upgrade to Pro for unlimited chats.";
+      warningEl.style.display = "block";
+    } else if (pct >= 90) {
+      warningEl.className = "usage-warning danger";
+      warningEl.textContent = `You've used ${Math.round(pct)}% of your monthly limit (${used}/${limit}).`;
+      warningEl.style.display = "block";
+    } else if (pct >= 70) {
+      warningEl.className = "usage-warning warn";
+      warningEl.textContent = `Approaching monthly limit: ${used}/${limit} chats used.`;
+      warningEl.style.display = "block";
+    } else {
+      warningEl.style.display = "none";
+    }
+  }
+
+  // Verification status
+  const verBadge = document.getElementById("verificationBadge");
+  if (verBadge) {
+    const vs = provider.verificationStatus || "pending";
+    const labels = { pending: "Verification Pending", verified: "Verified", rejected: "Verification Rejected" };
+    verBadge.textContent = labels[vs] || labels.pending;
+    verBadge.className = "verification-badge verification-" + vs;
+    verBadge.style.display = "inline-block";
+  }
+}
+
+// Onboarding checklist — guided activation card at top of dashboard.
+async function loadOnboardingStatus() {
+  if (!currentProvider) return;
+  const card = document.getElementById("onboardingChecklistCard");
+  if (!card) return;
+  try {
+    const res = await fetchWithAuth("/api/provider/onboarding-status");
+    if (!res.ok) { setVisible(card, false); return; }
+    const data = await res.json();
+
+    if (data.isComplete) {
+      setVisible(card, false);
+      return;
+    }
+
+    const percent = data.percentComplete || 0;
+    const percentEl = document.getElementById("onboardingPercent");
+    const barEl = document.getElementById("onboardingProgressBar");
+    if (percentEl) percentEl.textContent = percent + "%";
+    if (barEl) barEl.style.width = percent + "%";
+
+    const nextEl = document.getElementById("onboardingNext");
+    if (nextEl) {
+      if (data.nextStep && data.nextStep.label) {
+        nextEl.textContent = "Next: " + data.nextStep.label;
+        setVisible(nextEl, true);
+      } else {
+        setVisible(nextEl, false);
+      }
+    }
+
+    const stepsEl = document.getElementById("onboardingSteps");
+    if (stepsEl) {
+      stepsEl.innerHTML = (data.steps || []).map((s) => {
+        const cls = s.done ? "done" : "todo";
+        const mark = s.done ? "✓" : "○";
+        const optional = s.optional ? '<span class="optional-tag">optional</span>' : "";
+        return `<li class="onboarding-step ${cls}"><span class="check">${mark}</span><span>${escapeHtml(s.label)}</span>${optional}</li>`;
+      }).join("");
+    }
+
+    setVisible(card, true);
+  } catch (e) {
+    setVisible(card, false);
+  }
+}
+
+// Verification status banner — clear messaging about review state.
+async function loadVerificationStatus() {
+  if (!currentProvider) return;
+  const banner = document.getElementById("verificationBanner");
+  if (!banner) return;
+  try {
+    const res = await fetchWithAuth("/api/provider/verification-status");
+    if (!res.ok) { setVisible(banner, false); return; }
+    const data = await res.json();
+    const status = data.verificationStatus || "pending";
+
+    let html = "";
+    let title = "";
+    if (status === "verified") {
+      title = "✓ Credentials verified";
+    } else if (status === "rejected") {
+      title = "Verification needs attention";
+    } else {
+      title = "Verification in progress";
+    }
+
+    html += `<h3>${title}</h3>`;
+    html += `<p class="verification-message">${escapeHtml(data.message || "")}</p>`;
+
+    if (status === "pending") {
+      html += `<p class="verification-detail">Reviews complete within ${escapeHtml(String(data.slaHours))} hours. Your preview link works right now while you wait.</p>`;
+    } else if (status === "rejected") {
+      if (data.rejectionReason) {
+        html += `<div class="verification-reason">Reason: ${escapeHtml(data.rejectionReason)}</div>`;
+      }
+      if (data.canResubmit) {
+        html += `<button id="resubmitVerificationBtn" class="secondary">Resubmit credentials</button>`;
+      }
+    }
+
+    banner.innerHTML = html;
+    banner.className = "card verification-banner is-" + status;
+    setVisible(banner, true);
+
+    const resubmitBtn = document.getElementById("resubmitVerificationBtn");
+    if (resubmitBtn) {
+      resubmitBtn.addEventListener("click", () => {
+        showToast("Update your credentials in the onboarding form, then resubmit.");
+        const certInput = document.getElementById("certificateInput");
+        if (certInput) certInput.scrollIntoView({ behavior: "smooth" });
+      });
+    }
+  } catch (e) {
+    setVisible(banner, false);
+  }
+}
+
+// Preview link callout — prominent when provider is in 'preview' status.
+function updatePreviewCallout(provider) {
+  const callout = document.getElementById("previewCallout");
+  if (!callout || !provider) return;
+  if (provider.status === "preview") {
+    const link = `${window.location.origin}/${provider.handle}`;
+    const linkEl = document.getElementById("previewCalloutLink");
+    if (linkEl) linkEl.textContent = link;
+    setVisible(callout, true);
+  } else {
+    setVisible(callout, false);
+  }
+}
+
+async function checkOnboarding() {
+  const user = firebase.auth().currentUser;
+
+  // Hide auth panel and show sign out button
+  setVisible(authPanel, false);
+  setVisible(signOutBtn, true);
+
+  try {
+    const provider = await loadProvider();
+    if (!provider) {
+      // No provider profile exists - show onboarding
+      console.log('No provider found, showing onboarding form');
+      setVisible(onboardingPanel, true);
+      setVisible(billingSetupPanel, false);
+      setVisible(dashboardPanel, false);
+      renderTopicCheckboxes(topicsList, TOPICS);
+      return;
+    }
+
+    // Provider exists - check if billing is set up
+    console.log('Provider found:', provider.handle || provider.displayName);
+    console.log('Billing status:', {
+      stripeAccountId: provider.stripeAccountId || 'not set',
+      stripeOnboardingComplete: provider.stripeOnboardingComplete || false,
+      pricingModel: provider.pricingModel || 'not set'
+    });
+
+    // Billing is OPTIONAL and skippable — doctors reach value (a working
+    // preview link + dashboard) immediately. Billing is only forced when the
+    // doctor has explicitly chosen a PAID pricing model but not finished Stripe.
+    const needsStripe = provider.pricingModel && provider.pricingModel !== 'free';
+    const stripeConfigured = provider.stripeAccountId && provider.stripeOnboardingComplete;
+    const needsBillingSetup = needsStripe && !stripeConfigured;
+
+    if (needsBillingSetup) {
+      console.log('Paid plan chosen but Stripe incomplete, showing billing setup');
+      setVisible(onboardingPanel, false);
+      setVisible(billingSetupPanel, true);
+      setVisible(dashboardPanel, false);
+      await renderBillingSetup(provider);
+      return;
+    }
+
+    // Free or fully-configured — go straight to the dashboard.
+    console.log('Showing dashboard');
+    await renderDashboard(provider);
+  } catch (err) {
+    console.log('No provider found (expected for new users) - showing onboarding');
+    console.log('Error details:', err.message);
+    // Show onboarding on error (likely 404 = no provider)
+    setVisible(onboardingPanel, true);
+    setVisible(billingSetupPanel, false);
+    setVisible(dashboardPanel, false);
+    renderTopicCheckboxes(topicsList, TOPICS);
+  }
+}
+
+async function checkLaunchStatus() {
+  try {
+    const res = await fetch('/api/launch-status');
+    const data = await res.json();
+    return data.isOpen;
+  } catch {
+    return true; // fail open
+  }
+}
+
+async function initAuth() {
+  const config = window.EVALDOC_FIREBASE_CONFIG || {};
+  if (!config.apiKey) {
+    setError(authError, "Missing Firebase config. Update /app/config.js.");
+    return;
+  }
+
+  firebase.initializeApp(config);
+  const auth = firebase.auth();
+
+  const isOpen = await checkLaunchStatus();
+
+  auth.onAuthStateChanged((user) => {
+    if (!user) {
+      console.log('❌ No user logged in');
+      if (!isOpen) {
+        // Pre-launch: show waitlist instead of auth
+        setVisible(waitlistPanel, true);
+        setVisible(authPanel, false);
+      } else {
+        setVisible(waitlistPanel, false);
+        setVisible(authPanel, true);
+      }
+      setVisible(onboardingPanel, false);
+      setVisible(dashboardPanel, false);
+      setVisible(signOutBtn, false);
+      return;
+    }
+
+    // User is logged in - show details
+    console.log('✅ USER LOGGED IN:');
+    console.log('  Email:', user.email);
+    console.log('  UID:', user.uid);
+    console.log('  Display Name:', user.displayName || 'Not set');
+    console.log('  Email Verified:', user.emailVerified);
+
+    setVisible(waitlistPanel, false);
+    checkOnboarding();
+  });
+}
+
+// Map raw Firebase auth error codes to friendly, non-leaky messages.
+function friendlyAuthError(err) {
+  const code = (err && err.code) || "";
+  const messages = {
+    "auth/invalid-email": "That email address doesn't look right.",
+    "auth/user-not-found": "Incorrect email or password.",
+    "auth/wrong-password": "Incorrect email or password.",
+    "auth/invalid-credential": "Incorrect email or password.",
+    "auth/invalid-login-credentials": "Incorrect email or password.",
+    "auth/email-already-in-use": "An account with that email already exists — try signing in.",
+    "auth/weak-password": "Password must be at least 6 characters.",
+    "auth/too-many-requests": "Too many attempts. Please wait a moment and try again.",
+    "auth/network-request-failed": "Network error. Check your connection and try again.",
+    "auth/user-disabled": "This account has been disabled. Contact support.",
+    "auth/operation-not-allowed": "Email sign-in is not enabled. Contact support."
+  };
+  return messages[code] || "Something went wrong. Please try again.";
+}
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+async function withButtonBusy(button, busyLabel, fn) {
+  const original = button.textContent;
+  button.disabled = true;
+  button.textContent = busyLabel;
+  try {
+    await fn();
+  } finally {
+    button.disabled = false;
+    button.textContent = original;
+  }
+}
+
+const loginForm = document.getElementById("loginForm");
+const signupForm = document.getElementById("signupForm");
+const forgotPasswordLink = document.getElementById("forgotPasswordLink");
+
+loginForm.addEventListener("submit", async (event) => {
+  event.preventDefault();
+  setError(authError, "");
+  const email = loginEmail.value.trim();
+  const password = loginPassword.value;
+  if (!email || !password) {
+    setError(authError, "Enter your email and password.");
+    return;
+  }
+  await withButtonBusy(loginBtn, "Signing in…", async () => {
+    try {
+      await firebase.auth().signInWithEmailAndPassword(email, password);
+    } catch (err) {
+      setError(authError, friendlyAuthError(err));
+    }
+  });
+});
+
+signupForm.addEventListener("submit", async (event) => {
+  event.preventDefault();
+  setError(authError, "");
+  const email = signupEmail.value.trim();
+  const password = signupPassword.value;
+  if (!EMAIL_RE.test(email)) {
+    setError(authError, "Please enter a valid email address.");
+    return;
+  }
+  if (password.length < 6) {
+    setError(authError, "Password must be at least 6 characters.");
+    return;
+  }
+  await withButtonBusy(signupBtn, "Creating…", async () => {
+    try {
+      await firebase.auth().createUserWithEmailAndPassword(email, password);
+    } catch (err) {
+      setError(authError, friendlyAuthError(err));
+    }
+  });
+});
+
+if (forgotPasswordLink) {
+  forgotPasswordLink.addEventListener("click", async (event) => {
+    event.preventDefault();
+    setError(authError, "");
+    const email = loginEmail.value.trim();
+    if (!EMAIL_RE.test(email)) {
+      setError(authError, "Enter your email above, then click Forgot password.");
+      return;
+    }
+    try {
+      await firebase.auth().sendPasswordResetEmail(email);
+      setError(authError, "Password reset email sent — check your inbox.");
+    } catch (err) {
+      setError(authError, friendlyAuthError(err));
+    }
+  });
+}
+
+signOutBtn.addEventListener("click", async () => {
+  await firebase.auth().signOut();
+});
+
+onboardingForm.addEventListener("submit", handleOnboardingSubmit);
+
+saveTopicsBtn.addEventListener("click", async () => {
+  const selectedTopics = Array.from(topicsManage.querySelectorAll("input[type=checkbox]"))
+    .filter((input) => input.checked)
+    .map((input) => input.value);
+
+  await fetchWithAuth("/api/provider/update", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ enabledTopics: selectedTopics })
+  });
+  const provider = await loadProvider();
+  if (provider) {
+    renderTopicCheckboxes(topicsManage, provider.enabledTopics || []);
+    updateShareKit(provider);
+  }
+});
+
+saveSettingsBtn.addEventListener("click", async () => {
+  const g = (id) => (document.getElementById(id) || {}).value || "";
+  const payload = {
+    welcomeMessage: welcomeUpdate.value.trim(),
+    status: statusSelect.value,
+    brandPrimaryColor: g("brandPrimaryUpdate").trim() || undefined,
+    brandSecondaryColor: g("brandSecondaryUpdate").trim() || undefined,
+    contactInfo: {
+      phone: g("contactPhone").trim(),
+      email: g("contactEmail").trim(),
+      address: g("contactAddress").trim()
+    },
+    businessHours: {
+      open: g("hoursOpen"),
+      close: g("hoursClose"),
+      summary: g("hoursSummary").trim()
+    }
+  };
+  const res = await fetchWithAuth("/api/provider/update", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  // Save notification preferences in parallel
+  const notifPayload = {
+    escalationNotify: document.getElementById("notifEscalation")?.checked ?? true,
+    unreadNotify: document.getElementById("notifUnread")?.checked ?? true,
+    dailyDigestEnabled: document.getElementById("notifDigest")?.checked ?? false
+  };
+  fetchWithAuth("/api/doctor/notifications/preferences", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(notifPayload)
+  }).catch(() => {});
+
+  if (res.ok) {
+    showToast("Settings saved");
+  } else {
+    const errData = await res.json().catch(() => ({}));
+    if (errData.code === "VERIFICATION_REQUIRED") {
+      showToast("Cannot publish: medical credentials must be verified first", true);
+    } else {
+      showToast("Failed to save settings", true);
+    }
+  }
+  const provider = await loadProvider();
+  if (provider) {
+    welcomeUpdate.value = provider.welcomeMessage || "";
+    statusSelect.value = provider.status || "draft";
+    updateShareKit(provider);
+  }
+});
+
+function showToast(text, isError) {
+  const toast = document.createElement("div");
+  toast.className = "toast" + (isError ? " toast-error" : "");
+  toast.textContent = text;
+  document.body.appendChild(toast);
+  setTimeout(() => { toast.classList.add("toast-visible"); }, 10);
+  setTimeout(() => { toast.remove(); }, 2500);
+}
+
+refreshAnalyticsBtn.addEventListener("click", async () => {
+  await loadAnalytics();
+  await loadConversations();
+});
+
+copyLinkBtn.addEventListener("click", async () => {
+  if (!currentProvider) return;
+  const link = `${window.location.origin}/${currentProvider.handle}`;
+  try {
+    await navigator.clipboard.writeText(link);
+    const original = copyLinkBtn.textContent;
+    copyLinkBtn.textContent = "Copied!";
+    setTimeout(() => { copyLinkBtn.textContent = original; }, 2000);
+  } catch (err) {
+    prompt("Copy this link:", link);
+  }
+});
+
+const previewCopyBtn = document.getElementById("previewCopyBtn");
+if (previewCopyBtn) {
+  previewCopyBtn.addEventListener("click", async () => {
+    if (!currentProvider) return;
+    const link = `${window.location.origin}/${currentProvider.handle}`;
+    try {
+      await navigator.clipboard.writeText(link);
+      const original = previewCopyBtn.textContent;
+      previewCopyBtn.textContent = "Copied!";
+      setTimeout(() => { previewCopyBtn.textContent = original; }, 2000);
+    } catch (err) {
+      prompt("Copy this link:", link);
+    }
+  });
+}
+
+downloadQRBtn.addEventListener("click", () => {
+  if (!currentProvider) return;
+
+  const link = `${window.location.origin}/${currentProvider.handle}`;
+
+  function downloadBlob(blob) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `${currentProvider.handle}-qr-code.png`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  }
+
+  if (window.QRCode) {
+    const downloadCanvas = document.createElement('canvas');
+    QRCode.toCanvas(downloadCanvas, link, {
+      width: 512, margin: 2,
+      color: { dark: '#000000', light: '#FFFFFF' }
+    }, (error) => {
+      if (error) {
+        console.error('QR code generation error:', error);
+        return;
+      }
+      downloadCanvas.toBlob(downloadBlob);
+    });
+  } else {
+    fetch(`/api/qr/${currentProvider.handle}`)
+      .then(r => r.blob())
+      .then(downloadBlob)
+      .catch(err => console.error('QR download failed:', err));
+  }
+});
+
+if (previewChatBtn) {
+  previewChatBtn.addEventListener("click", () => {
+    if (!currentProvider) return;
+    window.open(`/${currentProvider.handle}`, "_blank");
+  });
+}
+
+// Safety events
+async function loadSafetyEvents() {
+  const el = document.getElementById("safetyEventsList");
+  if (!el || !currentProvider) return;
+  try {
+    const res = await fetchWithAuth("/api/safety-events?limit=10");
+    if (!res.ok) { el.textContent = "Failed to load."; return; }
+    const data = await res.json();
+    if (!data.events || !data.events.length) {
+      el.textContent = "No safety events recorded.";
+      return;
+    }
+    el.innerHTML = data.events.map(ev => {
+      const d = ev.createdAt?._seconds ? new Date(ev.createdAt._seconds * 1000).toLocaleString() : "";
+      const badge = ev.eventType === "escalated" ? "danger" : ev.eventType === "blocked_input" ? "warning" : "warning";
+      return `<div style="padding:0.6rem 0;border-bottom:1px solid var(--gray-200);display:flex;justify-content:space-between;align-items:center;">
+        <div>
+          <span class="pill" style="background:var(--${badge});color:#fff;font-size:0.75rem;padding:0.2rem 0.5rem;border-radius:4px;">${escapeHtml(ev.eventType)}</span>
+          <span style="margin-left:0.5rem;">${escapeHtml(ev.details?.reason || ev.details?.pattern || "")}</span>
+        </div>
+        <span style="font-size:0.75rem;color:var(--gray-400);">${d}</span>
+      </div>`;
+    }).join("");
+  } catch (e) {
+    el.textContent = "Error loading safety events.";
+  }
+}
+
+document.getElementById("refreshSafetyBtn")?.addEventListener("click", loadSafetyEvents);
+
+// Export conversations as CSV
+document.getElementById("exportConversationsBtn")?.addEventListener("click", async () => {
+  if (!currentProvider) return;
+  const res = await fetchWithAuth("/api/conversations?limit=500");
+  if (!res.ok) { showToast("Export failed", true); return; }
+  const data = await res.json();
+  const rows = [["Date", "Topic", "Escalated", "Satisfaction", "Last Message"]];
+  (data.conversations || []).forEach(c => {
+    const date = c.createdAt?._seconds ? new Date(c.createdAt._seconds * 1000).toISOString() : "";
+    rows.push([
+      date,
+      c.topic || "",
+      c.isEscalated ? "Yes" : "No",
+      c.satisfaction || "",
+      (c.lastUserMessage || "").replace(/"/g, '""')
+    ]);
+  });
+  const csv = rows.map(r => r.map(v => `"${v}"`).join(",")).join("\n");
+  const blob = new Blob([csv], { type: "text/csv" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = `conversations-${new Date().toISOString().slice(0, 10)}.csv`;
+  a.click();
+  URL.revokeObjectURL(url);
+  showToast("Exported!");
+});
+
+// Share copy templates
+function copyText(text) {
+  navigator.clipboard.writeText(text).then(() => showToast("Copied!")).catch(() => {});
+}
+
+document.getElementById("copySocialTemplate")?.addEventListener("click", () => {
+  if (!currentProvider) return;
+  const link = `${window.location.origin}/${currentProvider.handle}`;
+  const name = currentProvider.displayName || "your doctor";
+  copyText(`Have health questions? Chat with ${name} anytime — free, private, and instant.\n\n${link}`);
+});
+
+document.getElementById("copyEmailTemplate")?.addEventListener("click", () => {
+  if (!currentProvider) return;
+  const link = `${window.location.origin}/${currentProvider.handle}`;
+  const name = currentProvider.displayName || "our practice";
+  copyText(`Hi,\n\nWe're excited to share a new way to get answers to your health questions. Visit the link below to chat with ${name}'s AI health assistant — available 24/7 for general health info, appointment prep, and more.\n\n${link}\n\nThis service provides educational health information only. For emergencies, always call 911.`);
+});
+
+document.getElementById("copySmsTemplate")?.addEventListener("click", () => {
+  if (!currentProvider) return;
+  const link = `${window.location.origin}/${currentProvider.handle}`;
+  copyText(`Health questions? Chat with your doctor's AI assistant anytime: ${link}`);
+});
+
+// Payment & Revenue Management
+const statRevenue = document.getElementById("statRevenue");
+const statTransactions = document.getElementById("statTransactions");
+const statSubscriptions = document.getElementById("statSubscriptions");
+const viewTransactionsBtn = document.getElementById("viewTransactionsBtn");
+const closeTransactionsBtn = document.getElementById("closeTransactionsBtn");
+const transactionsPanel = document.getElementById("transactionsPanel");
+const transactionsList = document.getElementById("transactionsList");
+const paymentEnabledSelect = document.getElementById("paymentEnabledSelect");
+const pricingModelSelect = document.getElementById("pricingModelSelect");
+const perChatPriceInput = document.getElementById("perChatPriceInput");
+const subscriptionPriceInput = document.getElementById("subscriptionPriceInput");
+const savePricingBtn = document.getElementById("savePricingBtn");
+const pricingError = document.getElementById("pricingError");
+
+async function loadRevenueAnalytics() {
+  try {
+    const res = await fetchWithAuth("/api/payment/revenue");
+    if (!res.ok) {
+      console.error("Failed to load revenue analytics");
+      return;
+    }
+    const data = await res.json();
+
+    statRevenue.textContent = `$${data.totalRevenue.toFixed(2)}`;
+    statTransactions.textContent = data.transactionCount;
+    statSubscriptions.textContent = data.activeSubscriptions;
+  } catch (error) {
+    console.error("Error loading revenue analytics:", error);
+  }
+}
+
+async function loadPricingConfig() {
+  if (!currentProvider) return;
+
+  paymentEnabledSelect.value = currentProvider.paymentEnabled ? "true" : "false";
+  pricingModelSelect.value = currentProvider.pricingModel || "free";
+  perChatPriceInput.value = currentProvider.perChatPrice || "";
+  subscriptionPriceInput.value = currentProvider.subscriptionPrice || "";
+
+  // Update field visibility based on pricing model
+  updatePricingFieldsVisibility();
+}
+
+function updatePricingFieldsVisibility() {
+  const model = pricingModelSelect.value;
+  const paymentEnabled = paymentEnabledSelect.value === "true";
+
+  perChatPriceInput.parentElement.style.display =
+    paymentEnabled && (model === "per-chat" || model === "hybrid") ? "block" : "none";
+  subscriptionPriceInput.parentElement.style.display =
+    paymentEnabled && (model === "subscription" || model === "hybrid") ? "block" : "none";
+}
+
+paymentEnabledSelect.addEventListener("change", updatePricingFieldsVisibility);
+pricingModelSelect.addEventListener("change", updatePricingFieldsVisibility);
+
+savePricingBtn.addEventListener("click", async () => {
+  setError(pricingError, "");
+
+  const paymentEnabled = paymentEnabledSelect.value === "true";
+  const pricingModel = pricingModelSelect.value;
+  const perChatPrice = parseFloat(perChatPriceInput.value) || 0;
+  const subscriptionPrice = parseFloat(subscriptionPriceInput.value) || 0;
+
+  // Validation
+  if (paymentEnabled && pricingModel !== "free") {
+    if ((pricingModel === "per-chat" || pricingModel === "hybrid") && perChatPrice <= 0) {
+      setError(pricingError, "Per-chat price must be greater than 0");
+      return;
+    }
+    if ((pricingModel === "subscription" || pricingModel === "hybrid") && subscriptionPrice <= 0) {
+      setError(pricingError, "Subscription price must be greater than 0");
+      return;
+    }
+  }
+
+  try {
+    const res = await fetchWithAuth("/api/payment/update-pricing", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        paymentEnabled,
+        pricingModel: paymentEnabled ? pricingModel : "free",
+        perChatPrice,
+        subscriptionPrice
+      })
+    });
+
+    if (!res.ok) {
+      const error = await res.json();
+      setError(pricingError, error.error || "Failed to update pricing");
+      return;
+    }
+
+    setError(pricingError, "✓ Pricing updated successfully");
+    await loadProvider();
+    await loadPricingConfig();
+  } catch (error) {
+    console.error("Error updating pricing:", error);
+    setError(pricingError, "Failed to update pricing");
+  }
+});
+
+viewTransactionsBtn.addEventListener("click", async () => {
+  try {
+    const res = await fetchWithAuth("/api/payment/transactions?limit=50");
+    if (!res.ok) {
+      console.error("Failed to load transactions");
+      return;
+    }
+    const data = await res.json();
+
+    if (data.transactions.length === 0) {
+      transactionsList.innerHTML = "<p style='color: #666;'>No transactions yet</p>";
+    } else {
+      transactionsList.innerHTML = data.transactions.map(tx => `
+        <div style="padding: 1rem; border: 1px solid #e0e0e0; border-radius: 8px; margin-bottom: 0.5rem;">
+          <div style="display: flex; justify-content: space-between; align-items: center;">
+            <div>
+              <strong>$${(tx.amount / 100).toFixed(2)}</strong>
+              <span style="color: #666; margin-left: 0.5rem;">${tx.status}</span>
+            </div>
+            <div style="color: #666; font-size: 0.875rem;">
+              ${new Date(tx.createdAt).toLocaleString()}
+            </div>
+          </div>
+          <div style="color: #666; font-size: 0.875rem; margin-top: 0.5rem;">
+            Patient: ${tx.patientId}
+            ${tx.conversationId ? `<br>Conversation: ${tx.conversationId}` : ""}
+          </div>
+        </div>
+      `).join("");
+    }
+
+    transactionsPanel.style.display = "block";
+  } catch (error) {
+    console.error("Error loading transactions:", error);
+  }
+});
+
+closeTransactionsBtn.addEventListener("click", () => {
+  transactionsPanel.style.display = "none";
+});
+
+// Billing Setup Event Handlers
+const createStripeAccountBtn = document.getElementById("createStripeAccountBtn");
+const completeStripeOnboardingBtn = document.getElementById("completeStripeOnboardingBtn");
+const saveBillingPricingBtn = document.getElementById("saveBillingPricingBtn");
+const skipBillingBtn = document.getElementById("skipBillingBtn");
+const billingPricingModel = document.getElementById("billingPricingModel");
+const billingSubscriptionPrice = document.getElementById("billingSubscriptionPrice");
+const billingPerChatPrice = document.getElementById("billingPerChatPrice");
+const subscriptionPricingFields = document.getElementById("subscriptionPricingFields");
+const perChatPricingFields = document.getElementById("perChatPricingFields");
+const billingPricingError = document.getElementById("billingPricingError");
+const stripeError = document.getElementById("stripeError");
+
+// Toggle pricing fields based on model selection
+billingPricingModel.addEventListener("change", (e) => {
+  const model = e.target.value;
+  setVisible(subscriptionPricingFields, model === "subscription");
+  setVisible(perChatPricingFields, model === "per-chat");
+});
+
+// Create Stripe Connect Account
+createStripeAccountBtn.addEventListener("click", async () => {
+  setError(stripeError, "Creating Stripe account...");
+  createStripeAccountBtn.disabled = true;
+
+  try {
+    const res = await fetchWithAuth("/api/stripe/create-connect-account", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+
+    if (!res.ok) {
+      const error = await res.json();
+      setError(stripeError, error.error || "Failed to create Stripe account");
+      createStripeAccountBtn.disabled = false;
+      return;
+    }
+
+    const data = await res.json();
+    setError(stripeError, "✓ Stripe account created! Redirecting to onboarding...");
+
+    // Reload provider to get updated Stripe account ID
+    const provider = await loadProvider();
+    await renderBillingSetup(provider);
+  } catch (error) {
+    console.error("Error creating Stripe account:", error);
+    setError(stripeError, "Failed to create Stripe account");
+    createStripeAccountBtn.disabled = false;
+  }
+});
+
+// Complete Stripe Onboarding
+completeStripeOnboardingBtn.addEventListener("click", async () => {
+  completeStripeOnboardingBtn.disabled = true;
+  completeStripeOnboardingBtn.textContent = "Generating link...";
+
+  try {
+    const res = await fetchWithAuth("/api/stripe/create-account-link", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        returnUrl: `${window.location.origin}/app`,
+        refreshUrl: `${window.location.origin}/app`
+      })
+    });
+
+    if (!res.ok) {
+      const error = await res.json();
+      alert(error.error || "Failed to generate onboarding link");
+      completeStripeOnboardingBtn.disabled = false;
+      completeStripeOnboardingBtn.textContent = "Complete Stripe Setup";
+      return;
+    }
+
+    const data = await res.json();
+    // Redirect to Stripe onboarding
+    window.location.href = data.url;
+  } catch (error) {
+    console.error("Error generating Stripe onboarding link:", error);
+    alert("Failed to generate onboarding link");
+    completeStripeOnboardingBtn.disabled = false;
+    completeStripeOnboardingBtn.textContent = "Complete Stripe Setup";
+  }
+});
+
+// Save Billing Pricing
+saveBillingPricingBtn.addEventListener("click", async () => {
+  setError(billingPricingError, "");
+  saveBillingPricingBtn.disabled = true;
+
+  const pricingModel = billingPricingModel.value;
+  const subscriptionPrice = parseFloat(billingSubscriptionPrice.value) || 0;
+  const perChatPrice = parseFloat(billingPerChatPrice.value) || 0;
+
+  // Validation
+  if (pricingModel === "subscription" && subscriptionPrice <= 0) {
+    setError(billingPricingError, "Please enter a valid subscription price");
+    saveBillingPricingBtn.disabled = false;
+    return;
+  }
+
+  if (pricingModel === "per-chat" && perChatPrice <= 0) {
+    setError(billingPricingError, "Please enter a valid per-chat price");
+    saveBillingPricingBtn.disabled = false;
+    return;
+  }
+
+  try {
+    const payload = {
+      paymentEnabled: pricingModel !== "free",
+      pricingModel: pricingModel,
+      subscriptionPrice: subscriptionPrice,
+      perChatPrice: perChatPrice
+    };
+
+    const res = await fetchWithAuth("/api/payment/update-pricing", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+
+    if (!res.ok) {
+      const error = await res.json();
+      setError(billingPricingError, error.error || "Failed to save pricing");
+      saveBillingPricingBtn.disabled = false;
+      return;
+    }
+
+    setError(billingPricingError, "✓ Pricing saved! Loading dashboard...");
+
+    // Reload provider and show dashboard
+    const provider = await loadProvider();
+    await renderDashboard(provider);
+  } catch (error) {
+    console.error("Error saving pricing:", error);
+    setError(billingPricingError, "Failed to save pricing");
+    saveBillingPricingBtn.disabled = false;
+  }
+});
+
+// Skip Billing Setup
+skipBillingBtn.addEventListener("click", async () => {
+  try {
+    // Set to free model and continue to dashboard
+    const res = await fetchWithAuth("/api/payment/update-pricing", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        paymentEnabled: false,
+        pricingModel: "free",
+        subscriptionPrice: 0,
+        perChatPrice: 0
+      })
+    });
+
+    if (!res.ok) {
+      console.error("Failed to skip billing setup");
+      return;
+    }
+
+    // Reload provider and show dashboard
+    const provider = await loadProvider();
+    await renderDashboard(provider);
+  } catch (error) {
+    console.error("Error skipping billing:", error);
+  }
+});
+
+// Waitlist form
+document.getElementById('waitlistForm').addEventListener('submit', async (e) => {
+  e.preventDefault();
+  const msg = document.getElementById('waitlistMessage');
+  const btn = document.getElementById('waitlistSubmitBtn');
+  const email = document.getElementById('waitlistEmail').value.trim();
+  const name = document.getElementById('waitlistName').value.trim();
+  const specialty = document.getElementById('waitlistSpecialty').value.trim();
+
+  msg.textContent = 'Submitting...';
+  btn.disabled = true;
+
+  try {
+    const res = await fetch('/api/waitlist', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, name, specialty })
+    });
+    const data = await res.json();
+    if (res.ok) {
+      msg.textContent = data.status === 'already_registered'
+        ? 'You are already on the waitlist. We will be in touch!'
+        : 'You are on the list! We will notify you when EvalDoc launches on April 1, 2026.';
+      document.getElementById('waitlistForm').reset();
+    } else {
+      msg.textContent = data.error || 'Something went wrong. Please try again.';
+      btn.disabled = false;
+    }
+  } catch {
+    msg.textContent = 'Network error. Please try again.';
+    btn.disabled = false;
+  }
+});
+
+// "Already approved? Sign in" toggle
+document.getElementById('showAuthLink').addEventListener('click', (e) => {
+  e.preventDefault();
+  setVisible(waitlistPanel, false);
+  setVisible(authPanel, true);
+});
+
+// Notifications
+async function loadNotifications() {
+  try {
+    const res = await fetchWithAuth("/api/doctor/notifications?limit=10");
+    if (!res.ok) return;
+    const data = await res.json();
+    const badge = document.getElementById("notificationBadge");
+    if (badge) {
+      if (data.unreadCount > 0) {
+        badge.textContent = data.unreadCount > 9 ? "9+" : data.unreadCount;
+        badge.style.display = "flex";
+      } else {
+        badge.style.display = "none";
+      }
+    }
+    const list = document.getElementById("notificationList");
+    if (list) {
+      if (!data.notifications || !data.notifications.length) {
+        list.innerHTML = '<div class="notification-empty">No notifications</div>';
+      } else {
+        list.innerHTML = data.notifications.map(n => {
+          const time = n.createdAt ? new Date(n.createdAt._seconds ? n.createdAt._seconds * 1000 : n.createdAt).toLocaleString() : "";
+          return `<div class="notification-item${n.read ? "" : " unread"}" data-id="${n.id}">
+            <div class="notification-title">${escapeHtml(n.title || "")}</div>
+            <div class="notification-body">${escapeHtml(n.body || "")}</div>
+            <div class="notification-time">${time}</div>
+          </div>`;
+        }).join("");
+      }
+    }
+  } catch (e) {
+    // non-critical
+  }
+}
+
+const notificationBell = document.getElementById("notificationBell");
+const notificationDropdown = document.getElementById("notificationDropdown");
+if (notificationBell && notificationDropdown) {
+  notificationBell.addEventListener("click", (e) => {
+    e.stopPropagation();
+    const isVisible = notificationDropdown.style.display !== "none";
+    notificationDropdown.style.display = isVisible ? "none" : "block";
+    if (!isVisible) loadNotifications();
+  });
+  document.addEventListener("click", (e) => {
+    if (!notificationDropdown.contains(e.target) && e.target !== notificationBell) {
+      notificationDropdown.style.display = "none";
+    }
+  });
+}
+
+const markAllReadBtn = document.getElementById("markAllReadBtn");
+if (markAllReadBtn) {
+  markAllReadBtn.addEventListener("click", async () => {
+    await fetchWithAuth("/api/doctor/notifications/read", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({})
+    });
+    await loadNotifications();
+  });
+}
+
+// Conversation filters
+const conversationSearch = document.getElementById("conversationSearch");
+const conversationFilter = document.getElementById("conversationFilter");
+
+if (conversationSearch) {
+  let searchTimeout;
+  conversationSearch.addEventListener("input", () => {
+    clearTimeout(searchTimeout);
+    searchTimeout = setTimeout(() => loadConversations(false), 300);
+  });
+}
+
+if (conversationFilter) {
+  conversationFilter.addEventListener("change", () => loadConversations(false));
+}
+
+document.addEventListener("keydown", (e) => {
+  if (e.target.tagName === "INPUT" || e.target.tagName === "TEXTAREA" || e.target.tagName === "SELECT") return;
+  if (e.key === "r" && !e.ctrlKey && !e.metaKey) {
+    loadAnalytics();
+    loadConversations();
+  }
+  if (e.key === "?" && e.shiftKey) {
+    showToast("Shortcuts: R=refresh, E=export, P=preview chat");
+  }
+  if (e.key === "e" && !e.ctrlKey && !e.metaKey) {
+    document.getElementById("exportConversationsBtn")?.click();
+  }
+  if (e.key === "p" && !e.ctrlKey && !e.metaKey) {
+    previewChatBtn?.click();
+  }
+});
+
+// Account management — data export & account deletion (GDPR self-serve)
+const exportAccountBtn = document.getElementById("exportAccountBtn");
+if (exportAccountBtn) {
+  exportAccountBtn.addEventListener("click", async () => {
+    const msg = document.getElementById("accountMessage");
+    if (msg) msg.textContent = "Preparing your data...";
+    exportAccountBtn.disabled = true;
+    try {
+      const res = await fetchWithAuth("/api/account/export");
+      if (!res.ok) {
+        if (msg) msg.textContent = "Export failed. Please try again.";
+        return;
+      }
+      const blob = await res.blob();
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `evaldoc-export-${new Date().toISOString().slice(0, 10)}.json`;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+      if (msg) msg.textContent = "Your data has been downloaded.";
+    } catch (e) {
+      if (msg) msg.textContent = "Export failed. Please try again.";
+    } finally {
+      exportAccountBtn.disabled = false;
+    }
+  });
+}
+
+const deleteAccountBtn = document.getElementById("deleteAccountBtn");
+const deleteConfirm = document.getElementById("deleteConfirm");
+const deleteConfirmInput = document.getElementById("deleteConfirmInput");
+const confirmDeleteBtn = document.getElementById("confirmDeleteBtn");
+const cancelDeleteBtn = document.getElementById("cancelDeleteBtn");
+const deleteError = document.getElementById("deleteError");
+
+if (deleteAccountBtn && deleteConfirm) {
+  deleteAccountBtn.addEventListener("click", () => {
+    setVisible(deleteConfirm, true);
+    if (deleteConfirmInput) {
+      deleteConfirmInput.value = "";
+      deleteConfirmInput.focus();
+    }
+    if (confirmDeleteBtn) confirmDeleteBtn.disabled = true;
+    setError(deleteError, "");
+  });
+}
+
+if (cancelDeleteBtn && deleteConfirm) {
+  cancelDeleteBtn.addEventListener("click", () => {
+    setVisible(deleteConfirm, false);
+    if (deleteConfirmInput) deleteConfirmInput.value = "";
+    setError(deleteError, "");
+  });
+}
+
+if (deleteConfirmInput && confirmDeleteBtn) {
+  deleteConfirmInput.addEventListener("input", () => {
+    confirmDeleteBtn.disabled = deleteConfirmInput.value.trim() !== "DELETE";
+  });
+}
+
+if (confirmDeleteBtn) {
+  confirmDeleteBtn.addEventListener("click", async () => {
+    if (deleteConfirmInput && deleteConfirmInput.value.trim() !== "DELETE") return;
+    confirmDeleteBtn.disabled = true;
+    setError(deleteError, "Deleting your account...");
+    try {
+      const res = await fetchWithAuth("/api/account", {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ confirm: "DELETE" })
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        setError(deleteError, data.error || "Failed to delete account.");
+        confirmDeleteBtn.disabled = false;
+        return;
+      }
+      // Sign out and reload to a clean state.
+      await firebase.auth().signOut();
+      window.location.reload();
+    } catch (e) {
+      setError(deleteError, "Failed to delete account.");
+      confirmDeleteBtn.disabled = false;
+    }
+  });
+}
+
+initAuth();