@agent-native/core-corpus 0.214.0 → 0.217.0

package/corpus/templates/analytics/app/pages/sessions/SessionOutputs.tsx

@@ -0,0 +1,197 @@
+import { useActionQuery } from "@agent-native/core/client/hooks";
+import { useT } from "@agent-native/core/client/i18n";
+import { useLab } from "@agent-native/core/client/labs";
+import {
+  IconExternalLink,
+  IconPackage,
+  IconRefresh,
+} from "@tabler/icons-react";
+
+import { Button } from "@/components/ui/button";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@/components/ui/popover";
+import { cn } from "@/lib/utils";
+
+import { ANALYTICS_SESSIONS_TRIAGE_LAB } from "../../../shared/labs";
+import {
+  MIN_PRESENTATION_MS,
+  OUTPUT_USE_WINDOW_DAYS,
+  type OutputUseApp,
+  type SessionOutput,
+  type SessionRecordingOutputs,
+} from "../../../shared/output-use";
+
+type T = ReturnType<typeof useT>;
+
+export function unusedFilterLabel(app: OutputUseApp, t: T): string {
+  switch (app) {
+    case "slides":
+      return t("sessions.unusedSlidesDecks");
+  }
+}
+
+export function unusedRuleText(app: OutputUseApp, t: T): string {
+  switch (app) {
+    case "slides":
+      return t("sessions.unusedSlidesRule", {
+        days: String(OUTPUT_USE_WINDOW_DAYS),
+        seconds: String(MIN_PRESENTATION_MS / 1000),
+      });
+  }
+}
+
+function openOutputLabel(output: SessionOutput, t: T): string {
+  switch (output.app) {
+    case "slides":
+      return t("sessions.openDeck");
+  }
+}
+
+function outputTitle(output: SessionOutput, t: T): string {
+  const date = new Date(output.madeAt).toLocaleDateString();
+  switch (output.app) {
+    case "slides":
+      return t("sessions.deckMadeOn", { date });
+  }
+}
+
+export function outputStatusText(output: SessionOutput, t: T): string {
+  switch (output.status) {
+    case "used": {
+      const date = output.usedAt
+        ? new Date(output.usedAt).toLocaleDateString()
+        : "";
+      if (output.usedEvent === "presentation_ended") {
+        return t("sessions.outputPresentedOn", { date });
+      }
+      if (output.usedEvent === "deck_exported") {
+        return t("sessions.outputExportedOn", { date });
+      }
+      return t("sessions.outputUsedOn", { date });
+    }
+    case "unused":
+      return t("sessions.outputUnused", {
+        days: String(OUTPUT_USE_WINDOW_DAYS),
+      });
+    case "open":
+      return t("sessions.outputOpen", {
+        date: new Date(output.useBy).toLocaleDateString(),
+      });
+    case "unmeasured":
+      return t("sessions.outputUnmeasured");
+  }
+}
+
+function OutputLink({ output }: { output: SessionOutput }) {
+  const t = useT();
+  if (!output.url) return null;
+  return (
+    <Button asChild variant="ghost" size="xs" className="shrink-0">
+      <a href={output.url} target="_blank" rel="noreferrer">
+        {openOutputLabel(output, t)}
+        <IconExternalLink />
+      </a>
+    </Button>
+  );
+}
+
+// A link cannot nest inside the row's replay link, so this sits beside it.
+export function UnusedOutputLink({
+  outputs,
+}: {
+  outputs?: SessionOutput[] | null;
+}) {
+  const t = useT();
+  const unusedOutputs = (outputs ?? []).filter(
+    (output) => output.status === "unused",
+  );
+  const linked = unusedOutputs.find((output) => output.url);
+  if (!linked) return null;
+  return (
+    <div className="flex shrink-0 items-center gap-1 px-3">
+      <OutputLink output={linked} />
+      {unusedOutputs.length > 1 ? (
+        <span className="text-xs text-muted-foreground">
+          {t("sessions.moreOutputs", {
+            count: String(unusedOutputs.length - 1),
+          })}
+        </span>
+      ) : null}
+    </div>
+  );
+}
+
+/** The outputs a replay's session made, and whether each was used in time. */
+export function SessionOutputsButton({ recordingId }: { recordingId: string }) {
+  const t = useT();
+  const lab = useLab(ANALYTICS_SESSIONS_TRIAGE_LAB);
+  const query = useActionQuery<SessionRecordingOutputs>(
+    "list-session-outputs",
+    { recordingIds: [recordingId] },
+    { enabled: lab, staleTime: 30_000 },
+  );
+  if (!lab) return null;
+  if (query.isError && !query.data) {
+    return (
+      <Button
+        variant="ghost"
+        size="sm"
+        onClick={() => void query.refetch()}
+        disabled={query.isFetching}
+      >
+        <IconRefresh className={cn(query.isFetching && "animate-spin")} />
+        {t("sessions.outputsUnavailable")}
+      </Button>
+    );
+  }
+  const outputs = query.data?.outputs[recordingId];
+  if (!outputs?.length) return null;
+  const omitted = query.data?.omittedOutputs[recordingId] ?? 0;
+  const total = outputs.length + omitted;
+  return (
+    <Popover>
+      <PopoverTrigger asChild>
+        <Button variant="outline">
+          <IconPackage />
+          {t(
+            total === 1 ? "sessions.deckCountSingular" : "sessions.deckCount",
+            { count: String(total) },
+          )}
+        </Button>
+      </PopoverTrigger>
+      <PopoverContent align="end" className="w-80">
+        <ul className="space-y-3">
+          {outputs.map((output) => (
+            <li
+              key={`${output.app}:${output.outputId}`}
+              className="flex items-start justify-between gap-3"
+            >
+              <span className="min-w-0 text-sm">
+                <span className="block truncate font-medium">
+                  {outputTitle(output, t)}
+                </span>
+                <span
+                  className={cn(
+                    "block text-xs text-muted-foreground",
+                    output.status === "unused" && "text-foreground",
+                  )}
+                >
+                  {outputStatusText(output, t)}
+                </span>
+              </span>
+              <OutputLink output={output} />
+            </li>
+          ))}
+        </ul>
+        {omitted ? (
+          <p className="mt-3 text-xs text-muted-foreground">
+            {t("sessions.moreOutputs", { count: String(omitted) })}
+          </p>
+        ) : null}
+      </PopoverContent>
+    </Popover>
+  );
+}

package/corpus/templates/analytics/app/pages/sessions/SessionsTriagePage.tsx

@@ -6,6 +6,7 @@ import {
   IconChevronLeft,
   IconChevronRight,
   IconGauge,
+  IconPackageOff,
   IconPhoto,
   IconRefresh,
   IconX,
@@ -44,6 +45,14 @@ import { useReplayStorageStatus } from "@/hooks/use-replay-storage-status";
 import { cn } from "@/lib/utils";
 
 import { ANALYTICS_SESSIONS_TRIAGE_LAB } from "../../../shared/labs";
+import {
+  isOutputUseApp,
+  OUTPUT_USE_APPS,
+  OUTPUT_USE_WINDOW_DAYS,
+  type OutputUseApp,
+  type SessionOutput,
+  UNUSED_OUTPUT_PARAM,
+} from "../../../shared/output-use";
 import {
   sessionDateBound,
   sessionDateForDisplay,
@@ -86,6 +95,11 @@ import {
   SessionFrictionFilter,
   SessionFrictionStrip,
 } from "./SessionFriction";
+import {
+  UnusedOutputLink,
+  unusedFilterLabel,
+  unusedRuleText,
+} from "./SessionOutputs";
 import { SessionReplayStoryboardExportDialog } from "./SessionReplayStoryboardExportDialog";
 import {
   EmptySessionsState,
@@ -128,6 +142,10 @@ type Page = {
   frictionCoverageStartedAt?: string | null;
   /** Present when a speed filter applied; null: nothing measured yet. */
   performanceCoverageStartedAt?: string | null;
+  /** Present when the unused filter applied, by recording id. */
+  outputs?: Record<string, SessionOutput[] | null>;
+  /** Present when the unused filter applied; null: nothing tracked yet. */
+  outputCoverageStartedAt?: string | null;
 };
 
 const RANGES: Range[] = ["24h", "7d", "30d", "90d", "all"];
@@ -303,11 +321,18 @@ export function SessionsTriagePage() {
   const slow: SlowSessionFilter | undefined =
     eventsLabEnabled && isSlowSessionFilter(urlSlow) ? urlSlow : undefined;
   const urlHasSlowFilter = isSlowSessionFilter(urlSlow);
-  // A shared link with event, friction, or slow conditions waits briefly for
-  // the Lab state instead of listing unfiltered sessions. Nothing else waits,
-  // and a hung read stops holding the list and reads as failed.
+  const urlUnused = params.get(UNUSED_OUTPUT_PARAM);
+  const unused: OutputUseApp | undefined =
+    eventsLabEnabled && isOutputUseApp(urlUnused) ? urlUnused : undefined;
+  const urlHasUnusedFilter = isOutputUseApp(urlUnused);
+  // A shared link with event, friction, slow, or unused conditions waits
+  // briefly for the Lab state instead of listing unfiltered sessions. Nothing
+  // else waits, and a hung read stops holding the list and reads as failed.
   const urlHasLabFilters =
-    urlHasEventConditions || urlHasFrictionParams || urlHasSlowFilter;
+    urlHasEventConditions ||
+    urlHasFrictionParams ||
+    urlHasSlowFilter ||
+    urlHasUnusedFilter;
   const [labWaitExpired, setLabWaitExpired] = useState(false);
   const waitsForLab = urlHasLabFilters && eventsLab.isLoading;
   useEffect(() => {
@@ -445,6 +470,7 @@ export function SessionsTriagePage() {
         frictionSignals: frictionSignals.length ? frictionSignals : undefined,
         includeFriction: frictionApplied || undefined,
         slow,
+        unused,
         sort,
         offset: (page - 1) * SESSION_PAGE_SIZE,
         limit: SESSION_PAGE_SIZE,
@@ -491,6 +517,18 @@ export function SessionsTriagePage() {
         : t("sessions.speedCoverageSince", {
             date: new Date(speedCoverageStartedAt).toLocaleDateString(),
           });
+  const outputCoverageStartedAt = data?.outputCoverageStartedAt;
+  const outputCoverageNote =
+    outputCoverageStartedAt === undefined
+      ? null
+      : outputCoverageStartedAt === null
+        ? t("sessions.outputCoverageStarting", {
+            days: String(OUTPUT_USE_WINDOW_DAYS),
+          })
+        : t("sessions.outputCoverageSince", {
+            date: new Date(outputCoverageStartedAt).toLocaleDateString(),
+            days: String(OUTPUT_USE_WINDOW_DAYS),
+          });
   const total = data?.total ?? 0;
   // Speed hints load beside the list, keyed on its rows, so turning the Lab
   // on adds them without fetching the list again.
@@ -539,6 +577,7 @@ export function SessionsTriagePage() {
         : undefined,
       frictionSignals: frictionSignals.length ? frictionSignals : undefined,
       slow,
+      unused,
       sort,
       limit: 1,
     },
@@ -909,6 +948,54 @@ export function SessionsTriagePage() {
             </PopoverContent>
           </Popover>
         ) : null}
+        {eventsLabEnabled ? (
+          <Popover>
+            <PopoverTrigger asChild>
+              <Button
+                variant={unused ? "secondary" : "outline"}
+                size="sm"
+                className={cn(
+                  "h-8 border border-input font-normal",
+                  !unused && "bg-transparent hover:bg-accent",
+                )}
+              >
+                <IconPackageOff />
+                {unused
+                  ? unusedFilterLabel(unused, t)
+                  : t("sessions.unusedOutputs")}
+              </Button>
+            </PopoverTrigger>
+            <PopoverContent align="start" className="w-72">
+              <div className="space-y-3">
+                <Select
+                  value={unused ?? "all"}
+                  onValueChange={(value) =>
+                    setFilter(UNUSED_OUTPUT_PARAM, value === "all" ? "" : value)
+                  }
+                >
+                  <SelectTrigger aria-label={t("sessions.unusedOutputs")}>
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="all">
+                      {t("sessions.anyOutcome")}
+                    </SelectItem>
+                    {OUTPUT_USE_APPS.map((value) => (
+                      <SelectItem key={value} value={value}>
+                        {unusedFilterLabel(value, t)}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+                {OUTPUT_USE_APPS.map((value) => (
+                  <p key={value} className="text-xs text-muted-foreground">
+                    {unusedRuleText(value, t)}
+                  </p>
+                ))}
+              </div>
+            </PopoverContent>
+          </Popover>
+        ) : null}
         {hasActiveFilters ? (
           <Button
             variant="ghost"
@@ -959,6 +1046,14 @@ export function SessionsTriagePage() {
           {t("sessions.speedFilterNeedsLab")}
         </p>
       ) : null}
+      {urlHasUnusedFilter &&
+      !eventsLabEnabled &&
+      !eventsLab.isLoading &&
+      !eventsLab.isError ? (
+        <p className="text-xs text-muted-foreground" role="status">
+          {t("sessions.unusedFilterNeedsLab")}
+        </p>
+      ) : null}
       {eventsLabEnabled &&
       !frictionApplied &&
       rowFrictionError &&
@@ -1012,6 +1107,13 @@ export function SessionsTriagePage() {
           {speedCoverageNote}
         </p>
       ) : null}
+      {outputCoverageStartedAt !== undefined &&
+      recordings.length > 0 &&
+      rangePredatesCoverage(dateBounds.from, outputCoverageStartedAt) ? (
+        <p className="text-xs text-muted-foreground" role="status">
+          {outputCoverageNote}
+        </p>
+      ) : null}
       <Card>
         <div className="flex items-center justify-between gap-2 border-b px-4 py-2 text-sm">
           <div className="text-muted-foreground" aria-live="polite">
@@ -1099,6 +1201,9 @@ export function SessionsTriagePage() {
                   {speedCoverageNote ? (
                     <p className="mt-1 text-xs">{speedCoverageNote}</p>
                   ) : null}
+                  {outputCoverageNote ? (
+                    <p className="mt-1 text-xs">{outputCoverageNote}</p>
+                  ) : null}
                   {showEmptySessionRecovery ? (
                     <Button
                       variant="outline"
@@ -1273,6 +1378,11 @@ export function SessionsTriagePage() {
                               />
                             </span>
                           </Link>
+                          {unused ? (
+                            <UnusedOutputLink
+                              outputs={data?.outputs?.[recording.id]}
+                            />
+                          ) : null}
                         </div>
                       </SessionRow>
                     ))}

package/corpus/templates/analytics/changelog/2026-10-15-sessions-can-find-people-who-made-a-slides-deck-but-didn-t-p.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-10-15
+---
+
+Sessions can find people who made a Slides deck but didn't present or export it within 7 days, and the event catalog flags apps with no "used it" event (Sessions triage Lab)

package/corpus/templates/analytics/changelog/2026-10-16-the-activation-funnel-counts-visitors-who-decline-analytics-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-16
+---
+
+The activation funnel counts visitors who decline analytics cookies and then sign up in the same visit

package/corpus/templates/analytics/changelog/2026-10-21-session-replay-quotas-count-the-compressed-size-analytics-st.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-21
+---
+
+Session replay quotas count the compressed size Analytics stores, so recordings from other sites no longer use up the daily limit early

package/corpus/templates/analytics/server/db/schema.ts

@@ -654,6 +654,73 @@ export const analyticsPerformanceCoverage = table(
   },
 );
 
+// Each output an app reported making, from `shared/output-use.ts`, and its
+// first use. A null madeAt means only uses have arrived so far; useBy is
+// madeAt plus the use window, so "used in time" compares two stored values.
+export const analyticsOutputOutcomes = table(
+  "analytics_output_outcomes",
+  {
+    id: text("id").primaryKey(),
+    tenantKey: text("tenant_key").notNull(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    app: text("app").notNull(),
+    outputType: text("output_type").notNull(),
+    outputId: text("output_id").notNull(),
+    madeAt: text("made_at"),
+    useBy: text("use_by"),
+    madeSessionId: text("made_session_id"),
+    firstUsedAt: text("first_used_at"),
+    usedEvent: text("used_event"),
+    lastSeenAt: text("last_seen_at").notNull(),
+  },
+  (t) => ({
+    outputOutcomeUnique: uniqueIndex("analytics_output_outcomes_key_idx").on(
+      t.tenantKey,
+      t.app,
+      t.outputId,
+    ),
+    madeSessionIdx: index("analytics_output_outcomes_made_session_idx").on(
+      t.tenantKey,
+      t.madeSessionId,
+    ),
+    lastSeenIdx: index("analytics_output_outcomes_last_seen_idx").on(
+      t.lastSeenAt,
+    ),
+  }),
+);
+
+// Event-time spans in which a failed write may have dropped an output's use,
+// so no output made in or before one can read as unused.
+export const analyticsOutputOutcomeGaps = table(
+  "analytics_output_outcome_gaps",
+  {
+    id: text("id").primaryKey(),
+    tenantKey: text("tenant_key").notNull(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    firstAt: text("first_at").notNull(),
+    lastAt: text("last_at").notNull(),
+    recordedAt: text("recorded_at").notNull(),
+  },
+  (t) => ({
+    outputOutcomeGapTenantIdx: index(
+      "analytics_output_outcome_gaps_tenant_idx",
+    ).on(t.tenantKey, t.lastAt),
+  }),
+);
+
+// When each tenant's output outcomes began.
+export const analyticsOutputOutcomeCoverage = table(
+  "analytics_output_outcome_coverage",
+  {
+    tenantKey: text("tenant_key").primaryKey(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    startedAt: text("started_at").notNull(),
+  },
+);
+
 export const analyticsUserDays = table("analytics_user_days", {
   id: text("id").primaryKey(),
   tenantKey: text("tenant_key").notNull(),

package/corpus/templates/analytics/server/lib/canonical-first-party-dashboard-repair.ts

@@ -651,6 +651,15 @@ const ORIGIN_MAIN_PANEL_REPLACEMENTS: readonly FingerprintedPanelReplacement[] =
         "ba2e861c2044e2fec669bcb15a878a675eaf426f51bcfe4db32ebd228d2050f0",
       sql: buildPanel("activation-funnel")!.sql,
     },
+    // The funnel before it joined visitors without analytics consent to
+    // their signup through the session.
+    {
+      id: "activation-funnel",
+      source: "first-party",
+      sha256:
+        "21df6cc1f26862531504c21fb5a558c87b58615118fcd0ad1913a971fa8387a6",
+      sql: buildPanel("activation-funnel")!.sql,
+    },
     {
       id: "retention-over-time",
       source: "bigquery",

package/corpus/templates/analytics/server/lib/first-party-analytics.ts

@@ -74,6 +74,10 @@ import {
   boundedIdentity,
   boundedText,
 } from "./indexed-text.js";
+import {
+  recordLostOutputBatch,
+  recordOutputOutcomes,
+} from "./output-outcomes.js";
 import { parseIngestBody, requestError } from "./request-errors.js";
 import {
   recordEventCatalog,
@@ -243,6 +247,7 @@ async function persistBigQueryRowsWithMigrationFallback(
       );
       await recordSessionEventIndex(tx, rows, receivedAt);
       await recordSessionPerformance(tx, rows, receivedAt);
+      await recordOutputOutcomes(tx, rows, receivedAt);
     });
   } catch (error) {
     if (!isFirstPartyAnalyticsDeliveryQueueMissingError(error)) throw error;
@@ -269,6 +274,7 @@ async function persistBigQueryRowsWithMigrationFallback(
       }
       await recordSessionEventIndex(tx, rows, receivedAt);
       await recordSessionPerformance(tx, rows, receivedAt);
+      await recordOutputOutcomes(tx, rows, receivedAt);
     });
     try {
       const result = await runWithRequestContext(
@@ -948,31 +954,29 @@ export async function recordAnalyticsEvents(
     };
   });
 
-  const backend = await getFirstPartyAnalyticsBackend({
-    userEmail: key.ownerEmail,
-    orgId: key.orgId ?? null,
-  });
-
-  if (rows.length && backend.sink === "dual") {
-    try {
-      await runWithRequestContext(
-        {
-          userEmail: key.ownerEmail,
-          orgId: key.orgId ?? undefined,
-        },
-        () => insertFirstPartyAnalyticsRows(rows, backend.table),
-      );
-    } catch (error) {
-      console.error(
-        "[first-party-analytics] BigQuery dual-write failed; retaining Postgres event:",
-        error,
-      );
-    }
-  }
-
   let persistenceError: unknown = null;
   if (rows.length) {
     try {
+      const backend = await getFirstPartyAnalyticsBackend({
+        userEmail: key.ownerEmail,
+        orgId: key.orgId ?? null,
+      });
+      if (backend.sink === "dual") {
+        try {
+          await runWithRequestContext(
+            {
+              userEmail: key.ownerEmail,
+              orgId: key.orgId ?? undefined,
+            },
+            () => insertFirstPartyAnalyticsRows(rows, backend.table),
+          );
+        } catch (error) {
+          console.error(
+            "[first-party-analytics] BigQuery dual-write failed; retaining Postgres event:",
+            error,
+          );
+        }
+      }
       if (backend.sink === "bigquery") {
         await persistBigQueryRowsWithMigrationFallback(
           db,
@@ -998,10 +1002,12 @@ export async function recordAnalyticsEvents(
           await upsertFirstPartyAnalyticsRollups(rows, tx);
           await recordSessionEventIndex(tx, rows, receivedAt);
           await recordSessionPerformance(tx, rows, receivedAt);
+          await recordOutputOutcomes(tx, rows, receivedAt);
         });
       }
     } catch (error) {
       persistenceError = error;
+      await recordLostOutputBatch(db, rows, receivedAt);
     }
   }
   if (rows.length && !persistenceError) {

package/corpus/templates/analytics/server/lib/first-party-metric-catalog.ts

@@ -1022,22 +1022,57 @@ const FUNNEL_EVENTS_CTE = `WITH auth_identity_bridge AS (
     AND NULLIF(e.anonymous_id, '') IS NOT NULL
   GROUP BY NULLIF(e.anonymous_id, '')
   HAVING COUNT(DISTINCT NULLIF(e.properties::jsonb ->> 'auth_user_id', '')) <= 1
+), signup_session_identity AS (
+  -- Visitors in the consent region send no anonymous id until they accept
+  -- analytics cookies, so their pre-signup events reach the signup only
+  -- through the session they share with it.
+  SELECT NULLIF(e.session_id, '') AS session_id,
+    MIN(NULLIF(e.properties::jsonb ->> 'auth_user_id', '')) AS signup_auth_user_id,
+    MIN(
+      CASE
+        WHEN NULLIF(e.user_id, '') LIKE '%@%.%' THEN e.user_id
+        WHEN NULLIF(e.user_key, '') LIKE '%@%.%' THEN e.user_key
+      END
+    ) AS signup_user_email
+  FROM analytics_events e
+  WHERE e.event_name = 'signup'
+    AND ${DASHBOARD_TIME_RANGE_FILTER}
+    AND ${DASHBOARD_APP_FILTER}
+    AND ${FIRST_PARTY_TEMPLATE_FILTER}
+    AND NULLIF(e.session_id, '') IS NOT NULL
+  GROUP BY NULLIF(e.session_id, '')
+  -- A session with two signups can't say whose visit it was.
+  HAVING COUNT(DISTINCT NULLIF(e.properties::jsonb ->> 'auth_user_id', '')) <= 1
+    AND COUNT(
+      DISTINCT CASE
+        WHEN NULLIF(e.user_id, '') LIKE '%@%.%' THEN e.user_id
+        WHEN NULLIF(e.user_key, '') LIKE '%@%.%' THEN e.user_key
+      END
+    ) <= 1
 ), raw_funnel_events AS (
   SELECT e.*,
     COALESCE(
       NULLIF(e.properties::jsonb ->> 'auth_user_id', ''),
       si.signup_auth_user_id,
       si.signup_user_email,
+      ss.signup_auth_user_id,
+      ss.signup_user_email,
       NULLIF(e.user_id, ''),
       NULLIF(e.anonymous_id, '')
     ) AS funnel_user_key,
     COALESCE(
       CASE WHEN NULLIF(e.user_id, '') LIKE '%@%.%' THEN e.user_id END,
       CASE WHEN NULLIF(e.user_key, '') LIKE '%@%.%' THEN e.user_key END,
-      si.signup_user_email
+      si.signup_user_email,
+      ss.signup_user_email
     ) AS funnel_user_email
   FROM analytics_events e
   LEFT JOIN signup_identity si ON si.anonymous_id = NULLIF(e.anonymous_id, '')
+  LEFT JOIN signup_session_identity ss
+    ON NULLIF(e.anonymous_id, '') IS NULL
+    AND NULLIF(e.user_id, '') IS NULL
+    AND NULLIF(e.properties::jsonb ->> 'auth_user_id', '') IS NULL
+    AND ss.session_id = NULLIF(e.session_id, '')
   WHERE ${DASHBOARD_TIME_RANGE_FILTER}
     AND ${DASHBOARD_APP_FILTER}
     AND ${FIRST_PARTY_TEMPLATE_FILTER}