@liiift-studio/sanity-visitor-insights 0.1.0

package/src/server/orders.ts

@@ -0,0 +1,127 @@
+/**
+ * Order counts from Sanity, used only as a conversion anchor.
+ *
+ * Orders on these sites carry customer names, emails and postal addresses. Joining that to
+ * behavioural analytics would turn aggregate statistics into personal-data processing and put the
+ * GA4 property at risk under Google's terms, so no query in this file may project a PII field.
+ * The projections below are allow-lists, not conveniences: every GROQ query here names the exact
+ * fields it returns, and none of them is a customer identifier.
+ *
+ * Revenue is likewise absent. This package reports behaviour; the sales portal reports sales.
+ */
+
+/** Fields safe to read from an order. Nothing here identifies a person. */
+const SAFE_ORDER_PROJECTION = '{ _createdAt, orderStatus }'
+
+/** A daily count of orders. */
+export interface OrderCounts {
+	byDate: Record<string, number>
+	total: number
+}
+
+/** Orders attributable to a typeface, for the interest report. */
+export interface TypefaceOrderCounts {
+	/** Typeface title to order count. */
+	byTypeface: Record<string, number>
+	total: number
+}
+
+/** What this module needs from a Sanity client — kept minimal so it is trivial to stub in tests. */
+export interface SanityQueryClient {
+	fetch<T>(query: string, params?: Record<string, unknown>): Promise<T>
+}
+
+/**
+ * Build a GROQ filter for orders in a date range.
+ * `excludeFilter` lets a site drop non-typeface orders, e.g. merch-only orders on Darden, which
+ * would otherwise inflate a family's apparent purchase count.
+ */
+function orderFilter(documentType: string, excludeFilter?: string): string {
+	const clauses = [
+		`_type == $documentType`,
+		`_createdAt >= $start`,
+		`_createdAt <= $end`,
+	]
+	if (excludeFilter) clauses.push(`(${excludeFilter})`)
+	return clauses.join(' && ')
+}
+
+/**
+ * Count orders per day across a range.
+ *
+ * Bounds are passed as full timestamps because `_createdAt` is a UTC datetime; comparing it to a
+ * bare date would silently drop the last day's orders.
+ *
+ * @param client - a Sanity client
+ * @param documentType - the site's order document type
+ * @param start - inclusive ISO date
+ * @param end - inclusive ISO date
+ * @param excludeFilter - optional GROQ clause excluding non-typeface orders
+ */
+export async function countOrders(
+	client: SanityQueryClient,
+	documentType: string,
+	start: string,
+	end: string,
+	excludeFilter?: string,
+): Promise<OrderCounts> {
+	const query = `*[${orderFilter(documentType, excludeFilter)}]${SAFE_ORDER_PROJECTION}`
+
+	const orders = await client.fetch<Array<{ _createdAt: string }>>(query, {
+		documentType,
+		start: `${start}T00:00:00Z`,
+		end: `${end}T23:59:59Z`,
+	})
+
+	const byDate: Record<string, number> = {}
+	for (const order of orders) {
+		const date = order._createdAt.slice(0, 10)
+		byDate[date] = (byDate[date] ?? 0) + 1
+	}
+
+	return { byDate, total: orders.length }
+}
+
+/**
+ * Count orders per typeface across a range.
+ *
+ * Returns an empty result when the site has no usable typeface field on orders, rather than
+ * guessing — an absent join is reported as unavailable upstream, not as zero purchases.
+ *
+ * @param typefacesField - the order field holding typeface references, or null when absent
+ */
+export async function countOrdersByTypeface(
+	client: SanityQueryClient,
+	documentType: string,
+	typefacesField: string | null,
+	start: string,
+	end: string,
+	excludeFilter?: string,
+): Promise<TypefaceOrderCounts | null> {
+	if (!typefacesField) return null
+
+	// Dereferences only the typeface title — never the order's customer fields.
+	const query = `*[${orderFilter(documentType, excludeFilter)}]{
+		"typefaces": ${typefacesField}[]->{ title }
+	}`
+
+	const orders = await client.fetch<Array<{ typefaces?: Array<{ title?: string } | null> | null }>>(query, {
+		documentType,
+		start: `${start}T00:00:00Z`,
+		end: `${end}T23:59:59Z`,
+	})
+
+	const byTypeface: Record<string, number> = {}
+	let total = 0
+
+	for (const order of orders) {
+		for (const typeface of order.typefaces ?? []) {
+			const title = typeface?.title
+			if (!title) continue
+			byTypeface[title] = (byTypeface[title] ?? 0) + 1
+			total += 1
+		}
+	}
+
+	return { byTypeface, total }
+}

package/src/server/reports/acquisition.ts

@@ -0,0 +1,85 @@
+/**
+ * Acquisition — where visitors come from.
+ *
+ * Design-industry referrers are pulled out as a named segment rather than left in a generic
+ * referrer table. A visit from Fonts In Use or Typewolf is a pre-qualified, industry-literate
+ * visitor and behaves nothing like average organic traffic; burying those rows among search and
+ * social discards the distinction a foundry actually acts on.
+ *
+ * `(not set)` rows are surfaced rather than swept into "other". On a type-foundry site they can be
+ * a large share — bookmarked visits, stripped referrers, AI crawlers — and hiding them makes the
+ * table look more complete than it is.
+ */
+
+import type { AcquisitionData, SourceRow } from '../../reportData'
+import type { DateRange } from '../../types'
+import { sumFirstMetric, type Ga4Client } from '../ga4'
+
+/** Referrer hosts that identify a design-industry source worth tracking separately. */
+export const DESIGN_INDUSTRY_SOURCES = [
+	'fontsinuse.com',
+	'typewolf.com',
+	'typographica.org',
+	'fonts.google.com',
+	'behance.net',
+	'dribbble.com',
+	'itsnicethat.com',
+] as const
+
+
+
+/** Whether a GA4 source value is one of the unattributed buckets rather than a real referrer. */
+function isUnattributed(source: string): boolean {
+	const normalised = source.toLowerCase()
+	return normalised === '(not set)' || normalised === '(direct)' || normalised === '(none)' || normalised === ''
+}
+
+/** Whether a GA4 source value matches a design-industry referrer. */
+function isDesignIndustry(source: string): boolean {
+	const normalised = source.toLowerCase()
+	return DESIGN_INDUSTRY_SOURCES.some((known) => normalised === known || normalised.endsWith(`.${known}`))
+}
+
+/**
+ * Run the acquisition report.
+ *
+ * @param ga4 - client for the site's property
+ * @param range - the requested range
+ * @param limit - maximum source rows to return
+ */
+export async function acquisition(ga4: Ga4Client, range: DateRange, limit = 25): Promise<AcquisitionData> {
+	const report = await ga4.runReport({
+		dimensions: [{ name: 'sessionSource' }, { name: 'sessionDefaultChannelGroup' }],
+		metrics: [{ name: 'sessions' }],
+		dateRanges: [{ startDate: range.start, endDate: range.end }],
+		orderBys: [{ metric: { metricName: 'sessions' }, desc: true }],
+		limit,
+	})
+
+	const rows: SourceRow[] = report.rows.map((row) => {
+		const source = row.dimensions[0] ?? '(not set)'
+		const sessions = row.metrics[0]
+
+		return {
+			source,
+			channel: row.dimensions[1] ?? 'Unassigned',
+			sessions: Number.isFinite(sessions) ? (sessions as number) : 0,
+			designIndustry: isDesignIndustry(source),
+			unattributed: isUnattributed(source),
+		}
+	})
+
+	const totalSessions = sumFirstMetric(report)
+	const sumWhere = (predicate: (row: SourceRow) => boolean) =>
+		rows.filter(predicate).reduce((total, row) => total + row.sessions, 0)
+
+	return {
+		rows,
+		totalSessions,
+		designIndustryShare: totalSessions > 0 ? sumWhere((r) => r.designIndustry) / totalSessions : null,
+		unattributedShare: totalSessions > 0 ? sumWhere((r) => r.unattributed) / totalSessions : null,
+		rowsWithheld: report.thresholded,
+	}
+}
+
+export type { AcquisitionData, SourceRow } from '../../reportData'

package/src/server/reports/journey.ts

@@ -0,0 +1,112 @@
+/**
+ * Journey — how far visitors get, and where they stop.
+ *
+ * This is an ordered step funnel, not a path graph, and that is a deliberate limit rather than a
+ * simplification. GA4's Data API has no path-exploration endpoint; Path Exploration is a UI-only
+ * feature. What is available is per-event totals and `runFunnelReport`, an alpha surface that
+ * returns step-conversion marginals — not observed sequences. Rendering ribbons from marginals
+ * would assert that a given visitor went A to B to C when no such co-occurrence was ever measured.
+ *
+ * So each step is reported as its own honest total, adjacent drop-off is derived between steps, and
+ * the response is explicitly flagged as an approximation for the UI to display.
+ *
+ * A step whose event is not instrumented on this site reports as unavailable, never as zero. On a
+ * site missing `begin_checkout`, the cart-to-checkout drop-off is not "100% drop-off" — it is
+ * unmeasured, and the two must not look alike.
+ */
+
+import type { JourneyData, JourneyStep, ExitPage } from '../../reportData'
+import type { DateRange, MetricValue } from '../../types'
+import type { SiteAnalyticsConfig } from '../../core/siteConfig'
+import { applyCoverage, coverageForRange } from '../../core/cutover'
+import { eventNameFilter, sumFirstMetric, type Ga4Client } from '../ga4'
+
+/** The funnel, in order. Each entry names the GA4 event that evidences the step. */
+export const JOURNEY_STEPS = [
+	{ key: 'landed', label: 'Landed', event: 'page_view' },
+	{ key: 'viewed_typeface', label: 'Viewed a typeface', event: 'view_item' },
+	{ key: 'tested', label: 'Used the type tester', event: 'tester_engaged' },
+	{ key: 'added_to_cart', label: 'Added to cart', event: 'add_to_cart' },
+	{ key: 'began_checkout', label: 'Began checkout', event: 'begin_checkout' },
+	{ key: 'purchased', label: 'Purchased', event: 'purchase' },
+] as const
+
+
+
+
+const APPROXIMATION_NOTE =
+	'These are independent per-step totals, not tracked journeys. GA4 cannot report the actual path a ' +
+	'visitor took, so a visitor counted at one step is not necessarily the same visitor counted at the next.'
+
+/**
+ * Run the journey report.
+ *
+ * All step queries go in one batched call rather than one request per step, which would otherwise
+ * make this the most quota-expensive panel in the tool.
+ */
+export async function journey(config: SiteAnalyticsConfig, ga4: Ga4Client, range: DateRange): Promise<JourneyData> {
+	// Only query steps whose event could return data; skip the rest to save quota.
+	const coverages = JOURNEY_STEPS.map((step) => ({
+		step,
+		coverage: coverageForRange(config.eventCutovers, step.event, range),
+	}))
+
+	const queryable = coverages.filter((entry) => entry.coverage.status !== 'none')
+
+	const reports = await ga4.batchRunReports(
+		queryable.map((entry) => ({
+			metrics: [{ name: 'eventCount' }],
+			dateRanges: [{ startDate: range.start, endDate: range.end }],
+			dimensionFilter: eventNameFilter(entry.step.event),
+		})),
+	)
+
+	const countsByEvent = new Map<string, number>()
+	queryable.forEach((entry, index) => {
+		const report = reports[index]
+		if (report) countsByEvent.set(entry.step.event, sumFirstMetric(report))
+	})
+
+	const steps: JourneyStep[] = []
+	let previousMeasurable: number | null = null
+
+	for (const { step, coverage } of coverages) {
+		const raw = countsByEvent.has(step.event) ? (countsByEvent.get(step.event) as number) : null
+		const count = applyCoverage(raw, coverage)
+
+		const current = count.status === 'unavailable' ? null : count.value
+		const conversionFromPrevious =
+			previousMeasurable !== null && current !== null && previousMeasurable > 0
+				? current / previousMeasurable
+				: null
+
+		steps.push({ key: step.key, label: step.label, event: step.event, count, conversionFromPrevious })
+
+		// Only advance the baseline on a measurable step, so an unavailable rung does not
+		// silently make the next step's conversion look like a collapse.
+		if (current !== null) previousMeasurable = current
+	}
+
+	let topExitPages: ExitPage[] = []
+	try {
+		const exits = await ga4.runReport({
+			dimensions: [{ name: 'pagePath' }],
+			metrics: [{ name: 'exits' }],
+			dateRanges: [{ startDate: range.start, endDate: range.end }],
+			orderBys: [{ metric: { metricName: 'exits' }, desc: true }],
+			limit: 10,
+		})
+
+		topExitPages = exits.rows.map((row) => ({
+			path: row.dimensions[0] ?? '(unknown)',
+			exits: Number.isFinite(row.metrics[0]) ? (row.metrics[0] as number) : 0,
+		}))
+	} catch (e) {
+		// Exit pages are supplementary; losing them should not fail the funnel.
+		console.error('Visitor insights: exit-page query failed:', (e as Error).message)
+	}
+
+	return { steps, topExitPages, approximate: true, approximationNote: APPROXIMATION_NOTE }
+}
+
+export type { JourneyData, JourneyStep, ExitPage } from '../../reportData'

package/src/server/reports/measurementHealth.ts

@@ -0,0 +1,170 @@
+/**
+ * Measurement Health — "what are we missing?", answered honestly.
+ *
+ * This panel began life as a "coverage gap" that subtracted Vercel pageviews from GA4 sessions and
+ * attributed the difference to consent, ad-blockers and bots. That is not a valid subtraction:
+ * sessions and pageviews are different units, so the difference is dominated by the unit mismatch
+ * rather than by anything missing. Worse, GA4 exposes no signal that separates consent-denied from
+ * blocked from bot traffic, so the attribution would have been a guess rendered with the authority
+ * of a measurement.
+ *
+ * What this reports instead:
+ *   - GA4 pageviews against Vercel pageviews, the same unit on both sides
+ *   - GA4 sessions and orders alongside as context, never subtracted
+ *   - one residual, labelled unexplained, with the causes we can actually measure broken out
+ *
+ * The only cause we can measure is consent: a `consent_granted` event makes the acceptance rate a
+ * real number rather than an inference. Until that event is instrumented, the residual stays whole
+ * and the panel says why.
+ */
+
+import type { MeasurementHealthData } from '../../reportData'
+import type { DateRange, MetricValue } from '../../types'
+import { ok, unavailable } from '../../types'
+import type { SiteAnalyticsConfig } from '../../core/siteConfig'
+import { coverageForRange } from '../../core/cutover'
+import { sumFirstMetric, type Ga4Client } from '../ga4'
+import type { VercelClient } from '../vercel'
+import { countOrders, type SanityQueryClient } from '../orders'
+
+/** The event whose presence turns the consent share from a guess into a measurement. */
+const CONSENT_EVENT = 'consent_granted'
+
+
+/** Inputs for the measurement-health report. */
+export interface MeasurementHealthInput {
+	config: SiteAnalyticsConfig
+	range: DateRange
+	ga4: Ga4Client | null
+	vercel: VercelClient | null
+	sanity: SanityQueryClient | null
+}
+
+/** Build the plain-language reading shown beneath the figures. */
+function interpret(ga4Views: MetricValue, vercelViews: MetricValue, shortfall: number | null, consent: MetricValue): string {
+	if (ga4Views.status === 'unavailable' && vercelViews.status === 'unavailable') {
+		return 'Neither source answered, so nothing can be said about coverage for this range.'
+	}
+	if (shortfall === null) {
+		return 'Only one pageview source answered, so the two cannot be compared for this range.'
+	}
+
+	const percent = Math.round(Math.abs(shortfall) * 100)
+
+	if (Math.abs(shortfall) < 0.05) {
+		return `GA4 and Vercel agree to within ${percent}% on pageviews. Nothing here suggests a measurement problem.`
+	}
+
+	const direction = shortfall > 0 ? 'fewer' : 'more'
+	const base = `GA4 recorded ${percent}% ${direction} pageviews than Vercel.`
+
+	if (consent.status === 'unavailable') {
+		return `${base} How much of that is consent refusal cannot be measured until the consent_granted event is instrumented, so the difference is currently unexplained rather than attributed.`
+	}
+
+	const consentPercent = Math.round((1 - consent.value / 100) * 100)
+	return `${base} Around ${consentPercent}% of sessions did not grant analytics consent, which accounts for part of it. The remainder is unexplained — ad-blocking and bot filtering are plausible but are not separately measurable.`
+}
+
+/**
+ * Run the measurement-health report.
+ *
+ * Each source is queried independently and a failure in one degrades only its own figures, so the
+ * panel can always say which source did not answer rather than showing an unexplained blank.
+ */
+export async function measurementHealth(input: MeasurementHealthInput): Promise<MeasurementHealthData> {
+	const { config, range, ga4, vercel, sanity } = input
+
+	let ga4Pageviews: MetricValue = unavailable('source_error', 'GA4 not configured')
+	let ga4Sessions: MetricValue = unavailable('source_error', 'GA4 not configured')
+	let consentRate: MetricValue = unavailable('not_instrumented')
+
+	if (ga4) {
+		try {
+			// One batched call rather than three separate quota-charged requests.
+			const [views, sessions, consent] = await ga4.batchRunReports([
+				{
+					metrics: [{ name: 'screenPageViews' }],
+					dateRanges: [{ startDate: range.start, endDate: range.end }],
+				},
+				{
+					metrics: [{ name: 'sessions' }],
+					dateRanges: [{ startDate: range.start, endDate: range.end }],
+				},
+				{
+					metrics: [{ name: 'eventCount' }],
+					dimensions: [{ name: 'eventName' }],
+					dateRanges: [{ startDate: range.start, endDate: range.end }],
+					dimensionFilter: {
+						filter: {
+							fieldName: 'eventName',
+							stringFilter: { matchType: 'EXACT', value: CONSENT_EVENT },
+						},
+					},
+				},
+			])
+
+			if (views) ga4Pageviews = ok(sumFirstMetric(views))
+			if (sessions) ga4Sessions = ok(sumFirstMetric(sessions))
+
+			const consentCoverage = coverageForRange(config.eventCutovers, CONSENT_EVENT, range)
+			if (consentCoverage.status === 'full' && consent && ga4Sessions.status === 'ok' && ga4Sessions.value > 0) {
+				// Expressed as a percentage of sessions, capped since one session can fire it twice.
+				const rate = Math.min(100, (sumFirstMetric(consent) / ga4Sessions.value) * 100)
+				consentRate = ok(Math.round(rate * 10) / 10)
+			} else if (consentCoverage.status === 'partial') {
+				consentRate = unavailable('before_cutover', `Instrumented from ${consentCoverage.cutover}`)
+			}
+		} catch (e) {
+			console.error('Visitor insights: GA4 measurement-health query failed:', (e as Error).message)
+			ga4Pageviews = unavailable('source_error')
+			ga4Sessions = unavailable('source_error')
+		}
+	}
+
+	let vercelPageviews: MetricValue = unavailable('source_error', 'Vercel not configured')
+	if (vercel) {
+		try {
+			const result = await vercel.pageviews(range.start, range.end)
+			vercelPageviews = ok(result.total)
+		} catch (e) {
+			console.error('Visitor insights: Vercel query failed:', (e as Error).message)
+			vercelPageviews = unavailable('source_error')
+		}
+	}
+
+	let orders: MetricValue = unavailable('source_error', 'Sanity not configured')
+	if (sanity) {
+		try {
+			const counts = await countOrders(
+				sanity,
+				config.orders.documentType,
+				range.start,
+				range.end,
+				config.orders.excludeFilter,
+			)
+			orders = ok(counts.total)
+		} catch (e) {
+			console.error('Visitor insights: order count failed:', (e as Error).message)
+			orders = unavailable('source_error')
+		}
+	}
+
+	// Computed only when both operands are real numbers, and only between matching units.
+	const shortfallRatio =
+		ga4Pageviews.status !== 'unavailable' && vercelPageviews.status !== 'unavailable' && vercelPageviews.value > 0
+			? (vercelPageviews.value - ga4Pageviews.value) / vercelPageviews.value
+			: null
+
+	return {
+		ga4Pageviews,
+		vercelPageviews,
+		shortfallRatio,
+		ga4Sessions,
+		orders,
+		consentRate,
+		interpretation: interpret(ga4Pageviews, vercelPageviews, shortfallRatio, consentRate),
+	}
+}
+
+export type { MeasurementHealthData } from '../../reportData'

package/src/server/reports/typefaceInterest.ts

@@ -0,0 +1,140 @@
+/**
+ * Typeface interest — viewed, tested, bought, per family.
+ *
+ * This is the one panel GA4's own UI cannot produce, because it joins GA4 engagement to Sanity
+ * order documents. It is also the panel most easily misread, so two things are stated in the
+ * response rather than left to the reader:
+ *
+ *   1. It measures aggregate interest per family, not one person's journey. In foundry sales the
+ *      designer who tests a typeface is frequently not the person who later pays for it, and the
+ *      gap between the two can be months. A low tested-to-bought ratio is therefore not a broken
+ *      funnel, and the UI must not frame it as one.
+ *   2. "Tested" counts only genuine engagement — a `tester_engaged` event fired when the visitor
+ *      changed something. Firing on tester open would count every default-state page load as a
+ *      test and make the ratio meaningless.
+ */
+
+import type { TypefaceInterestData, TypefaceInterestRow } from '../../reportData'
+import type { DateRange, MetricValue } from '../../types'
+import { ok, unavailable } from '../../types'
+import type { SiteAnalyticsConfig } from '../../core/siteConfig'
+import { coverageForRange } from '../../core/cutover'
+import { eventNameFilter, type Ga4Client } from '../ga4'
+import { countOrdersByTypeface, type SanityQueryClient } from '../orders'
+
+/** GA4 event evidencing a typeface page view. */
+const VIEW_EVENT = 'view_item'
+
+/** GA4 event evidencing real type-tester engagement. */
+const TEST_EVENT = 'tester_engaged'
+
+
+
+const INTERPRETATION_NOTE =
+	'Aggregate interest per family, not individual journeys. The person who tests a typeface is often ' +
+	'not the person who buys it, and may buy months later — so a low tested-to-bought ratio is not ' +
+	'necessarily a conversion problem.'
+
+/**
+ * Read per-typeface event counts keyed by the GA4 `itemName` dimension.
+ * Returns null when the event is not usable for this range, so the caller can distinguish
+ * "no data" from "no interest".
+ */
+async function countsByItem(
+	config: SiteAnalyticsConfig,
+	ga4: Ga4Client,
+	range: DateRange,
+	eventName: string,
+): Promise<Map<string, number> | null> {
+	if (coverageForRange(config.eventCutovers, eventName, range).status === 'none') return null
+
+	const report = await ga4.runReport({
+		dimensions: [{ name: 'itemName' }],
+		metrics: [{ name: 'eventCount' }],
+		dateRanges: [{ startDate: range.start, endDate: range.end }],
+		dimensionFilter: eventNameFilter(eventName),
+		orderBys: [{ metric: { metricName: 'eventCount' }, desc: true }],
+		limit: 100,
+	})
+
+	const counts = new Map<string, number>()
+	for (const row of report.rows) {
+		const name = row.dimensions[0]
+		const value = row.metrics[0]
+		if (name && Number.isFinite(value)) counts.set(name, value as number)
+	}
+
+	return counts
+}
+
+/** Inputs for the typeface-interest report. */
+export interface TypefaceInterestInput {
+	config: SiteAnalyticsConfig
+	range: DateRange
+	ga4: Ga4Client
+	sanity: SanityQueryClient | null
+}
+
+/** Run the typeface-interest report. */
+export async function typefaceInterest(input: TypefaceInterestInput): Promise<TypefaceInterestData> {
+	const { config, range, ga4, sanity } = input
+
+	const [viewed, tested] = await Promise.all([
+		countsByItem(config, ga4, range, VIEW_EVENT),
+		countsByItem(config, ga4, range, TEST_EVENT),
+	])
+
+	let bought: Map<string, number> | null = null
+	if (sanity) {
+		try {
+			const counts = await countOrdersByTypeface(
+				sanity,
+				config.orders.documentType,
+				config.orders.typefacesField,
+				range.start,
+				range.end,
+				config.orders.excludeFilter,
+			)
+			if (counts) bought = new Map(Object.entries(counts.byTypeface))
+		} catch (e) {
+			console.error('Visitor insights: per-typeface order count failed:', (e as Error).message)
+		}
+	}
+
+	// Union of every family seen by any source, so a family that sold but was never viewed
+	// (or vice versa) still appears rather than being silently dropped.
+	const families = new Set<string>([
+		...(viewed?.keys() ?? []),
+		...(tested?.keys() ?? []),
+		...(bought?.keys() ?? []),
+	])
+
+	const metric = (counts: Map<string, number> | null, family: string, missingReason: 'not_instrumented' | 'not_applicable'): MetricValue =>
+		counts === null ? unavailable(missingReason) : ok(counts.get(family) ?? 0)
+
+	const rows: TypefaceInterestRow[] = [...families].map((family) => {
+		const viewedMetric = metric(viewed, family, 'not_instrumented')
+		const testedMetric = metric(tested, family, 'not_instrumented')
+		const boughtMetric = bought === null ? unavailable('not_applicable', 'Orders do not resolve to typefaces on this site') : ok(bought.get(family) ?? 0)
+
+		const testRate =
+			viewedMetric.status !== 'unavailable' &&
+			testedMetric.status !== 'unavailable' &&
+			viewedMetric.value > 0
+				? testedMetric.value / viewedMetric.value
+				: null
+
+		return { typeface: family, viewed: viewedMetric, tested: testedMetric, bought: boughtMetric, testRate }
+	})
+
+	// Most-viewed first, with unavailable views sorting last rather than as zero.
+	rows.sort((a, b) => {
+		const av = a.viewed.status === 'unavailable' ? -1 : a.viewed.value
+		const bv = b.viewed.status === 'unavailable' ? -1 : b.viewed.value
+		return bv - av
+	})
+
+	return { rows, interpretationNote: INTERPRETATION_NOTE, rowsWithheld: false }
+}
+
+export type { TypefaceInterestData, TypefaceInterestRow } from '../../reportData'