@bash-app/bash-common 30.433.0 → 30.434.0

package/src/intros/__tests__/introsReleaseGates.test.ts

@@ -0,0 +1,181 @@
+import { isIntrosAdult } from "../age.js";
+import {
+  attributeMayBeUsedInExperiments,
+  validateAttributeValue,
+} from "../attributeCatalog.js";
+import { attendanceCopy, visibleAttendanceTier } from "../attendance.js";
+import { intentsComplement } from "../intents.js";
+import { applyIntroductionAction, type TransitionIntro } from "../transitions.js";
+import { parseProfilePatch, warmInviteNamesOtherPerson } from "../validation.js";
+
+const mystery = (overrides: Partial<TransitionIntro> = {}): TransitionIntro => ({
+  source: "BashSuggested",
+  mode: "Mystery",
+  state: "Open",
+  closedReason: null,
+  interestLow: "Pending",
+  interestHigh: "Pending",
+  ...overrides,
+});
+
+describe("Intros release gates", () => {
+  describe("SEC-02 / REV-02 / REV-04 mutual consent", () => {
+    it("does not reveal after only one person is interested", () => {
+      const result = applyIntroductionAction(mystery(), "low", "interested");
+      expect(result.ok && result.state).toBe("Open");
+      expect(result.ok && result.revealNow).toBe(false);
+      expect(result.ok && result.interestHigh).toBe("Pending");
+    });
+
+    it("schedules a reveal only after both are interested, without revealing immediately", () => {
+      const result = applyIntroductionAction(
+        mystery({ interestLow: "Interested" }),
+        "high",
+        "interested"
+      );
+      expect(result.ok && result.state).toBe("Mutual");
+      expect(result.ok && result.revealNow).toBe(false);
+    });
+  });
+
+  describe("SEC-03 / REV-06 withdrawal", () => {
+    it("closes a mutual intro when either person withdraws before reveal", () => {
+      const result = applyIntroductionAction(
+        mystery({
+          state: "Mutual",
+          interestLow: "Interested",
+          interestHigh: "Interested",
+        }),
+        "high",
+        "withdraw"
+      );
+      expect(result.ok && result.closedReason).toBe("Withdrawn");
+      expect(result.ok && result.revealNow).toBe(false);
+    });
+  });
+
+  describe("SEC-08 / MAT romance isolation", () => {
+    it("matches romance only when both selected romance", () => {
+      expect(intentsComplement(["Romance"], ["Friends"])).toBeNull();
+      expect(intentsComplement(["Romance", "Friends"], ["Friends"])).toBe("Friends");
+      expect(intentsComplement(["Romance"], ["Romance"])).toBe("Romance");
+    });
+
+    it("matches mentorship as complementary roles", () => {
+      expect(intentsComplement(["MentorSeek"], ["MentorOffer"])).toBe("MentorSeek");
+      expect(intentsComplement(["MentorSeek"], ["MentorSeek"])).toBeNull();
+    });
+
+    it("does not match people with no shared intention", () => {
+      expect(intentsComplement(["Friends"], ["Professional"])).toBeNull();
+    });
+  });
+
+  describe("SEC-09 minors", () => {
+    const now = new Date("2026-10-15T12:00:00Z");
+
+    it("rejects a missing birthday and anyone under 18", () => {
+      expect(isIntrosAdult(null, now)).toBe(false);
+      expect(isIntrosAdult(new Date("2010-01-01T00:00:00Z"), now)).toBe(false);
+      expect(isIntrosAdult(new Date("2008-10-16T00:00:00Z"), now)).toBe(false);
+    });
+
+    it("accepts someone who turned 18", () => {
+      expect(isIntrosAdult(new Date("2008-10-15T00:00:00Z"), now)).toBe(true);
+    });
+  });
+
+  describe("SEC-11 warm invite names", () => {
+    it("names the other person only when both recipients chose named intros", () => {
+      expect(warmInviteNamesOtherPerson("Named", "Named")).toBe(true);
+      expect(warmInviteNamesOtherPerson("Named", "Anonymous")).toBe(false);
+      expect(warmInviteNamesOtherPerson(null, null)).toBe(false);
+    });
+  });
+
+  describe("SEC-07 / ONB-08 private attributes", () => {
+    it("refuses experimental matching for Human Design", () => {
+      expect(attributeMayBeUsedInExperiments("HumanDesign")).toBe(false);
+      const parsed = parseProfilePatch({
+        attributes: {
+          HumanDesign: {
+            value: "Generator",
+            visibility: "OnlyMe",
+            allowExperimentalMatching: true,
+          },
+        },
+      });
+      expect(parsed.ok).toBe(false);
+    });
+
+    it("keeps a private Myers-Briggs value valid without using it as a score", () => {
+      const value = validateAttributeValue("MyersBriggs", "enfp");
+      expect(value.ok && value.value).toBe("ENFP");
+    });
+
+    it("accepts a null unknown attribute as a removal and rejects a value for it", () => {
+      const removed = parseProfilePatch({ attributes: { Enneagram: null } });
+      expect(removed.ok && removed.value.discardAttributes).toEqual(["Enneagram"]);
+      const invented = parseProfilePatch({
+        attributes: { Enneagram: { value: "Type 4", visibility: "OnlyMe", allowExperimentalMatching: true } },
+      });
+      expect(invented.ok).toBe(false);
+    });
+  });
+
+  describe("REV-14 attendance wording", () => {
+    it("never says someone is checked in unless they allowed that disclosure", () => {
+      expect(attendanceCopy("CheckedIn", false)).toBe(
+        "Could be a good night to meet someone new."
+      );
+      expect(visibleAttendanceTier({
+        checkedIn: true,
+        registered: true,
+        shareRegistration: false,
+      })).toBe("Recommended");
+      expect(attendanceCopy("CheckedIn", true)).toBe("Checked in.");
+    });
+  });
+
+  describe("ONB-05 romance ages", () => {
+    it("rejects a romance age range that includes minors", () => {
+      const parsed = parseProfilePatch({
+        romance: { seekingGenders: ["everyone"], ageMin: 16, ageMax: 30 },
+      });
+      expect(parsed.ok).toBe(false);
+    });
+  });
+
+  describe("WRM-05 warm mutual accept", () => {
+    it("reveals a warm intro only after the second person accepts", () => {
+      const first = applyIntroductionAction(
+        mystery({ source: "Warm" }),
+        "low",
+        "sounds_good"
+      );
+      expect(first.ok && first.revealNow).toBe(false);
+      if (!first.ok) return;
+      const second = applyIntroductionAction(
+        mystery({
+          source: "Warm",
+          interestLow: first.interestLow,
+          interestHigh: first.interestHigh,
+        }),
+        "high",
+        "sounds_good"
+      );
+      expect(second.ok && second.state).toBe("Revealed");
+      expect(second.ok && second.revealNow).toBe(true);
+    });
+
+    it("does not reveal when one person declines", () => {
+      const result = applyIntroductionAction(
+        mystery({ source: "Warm", interestLow: "Interested" }),
+        "high",
+        "decline"
+      );
+      expect(result.ok && result.state).toBe("Closed");
+      expect(result.ok && result.closedReason).toBe("Declined");
+    });
+  });
+});

package/src/intros/__tests__/psychExperiment.test.ts

@@ -0,0 +1,99 @@
+import { introHint } from "../reasons.js";
+import {
+  appendPsychExperiment,
+  experimentContribution,
+  psychExperimentCode,
+  rankWithExperiment,
+} from "../psychExperiment.js";
+
+const closeEnergy = {
+  kind: "BigFive",
+  allowExperimentalMatching: true,
+  value: { extraversion: 80, openness: 10, conscientiousness: 10, agreeableness: 10, neuroticism: 10 },
+};
+
+describe("experimental psychology matching", () => {
+  it("adds no signal without both people's experiment consent", () => {
+    const other = { experimentConsent: true, attributes: [closeEnergy] };
+    expect(
+      experimentContribution({ experimentConsent: false, attributes: [closeEnergy] }, other)
+    ).toEqual({ codes: [], rankBoost: 0 });
+    expect(psychExperimentCode({ experimentConsent: false, attributes: [closeEnergy] }, other)).toBeNull();
+  });
+
+  it("ignores an attribute the person did not allow, including Human Design", () => {
+    const design = {
+      kind: "HumanDesign",
+      allowExperimentalMatching: true,
+      value: "Generator",
+    };
+    const withheld = { ...closeEnergy, allowExperimentalMatching: false };
+    expect(
+      experimentContribution(
+        { experimentConsent: true, attributes: [design, withheld] },
+        { experimentConsent: true, attributes: [design, closeEnergy] }
+      ).rankBoost
+    ).toBe(0);
+  });
+
+  it("reorders on a consented social-energy note and does not expose the score", () => {
+    const contribution = experimentContribution(
+      { experimentConsent: true, attributes: [closeEnergy] },
+      {
+        experimentConsent: true,
+        attributes: [{ ...closeEnergy, value: { ...closeEnergy.value, extraversion: 70 } }],
+      }
+    );
+    expect(contribution.rankBoost).toBe(1);
+    expect(contribution.codes).toContain("PSYCH_SIGNAL:similar_social_energy");
+    const codes = appendPsychExperiment(["INTENT:Friends"], 
+      { experimentConsent: true, attributes: [closeEnergy] },
+      { experimentConsent: true, attributes: [closeEnergy] },
+      true
+    );
+    expect(introHint(codes)).toMatch(/social energy/i);
+    expect(introHint(codes)).toMatch(/not a compatibility score/i);
+    expect(JSON.stringify(codes)).not.toMatch(/80|ENFP|Generator|Achiever/);
+  });
+
+  it("leaves baseline order and codes unchanged when the experiment flag is off", () => {
+    const people = ["first", "second"];
+    const ranker = jest.fn(() => ({ codes: ["PSYCH_SHARED"], rankBoost: 2 }));
+    expect(rankWithExperiment(people, ranker, false).map((row) => row.item)).toEqual(people);
+    expect(ranker).not.toHaveBeenCalled();
+    expect(
+      appendPsychExperiment(
+        ["INTENT:Friends"],
+        { experimentConsent: true, attributes: [closeEnergy] },
+        { experimentConsent: true, attributes: [closeEnergy] },
+        false
+      )
+    ).toEqual(["INTENT:Friends"]);
+  });
+
+  it("puts the stronger consented overlap ahead without replacing the baseline reason", () => {
+    const ranked = rankWithExperiment(
+      [
+        { id: "plain", boost: 0 },
+        { id: "closer", boost: 2 },
+      ],
+      (item) => ({ codes: item.boost ? ["PSYCH_SHARED"] : [], rankBoost: item.boost }),
+      true
+    );
+    expect(ranked.map((row) => row.item.id)).toEqual(["closer", "plain"]);
+    expect(ranked[1]?.contribution.codes).toEqual([]);
+  });
+
+  it("caps the reorder boost at 2", () => {
+    const shared = {
+      experimentConsent: true,
+      attributes: [
+        closeEnergy,
+        { kind: "LocusOfControl", allowExperimentalMatching: true, value: "internal" },
+        { kind: "CliftonStrengths", allowExperimentalMatching: true, value: ["Learner"] },
+        { kind: "MyersBriggs", allowExperimentalMatching: true, value: "ENFP" },
+      ],
+    };
+    expect(experimentContribution(shared, shared).rankBoost).toBe(2);
+  });
+});

package/src/intros/__tests__/reasons.test.ts

@@ -0,0 +1,122 @@
+import {
+  eventScopedReason,
+  introHint,
+  pairMatchReason,
+  rankEventForPair,
+  eventReasonSpecificity,
+  romancePairFits,
+  type RomanceFit,
+} from "../reasons.js";
+
+describe("matching reasons", () => {
+  it("does not globally match two people who only both want friends", () => {
+    expect(
+      pairMatchReason(
+        { intents: ["Friends"], topics: ["jazz"], work: [] },
+        { intents: ["Friends"], topics: ["photography"], work: [] }
+      )
+    ).toBeNull();
+  });
+
+  it("matches friends who share a topic and explains it without a name", () => {
+    const reason = pairMatchReason(
+      { intents: ["Friends"], topics: ["photography"], work: [] },
+      { intents: ["Friends"], topics: ["Photography"], work: [] }
+    );
+    expect(reason?.intent).toBe("Friends");
+    expect(introHint(reason?.codes ?? [])).toMatch(/photography/i);
+    expect(introHint(reason?.codes ?? [])).not.toMatch(/Alex|Jordan/);
+  });
+
+  it("matches a mentor with someone looking for one", () => {
+    expect(
+      pairMatchReason(
+        { intents: ["MentorSeek"], topics: [], work: [] },
+        { intents: ["MentorOffer"], topics: [], work: [] }
+      )?.intent
+    ).toBe("MentorSeek");
+  });
+
+  it("allows romance only at an event that permits it", () => {
+    const people = {
+      a: { intents: ["Romance"], topics: [], work: [] },
+      b: { intents: ["Romance"], topics: [], work: [] },
+    };
+    expect(eventScopedReason(people.a, people.b, false)).toBeNull();
+    expect(eventScopedReason(people.a, people.b, true)?.intent).toBe("Romance");
+  });
+
+  it("rejects a romance pair that misses an age or gender limit and accepts an empty seeking list", () => {
+    const older: RomanceFit = {
+      consented: true,
+      dob: new Date("1980-01-01T00:00:00Z"),
+      gender: "Female",
+      seekingGenders: ["Male"],
+      ageMin: 30,
+      ageMax: 45,
+    };
+    const youngerMale: RomanceFit = {
+      consented: true,
+      dob: new Date("2000-06-01T00:00:00Z"),
+      gender: "Male",
+      seekingGenders: [],
+      ageMin: null,
+      ageMax: null,
+    };
+    const fittingMale: RomanceFit = {
+      ...youngerMale,
+      dob: new Date("1990-06-01T00:00:00Z"),
+    };
+    const now = new Date("2026-10-20T00:00:00Z");
+    const profiles = {
+      a: { intents: ["Romance"], topics: [], work: [] },
+      b: { intents: ["Romance"], topics: [], work: [] },
+    };
+    expect(romancePairFits(older, youngerMale, now)).toBe(false);
+    expect(romancePairFits(older, fittingMale, now)).toBe(true);
+    expect(romancePairFits(older, { ...fittingMale, gender: "Female" }, now)).toBe(false);
+    expect(eventScopedReason(profiles.a, profiles.b, true, { a: older, b: youngerMale }, now)).toBeNull();
+    expect(pairMatchReason(profiles.a, profiles.b, { a: older, b: fittingMale }, now)?.intent).toBe("Romance");
+    expect(
+      eventScopedReason(profiles.a, profiles.b, true, { a: older, b: { ...fittingMale, gender: "Female" } }, now)
+    ).toBeNull();
+    expect(
+      eventScopedReason(
+        profiles.a,
+        profiles.b,
+        true,
+        { a: { ...older, seekingGenders: [] }, b: { ...fittingMale, seekingGenders: [] } },
+        now
+      )?.intent
+    ).toBe("Romance");
+  });
+
+  it("still matches two people who only both want friends at an event, behind a shared interest", () => {
+    const broad = eventScopedReason(
+      { intents: ["Friends"], topics: ["jazz"], work: [] },
+      { intents: ["Friends"], topics: ["photography"], work: [] },
+      false
+    );
+    const specific = eventScopedReason(
+      { intents: ["Friends"], topics: ["photography"], work: [] },
+      { intents: ["Friends"], topics: ["Photography"], work: [] },
+      false
+    );
+    expect(broad?.intent).toBe("Friends");
+    expect(specific && eventReasonSpecificity(specific)).toBeGreaterThan(broad ? eventReasonSpecificity(broad) : 0);
+    expect(
+      eventReasonSpecificity({ intent: "MentorSeek", codes: ["INTENT:MentorSeek"] })
+    ).toBeGreaterThan(specific ? eventReasonSpecificity(specific) : 0);
+  });
+
+  it("prefers a bash whose type matches a shared interest", () => {
+    const id = rankEventForPair(
+      [
+        { id: "concert", eventType: "Music", city: "Salt Lake City" },
+        { id: "mixer", eventType: "photography workshop", city: "Provo" },
+      ],
+      ["SHARED_TOPIC:photography"]
+    );
+    expect(id).toBe("mixer");
+  });
+});

package/src/intros/__tests__/sharedNotes.test.ts

@@ -0,0 +1,20 @@
+import { describeSharedNote } from "../sharedNotes.js";
+
+describe("notes visible after reveal", () => {
+  it("describes an allowed note without turning it into a score", () => {
+    const note = describeSharedNote("BigFive", {
+      openness: 10,
+      conscientiousness: 20,
+      extraversion: 80,
+      agreeableness: 40,
+      neuroticism: 50,
+    });
+    expect(note?.tier).toBe("Research-backed construct");
+    expect(note?.text).toMatch(/Extraversion 80/);
+    expect(JSON.stringify(note)).not.toMatch(/compatibility/);
+  });
+
+  it("ignores a kind this catalog does not support", () => {
+    expect(describeSharedNote("Enneagram", "4")).toBeNull();
+  });
+});

package/src/intros/__tests__/transitions.test.ts

@@ -0,0 +1,61 @@
+import { applyIntroductionAction } from "../transitions.js";
+
+const openMystery = {
+  source: "BashSuggested" as const,
+  mode: "Mystery" as const,
+  state: "Open" as const,
+  closedReason: null,
+  interestLow: "Pending",
+  interestHigh: "Pending",
+};
+
+describe("introduction transitions", () => {
+  it("treats mutual interest as the reveal consent without revealing yet", () => {
+    const one = applyIntroductionAction(openMystery, "low", "interested");
+    expect(one.ok && one.state).toBe("Open");
+    if (!one.ok) return;
+    const both = applyIntroductionAction(
+      { ...openMystery, interestLow: one.interestLow, interestHigh: one.interestHigh },
+      "high",
+      "interested"
+    );
+    expect(both.ok && both.state).toBe("Mutual");
+    expect(both.ok && both.revealNow).toBe(false);
+  });
+
+  it("reveals a warm intro only when both accept", () => {
+    const one = applyIntroductionAction(
+      { ...openMystery, source: "Warm" },
+      "low",
+      "sounds_good"
+    );
+    expect(one.ok && one.state).toBe("Open");
+    if (!one.ok) return;
+    const both = applyIntroductionAction(
+      {
+        ...openMystery,
+        source: "Warm",
+        interestLow: one.interestLow,
+        interestHigh: one.interestHigh,
+      },
+      "high",
+      "sounds_good"
+    );
+    expect(both.ok && both.revealNow).toBe(true);
+  });
+
+  it("lets a withdrawal close an intro before reveal", () => {
+    const result = applyIntroductionAction(
+      { ...openMystery, state: "Mutual", interestLow: "Interested", interestHigh: "Interested" },
+      "low",
+      "withdraw"
+    );
+    expect(result.ok && result.state).toBe("Closed");
+    expect(result.ok && result.closedReason).toBe("Withdrawn");
+  });
+
+  it("rejects say hi before reveal", () => {
+    const result = applyIntroductionAction(openMystery, "low", "say_hi");
+    expect(result.ok).toBe(false);
+  });
+});

package/src/intros/__tests__/warmDisclosure.test.ts

@@ -0,0 +1,10 @@
+import { warmInviteNamesOtherPerson } from "../validation.js";
+
+describe("warm intro disclosure", () => {
+  it("hides the other person's name unless both chose named intros", () => {
+    expect(warmInviteNamesOtherPerson("Named", "Named")).toBe(true);
+    expect(warmInviteNamesOtherPerson("Named", "Anonymous")).toBe(false);
+    expect(warmInviteNamesOtherPerson(null, "Named")).toBe(false);
+    expect(warmInviteNamesOtherPerson("Off", "Off")).toBe(false);
+  });
+});

package/src/intros/age.ts

@@ -0,0 +1,13 @@
+export const INTROS_MINIMUM_AGE = 18;
+
+export function ageInYears(dob: Date, now = new Date()): number {
+  let age = now.getUTCFullYear() - dob.getUTCFullYear();
+  const month = now.getUTCMonth() - dob.getUTCMonth();
+  if (month < 0 || (month === 0 && now.getUTCDate() < dob.getUTCDate())) age -= 1;
+  return age;
+}
+
+export function isIntrosAdult(dob: Date | null | undefined, now = new Date()): boolean {
+  if (!dob) return false;
+  return ageInYears(dob, now) >= INTROS_MINIMUM_AGE;
+}

package/src/intros/attendance.ts

@@ -0,0 +1,33 @@
+export const CONFIRMED_TICKET_STATUSES = [
+  "Pending",
+  "P2PConfirmed",
+  "CheckedIn",
+  "Attended",
+] as const;
+
+export function isConfirmedTicketStatus(status: string | null | undefined): boolean {
+  return (CONFIRMED_TICKET_STATUSES as readonly string[]).includes(status ?? "");
+}
+
+export type AttendanceTier = "Recommended" | "Interested" | "Registered" | "CheckedIn";
+
+/** Strongest public wording without evidence and disclosure consent. */
+export function attendanceCopy(
+  tier: AttendanceTier,
+  shareRegistration: boolean
+): string {
+  if (tier === "CheckedIn" && shareRegistration) return "Checked in.";
+  if (tier === "Registered" && shareRegistration) return "Your match has a spot.";
+  return "Could be a good night to meet someone new.";
+}
+
+export function visibleAttendanceTier(args: {
+  checkedIn: boolean;
+  registered: boolean;
+  shareRegistration: boolean;
+}): AttendanceTier {
+  if (!args.shareRegistration) return "Recommended";
+  if (args.checkedIn) return "CheckedIn";
+  if (args.registered) return "Registered";
+  return "Recommended";
+}

package/src/intros/attributeCatalog.ts

@@ -0,0 +1,113 @@
+export const INTROS_ATTRIBUTE_KINDS = [
+  "BigFive",
+  "MyersBriggs",
+  "LocusOfControl",
+  "CliftonStrengths",
+  "EmotionalIntelligence",
+  "HumanDesign",
+] as const;
+
+export type IntrosAttributeKind = (typeof INTROS_ATTRIBUTE_KINDS)[number];
+
+export type IntrosEvidenceTier =
+  | "ResearchBackedConstruct"
+  | "SelfReportedTypology"
+  | "Exploratory";
+
+export const CLIFTON_THEMES = [
+  "Achiever",
+  "Learner",
+  "Relator",
+  "Strategic",
+  "Woo",
+  "Empathy",
+  "Focus",
+  "Ideation",
+] as const;
+
+export const HUMAN_DESIGN_TYPES = [
+  "Manifestor",
+  "Generator",
+  "ManifestingGenerator",
+  "Projector",
+  "Reflector",
+] as const;
+
+export function isIntrosAttributeKind(value: string): value is IntrosAttributeKind {
+  return (INTROS_ATTRIBUTE_KINDS as readonly string[]).includes(value);
+}
+
+export function attributeEvidenceTier(kind: IntrosAttributeKind): IntrosEvidenceTier {
+  if (kind === "BigFive" || kind === "LocusOfControl") return "ResearchBackedConstruct";
+  if (kind === "HumanDesign") return "Exploratory";
+  return "SelfReportedTypology";
+}
+
+export function attributeMayBeUsedInExperiments(kind: IntrosAttributeKind): boolean {
+  return attributeEvidenceTier(kind) !== "Exploratory";
+}
+
+export type AttributeValidation = { ok: true; value: unknown } | { ok: false; error: string };
+
+export function validateAttributeValue(
+  kind: IntrosAttributeKind,
+  raw: unknown
+): AttributeValidation {
+  if (kind === "MyersBriggs") {
+    if (typeof raw !== "string" || !/^[EI][SN][TF][JP]$/i.test(raw)) {
+      return { ok: false, error: "Enter a 4-letter type such as ENFP" };
+    }
+    return { ok: true, value: raw.toUpperCase() };
+  }
+  if (kind === "LocusOfControl") {
+    if (raw !== "internal" && raw !== "external" && raw !== "mixed") {
+      return { ok: false, error: "Choose internal, external, or mixed" };
+    }
+    return { ok: true, value: raw };
+  }
+  if (kind === "EmotionalIntelligence") {
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1 || raw > 5) {
+      return { ok: false, error: "Choose a number from 1 to 5" };
+    }
+    return { ok: true, value: raw };
+  }
+  if (kind === "HumanDesign") {
+    if (typeof raw !== "string" || !(HUMAN_DESIGN_TYPES as readonly string[]).includes(raw)) {
+      return { ok: false, error: "Choose a Human Design type" };
+    }
+    return { ok: true, value: raw };
+  }
+  if (kind === "CliftonStrengths") {
+    if (!Array.isArray(raw) || raw.length < 1 || raw.length > 5) {
+      return { ok: false, error: "Choose up to 5 themes" };
+    }
+    const themes = raw.filter((item): item is string => typeof item === "string");
+    if (
+      themes.length !== raw.length ||
+      themes.some((theme) => !(CLIFTON_THEMES as readonly string[]).includes(theme))
+    ) {
+      return { ok: false, error: "Use theme names only" };
+    }
+    return { ok: true, value: themes };
+  }
+  if (raw == null || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ok: false, error: "Big Five needs five scores" };
+  }
+  const record = raw as Record<string, unknown>;
+  const keys = [
+    "openness",
+    "conscientiousness",
+    "extraversion",
+    "agreeableness",
+    "neuroticism",
+  ] as const;
+  const next: Record<string, number> = {};
+  for (const key of keys) {
+    const n = record[key];
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 0 || n > 100) {
+      return { ok: false, error: "Each Big Five score is a whole number from 0 to 100" };
+    }
+    next[key] = n;
+  }
+  return { ok: true, value: next };
+}

package/src/intros/index.ts

@@ -0,0 +1,9 @@
+export * from "./age.js";
+export * from "./attendance.js";
+export * from "./attributeCatalog.js";
+export * from "./intents.js";
+export * from "./psychExperiment.js";
+export * from "./reasons.js";
+export * from "./sharedNotes.js";
+export * from "./transitions.js";
+export * from "./validation.js";