create-ailk 0.1.1 → 0.3.0

package/templates/apps/api/src/services/__tests__/waitlist-signups.test.ts

@@ -1,354 +0,0 @@
-/**
- * @file waitlist-signups.test.ts
- *
- * The respondent read (#4731 D2/D3/D4/D5). Mocked Prisma with a
- * where-clause-honoring in-memory Lead table (the `waitlist-dashboard.test.ts`
- * discipline) so the case-insensitive email match, the site scope, the
- * experimentKey payload filter, and newest-wins ordering are exercised by
- * what the service actually passes to the DB — not by a static return.
- * Every fence is asserted: exact seven keys; unverified → NO Lead read;
- * no lead → signup_not_found; foreign site → signup_not_found; every read
- * scoped; no other payload key leaves the row.
- */
-import { readMySignup } from "../waitlist-signups";
-
-// eslint-disable-next-line no-restricted-syntax -- jest mock factory must be hoisted
-jest.mock("../../lib/prisma.js", () => ({
-  prisma: {
-    user: { findUnique: jest.fn() },
-    lead: { findFirst: jest.fn() },
-    waitlistScore: { findFirst: jest.fn() },
-    flowSession: { findFirst: jest.fn() },
-  },
-}));
-
-import { prisma } from "../../lib/prisma.js";
-
-// ── Fixtures ─────────────────────────────────────────────────────────────────
-
-const SITE = "wksp_00000000-0000-7000-8000-000000000001";
-const OTHER_SITE = "wksp_00000000-0000-7000-8000-0000000000bb";
-const USER_ID = "user_00000000-0000-7000-8000-0000000000a1";
-const EXPERIMENT = "ailk-founder-diagnostic";
-
-const LEAD_OLD = "lead_00000000-0000-7000-8000-0000000000a1";
-const LEAD_NEW = "lead_00000000-0000-7000-8000-0000000000a2";
-const LEAD_FOREIGN = "lead_00000000-0000-7000-8000-0000000000b1";
-
-type LeadRow = {
-  id: string;
-  siteId: string;
-  email: string;
-  payload: Record<string, unknown>;
-  createdAt: Date;
-};
-
-const LEADS: LeadRow[] = [
-  {
-    id: LEAD_OLD,
-    siteId: SITE,
-    // Stored AS TYPED (mixed case) — the D3 normalization case.
-    email: "Alice@Example.com",
-    payload: {
-      experimentKey: EXPERIMENT,
-      waitlistKey: "early_bird",
-      q3: "old answer",
-      name: "Alice",
-      url: "https://alice.example",
-      email: "Alice@Example.com",
-    },
-    createdAt: new Date("2026-09-01T00:00:00.000Z"),
-  },
-  {
-    id: LEAD_NEW,
-    siteId: SITE,
-    email: "alice@example.com",
-    payload: {
-      experimentKey: EXPERIMENT,
-      waitlistKey: "general",
-      q1: "solo_builder",
-      q3: "Our site never ships.",
-      name: "Alice",
-      url: "https://alice.example",
-      email: "alice@example.com",
-      aeoScore: { status: "unavailable", reason: "crawl_failed", message: "x" },
-    },
-    createdAt: new Date("2026-09-03T00:00:00.000Z"),
-  },
-  {
-    id: LEAD_FOREIGN,
-    siteId: OTHER_SITE,
-    email: "alice@example.com",
-    payload: { experimentKey: EXPERIMENT, waitlistKey: "foreign", q3: "foreign" },
-    createdAt: new Date("2026-09-04T00:00:00.000Z"),
-  },
-];
-
-const SCORES = [
-  { leadId: LEAD_NEW, siteId: SITE, experimentKey: EXPERIMENT, tier: "hot", score: 12 },
-  { leadId: LEAD_OLD, siteId: SITE, experimentKey: EXPERIMENT, tier: "warm", score: 7 },
-  { leadId: LEAD_FOREIGN, siteId: OTHER_SITE, experimentKey: EXPERIMENT, tier: "hot", score: 99 },
-];
-
-const AEO_UNAVAILABLE = { status: "unavailable", reason: "crawl_failed", message: "This URL cannot be scored." };
-
-const SESSIONS = [
-  {
-    leadId: LEAD_NEW,
-    siteId: SITE,
-    aeoScore: AEO_UNAVAILABLE,
-    completedAt: new Date("2026-09-03T00:00:05.000Z"),
-  },
-  { leadId: LEAD_OLD, siteId: SITE, aeoScore: null, completedAt: new Date("2026-09-01T00:00:05.000Z") },
-];
-
-// ── A where-clause-honoring in-memory matcher ────────────────────────────────
-
-type Where = Record<string, unknown>;
-
-function matchesLead(row: LeadRow, where: Where): boolean {
-  for (const [key, cond] of Object.entries(where)) {
-    if (key === "email") {
-      const c = cond as { equals: string; mode?: string };
-      const stored = c.mode === "insensitive" ? row.email.toLowerCase() : row.email;
-      const wanted = c.mode === "insensitive" ? c.equals.toLowerCase() : c.equals;
-      if (stored !== wanted) return false;
-      continue;
-    }
-    if (key === "payload") {
-      const { path, equals } = cond as { path: string[]; equals: unknown };
-      if (row.payload[path[0] as string] !== equals) return false;
-      continue;
-    }
-    if ((row as Record<string, unknown>)[key] !== cond) return false;
-  }
-  return true;
-}
-
-function matchesScalar(row: Record<string, unknown>, where: Where): boolean {
-  for (const [key, cond] of Object.entries(where)) {
-    if (cond !== null && typeof cond === "object" && "not" in (cond as object)) {
-      if (row[key] === (cond as { not: unknown }).not) return false;
-      continue;
-    }
-    if (row[key] !== cond) return false;
-  }
-  return true;
-}
-
-function installFixtureMocks(): void {
-  (prisma.lead.findFirst as jest.Mock).mockImplementation(
-    ({ where, orderBy }: { where: Where; orderBy?: { createdAt: "asc" | "desc" } }) => {
-      const rows = LEADS.filter((r) => matchesLead(r, where));
-      if (orderBy?.createdAt === "desc") rows.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-      else rows.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      const hit = rows[0];
-      return Promise.resolve(hit ? { id: hit.id, payload: hit.payload, createdAt: hit.createdAt } : null);
-    },
-  );
-  (prisma.waitlistScore.findFirst as jest.Mock).mockImplementation(({ where }: { where: Where }) => {
-    const hit = SCORES.find((r) => matchesScalar(r, where));
-    return Promise.resolve(hit ? { tier: hit.tier, score: hit.score } : null);
-  });
-  (prisma.flowSession.findFirst as jest.Mock).mockImplementation(({ where }: { where: Where }) => {
-    const hit = SESSIONS.find((r) => matchesScalar(r, where));
-    return Promise.resolve(hit ? { aeoScore: hit.aeoScore, completedAt: hit.completedAt } : null);
-  });
-}
-
-function user(overrides?: Partial<{ email: string; emailVerified: boolean }>) {
-  return {
-    id: USER_ID,
-    email: overrides?.email ?? "alice@example.com",
-    emailVerified: overrides?.emailVerified ?? true,
-  };
-}
-
-beforeEach(() => {
-  jest.clearAllMocks();
-  process.env.AILK_SITE_ID = SITE;
-  installFixtureMocks();
-});
-
-afterAll(() => {
-  delete process.env.AILK_SITE_ID;
-});
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-describe("readMySignup — the verified, found path (D5)", () => {
-  it("returns EXACTLY the seven contract keys and only q3 under answers", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) throw new Error("unreachable");
-    expect(Object.keys(result.value).sort()).toEqual(
-      ["answers", "aeoScore", "completedAt", "experimentKey", "score", "tier", "waitlistKey"].sort(),
-    );
-    expect(Object.keys(result.value.answers)).toEqual(["q3"]);
-    expect(result.value).toEqual({
-      experimentKey: EXPERIMENT,
-      waitlistKey: "general",
-      completedAt: "2026-09-03T00:00:05.000Z",
-      tier: "hot",
-      score: 12,
-      aeoScore: AEO_UNAVAILABLE,
-      answers: { q3: "Our site never ships." },
-    });
-    // Nothing else from the payload leaves the row.
-    const serialized = JSON.stringify(result.value);
-    for (const leaked of ["name", "url", "q1", "solo_builder", "alice.example", "@example.com"]) {
-      expect(serialized).not.toContain(leaked);
-    }
-  });
-
-  it("reads the User exactly as lead-promotion.ts does (id, email, emailVerified by id)", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-
-    await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(prisma.user.findUnique).toHaveBeenCalledWith({
-      where: { id: USER_ID },
-      select: { id: true, email: true, emailVerified: true },
-    });
-  });
-
-  it("newest createdAt wins when two leads match (AC-5)", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(result.ok && result.value.waitlistKey).toBe("general"); // LEAD_NEW, not LEAD_OLD
-    expect(prisma.lead.findFirst).toHaveBeenCalledWith(
-      expect.objectContaining({ orderBy: { createdAt: "desc" } }),
-    );
-  });
-
-  it("matches a mixed-case stored Lead.email case-insensitively on the trimmed user email (D3)", async () => {
-    // Only the OLD lead carries the mixed-case stored email; pick it by
-    // restricting the fixture to that row.
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user({ email: "  ALICE@example.COM " }));
-    (prisma.lead.findFirst as jest.Mock).mockImplementation(({ where }: { where: Where }) => {
-      const hit = LEADS.filter((r) => r.id === LEAD_OLD).find((r) => matchesLead(r, where));
-      return Promise.resolve(hit ? { id: hit.id, payload: hit.payload, createdAt: hit.createdAt } : null);
-    });
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(result.ok && result.value.waitlistKey).toBe("early_bird");
-    const call = (prisma.lead.findFirst as jest.Mock).mock.calls[0][0] as { where: Where };
-    expect(call.where.email).toEqual({ equals: "alice@example.com", mode: "insensitive" });
-  });
-
-  it("scopes EVERY read to currentSiteId() and filters the Lead by payload.experimentKey (AC-7)", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-
-    await readMySignup(USER_ID, EXPERIMENT);
-
-    const leadWhere = (prisma.lead.findFirst as jest.Mock).mock.calls[0][0].where as Where;
-    expect(leadWhere.siteId).toBe(SITE);
-    expect(leadWhere.payload).toEqual({ path: ["experimentKey"], equals: EXPERIMENT });
-    const scoreWhere = (prisma.waitlistScore.findFirst as jest.Mock).mock.calls[0][0].where as Where;
-    expect(scoreWhere).toEqual({ leadId: LEAD_NEW, siteId: SITE, experimentKey: EXPERIMENT });
-    const sessionWhere = (prisma.flowSession.findFirst as jest.Mock).mock.calls[0][0].where as Where;
-    expect(sessionWhere).toEqual({ leadId: LEAD_NEW, siteId: SITE, completedAt: { not: null } });
-  });
-
-  it("a lead that exists only at another site is signup_not_found (never cross-site)", async () => {
-    process.env.AILK_SITE_ID = "wksp_00000000-0000-7000-8000-0000000000cc";
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(result).toEqual({
-      ok: false,
-      error: { kind: "signup_not_found", message: "Signup not found" },
-    });
-  });
-
-  it("returns null tier/score when the fail-soft score row is absent, and null aeoScore when unparsable", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-    (prisma.waitlistScore.findFirst as jest.Mock).mockResolvedValue(null);
-    (prisma.flowSession.findFirst as jest.Mock).mockResolvedValue({
-      aeoScore: { status: "bogus" },
-      completedAt: new Date("2026-09-03T00:00:05.000Z"),
-    });
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(result.ok && result.value.tier).toBeNull();
-    expect(result.ok && result.value.score).toBeNull();
-    expect(result.ok && result.value.aeoScore).toBeNull();
-  });
-
-  it("falls back to Lead.createdAt for completedAt when no completing session exists, and q3 null when absent", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-    (prisma.flowSession.findFirst as jest.Mock).mockResolvedValue(null);
-    (prisma.lead.findFirst as jest.Mock).mockResolvedValue({
-      id: LEAD_NEW,
-      payload: { experimentKey: EXPERIMENT, waitlistKey: "general", q3: 42 },
-      createdAt: new Date("2026-09-03T00:00:00.000Z"),
-    });
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(result.ok && result.value.completedAt).toBe("2026-09-03T00:00:00.000Z");
-    expect(result.ok && result.value.answers.q3).toBeNull();
-  });
-});
-
-describe("readMySignup — the refusals (D2/D4)", () => {
-  it("email_unverified: refuses BEFORE any Lead read (AC-3)", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user({ emailVerified: false }));
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(result.ok).toBe(false);
-    expect(!result.ok && result.error.kind).toBe("email_unverified");
-    expect(prisma.lead.findFirst).not.toHaveBeenCalled();
-    expect(prisma.waitlistScore.findFirst).not.toHaveBeenCalled();
-    expect(prisma.flowSession.findFirst).not.toHaveBeenCalled();
-  });
-
-  it("not_found_user: no User row → no Lead read", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(null);
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(!result.ok && result.error.kind).toBe("not_found_user");
-    expect(prisma.lead.findFirst).not.toHaveBeenCalled();
-  });
-
-  it("signup_not_found: a different email owns the leads (AC-4)", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user({ email: "bob@example.com" }));
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(!result.ok && result.error.kind).toBe("signup_not_found");
-    expect(prisma.waitlistScore.findFirst).not.toHaveBeenCalled();
-  });
-
-  it("signup_not_found: no lead for this experimentKey (AC-4)", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-
-    const result = await readMySignup(USER_ID, "some-other-experiment");
-
-    expect(!result.ok && result.error.kind).toBe("signup_not_found");
-  });
-
-  it("signup_not_found: a corrupt lead missing waitlistKey is not-found, never an out-of-contract value", async () => {
-    (prisma.user.findUnique as jest.Mock).mockResolvedValue(user());
-    (prisma.lead.findFirst as jest.Mock).mockResolvedValue({
-      id: LEAD_NEW,
-      payload: { experimentKey: EXPERIMENT, q3: "x" },
-      createdAt: new Date("2026-09-03T00:00:00.000Z"),
-    });
-
-    const result = await readMySignup(USER_ID, EXPERIMENT);
-
-    expect(!result.ok && result.error.kind).toBe("signup_not_found");
-    expect(prisma.waitlistScore.findFirst).not.toHaveBeenCalled();
-  });
-});

package/templates/apps/api/src/services/flow-aggregate.ts

@@ -1,232 +0,0 @@
-/**
- * @file flow-aggregate.ts
- * @description The anonymous aggregate-response service (#4771 D1/D2/D3).
- *
- * Read-only (no write verb is reachable from this module — the same
- * `prisma\.[a-zA-Z]+\.(create|update|upsert|delete|deleteMany|updateMany|createMany)`
- * probe `waitlist-dashboard.ts` asserts of itself returns 0 here too).
- *
- * Three scoped reads, each carrying `siteId`:
- *   1. `flowDefinition.findUnique` — existence only, mirroring `serveFlow`'s
- *      own lookup (`flow-engine.ts`). A slug with no `FlowDefinition` is
- *      `flow_not_found` (FR6).
- *   2. `waitlistExperiment.findMany` — resolves the slug to its backing
- *      register (D2), for question metadata + the `resultsReveal` flag. A
- *      flow with no backing register is legal (D2) — the response then
- *      carries an empty `questions[]`.
- *   3. `flowSession.findMany` — the respondent set: **completed** sessions
- *      for `(siteId, flowSlug)`, `completedAt` non-null, regardless of
- *      whether a `Lead` was ever created (D1 — a recommending-mode
- *      respondent has no Lead until the email moment, which the reveal is
- *      shown before).
- *
- * Per-question bucketing is the shared `computeAnswerDistributions`
- * (`./answer-distributions.js`, D4) — the same module `waitlist-dashboard.ts`
- * imports, fed `sessions.map((s) => flattenSessionState(s.state))` rather
- * than `leads.map((l) => l.payload)`.
- */
-import type { Prisma } from "@working-theory/database";
-import { logger } from "@working-theory/observability";
-import {
-  waitlistExperimentConfigSchema,
-  type FlowAggregate,
-  type FlowAggregateAnswerType,
-  type WaitlistExperimentConfig,
-} from "@working-theory/validation";
-
-import { prisma } from "../lib/prisma.js";
-
-import {
-  computeAnswerDistributions,
-  logAggregationCapHit,
-  MAX_AGGREGATION_ROWS,
-} from "./answer-distributions.js";
-import type { FlowEngineError } from "./flow-engine.js";
-
-export type GetFlowAggregateResult =
-  { ok: true; data: FlowAggregate } | { ok: false; error: FlowEngineError };
-
-// ─── DB-required guard ──────────────────────────────────────────────────────
-// Mirrors flow-engine.ts's own private `requireDb` (#3956 D5) — not exported
-// there, so re-declared here rather than widening that module's surface for
-// one boolean check (the same engine-local-helper convention `flow-engine.ts`
-// already documents for `flattenFlowState`, below).
-
-const FLOWS_NOT_CONFIGURED_ERROR: FlowEngineError = {
-  kind: "flows_not_configured",
-  message: "Flows are not configured.",
-};
-
-function requireDb(): FlowEngineError | null {
-  if (!process.env.DATABASE_URL) return FLOWS_NOT_CONFIGURED_ERROR;
-  return null;
-}
-
-// ─── flattenSessionState ────────────────────────────────────────────────────
-// Mirrors flow-engine.ts's private `flattenFlowState` (:682-689) — collapses
-// FlowSession.state's step-keyed two-level shape (`{ [stepKey]: { [field]:
-// value } }`) into the flat `{ [field]: value }` map `readPayloadAnswer`
-// expects. Not imported: `flattenFlowState` is engine-local and unexported,
-// the exact "mirrors ... engine-local, since that one isn't exported"
-// convention flow-engine.ts's own doc comment already states for its
-// sibling helper. Behaviour is byte-identical to the mirrored function.
-
-function flattenSessionState(state: unknown): Record<string, unknown> {
-  const flat: Record<string, unknown> = {};
-  if (!state || typeof state !== "object") return flat;
-  for (const stepKey of Object.keys(state as Record<string, unknown>)) {
-    const stepData = (state as Record<string, unknown>)[stepKey];
-    if (stepData && typeof stepData === "object") Object.assign(flat, stepData);
-  }
-  return flat;
-}
-
-// ─── Row shapes ──────────────────────────────────────────────────────────────
-
-const FLOW_DEFINITION_EXISTS_SELECT = {
-  id: true,
-} as const satisfies Prisma.FlowDefinitionSelect;
-
-const EXPERIMENT_CONFIG_SELECT = {
-  id: true,
-  config: true,
-} as const satisfies Prisma.WaitlistExperimentSelect;
-type ExperimentConfigRow = Omit<
-  Prisma.WaitlistExperimentGetPayload<{
-    select: typeof EXPERIMENT_CONFIG_SELECT;
-  }>,
-  "config"
-> & { config: unknown };
-
-const FLOW_SESSION_STATE_SELECT = {
-  state: true,
-} as const satisfies Prisma.FlowSessionSelect;
-type FlowSessionStateRow = Omit<
-  Prisma.FlowSessionGetPayload<{ select: typeof FLOW_SESSION_STATE_SELECT }>,
-  "state"
-> & { state: unknown };
-
-// ─── getFlowAggregate ────────────────────────────────────────────────────────
-
-export async function getFlowAggregate(
-  siteId: string,
-  slug: string,
-): Promise<GetFlowAggregateResult> {
-  const dbError = requireDb();
-  if (dbError) return { ok: false, error: dbError };
-
-  // Existence check only — mirrors serveFlow's own FlowDefinition lookup
-  // (flow-engine.ts), so "unknown slug" resolves identically for both
-  // routes (FR6).
-  const definition = await prisma.flowDefinition.findUnique({
-    where: { siteId_slug: { siteId, slug } },
-    select: FLOW_DEFINITION_EXISTS_SELECT,
-  });
-  if (!definition) {
-    return {
-      ok: false,
-      error: { kind: "flow_not_found", message: "Flow not found." },
-    };
-  }
-
-  // D2 — question metadata + the resultsReveal flag come from the register,
-  // not the compiled flow. A flow with no backing register is legal (D2) —
-  // `matches` is then empty and `flaggedQuestions` stays [].
-  const experiments: ExperimentConfigRow[] =
-    await prisma.waitlistExperiment.findMany({
-      where: { siteId },
-      select: EXPERIMENT_CONFIG_SELECT,
-      // Deterministic read order (code-review finding, #4771) — without an
-      // explicit orderBy, Postgres does not guarantee row order, which
-      // would make the matches.length > 1 fallback below pick a genuinely
-      // arbitrary row rather than a defined "oldest wins" policy.
-      orderBy: { createdAt: "asc" },
-      // Bounds this anonymous read the same way the sibling
-      // flowSession.findMany read below is bounded (#5109).
-      take: MAX_AGGREGATION_ROWS,
-    });
-
-  const matches: WaitlistExperimentConfig[] = [];
-  for (const row of experiments) {
-    const parsed = waitlistExperimentConfigSchema.safeParse(row.config);
-    if (!parsed.success) {
-      // A corrupted register row must not abort an anonymous read — the
-      // same "skip, don't throw" posture waitlist-dashboard.ts's
-      // `listExperiments` applies to a corrupt config under kind:"all".
-      logger.warn(
-        { siteId, experimentId: row.id },
-        "[flow-aggregate] experiment config failed to parse — skipped",
-      );
-      continue;
-    }
-    if (parsed.data.waitlists.some((w) => w.flowSlug === slug)) {
-      matches.push(parsed.data);
-    }
-  }
-  if (matches.length > 1) {
-    // Spec §5.3 escalation boundary — a duplicate flowSlug across
-    // experiments for one site is a register-integrity question this
-    // service does not resolve arbitrarily. Logged rather than thrown so
-    // the anonymous read still degrades (first match, by the oldest
-    // `createdAt` per the orderBy above) instead of 500ing a public
-    // endpoint.
-    logger.warn(
-      { siteId, slug, matchCount: matches.length },
-      "[flow-aggregate] slug resolves to more than one WaitlistExperiment — using the first",
-    );
-  }
-  const config = matches[0];
-  const flaggedQuestions = (config?.questionSet.questions ?? []).filter(
-    (q) => q.resultsReveal === true,
-  );
-
-  // D1 — respondents are completed FlowSession rows, not Leads.
-  const sessions: FlowSessionStateRow[] = await prisma.flowSession.findMany({
-    where: { siteId, flowSlug: slug, completedAt: { not: null } },
-    select: FLOW_SESSION_STATE_SELECT,
-    // Deterministic read order (code-review finding, #4771) — earliest
-    // completions first, so a flow that exceeds MAX_AGGREGATION_ROWS drops
-    // its most recent respondents consistently rather than an arbitrary set.
-    orderBy: { completedAt: "asc" },
-    take: MAX_AGGREGATION_ROWS,
-  });
-  logAggregationCapHit(`flow-aggregate.${slug}`, sessions.length);
-
-  const answerSets = sessions.map((session) =>
-    flattenSessionState(session.state),
-  );
-  const distributions = computeAnswerDistributions(
-    flaggedQuestions,
-    answerSets,
-  );
-
-  const questions: FlowAggregate["questions"] = distributions.map((d, i) => {
-    const question = flaggedQuestions[i]!;
-    const labelsByValue = new Map(
-      (question.options ?? []).map((o) => [o.value, o.label]),
-    );
-    return {
-      id: d.questionId,
-      // Safe: flaggedQuestions is filtered to resultsReveal === true, and
-      // waitlist.ts's own superRefine only permits that flag on single/multi
-      // questions (D3) — no other answerType is reachable here.
-      answerType: d.answerType as FlowAggregateAnswerType,
-      answered: d.answered,
-      // Declared options only — an off-register "(other)" bucket has no
-      // register label to ship, and this schema's `label` is required
-      // (never fabricated). Still counted in `answered` above.
-      options: d.options
-        .filter((o) => labelsByValue.has(o.value))
-        .map((o) => ({
-          value: o.value,
-          label: labelsByValue.get(o.value)!,
-          count: o.count,
-        })),
-    };
-  });
-
-  return {
-    ok: true,
-    data: { slug, respondents: sessions.length, questions },
-  };
-}