@sonordev/contracts 2.7.1 → 2.8.0

package/dist/outreach.d.ts

@@ -0,0 +1,267 @@
+/** Bumped when a stored shape here (SegmentGrant, the segment key) changes incompatibly. */
+export declare const OUTREACH_CONTRACT_VERSION = 1;
+/** The badge Signal's outreach writer files and acts under. */
+export declare const OUTREACH_WRITER_BADGE = "signal.outreach.writer";
+/** The ledger kind segments belong to, and its key under settings.autonomy.segments. */
+export declare const OUTREACH_EMAIL_KIND = "outreach_email";
+/**
+ * Signal's one graduation bar: a track record earns sending without a click
+ * per item once at least minMeasured are measured, at least minWinRate of
+ * them won, and none degraded without being undone. Single source of truth
+ * for both APIs: Signal measures a kind or a segment against it, and an
+ * earned segment grant needs minMeasured receipts wherever
+ * grantEvidenceRefusal checks one.
+ */
+export declare const GRADUATION_BAR: {
+    readonly minMeasured: 5;
+    readonly minWinRate: 0.7;
+    readonly maxUnrevertedDegradations: 0;
+};
+/**
+ * A segment's standing, one vocabulary everywhere:
+ *  - ungranted: nobody turned it on (its next email is a first email);
+ *  - granted: a person turned it on and it's sending without a per-email click;
+ *  - paused: it stopped itself (a quality loss or a list signal) until a person resumes it;
+ *  - lapsed: the pitch changed since it was turned on, so its next email is a first email again;
+ *  - revoked: a person stopped it.
+ * "Awaiting first approval" is a drip check's answer, never a stored state.
+ */
+export declare const SEGMENT_STATES: readonly ['ungranted', 'granted', 'paused', 'lapsed', 'revoked'];
+export type SegmentState = (typeof SEGMENT_STATES)[number];
+export type OutreachSegmentSource = 'drip' | 'mcp';
+/** The vertical of a lead with no industry. Never grantable. */
+export declare const UNSPECIFIED_INDUSTRY = "unspecified";
+/**
+ * A prospect's industry as written, in the one order every caller uses: the
+ * target company's vertical, then its industry, then the lead's
+ * company_industry. Null when none is set.
+ */
+export declare function prospectIndustry(prospect: {
+    vertical?: unknown;
+    industry?: unknown;
+    company_industry?: unknown;
+} | null | undefined): string | null;
+/**
+ * An industry as it appears in a segment key: NFKC, accents folded, lowercase,
+ * "&" read as "and", every run of anything that isn't a-z or 0-9 a single
+ * "-", trimmed, at most 48 characters. Empty is 'unspecified'. There's no
+ * synonym table: "Roofing" and "Roofers" are two segments.
+ */
+export declare function normalizeIndustry(value: unknown): string;
+/** The fields of an outreach_narratives row that are its pitch. Its name, its switch and its forbidden phrases aren't. */
+export declare const NARRATIVE_PITCH_FIELDS: readonly ['positioning_statement', 'target_icp_description', 'tone_profile', 'hook_types', 'example_angles', 'value_prop_bullets'];
+/** A narrative row, or any object carrying its pitch fields; every other column (name, enabled, forbidden_phrases, ...) is read past. */
+export type NarrativePitch = {
+    [K in (typeof NARRATIVE_PITCH_FIELDS)[number]]?: unknown;
+} & Record<string, unknown>;
+/**
+ * The narrative's pitch, fingerprinted: FNV-1a of canonical JSON of
+ * NARRATIVE_PITCH_FIELDS only. Rewriting the pitch changes it, and that
+ * lapses a segment's grant. Renaming the narrative, switching it on or off,
+ * or tightening its forbidden phrases or avoid_tone doesn't: those take
+ * effect at once through the checker and the prompt.
+ */
+export declare function narrativeFingerprint(narrative: NarrativePitch | null | undefined): string;
+/** target_ref.segment on an outreach_email row: stamped once, at filing. */
+export interface OutreachSegment {
+    key: string;
+    source: OutreachSegmentSource;
+    narrative_id: string | null;
+    mailbox_id: string | null;
+    vertical: string;
+    label: string;
+    angle_fp: string | null;
+}
+/**
+ * A segment: which pitch, from which mailbox, to which kind of business.
+ *  - drip: `drip:<narrative uuid>@<mailbox uuid>|<vertical>`. Null when either id isn't a UUID.
+ *  - mcp: `mcp:-|<vertical>`. For metrics only; never granted.
+ */
+export declare function outreachSegment(input: {
+    source: OutreachSegmentSource;
+    narrativeId?: string | null;
+    mailboxId?: string | null;
+    industry?: unknown;
+    label?: string | null;
+    angleFp?: string | null;
+}): OutreachSegment | null;
+/** A segment's label: "<narrative name> to <industry as written>, from <mailbox address>". */
+export declare function outreachSegmentLabel(input: {
+    narrativeName?: unknown;
+    industry?: unknown;
+    mailboxAddress?: unknown;
+}): string;
+export type ParsedOutreachSegmentKey = {
+    source: 'drip';
+    narrative_id: string;
+    mailbox_id: string;
+    vertical: string;
+} | {
+    source: 'mcp';
+    vertical: string;
+};
+/**
+ * A segment key, parsed strictly, or null. Nothing else is ever used as a key
+ * in projects.settings, so a caller-chosen key ("__proto__", a long string)
+ * is refused before any read or write.
+ */
+export declare function parseOutreachSegmentKey(key: unknown): ParsedOutreachSegmentKey | null;
+/**
+ * Whether a segment can ever be turned on: a drip segment with a known
+ * industry. An mcp segment, or a lead with no industry, always waits for a
+ * person. (A row whose recipient Sonor already knows waits too; that's the
+ * row's relationship, checked separately.)
+ */
+export declare function isGrantableSegmentKey(key: unknown): boolean;
+/**
+ * A person's standing approval of one segment, at
+ * projects.settings.autonomy.segments.outreach_email[key]. Written only by
+ * Signal's AutonomyPolicyService.setSegmentGrant, refused on every generic
+ * settings writer, and only ever trusted after grantEvidenceRefusal passes.
+ */
+export interface SegmentGrant {
+    state: 'granted' | 'revoked';
+    /** first_email: a person approved the segment's first email unedited with "Send the rest like this". earned: they accepted Signal's offer once the bar was met. */
+    source: 'first_email' | 'earned';
+    /** contacts.id of the person who turned it on. */
+    by: string;
+    /** Where they did it. Never MCP. */
+    via: 'dashboard' | 'drafts';
+    at: string;
+    /** first_email: the ledger id of that email. earned: the offer's dedup key. */
+    ref: string;
+    /** earned: the ledger ids of the wins that earned it. */
+    receipts?: string[];
+    /** The mailbox it sends from. A grant never covers another mailbox. */
+    mailbox_id: string;
+    label: string;
+    /** narrativeFingerprint when it was turned on. A rewritten pitch lapses it. */
+    angle_fp: string;
+    /** Stopped itself. Cleared only by a person's resume. */
+    paused?: {
+        at: string;
+        reason: string;
+        loss_ref: string | null;
+    };
+    resumed?: {
+        by: string;
+        at: string;
+    };
+    revoked?: {
+        by: string;
+        at: string;
+        reason: string;
+    };
+}
+/**
+ * Every well-formed grant, by segment key. Pass projects.settings or its
+ * autonomy document. A key that doesn't parse strictly, or a grant that isn't
+ * the SegmentGrant shape, is left out: an unreadable grant counts as no grant.
+ */
+export declare function readSegmentGrants(source: unknown): Record<string, SegmentGrant>;
+/** The grant for a segment when it's live (granted, not paused, on a grantable key), else null. Evidence is checked separately. */
+export declare function activeSegmentGrant(source: unknown, key: string): SegmentGrant | null;
+export type SegmentGrantCoverage = {
+    covers: true;
+} | {
+    covers: false;
+    code: 'not_granted' | 'revoked' | 'paused' | 'other_person' | 'granted_after' | 'angle_changed' | 'other_mailbox';
+    reason: string;
+};
+/**
+ * Whether a live grant covers one row: refused when there's no grant, it was
+ * revoked or paused, the row names another approver, the row was filed
+ * before the grant, the pitch changed since (a different fingerprint), or the
+ * row sends from another mailbox.
+ */
+export declare function segmentGrantCovers(grant: SegmentGrant | null | undefined, row: {
+    by?: string | null;
+    createdAt: string | null | undefined;
+    angleFp: string | null | undefined;
+    mailboxId: string | null | undefined;
+}): SegmentGrantCoverage;
+/** The columns of a signal_proposals row grantEvidenceRefusal reads. */
+export interface GrantEvidenceRow {
+    id: string;
+    kind: string;
+    status: string;
+    project_id?: string | null;
+    created_by?: string | null;
+    reviewed_by?: string | null;
+    reviewed_at?: string | null;
+    target_ref?: unknown;
+    payload?: unknown;
+}
+export interface GrantEvidenceScope {
+    /** The segment key the grant is stored under. */
+    key: string;
+    /** GRADUATION_BAR.minMeasured: how many receipts an earned grant needs. */
+    minMeasured: number;
+    /** The project the grant is stored on. Rows from another project never count. */
+    projectId?: string | null;
+    /** contacts.id of reviewers known to be people (not agents). When given, every reviewer must be in it. */
+    people?: ReadonlySet<string> | ReadonlyArray<string> | null;
+}
+/**
+ * Why a grant can't be trusted, or null when the ledger rows it cites stand
+ * behind it. A grant that fails counts as no grant, so a grant forged into
+ * settings never sends anything.
+ *
+ * - first_email: grant.ref is an applied outreach_email the writer filed in
+ *   this project and segment, from the grant's mailbox, approved by grant.by
+ *   at or before grant.at, in Sonor (via dashboard or drafts, never MCP),
+ *   unedited, and read back verified.
+ * - earned: at least scope.minMeasured distinct receipts, each an applied
+ *   writer row in this segment and mailbox, for the same pitch, approved by a
+ *   person in Sonor at or before grant.at, unedited and read back verified.
+ */
+export declare function grantEvidenceRefusal(grant: SegmentGrant | null | undefined, refRows: ReadonlyArray<GrantEvidenceRow> | null | undefined, scope: GrantEvidenceScope): string | null;
+/** The live roles of the person asking, read by the caller. */
+export interface SegmentGranterRoles {
+    contact_type?: string | null;
+    is_platform_admin?: boolean | null;
+    /** Their role in the project's org. */
+    org_role?: string | null;
+    /** Their role on the project itself. */
+    project_role?: string | null;
+    /** Their role in the agency that manages the project's org. */
+    managing_org_role?: string | null;
+}
+/**
+ * Whether this person may turn a segment on (or resume it): never an agent
+ * contact; otherwise a platform admin, or an owner or admin of the project,
+ * its org, or the agency that manages that org.
+ */
+export declare function segmentGranterEligible(roles: SegmentGranterRoles | null | undefined): boolean;
+/**
+ * Domains anyone can sign up for. A matching address says nothing about the
+ * company someone works for, so a relationship check never matches on one.
+ */
+export declare const PUBLIC_MAILBOX_DOMAINS: ReadonlyArray<string>;
+/** Whether an address or a domain is a public mailbox provider's. Case and a leading "mailto:" or "@" don't matter. */
+export declare function isPublicMailboxDomain(value: unknown): boolean;
+/**
+ * - live: still waiting on a person or a held send. Leave the lead reserved.
+ * - sent: the email went out. The lead moves on.
+ * - retire: a person said it shouldn't go to this person. Drop the lead.
+ * - declined: a person turned this email down for another reason. The lead goes back in line.
+ * - refile: nothing was decided about the lead (wrong timing, expired,
+ *   superseded, the kind switched off, a send that never went out). It may be
+ *   filed again after its cooldown.
+ */
+export type DripRowDisposition = 'live' | 'sent' | 'retire' | 'declined' | 'refile';
+/** The columns of a signal_proposals row dripRowDisposition reads. */
+export interface DripLedgerRow {
+    status: string;
+    review_reason?: string | null;
+    reviewed_by?: string | null;
+    autonomy_decision?: unknown;
+    payload?: unknown;
+}
+/**
+ * What a drip's ledger row means for its lead. Signal's filing dedup and the
+ * Sonor API's reservation release both read it, so "decided" means one thing.
+ * A status it doesn't know reads as live: a lead stays reserved rather than
+ * being written to twice.
+ */
+export declare function dripRowDisposition(row: DripLedgerRow | null | undefined): DripRowDisposition;

package/dist/outreach.js

@@ -0,0 +1,351 @@
+'use strict';
+
+// src/contracts/business-claims.ts
+function fnv1a(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/contracts/outreach.ts
+var OUTREACH_CONTRACT_VERSION = 1;
+var OUTREACH_WRITER_BADGE = "signal.outreach.writer";
+var OUTREACH_EMAIL_KIND = "outreach_email";
+var GRADUATION_BAR = { minMeasured: 5, minWinRate: 0.7, maxUnrevertedDegradations: 0 };
+var SEGMENT_STATES = ["ungranted", "granted", "paused", "lapsed", "revoked"];
+var UNSPECIFIED_INDUSTRY = "unspecified";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var isUuid = (value) => typeof value === "string" && UUID.test(value);
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var nonEmpty = (value) => typeof value === "string" && value.trim().length > 0;
+function prospectIndustry(prospect) {
+  for (const value of [prospect?.vertical, prospect?.industry, prospect?.company_industry]) {
+    if (nonEmpty(value)) return value.trim();
+  }
+  return null;
+}
+function normalizeIndustry(value) {
+  if (typeof value !== "string") return UNSPECIFIED_INDUSTRY;
+  const slug = value.normalize("NFKC").normalize("NFD").replace(/\p{M}/gu, "").toLowerCase().replace(/&/g, " and ").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/g, "");
+  return slug || UNSPECIFIED_INDUSTRY;
+}
+var NARRATIVE_PITCH_FIELDS = [
+  "positioning_statement",
+  "target_icp_description",
+  "tone_profile",
+  "hook_types",
+  "example_angles",
+  "value_prop_bullets"
+];
+function canonical(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "string") return JSON.stringify(value.normalize("NFKC").replace(/\s+/g, " ").trim());
+  if (typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isRecord(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  }
+  return "null";
+}
+function narrativeFingerprint(narrative) {
+  const source = isRecord(narrative) ? narrative : {};
+  const pitch = {};
+  for (const field of NARRATIVE_PITCH_FIELDS) pitch[field] = source[field] ?? null;
+  return fnv1a(canonical(pitch));
+}
+function outreachSegment(input) {
+  const vertical = normalizeIndustry(input?.industry);
+  const label = typeof input?.label === "string" ? input.label : "";
+  const angle_fp = typeof input?.angleFp === "string" && input.angleFp ? input.angleFp : null;
+  if (input?.source === "drip") {
+    if (!isUuid(input.narrativeId) || !isUuid(input.mailboxId)) return null;
+    const narrative_id = input.narrativeId.toLowerCase();
+    const mailbox_id = input.mailboxId.toLowerCase();
+    return { key: `drip:${narrative_id}@${mailbox_id}|${vertical}`, source: "drip", narrative_id, mailbox_id, vertical, label, angle_fp };
+  }
+  if (input?.source === "mcp") {
+    const mailbox_id = isUuid(input.mailboxId) ? input.mailboxId.toLowerCase() : null;
+    return { key: `mcp:-|${vertical}`, source: "mcp", narrative_id: null, mailbox_id, vertical, label, angle_fp };
+  }
+  return null;
+}
+function outreachSegmentLabel(input) {
+  const name = nonEmpty(input?.narrativeName) ? input.narrativeName.trim() : "Outreach";
+  const industry = nonEmpty(input?.industry) ? input.industry.trim() : "leads with no industry";
+  const from = nonEmpty(input?.mailboxAddress) ? `, from ${input.mailboxAddress.trim()}` : "";
+  return `${name} to ${industry}${from}`;
+}
+var DRIP_KEY = /^drip:([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})@([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\|([a-z0-9-]{1,48})$/;
+var MCP_KEY = /^mcp:-\|([a-z0-9-]{1,48})$/;
+function parseOutreachSegmentKey(key) {
+  if (typeof key !== "string" || key.length > 140) return null;
+  const drip = DRIP_KEY.exec(key);
+  if (drip) return { source: "drip", narrative_id: drip[1], mailbox_id: drip[2], vertical: drip[3] };
+  const mcp = MCP_KEY.exec(key);
+  if (mcp) return { source: "mcp", vertical: mcp[1] };
+  return null;
+}
+function isGrantableSegmentKey(key) {
+  const parsed = parseOutreachSegmentKey(key);
+  return parsed?.source === "drip" && parsed.vertical !== UNSPECIFIED_INDUSTRY;
+}
+var isDate = (value) => typeof value === "string" && !Number.isNaN(Date.parse(value));
+function readGrant(value) {
+  if (!isRecord(value)) return null;
+  const { state, source, by, via, at, ref, receipts, mailbox_id, label, angle_fp, paused, resumed, revoked } = value;
+  if (state !== "granted" && state !== "revoked") return null;
+  if (source !== "first_email" && source !== "earned") return null;
+  if (via !== "dashboard" && via !== "drafts") return null;
+  if (!nonEmpty(by) || !isDate(at) || !nonEmpty(ref) || !nonEmpty(mailbox_id) || !nonEmpty(angle_fp) || typeof label !== "string") return null;
+  const grant = { state, source, by, via, at, ref, mailbox_id, label, angle_fp };
+  if (receipts !== void 0) {
+    if (!Array.isArray(receipts) || !receipts.every(nonEmpty)) return null;
+    grant.receipts = [...receipts];
+  }
+  if (paused !== void 0 && paused !== null) {
+    if (!isRecord(paused) || !isDate(paused.at) || typeof paused.reason !== "string") return null;
+    grant.paused = { at: paused.at, reason: paused.reason, loss_ref: nonEmpty(paused.loss_ref) ? paused.loss_ref : null };
+  }
+  if (resumed !== void 0 && resumed !== null) {
+    if (!isRecord(resumed) || !nonEmpty(resumed.by) || !isDate(resumed.at)) return null;
+    grant.resumed = { by: resumed.by, at: resumed.at };
+  }
+  if (revoked !== void 0 && revoked !== null) {
+    if (!isRecord(revoked) || !nonEmpty(revoked.by) || !isDate(revoked.at) || typeof revoked.reason !== "string") return null;
+    grant.revoked = { by: revoked.by, at: revoked.at, reason: revoked.reason };
+  }
+  return grant;
+}
+function readSegmentGrants(source) {
+  const autonomy = isRecord(source) && isRecord(source.autonomy) ? source.autonomy : source;
+  const segments = isRecord(autonomy) && isRecord(autonomy.segments) ? autonomy.segments[OUTREACH_EMAIL_KIND] : null;
+  const out = {};
+  if (!isRecord(segments)) return out;
+  for (const key of Object.keys(segments)) {
+    if (!parseOutreachSegmentKey(key)) continue;
+    const grant = readGrant(segments[key]);
+    if (grant) out[key] = grant;
+  }
+  return out;
+}
+function activeSegmentGrant(source, key) {
+  if (!isGrantableSegmentKey(key)) return null;
+  const grant = readSegmentGrants(source)[key];
+  return grant && grant.state === "granted" && !grant.paused ? grant : null;
+}
+function segmentGrantCovers(grant, row) {
+  if (!grant) return { covers: false, code: "not_granted", reason: "Nobody's turned this segment on." };
+  if (grant.state === "revoked") return { covers: false, code: "revoked", reason: "Someone stopped this segment." };
+  if (grant.paused) return { covers: false, code: "paused", reason: `This segment stopped itself: ${grant.paused.reason}` };
+  if (grant.state !== "granted") return { covers: false, code: "not_granted", reason: "Nobody's turned this segment on." };
+  if (row.by !== void 0 && row.by !== grant.by) return { covers: false, code: "other_person", reason: "This row names someone other than the person who turned the segment on." };
+  const created = Date.parse(row.createdAt ?? "");
+  const granted = Date.parse(grant.at);
+  if (!Number.isFinite(created) || !Number.isFinite(granted) || created < granted) {
+    return { covers: false, code: "granted_after", reason: "This email was written before the segment was turned on." };
+  }
+  if (!row.angleFp || row.angleFp !== grant.angle_fp) {
+    return { covers: false, code: "angle_changed", reason: "The pitch changed since this segment was turned on, so its next email needs a look." };
+  }
+  if (!row.mailboxId || row.mailboxId.toLowerCase() !== grant.mailbox_id.toLowerCase()) {
+    return { covers: false, code: "other_mailbox", reason: "This email sends from a different mailbox than the one the segment was turned on for." };
+  }
+  return { covers: true };
+}
+function segmentOf(row) {
+  return isRecord(row.target_ref) && isRecord(row.target_ref.segment) ? row.target_ref.segment : null;
+}
+function payloadOf(row) {
+  return isRecord(row.payload) ? row.payload : {};
+}
+function viaOf(row) {
+  const approval = payloadOf(row)._approval;
+  return isRecord(approval) ? approval.via : void 0;
+}
+function wasEdited(row) {
+  const edited = payloadOf(row).edited;
+  return isRecord(edited) && typeof edited.count === "number" && edited.count > 0;
+}
+function readBackStatus(row) {
+  const execution = payloadOf(row)._execution;
+  return isRecord(execution) && isRecord(execution.read_back) ? execution.read_back.status : void 0;
+}
+function evidenceRowRefusal(row, grant, scope, people) {
+  if (!row) return "isn't on record";
+  if (row.kind !== OUTREACH_EMAIL_KIND || row.created_by !== OUTREACH_WRITER_BADGE) return "isn't an email Signal's outreach writer wrote";
+  if (scope.projectId && row.project_id && row.project_id !== scope.projectId) return "belongs to another project";
+  if (row.status !== "applied") return "wasn't approved and sent";
+  const segment = segmentOf(row);
+  if (!segment || segment.key !== scope.key) return "is in a different segment";
+  if (typeof segment.mailbox_id !== "string" || segment.mailbox_id.toLowerCase() !== grant.mailbox_id.toLowerCase()) return "went out from a different mailbox";
+  if (typeof segment.angle_fp === "string" && segment.angle_fp !== grant.angle_fp) return "was written for an earlier version of the pitch";
+  if (!nonEmpty(row.reviewed_by) || row.reviewed_by.startsWith("agent:")) return "wasn't approved by a person";
+  if (people && !people.has(row.reviewed_by)) return "wasn't approved by a person";
+  const reviewed = Date.parse(row.reviewed_at ?? "");
+  if (!Number.isFinite(reviewed) || reviewed > Date.parse(grant.at)) return "was approved after the segment was turned on";
+  const via = viaOf(row);
+  if (via !== "dashboard" && via !== "drafts") return via === "mcp" ? "was approved through MCP, not in Sonor" : "doesn't say where it was approved";
+  if (wasEdited(row)) return "was edited before it was approved";
+  if (readBackStatus(row) !== "verified") return "wasn't confirmed to have arrived intact";
+  return null;
+}
+function grantEvidenceRefusal(grant, refRows, scope) {
+  if (!grant) return "There's no grant.";
+  if (!isGrantableSegmentKey(scope?.key)) return "This segment can't be turned on.";
+  const rows = /* @__PURE__ */ new Map();
+  for (const row of refRows ?? []) if (row && typeof row.id === "string") rows.set(row.id, row);
+  const people = scope.people ? new Set(scope.people) : null;
+  if (grant.source === "first_email") {
+    const row = rows.get(grant.ref);
+    const refusal = evidenceRowRefusal(row, grant, scope, people);
+    if (refusal) return `The email this segment was turned on from ${refusal}.`;
+    if (row.reviewed_by !== grant.by) return "The email this segment was turned on from was approved by someone else.";
+    return null;
+  }
+  const receipts = Array.from(new Set(grant.receipts ?? []));
+  const needed = Math.max(1, Math.ceil(Number(scope.minMeasured) || 0));
+  if (receipts.length < needed) {
+    return `Only ${receipts.length} of the ${needed} approvals this segment needs to earn its own sending are on record.`;
+  }
+  for (const id of receipts) {
+    const refusal = evidenceRowRefusal(rows.get(id), grant, scope, people);
+    if (refusal) return `One of the approvals this segment earned its sending with ${refusal}.`;
+  }
+  return null;
+}
+var GRANTER_ROLES = /* @__PURE__ */ new Set(["owner", "admin"]);
+function segmentGranterEligible(roles) {
+  if (!roles) return false;
+  if (typeof roles.contact_type === "string" && roles.contact_type.trim().toLowerCase() === "agent") return false;
+  if (roles.is_platform_admin === true) return true;
+  return [roles.org_role, roles.project_role, roles.managing_org_role].some(
+    (role) => typeof role === "string" && GRANTER_ROLES.has(role.trim().toLowerCase())
+  );
+}
+var PUBLIC_MAILBOX_DOMAINS = [
+  "gmail.com",
+  "googlemail.com",
+  "yahoo.com",
+  "ymail.com",
+  "rocketmail.com",
+  "hotmail.com",
+  "outlook.com",
+  "live.com",
+  "msn.com",
+  "aol.com",
+  "aim.com",
+  "icloud.com",
+  "me.com",
+  "mac.com",
+  "protonmail.com",
+  "proton.me",
+  "pm.me",
+  "gmx.com",
+  "gmx.net",
+  "mail.com",
+  "zoho.com",
+  "zohomail.com",
+  "yandex.com",
+  "fastmail.com",
+  "hey.com",
+  "tutanota.com",
+  "tuta.io",
+  "att.net",
+  "sbcglobal.net",
+  "bellsouth.net",
+  "comcast.net",
+  "verizon.net",
+  "cox.net",
+  "charter.net",
+  "earthlink.net",
+  "frontier.com",
+  "windstream.net",
+  "centurylink.net",
+  "optonline.net",
+  "juno.com",
+  "netzero.net",
+  "roadrunner.com",
+  "rr.com",
+  "qq.com",
+  "163.com",
+  "126.com",
+  "mail.ru",
+  "web.de",
+  "t-online.de",
+  "orange.fr",
+  "free.fr",
+  "btinternet.com",
+  "sky.com",
+  "rogers.com",
+  "shaw.ca",
+  "sympatico.ca",
+  "bigpond.com"
+];
+var PUBLIC_DOMAIN_SET = new Set(PUBLIC_MAILBOX_DOMAINS);
+var PUBLIC_DOMAIN_FAMILY = /^(?:yahoo|ymail|hotmail|live|outlook|msn|aol|gmx|yandex)\.(?:[a-z]{2,3}|co\.[a-z]{2}|com\.[a-z]{2})$/;
+var PUBLIC_DOMAIN_SUFFIX = [".rr.com"];
+function isPublicMailboxDomain(value) {
+  if (typeof value !== "string") return false;
+  let domain = value.trim().toLowerCase().replace(/^mailto:/, "");
+  const at = domain.lastIndexOf("@");
+  if (at >= 0) domain = domain.slice(at + 1);
+  domain = domain.replace(/\.+$/, "").replace(/^www\./, "");
+  if (!domain) return false;
+  return PUBLIC_DOMAIN_SET.has(domain) || PUBLIC_DOMAIN_FAMILY.test(domain) || PUBLIC_DOMAIN_SUFFIX.some((suffix) => domain.endsWith(suffix));
+}
+function dripRowDisposition(row) {
+  const payload = isRecord(row?.payload) ? row.payload : {};
+  const execution = isRecord(payload._execution) ? payload._execution : {};
+  switch (row?.status) {
+    case "proposed":
+    case "approved":
+      return "live";
+    case "applied":
+    case "auto_applied":
+    case "executed":
+    case "reverted":
+      return "sent";
+    case "failed":
+      return execution.sent === true ? "sent" : "refile";
+    case "rejected": {
+      const decision = isRecord(row?.autonomy_decision) ? row.autonomy_decision : {};
+      if (decision.allowed === "off" && !row?.reviewed_by) return "refile";
+      const reason = row?.review_reason;
+      if (reason === "wrong_recipient") return "retire";
+      if (reason === "wrong_timing" || reason === "withdrawn") return "refile";
+      return "declined";
+    }
+    case "expired":
+    case "superseded":
+    case "discarded":
+      return "refile";
+    default:
+      return "live";
+  }
+}
+
+exports.GRADUATION_BAR = GRADUATION_BAR;
+exports.NARRATIVE_PITCH_FIELDS = NARRATIVE_PITCH_FIELDS;
+exports.OUTREACH_CONTRACT_VERSION = OUTREACH_CONTRACT_VERSION;
+exports.OUTREACH_EMAIL_KIND = OUTREACH_EMAIL_KIND;
+exports.OUTREACH_WRITER_BADGE = OUTREACH_WRITER_BADGE;
+exports.PUBLIC_MAILBOX_DOMAINS = PUBLIC_MAILBOX_DOMAINS;
+exports.SEGMENT_STATES = SEGMENT_STATES;
+exports.UNSPECIFIED_INDUSTRY = UNSPECIFIED_INDUSTRY;
+exports.activeSegmentGrant = activeSegmentGrant;
+exports.dripRowDisposition = dripRowDisposition;
+exports.grantEvidenceRefusal = grantEvidenceRefusal;
+exports.isGrantableSegmentKey = isGrantableSegmentKey;
+exports.isPublicMailboxDomain = isPublicMailboxDomain;
+exports.narrativeFingerprint = narrativeFingerprint;
+exports.normalizeIndustry = normalizeIndustry;
+exports.outreachSegment = outreachSegment;
+exports.outreachSegmentLabel = outreachSegmentLabel;
+exports.parseOutreachSegmentKey = parseOutreachSegmentKey;
+exports.prospectIndustry = prospectIndustry;
+exports.readSegmentGrants = readSegmentGrants;
+exports.segmentGrantCovers = segmentGrantCovers;
+exports.segmentGranterEligible = segmentGranterEligible;