@odla-ai/chapter 0.54.1 → 0.54.2

package/dist/worker/index.js

@@ -383,12 +383,12 @@ function canonical(value) {
   return value;
 }
 async function stripeEventDigest(rawBody) {
-  const event = JSON.parse(rawBody);
-  if (!event || typeof event !== "object" || Array.isArray(event)) throw new TypeError("invalid Stripe event");
+  const event2 = JSON.parse(rawBody);
+  if (!event2 || typeof event2 !== "object" || Array.isArray(event2)) throw new TypeError("invalid Stripe event");
   const keys3 = ["id", "type", "created", "livemode", "account", "context", "api_version", "data"];
   return stripePayloadDigest(JSON.stringify(canonical({
     digestVersion: 1,
-    ...Object.fromEntries(keys3.filter((key3) => Object.hasOwn(event, key3)).map((key3) => [key3, event[key3]]))
+    ...Object.fromEntries(keys3.filter((key3) => Object.hasOwn(event2, key3)).map((key3) => [key3, event2[key3]]))
   })));
 }
 
@@ -655,13 +655,13 @@ function firstPrice(object2) {
   return { ...priceId ? { priceId } : {}, ...quantity !== void 0 ? { quantity } : {} };
 }
 function normalizeNetworkCommercialStripeEvent(input, digest) {
-  const event = raw(input);
-  const eventId = providerId(event.id, "evt_") ?? "";
-  const eventType = text(event.type) ?? "";
-  const object2 = raw(raw(event.data).object);
+  const event2 = raw(input);
+  const eventId = providerId(event2.id, "evt_") ?? "";
+  const eventType = text(event2.type) ?? "";
+  const object2 = raw(raw(event2.data).object);
   const objectId = providerId(object2.id) ?? "";
   const candidates = metadataCandidates(object2);
-  const identity = {};
+  const identity2 = {};
   const identityKeys2 = {
     appId: "odlaAppId",
     chapterId: "chapterId",
@@ -671,7 +671,7 @@ function normalizeNetworkCommercialStripeEvent(input, digest) {
   };
   for (const [target, source] of Object.entries(identityKeys2)) {
     const value = metadataValue(candidates, source);
-    if (value) identity[target] = value;
+    if (value) identity2[target] = value;
   }
   let objectKind = "ignored";
   if (eventType.startsWith("customer.subscription.")) objectKind = "subscription";
@@ -693,11 +693,11 @@ function normalizeNetworkCommercialStripeEvent(input, digest) {
     eventId,
     digest,
     eventType,
-    eventCreated: integer(event.created) ?? 0,
-    livemode: event.livemode === true,
+    eventCreated: integer(event2.created) ?? 0,
+    livemode: event2.livemode === true,
     objectKind,
     objectId,
-    identity,
+    identity: identity2,
     ...metadataValue(candidates, "applicationId") ? { applicationId: metadataValue(candidates, "applicationId") } : {},
     ...metadataValue(candidates, "personId") ? { personId: metadataValue(candidates, "personId") } : {},
     ...metadataValue(candidates, "membershipId") ? { membershipId: metadataValue(candidates, "membershipId") } : {},
@@ -1174,35 +1174,35 @@ function findGiftRef(obj) {
     ...chapterId ? { chapterId } : {}
   };
 }
-function normalizeWebhookEvent(event, options = {}) {
-  const obj = event.data?.object ?? {};
-  if (event.type === "charge.refunded" && (!Number.isSafeInteger(obj.amount) || Number(obj.amount) <= 0 || obj.amount_refunded !== obj.amount || obj.refunded !== true)) return { kind: "ignored", type: event.type };
+function normalizeWebhookEvent(event2, options = {}) {
+  const obj = event2.data?.object ?? {};
+  if (event2.type === "charge.refunded" && (!Number.isSafeInteger(obj.amount) || Number(obj.amount) <= 0 || obj.amount_refunded !== obj.amount || obj.refunded !== true)) return { kind: "ignored", type: event2.type };
   const gift = findGiftRef(obj);
   if (gift.giftIntentId) {
-    const { giftIntentId, providerObjectId, ...identity } = gift;
-    if (event.type === "payment_intent.succeeded" || event.type === "invoice.paid" && obj.billing_reason === "subscription_create") {
-      return { kind: "gift_paid", giftIntentId, providerObjectId, ...identity };
+    const { giftIntentId, providerObjectId, ...identity2 } = gift;
+    if (event2.type === "payment_intent.succeeded" || event2.type === "invoice.paid" && obj.billing_reason === "subscription_create") {
+      return { kind: "gift_paid", giftIntentId, providerObjectId, ...identity2 };
     }
-    if (event.type === "charge.refunded") return { kind: "gift_revoked", giftIntentId, ...identity, reason: "refunded" };
-    if (event.type === "customer.subscription.deleted") return { kind: "gift_revoked", giftIntentId, ...identity, reason: "canceled" };
-    return { kind: "ignored", type: event.type };
+    if (event2.type === "charge.refunded") return { kind: "gift_revoked", giftIntentId, ...identity2, reason: "refunded" };
+    if (event2.type === "customer.subscription.deleted") return { kind: "gift_revoked", giftIntentId, ...identity2, reason: "canceled" };
+    return { kind: "ignored", type: event2.type };
   }
   const ref = findApplicationRef(obj);
   const seatId = obj.metadata?.seatId;
   if (typeof seatId === "string" && seatId) {
-    if (!options.requireProviderPayment) return { kind: "ignored", type: event.type };
-    if (event.type === "payment_intent.succeeded") return { kind: "seat_paid", seatId, ...ref };
-    if (event.type === "charge.refunded") return { kind: "seat_refunded", seatId, ...ref };
-    return { kind: "ignored", type: event.type };
+    if (!options.requireProviderPayment) return { kind: "ignored", type: event2.type };
+    if (event2.type === "payment_intent.succeeded") return { kind: "seat_paid", seatId, ...ref };
+    if (event2.type === "charge.refunded") return { kind: "seat_refunded", seatId, ...ref };
+    return { kind: "ignored", type: event2.type };
   }
-  if (event.type === "invoice.paid" && options.requireProviderPayment || event.type === "invoice.payment_succeeded" && !options.requireProviderPayment) return { kind: "ignored", type: event.type };
-  switch (event.type) {
+  if (event2.type === "invoice.paid" && options.requireProviderPayment || event2.type === "invoice.payment_succeeded" && !options.requireProviderPayment) return { kind: "ignored", type: event2.type };
+  switch (event2.type) {
     case "invoice.payment_failed":
-      return options.requireProviderPayment && obj.billing_reason === "subscription_cycle" ? { kind: "renewal_failed", ...ref } : { kind: "ignored", type: event.type };
+      return options.requireProviderPayment && obj.billing_reason === "subscription_cycle" ? { kind: "renewal_failed", ...ref } : { kind: "ignored", type: event2.type };
     case "invoice.paid":
     case "invoice.payment_succeeded": {
       if (obj.billing_reason !== "subscription_create" && obj.billing_reason !== "subscription_cycle") {
-        return { kind: "ignored", type: event.type };
+        return { kind: "ignored", type: event2.type };
       }
       const renewalAt = membershipInvoicePeriodEnd(obj);
       const kind = obj.billing_reason === "subscription_create" ? "first_payment" : "renewal";
@@ -1216,11 +1216,11 @@ function normalizeWebhookEvent(event, options = {}) {
     case "charge.refunded":
       return { kind: "refunded", ...ref };
     case "customer.subscription.updated":
-      return options.requireProviderPayment ? { kind: "subscription_changed", ...ref } : { kind: "ignored", type: event.type };
+      return options.requireProviderPayment ? { kind: "subscription_changed", ...ref } : { kind: "ignored", type: event2.type };
     case "customer.subscription.deleted":
       return options.requireProviderPayment ? { kind: "subscription_changed", ...ref } : { kind: "canceled", ...ref };
     default:
-      return { kind: "ignored", type: event.type };
+      return { kind: "ignored", type: event2.type };
   }
 }
 function firstPaymentPatch(currentStatus, renewalAt) {
@@ -1584,6 +1584,41 @@ async function backfillCrm(deps) {
   return { synced, errors };
 }
 
+// src/email-retirement.ts
+function isRetiredEmailCopy(subject, text8) {
+  const subjectCopy = subject.trimStart().replace(/^\[dev\]\s*/i, "");
+  const bodyCopy = text8.trimStart().replace(/^\(dev redirect; original recipient: [^\r\n]*\)\r?\n\r?\n/, "");
+  return /^\(\s*unused\s*:/i.test(subjectCopy) || /^Unused\.\s*Switched off\b/i.test(bodyCopy);
+}
+
+// src/email.ts
+import { validateEmailCopy } from "@odla-ai/crm";
+
+// src/email-events.ts
+var identity = ["firstName", "lastName", "email", "phone", "state"];
+var policy = ["refundPolicyText", "commitmentText", "normsText"];
+var checkout = ["tier", "tierName", "paymentAmount", "paymentAmountSummary"];
+var optionalVariables = ["phone", "state", "paymentAmount", "paymentAmountSummary"];
+var event = (label, trigger, audience, variables, requiresTier = true) => ({ label, trigger, audience, variables: [...variables, ...policy], optionalVariables, requiresTier });
+var CHAPTER_EMAIL_EVENTS = {
+  adminNotification: event("Application notification", "Application submitted or payment received, according to notification settings", "Administrator", [...identity, ...checkout, "adminUrl", "membersUrl"]),
+  submitConfirmation: event("Application receipt", "Application submitted", "Applicant", [...identity, ...checkout, "submitNextStep", "membersUrl"]),
+  paymentConfirmation: event("Payment confirmation", "Membership payment received", "Applicant", ["firstName", ...checkout, "paymentNextStep"]),
+  prepEmail: event("Call confirmation", "Introduction call booked", "Applicant", [...identity, ...checkout, "startAt", "endAt", "timezone", "meetUrl", "htmlLink", "meetingTime", "meetingLink"]),
+  onboardingInvite: event("Membership welcome", "Membership approved", "Member", ["firstName", "membersUrl", "tierName"]),
+  namedSeatInvitation: event("Gift membership invitation", "A gift membership is ready to be accepted", "Gift recipient", ["firstName", "purchaserName", "chapterName", "acceptBy", "joinUrl", "tierName"]),
+  seatAccepted: event("Gift accepted", "Gift recipient accepts their membership", "Purchaser", ["firstName", "purchaserName", "recipientName", "tierName", "chapterName", "membersUrl"])
+};
+function chapterEmailEvents(chapter) {
+  const base = chapter.mode === "hub" ? Object.fromEntries(Object.entries(chapter.crm.config.templates ?? {}).map(([key3, spec]) => [key3, {
+    label: key3,
+    trigger: "Administrator sends a message",
+    audience: "Selected contact",
+    variables: spec.vars
+  }])) : CHAPTER_EMAIL_EVENTS;
+  return { ...base, ...chapter.config.emails?.events };
+}
+
 // src/email.ts
 function render(template, vars) {
   return template.replace(/\{\{(\w+)\}\}/g, (_, key3) => vars[key3] ?? "");
@@ -1607,21 +1642,233 @@ function isAlreadySent(priorRows) {
 function planDelivery(input) {
   const tpl = input.group.emailTemplates?.[input.template];
   if (!tpl) return { deliver: false, reason: "template-missing" };
-  if (tpl.enabled === false && !input.force) return { deliver: false, reason: "disabled" };
+  if (typeof tpl.enabled !== "boolean") return { deliver: false, reason: "template-invalid", issues: ["Choose explicitly whether this email is enabled."] };
+  if (tpl.enabled !== true && !input.force) return { deliver: false, reason: "disabled" };
+  if (!/^[^\s@,;<>]+@[^\s@,;<>]+\.[^\s@,;<>]+$/.test(input.to)) return { deliver: false, reason: "recipient-invalid" };
   const vars = groupVars(input.group, input.vars);
+  if (isRetiredEmailCopy(String(tpl.subject ?? ""), String(tpl.text ?? ""))) return { deliver: false, reason: "template-retired" };
+  const event2 = input.event ?? CHAPTER_EMAIL_EVENTS[input.template];
+  const issues = validateEmailCopy(tpl, {
+    allowedVariables: event2?.variables,
+    optionalVariables: event2?.optionalVariables,
+    requiredVariables: event2?.requiresTier ? ["tierName"] : [],
+    values: vars,
+    tierId: vars.tierId
+  });
+  if (issues.length) return { deliver: false, reason: "template-invalid", issues: issues.map((issue) => issue.message) };
   const isProd = input.envName === "prod";
   const redirect = !isProd && !!input.group.debugEmail;
   const transport = !isProd && !redirect ? "log-only" : input.cloudflareReady ? "cloudflare" : "log-only";
   const to = redirect ? input.group.debugEmail : input.to;
-  const subject = (redirect ? "[dev] " : "") + render(tpl.subject, vars);
+  const renderedSubject = render(tpl.subject, vars);
+  const renderedText = render(tpl.text, vars);
+  if (isRetiredEmailCopy(renderedSubject, renderedText)) return { deliver: false, reason: "template-retired" };
+  if (validateEmailCopy({ subject: renderedSubject, text: renderedText }, { allowedVariables: [] }).length) return { deliver: false, reason: "template-invalid" };
+  const subject = (redirect ? "[dev] " : "") + renderedSubject;
   const text8 = redirect ? `(dev redirect; original recipient: ${input.to})
 
-` + render(tpl.text, vars) : render(tpl.text, vars);
+` + renderedText : renderedText;
   return { deliver: true, transport, to, subject, text: text8, redirected: redirect };
 }
 
 // src/notify.ts
-var EMAIL_TEMPLATE_NAMES = ["adminNotification", "submitConfirmation", "paymentConfirmation", "prepEmail", "onboardingInvite"];
+import { validateEmailCopy as validateEmailCopy2 } from "@odla-ai/crm";
+
+// src/email-event-values.ts
+import { isEmailTierName } from "@odla-ai/crm";
+
+// src/tiers.ts
+function tierIsFree(tier) {
+  return !(tier.priceCents > 0) && !tier.stripePriceId;
+}
+function tierPayable(tier, group, hasSecretKey) {
+  if (tierIsFree(tier)) return true;
+  return Boolean(group.stripePublishableKey && tier.stripePriceId && hasSecretKey);
+}
+function byOrder(a, b) {
+  return a.sortOrder - b.sortOrder || a.id.localeCompare(b.id);
+}
+function resolveTiers(group, rows5 = []) {
+  const stored = rows5.filter((tier) => tier.active);
+  if (rows5.length) return [...stored].sort(byOrder);
+  return [{
+    id: "standard",
+    groupId: String(group.id ?? ""),
+    name: "Membership",
+    priceCents: group.standardPriceCents ?? 0,
+    currency: group.currency ?? "usd",
+    interval: group.interval ?? "year",
+    ...group.stripePriceId ? { stripePriceId: group.stripePriceId } : {},
+    sortOrder: 0,
+    active: true
+  }];
+}
+function offerableTiers(tiers, group, hasSecretKey) {
+  return tiers.filter((tier) => tier.active && tierPayable(tier, group, hasSecretKey));
+}
+function findTier(tiers, tierId) {
+  if (!tierId) return tiers.length === 1 ? tiers[0] : null;
+  return tiers.find((tier) => tier.id === tierId) ?? null;
+}
+function joinConfigTiers(tiers, defaults = {}, founding = /* @__PURE__ */ new Map()) {
+  return tiers.map((tier) => ({
+    id: tier.id,
+    name: tier.name,
+    priceCents: tier.priceCents,
+    currency: tier.currency ?? defaults.currency ?? "usd",
+    interval: tier.interval ?? defaults.interval ?? "year",
+    blurb: tier.blurb ?? "",
+    free: tierIsFree(tier),
+    ...founding.has(tier.id) ? { founding: founding.get(tier.id) } : {}
+  }));
+}
+
+// src/tiers-store.ts
+function rowToTier(row2, groupId) {
+  if (!row2 || typeof row2 !== "object" || Array.isArray(row2) || typeof row2.id !== "string" || !row2.id || row2.groupId !== void 0 && row2.groupId !== groupId || !Number.isSafeInteger(row2.priceCents) || Number(row2.priceCents) < 0 || row2.currency !== void 0 && (typeof row2.currency !== "string" || !/^[a-z]{3}$/.test(row2.currency)) || row2.interval !== void 0 && row2.interval !== "month" && row2.interval !== "year") {
+    throw Object.assign(new Error("stored membership tier is invalid"), { code: "tiers_unavailable" });
+  }
+  return {
+    id: String(row2.id ?? ""),
+    groupId: String(row2.groupId ?? groupId),
+    name: String(row2.name ?? ""),
+    priceCents: typeof row2.priceCents === "number" ? row2.priceCents : 0,
+    ...typeof row2.currency === "string" && row2.currency ? { currency: row2.currency } : {},
+    ...row2.interval === "year" || row2.interval === "month" ? { interval: row2.interval } : {},
+    ...typeof row2.stripePriceId === "string" && row2.stripePriceId ? { stripePriceId: row2.stripePriceId } : {},
+    ...typeof row2.blurb === "string" ? { blurb: row2.blurb } : {},
+    sortOrder: typeof row2.sortOrder === "number" ? row2.sortOrder : 0,
+    // A row that never set `active` is offered; only an explicit false retires
+    // a tier, so a half-seeded row cannot silently hide a membership.
+    active: row2.active !== false
+  };
+}
+async function loadTiers(db, group) {
+  const groupId = String(group.id ?? "");
+  let rows5;
+  try {
+    rows5 = (await db.query({
+      tiers: { $: { where: { groupId }, order: { sortOrder: "asc" }, limit: 100 } }
+    })).tiers;
+  } catch {
+    throw Object.assign(new Error("membership tiers are unavailable"), { code: "tiers_unavailable" });
+  }
+  if (!Array.isArray(rows5)) throw Object.assign(new Error("membership tiers response is invalid"), { code: "tiers_unavailable" });
+  const list = rows5.map((row2) => rowToTier(row2, groupId));
+  return resolveTiers(group, list);
+}
+async function loadOfferableTiers(db, group, hasSecretKey) {
+  return offerableTiers(await loadTiers(db, group), group, hasSecretKey);
+}
+
+// src/notification-variables.ts
+function lifecycleNotifyDeps(db, env) {
+  return {
+    db,
+    envName: env.ODLA_ENV,
+    sender: env.SEND_EMAIL,
+    from: env.EMAIL_FROM,
+    debugEmail: env.ODLA_DEBUG_EMAIL,
+    now: () => Date.now(),
+    newId: () => crypto.randomUUID()
+  };
+}
+async function frozenCheckoutVariables(db, app) {
+  const intent = (await db.query({ subscriptionCheckoutIntents: { $: { where: { id: String(app.id) }, limit: 1 } } })).subscriptionCheckoutIntents?.[0];
+  const offer = intent?.membershipOffer, contract = offer?.contract;
+  const offering = contract?.offering, quote = intent?.paymentQuote;
+  const amount = contract?.dueTodayCents ?? intent?.priceCents;
+  const currency = offering?.currency ?? intent?.currency;
+  let formatted = "";
+  if (Number.isSafeInteger(amount) && Number(amount) > 0 && typeof currency === "string" && /^[a-z]{3}$/.test(currency)) {
+    formatted = new Intl.NumberFormat("en-US", { style: "currency", currency: currency.toUpperCase() }).format(Number(amount) / 100);
+  }
+  return {
+    paymentAmount: formatted,
+    paymentAmountSummary: formatted ? ` of ${formatted}` : "",
+    tierName: typeof quote?.tierName === "string" ? quote.tierName : ""
+  };
+}
+async function catalogTierName(db, group, app) {
+  try {
+    return findTier(await loadTiers(db, group), typeof app.tierId === "string" ? app.tierId : null)?.name ?? "";
+  } catch {
+    return "";
+  }
+}
+async function checkoutVariables(db, group, app) {
+  const frozen = await frozenCheckoutVariables(db, app);
+  return frozen.tierName ? frozen : { ...frozen, tierName: await catalogTierName(db, group, app) };
+}
+function formatInstant(at2, timeZone) {
+  return new Intl.DateTimeFormat("en-US", {
+    weekday: "long",
+    month: "long",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZoneName: "short",
+    timeZone
+  }).format(new Date(at2));
+}
+var adminUrlFor = (origin) => `${origin}/admin/`;
+var membersUrlFor = (origin) => `${origin}/members/`;
+function applicantVariables(app) {
+  const text8 = (v) => typeof v === "string" ? v : "";
+  return { firstName: text8(app.firstName), lastName: text8(app.lastName), email: text8(app.email), phone: text8(app.phone), state: text8(app.state) };
+}
+function sampleVariables(origin, timeZone, now = Date.now()) {
+  const startAt = formatInstant(now + 864e5, timeZone);
+  return {
+    firstName: "Sample",
+    lastName: "Person",
+    email: "sample@example.com",
+    phone: "(555) 010-0100",
+    state: "CA",
+    tier: "Membership",
+    tierName: "Membership",
+    paymentAmount: "$100.00",
+    paymentAmountSummary: " of $100.00",
+    paymentNextStep: "Next, schedule your introduction call.",
+    submitNextStep: "Next, schedule your introduction call.",
+    startAt,
+    endAt: formatInstant(now + 864e5 + 45 * 6e4, timeZone),
+    timezone: timeZone,
+    meetUrl: "https://meet.google.com/sample",
+    htmlLink: "https://calendar.google.com/event?eid=sample",
+    meetingTime: startAt,
+    meetingLink: "https://meet.google.com/sample",
+    adminUrl: adminUrlFor(origin),
+    membersUrl: membersUrlFor(origin),
+    purchaserName: "Sample Purchaser",
+    recipientName: "Sample Recipient",
+    chapterName: "Sample Chapter",
+    acceptBy: new Date(now + 7 * 864e5).toISOString().slice(0, 10),
+    joinUrl: `${origin}/join?seat=sample`
+  };
+}
+
+// src/email-event-values.ts
+async function emailTierVariables(db, input) {
+  try {
+    const [apps, groups] = await Promise.all([
+      db.query({ applications: { $: { where: { id: input.applicationId }, limit: 1 } } }),
+      db.query({ groups: { $: { where: { id: input.groupId }, limit: 1 } } })
+    ]);
+    const app = apps.applications?.[0], group = groups.groups?.[0];
+    if (!app || !group || app.groupId !== input.groupId) return { tierName: "", tier: "" };
+    const tierId = input.tierId ?? (typeof app.tierId === "string" ? app.tierId : "");
+    if (!tierId) return { tierName: "", tier: "" };
+    const name = input.tierId ? await catalogTierName(db, group, { ...app, tierId }) : (await checkoutVariables(db, group, app)).tierName;
+    const tierName2 = isEmailTierName(name, tierId) ? name.trim() : "";
+    return { tierName: tierName2, tier: tierName2, tierId };
+  } catch {
+    return { tierName: "", tier: "" };
+  }
+}
+
+// src/notify.ts
 function fromAddress(configured, name) {
   const display = name?.trim();
   if (!display) return configured;
@@ -1638,14 +1885,17 @@ async function sendTemplated(deps, input) {
   const cloudflareReady = Boolean(deps.sender && deps.from);
   const override = deps.debugEmail?.trim();
   const group = deps.envName !== "prod" && deps.debugEmail !== void 0 ? { ...input.group, debugEmail: override && /^[^\s@,;<>]+@[^\s@,;<>]+\.[^\s@,;<>]+$/.test(override) ? override : void 0 } : input.group;
+  const event2 = input.event ?? CHAPTER_EMAIL_EVENTS[input.template];
+  const vars = event2?.requiresTier && input.applicationId ? { ...input.vars, ...await emailTierVariables(deps.db, { applicationId: input.applicationId, groupId: group.id, tierId: input.tierId }) } : input.vars;
   const decision = planDelivery({
     envName: deps.envName,
     group,
     template: input.template,
     to: input.to,
-    vars: input.vars,
+    vars,
     cloudflareReady,
-    force: input.force
+    force: input.force,
+    event: event2
   });
   if (!decision.deliver) return { sent: false, reason: decision.reason };
   const previous = prior[0];
@@ -1670,6 +1920,8 @@ async function sendTemplated(deps, input) {
     error: decision.transport === "log-only" ? "" : "delivery-pending",
     ...input.applicationId ? { applicationId: input.applicationId } : {}
   };
+  if (isRetiredEmailCopy(String(row2.subject), String(row2.body))) return { sent: false, reason: "template-retired" };
+  if (validateEmailCopy2({ subject: row2.subject, text: row2.body }, { allowedVariables: [] }).length) return { sent: false, reason: "template-invalid" };
   try {
     const claim = await deps.db.transact([{ t: "update", ns: "emailLog", id: id6, attrs: row2 }], {
       mutationId: `email-claim:${id6}:${attempt}`,
@@ -1716,17 +1968,17 @@ async function sendTemplated(deps, input) {
   return { sent: true };
 }
 function emailGroupFrom(row2) {
-  const str3 = (v) => typeof v === "string" ? v : void 0;
+  const str4 = (v) => typeof v === "string" ? v : void 0;
   const templates = row2.emailTemplates && typeof row2.emailTemplates === "object" ? row2.emailTemplates : {};
   return {
     id: String(row2.id),
     name: String(row2.name ?? ""),
-    replyTo: str3(row2.replyTo) ?? "",
-    debugEmail: str3(row2.debugEmail),
-    fromName: str3(row2.fromName),
-    refundPolicyText: str3(row2.refundPolicyText),
-    commitmentText: str3(row2.commitmentText),
-    normsText: str3(row2.normsText),
+    replyTo: str4(row2.replyTo) ?? "",
+    debugEmail: str4(row2.debugEmail),
+    fromName: str4(row2.fromName),
+    refundPolicyText: str4(row2.refundPolicyText),
+    commitmentText: str4(row2.commitmentText),
+    normsText: str4(row2.normsText),
     emailTemplates: templates
   };
 }
@@ -1839,15 +2091,15 @@ function membershipDiscountPolicyVersion(value) {
 // src/membership-offer.ts
 function createMembershipCommercialOffer(input) {
   const offering = membershipOfferingVersion(input.offering);
-  const policy = input.discountPolicy === void 0 || input.discountPolicy === null ? null : membershipDiscountPolicyVersion(input.discountPolicy);
+  const policy2 = input.discountPolicy === void 0 || input.discountPolicy === null ? null : membershipDiscountPolicyVersion(input.discountPolicy);
   const now = input.now;
   if (!Number.isSafeInteger(now) || now < 0 || !Number.isSafeInteger(input.approvedFoundingCount) || input.approvedFoundingCount < 0) {
     throw new TypeError("invalid offer clock or founding count");
   }
   if (offering.status !== "published" || now < offering.effectiveFrom || offering.effectiveUntil !== void 0 && now >= offering.effectiveUntil) throw new TypeError("offering is unavailable");
-  if (policy && policy.chapterId !== offering.chapterId) throw new TypeError("policy belongs to another chapter");
-  const founding = Boolean(policy && policy.status === "published" && offering.basePriceCents > 0 && policy.cohortEligibleSkuIds.includes(offering.baseSkuId) && now >= policy.qualifyingStartsAt && now < policy.qualifyingEndsAt && input.approvedFoundingCount < policy.softTarget);
-  const earned = founding ? policy : null;
+  if (policy2 && policy2.chapterId !== offering.chapterId) throw new TypeError("policy belongs to another chapter");
+  const founding = Boolean(policy2 && policy2.status === "published" && offering.basePriceCents > 0 && policy2.cohortEligibleSkuIds.includes(offering.baseSkuId) && now >= policy2.qualifyingStartsAt && now < policy2.qualifyingEndsAt && input.approvedFoundingCount < policy2.softTarget);
+  const earned = founding ? policy2 : null;
   const initialTermEndsAt = offering.term.kind === "fixed_end" ? offering.term.endsAt : addMembershipCalendarMonths(now, offering.term.months);
   if (initialTermEndsAt <= now) throw new TypeError("membership service term has ended");
   if (offering.term.kind === "rolling_months" && offering.term.months !== (offering.interval === "year" ? 12 : 1)) {
@@ -1939,15 +2191,15 @@ async function previewMembershipCommercialOffer(db, input) {
   }
   if (!Number.isSafeInteger(input.now) || input.now < 0) reject("invalid_offer_window");
   const state = await authoritativeState(db, input);
-  const { offering, policy } = await currentPolicy(db, input, false, state);
-  const approvedFoundingCount = policy ? state.cohortCounts[policy.cohortLabel] ?? 0 : 0;
+  const { offering, policy: policy2 } = await currentPolicy(db, input, false, state);
+  const approvedFoundingCount = policy2 ? state.cohortCounts[policy2.cohortLabel] ?? 0 : 0;
   if (!Number.isSafeInteger(approvedFoundingCount) || Number(approvedFoundingCount) < 0) reject("invalid_cohort_count");
   const contract = createMembershipCommercialOffer({
     offering,
-    discountPolicy: policy,
+    discountPolicy: policy2,
     approvedFoundingCount: Number(approvedFoundingCount),
     now: input.now,
-    couponId: await membershipDiscountCouponId(input, policy?.id)
+    couponId: await membershipDiscountCouponId(input, policy2?.id)
   });
   const discount = contract.billingTerms.discount;
   return {
@@ -1976,12 +2228,12 @@ async function currentPolicy(db, input, restartAware, state) {
   });
   if (!Array.isArray(rows5.membershipOfferingVersion) || !Array.isArray(rows5.discountPolicyVersion) || rows5.membershipOfferingVersion.length >= 200 || rows5.discountPolicyVersion.length >= 200) return reject("policy_history_incomplete");
   const offerings = rows5.membershipOfferingVersion.map((row2) => membershipOfferingVersion(row2.snapshot)).filter((offer) => offer.chapterId === input.chapterId && offer.baseSkuId === input.skuId && offer.status === "published" && input.now >= offer.effectiveFrom && (offer.effectiveUntil === void 0 || input.now < offer.effectiveUntil));
-  const policies = rows5.discountPolicyVersion.map((row2) => membershipDiscountPolicyVersion(row2.snapshot)).filter((policy2) => policy2.chapterId === input.chapterId && policy2.status === "published" && policy2.cohortEligibleSkuIds.includes(input.skuId) && input.now >= policy2.qualifyingStartsAt && input.now < policy2.qualifyingEndsAt);
+  const policies = rows5.discountPolicyVersion.map((row2) => membershipDiscountPolicyVersion(row2.snapshot)).filter((policy3) => policy3.chapterId === input.chapterId && policy3.status === "published" && policy3.cohortEligibleSkuIds.includes(input.skuId) && input.now >= policy3.qualifyingStartsAt && input.now < policy3.qualifyingEndsAt);
   const offering = offerings.sort((a, b) => b.version - a.version)[0];
   const restart = restartAware && input.applicationId ? await load(db, "membershipRestart", (await membershipOfferIdForRequest({ ...input, applicationId: input.applicationId, requestId: "checkout_binding" })).replace(/^offer_/, "membership_")) : void 0;
-  const policy = restart ? void 0 : policies.sort((a, b) => b.version - a.version)[0];
-  if (!offering || offerings.filter((item) => item.version === offering.version).length !== 1 || policy && policies.filter((item) => item.version === policy.version).length !== 1) reject("ambiguous_membership_policy");
-  return { offering, policy };
+  const policy2 = restart ? void 0 : policies.sort((a, b) => b.version - a.version)[0];
+  if (!offering || offerings.filter((item) => item.version === offering.version).length !== 1 || policy2 && policies.filter((item) => item.version === policy2.version).length !== 1) reject("ambiguous_membership_policy");
+  return { offering, policy: policy2 };
 }
 async function issueMembershipCommercialOffer(db, input) {
   validate(input);
@@ -1989,15 +2241,15 @@ async function issueMembershipCommercialOffer(db, input) {
   const state = await authoritativeState(db, input);
   const existing = await load(db, "membershipCheckoutOffer", input.offerId);
   if (existing) return restore(existing, input);
-  const { offering, policy } = await currentPolicy(db, input, true, state);
-  const approvedFoundingCount = policy ? state.cohortCounts[policy.cohortLabel] ?? 0 : 0;
+  const { offering, policy: policy2 } = await currentPolicy(db, input, true, state);
+  const approvedFoundingCount = policy2 ? state.cohortCounts[policy2.cohortLabel] ?? 0 : 0;
   if (!Number.isSafeInteger(approvedFoundingCount) || Number(approvedFoundingCount) < 0) reject("invalid_cohort_count");
   const contract = createMembershipCommercialOffer({
     offering,
-    discountPolicy: policy,
+    discountPolicy: policy2,
     approvedFoundingCount: Number(approvedFoundingCount),
     now: input.now,
-    couponId: await membershipDiscountCouponId(input, policy?.id)
+    couponId: await membershipDiscountCouponId(input, policy2?.id)
   });
   const value = {
     id: input.offerId,
@@ -2264,90 +2516,6 @@ async function verifyMembershipPaymentReceipt(value, target) {
   };
 }
 
-// src/tiers.ts
-function tierIsFree(tier) {
-  return !(tier.priceCents > 0) && !tier.stripePriceId;
-}
-function tierPayable(tier, group, hasSecretKey) {
-  if (tierIsFree(tier)) return true;
-  return Boolean(group.stripePublishableKey && tier.stripePriceId && hasSecretKey);
-}
-function byOrder(a, b) {
-  return a.sortOrder - b.sortOrder || a.id.localeCompare(b.id);
-}
-function resolveTiers(group, rows5 = []) {
-  const stored = rows5.filter((tier) => tier.active);
-  if (rows5.length) return [...stored].sort(byOrder);
-  return [{
-    id: "standard",
-    groupId: String(group.id ?? ""),
-    name: "Membership",
-    priceCents: group.standardPriceCents ?? 0,
-    currency: group.currency ?? "usd",
-    interval: group.interval ?? "year",
-    ...group.stripePriceId ? { stripePriceId: group.stripePriceId } : {},
-    sortOrder: 0,
-    active: true
-  }];
-}
-function offerableTiers(tiers, group, hasSecretKey) {
-  return tiers.filter((tier) => tier.active && tierPayable(tier, group, hasSecretKey));
-}
-function findTier(tiers, tierId) {
-  if (!tierId) return tiers.length === 1 ? tiers[0] : null;
-  return tiers.find((tier) => tier.id === tierId) ?? null;
-}
-function joinConfigTiers(tiers, defaults = {}, founding = /* @__PURE__ */ new Map()) {
-  return tiers.map((tier) => ({
-    id: tier.id,
-    name: tier.name,
-    priceCents: tier.priceCents,
-    currency: tier.currency ?? defaults.currency ?? "usd",
-    interval: tier.interval ?? defaults.interval ?? "year",
-    blurb: tier.blurb ?? "",
-    free: tierIsFree(tier),
-    ...founding.has(tier.id) ? { founding: founding.get(tier.id) } : {}
-  }));
-}
-
-// src/tiers-store.ts
-function rowToTier(row2, groupId) {
-  if (!row2 || typeof row2 !== "object" || Array.isArray(row2) || typeof row2.id !== "string" || !row2.id || row2.groupId !== void 0 && row2.groupId !== groupId || !Number.isSafeInteger(row2.priceCents) || Number(row2.priceCents) < 0 || row2.currency !== void 0 && (typeof row2.currency !== "string" || !/^[a-z]{3}$/.test(row2.currency)) || row2.interval !== void 0 && row2.interval !== "month" && row2.interval !== "year") {
-    throw Object.assign(new Error("stored membership tier is invalid"), { code: "tiers_unavailable" });
-  }
-  return {
-    id: String(row2.id ?? ""),
-    groupId: String(row2.groupId ?? groupId),
-    name: String(row2.name ?? ""),
-    priceCents: typeof row2.priceCents === "number" ? row2.priceCents : 0,
-    ...typeof row2.currency === "string" && row2.currency ? { currency: row2.currency } : {},
-    ...row2.interval === "year" || row2.interval === "month" ? { interval: row2.interval } : {},
-    ...typeof row2.stripePriceId === "string" && row2.stripePriceId ? { stripePriceId: row2.stripePriceId } : {},
-    ...typeof row2.blurb === "string" ? { blurb: row2.blurb } : {},
-    sortOrder: typeof row2.sortOrder === "number" ? row2.sortOrder : 0,
-    // A row that never set `active` is offered; only an explicit false retires
-    // a tier, so a half-seeded row cannot silently hide a membership.
-    active: row2.active !== false
-  };
-}
-async function loadTiers(db, group) {
-  const groupId = String(group.id ?? "");
-  let rows5;
-  try {
-    rows5 = (await db.query({
-      tiers: { $: { where: { groupId }, order: { sortOrder: "asc" }, limit: 100 } }
-    })).tiers;
-  } catch {
-    throw Object.assign(new Error("membership tiers are unavailable"), { code: "tiers_unavailable" });
-  }
-  if (!Array.isArray(rows5)) throw Object.assign(new Error("membership tiers response is invalid"), { code: "tiers_unavailable" });
-  const list = rows5.map((row2) => rowToTier(row2, groupId));
-  return resolveTiers(group, list);
-}
-async function loadOfferableTiers(db, group, hasSecretKey) {
-  return offerableTiers(await loadTiers(db, group), group, hasSecretKey);
-}
-
 // src/membership-restart-seat.ts
 async function expireRestartedMembershipSeat(db, target, member, now) {
   const ops = [], guards = [];
@@ -2854,89 +3022,6 @@ async function revokeRefundedApplicationRole(db, env, ctx, applicationId) {
   }
 }
 
-// src/notification-variables.ts
-function lifecycleNotifyDeps(db, env) {
-  return {
-    db,
-    envName: env.ODLA_ENV,
-    sender: env.SEND_EMAIL,
-    from: env.EMAIL_FROM,
-    debugEmail: env.ODLA_DEBUG_EMAIL,
-    now: () => Date.now(),
-    newId: () => crypto.randomUUID()
-  };
-}
-async function frozenCheckoutVariables(db, app) {
-  const intent = (await db.query({ subscriptionCheckoutIntents: { $: { where: { id: String(app.id) }, limit: 1 } } })).subscriptionCheckoutIntents?.[0];
-  const offer = intent?.membershipOffer, contract = offer?.contract;
-  const offering = contract?.offering, quote = intent?.paymentQuote;
-  const amount = contract?.dueTodayCents ?? intent?.priceCents;
-  const currency = offering?.currency ?? intent?.currency;
-  let formatted = "";
-  if (Number.isSafeInteger(amount) && Number(amount) > 0 && typeof currency === "string" && /^[a-z]{3}$/.test(currency)) {
-    formatted = new Intl.NumberFormat("en-US", { style: "currency", currency: currency.toUpperCase() }).format(Number(amount) / 100);
-  }
-  return {
-    paymentAmount: formatted,
-    paymentAmountSummary: formatted ? ` of ${formatted}` : "",
-    tierName: typeof quote?.tierName === "string" ? quote.tierName : ""
-  };
-}
-async function catalogTierName(db, group, app) {
-  try {
-    return findTier(await loadTiers(db, group), typeof app.tierId === "string" ? app.tierId : null)?.name ?? "";
-  } catch {
-    return "";
-  }
-}
-async function checkoutVariables(db, group, app) {
-  const frozen = await frozenCheckoutVariables(db, app);
-  return frozen.tierName ? frozen : { ...frozen, tierName: await catalogTierName(db, group, app) };
-}
-function formatInstant(at2, timeZone) {
-  return new Intl.DateTimeFormat("en-US", {
-    weekday: "long",
-    month: "long",
-    day: "numeric",
-    year: "numeric",
-    hour: "numeric",
-    minute: "2-digit",
-    timeZoneName: "short",
-    timeZone
-  }).format(new Date(at2));
-}
-var adminUrlFor = (origin) => `${origin}/admin/`;
-var membersUrlFor = (origin) => `${origin}/members/`;
-function applicantVariables(app) {
-  const text8 = (v) => typeof v === "string" ? v : "";
-  return { firstName: text8(app.firstName), lastName: text8(app.lastName), email: text8(app.email), phone: text8(app.phone), state: text8(app.state) };
-}
-function sampleVariables(origin, timeZone, now = Date.now()) {
-  const startAt = formatInstant(now + 864e5, timeZone);
-  return {
-    firstName: "Sample",
-    lastName: "Person",
-    email: "sample@example.com",
-    phone: "(555) 010-0100",
-    state: "CA",
-    tier: "Membership",
-    tierName: "Membership",
-    paymentAmount: "$100.00",
-    paymentAmountSummary: " of $100.00",
-    paymentNextStep: "Next, schedule your introduction call.",
-    submitNextStep: "Next, schedule your introduction call.",
-    startAt,
-    endAt: formatInstant(now + 864e5 + 45 * 6e4, timeZone),
-    timezone: timeZone,
-    meetUrl: "https://meet.google.com/sample",
-    htmlLink: "https://calendar.google.com/event?eid=sample",
-    meetingTime: startAt,
-    meetingLink: "https://meet.google.com/sample",
-    adminUrl: adminUrlFor(origin),
-    membersUrl: membersUrlFor(origin)
-  };
-}
-
 // src/payment-notifications.ts
 var groupFor = async (db, app) => {
   const result = await db.query({ groups: { $: { where: { id: String(app.groupId ?? "") }, limit: 1 } } });
@@ -3222,24 +3307,24 @@ async function revokeGiftClaim(db, claim, reason, now) {
 }
 
 // src/payments-route-support.ts
-async function findPaymentApplication(db, event) {
-  if ("applicationId" in event && event.applicationId) {
-    const rows5 = await db.query({ applications: { $: { where: { id: event.applicationId }, limit: 1 } } });
+async function findPaymentApplication(db, event2) {
+  if ("applicationId" in event2 && event2.applicationId) {
+    const rows5 = await db.query({ applications: { $: { where: { id: event2.applicationId }, limit: 1 } } });
     return rows5.applications?.[0];
   }
-  if (event.kind !== "refunded" && "customerId" in event && event.customerId) {
-    const { applications } = await db.query({ applications: { $: { where: { stripeCustomerId: event.customerId }, limit: 2 } } });
+  if (event2.kind !== "refunded" && "customerId" in event2 && event2.customerId) {
+    const { applications } = await db.query({ applications: { $: { where: { stripeCustomerId: event2.customerId }, limit: 2 } } });
     return Array.isArray(applications) && applications.length === 1 ? applications[0] : void 0;
   }
   return void 0;
 }
-function paymentEventPatch(event, status2) {
-  if ((status2 === "refunded" || status2 === "declined") && (event.kind === "first_payment" || event.kind === "renewal")) return {};
-  switch (event.kind) {
+function paymentEventPatch(event2, status2) {
+  if ((status2 === "refunded" || status2 === "declined") && (event2.kind === "first_payment" || event2.kind === "renewal")) return {};
+  switch (event2.kind) {
     case "first_payment":
-      return firstPaymentPatch(status2, event.renewalAt);
+      return firstPaymentPatch(status2, event2.renewalAt);
     case "renewal":
-      return event.renewalAt !== void 0 ? renewalPatch(event.renewalAt) : {};
+      return event2.renewalAt !== void 0 ? renewalPatch(event2.renewalAt) : {};
     case "refunded":
       return refundedPatch();
     case "canceled":
@@ -3260,10 +3345,10 @@ function paymentLineItems(group, tier) {
 }
 
 // src/member-system-contract.ts
-function classifyMemberStripeEvent(identity, target, hasProvenLegacyLocalLink) {
+function classifyMemberStripeEvent(identity2, target, hasProvenLegacyLocalLink) {
   const keys3 = ["appId", "environment", "dataEnvironment", "runtime", "chapterId"];
-  const supplied = keys3.filter((key3) => identity[key3] !== void 0);
-  if (supplied.some((key3) => identity[key3] !== target[key3])) return "ignore_sibling";
+  const supplied = keys3.filter((key3) => identity2[key3] !== void 0);
+  if (supplied.some((key3) => identity2[key3] !== target[key3])) return "ignore_sibling";
   if (supplied.length === keys3.length) return "apply";
   return hasProvenLegacyLocalLink ? "apply_legacy" : "quarantine_unmatched";
 }
@@ -3273,12 +3358,12 @@ var firstRow = async (db, ns, q) => {
   const rows5 = (await db.query({ [ns]: { $: q } }))[ns];
   return Array.isArray(rows5) ? rows5[0] : void 0;
 };
-var stripeEventIdentity = (event) => ({
-  ...event.appId ? { appId: event.appId } : {},
-  ...event.environment ? { environment: event.environment } : {},
-  ...event.dataEnvironment ? { dataEnvironment: event.dataEnvironment } : {},
-  ...event.runtime ? { runtime: event.runtime } : {},
-  ...event.chapterId ? { chapterId: event.chapterId } : {}
+var stripeEventIdentity = (event2) => ({
+  ...event2.appId ? { appId: event2.appId } : {},
+  ...event2.environment ? { environment: event2.environment } : {},
+  ...event2.dataEnvironment ? { dataEnvironment: event2.dataEnvironment } : {},
+  ...event2.runtime ? { runtime: event2.runtime } : {},
+  ...event2.chapterId ? { chapterId: event2.chapterId } : {}
 });
 var stripeEventTarget = (env, ctx) => ({
   appId: env.ODLA_APP_ID,
@@ -3288,12 +3373,12 @@ var stripeEventTarget = (env, ctx) => ({
   chapterId: ctx.chapter.id
 });
 var receiptFor = (db, eventId) => firstRow(db, "stripeEventReceipts", { where: { eventId }, limit: 1 });
-function reportStripePartition(level, eventId, event, disposition) {
+function reportStripePartition(level, eventId, event2, disposition) {
   console[level]("chapter stripe partition", JSON.stringify({
     eventId,
-    kind: event.kind,
+    kind: event2.kind,
     disposition,
-    ...stripeEventIdentity(event)
+    ...stripeEventIdentity(event2)
   }));
 }
 var QUARANTINE_DISPOSITIONS = ["quarantine_unmatched", "quarantine_collision"];
@@ -3312,8 +3397,8 @@ async function alertStripeQuarantine(db, ctx, eventId, disposition) {
     artifacts: { eventId, eventIds: queued.slice(0, QUEUE_IDS).map((row2) => String(row2.eventId)) }
   });
 }
-async function reportStripeCollision(db, ctx, eventId, event) {
-  reportStripePartition("error", eventId, event, "quarantine_collision");
+async function reportStripeCollision(db, ctx, eventId, event2) {
+  reportStripePartition("error", eventId, event2, "quarantine_collision");
   await alertStripeQuarantine(db, ctx, eventId, "quarantine_collision");
 }
 async function storeStripeReceipt(db, input) {
@@ -3348,18 +3433,18 @@ async function storeStripeReceipt(db, input) {
   const raced = await receiptFor(db, input.eventId);
   return raced?.digest === input.digest || raced?.digest === input.legacyDigest ? "replayed" : "collision";
 }
-async function quarantineStripeEvent(db, eventId, digest, event, ctx) {
+async function quarantineStripeEvent(db, eventId, digest, event2, ctx) {
   const disposition = "quarantine_unmatched";
-  const stored = await storeStripeReceipt(db, { eventId, digest, event, disposition, matched: false });
+  const stored = await storeStripeReceipt(db, { eventId, digest, event: event2, disposition, matched: false });
   if (stored === "collision") {
-    await reportStripeCollision(db, ctx, eventId, event);
+    await reportStripeCollision(db, ctx, eventId, event2);
     return json({ ok: true, matched: false, collision: true });
   }
-  reportStripePartition("warn", eventId, event, disposition);
+  reportStripePartition("warn", eventId, event2, disposition);
   if (stored === "stored") await alertStripeQuarantine(db, ctx, eventId, disposition);
   return json({ ok: true, matched: false, disposition, ...stored === "replayed" ? { replayed: true } : {} });
 }
-async function replayedStripeReceipt(db, eventId, digest, event, legacyDigest, ctx) {
+async function replayedStripeReceipt(db, eventId, digest, event2, legacyDigest, ctx) {
   const existing = await receiptFor(db, eventId);
   if (!existing) return null;
   if (existing.retryReady === true && existing.reviewedDigest === digest) return null;
@@ -3369,7 +3454,7 @@ async function replayedStripeReceipt(db, eventId, digest, event, legacyDigest, c
       collisionDigest: digest,
       retryReady: false
     } }], { guards: [{ ns: "stripeEventReceipts", id: String(existing.id), exists: true, equals: { digest: existing.digest } }] });
-    await reportStripeCollision(db, ctx, eventId, event);
+    await reportStripeCollision(db, ctx, eventId, event2);
     return json({ ok: true, matched: false, collision: true });
   }
   return json({ ok: true, matched: existing.matched === true, replayed: true });
@@ -3383,42 +3468,42 @@ async function firstRow2(db, ns, q) {
 }
 async function reconcileChapterStripeEvent(input, env, ctx) {
   const db = ctx.makeDb(env);
-  const { rawBody, eventId, event } = input;
-  if (event.kind === "ignored") return json({ ok: true, ignored: event.type });
+  const { rawBody, eventId, event: event2 } = input;
+  if (event2.kind === "ignored") return json({ ok: true, ignored: event2.type });
   const digest = await stripeEventDigest(rawBody);
   const legacyDigest = await stripePayloadDigest(rawBody);
-  const identity = stripeEventIdentity(event);
+  const identity2 = stripeEventIdentity(event2);
   const target = stripeEventTarget(env, ctx);
-  const preliminary = classifyMemberStripeEvent(identity, target, false);
+  const preliminary = classifyMemberStripeEvent(identity2, target, false);
   if (preliminary === "ignore_sibling") {
-    reportStripePartition("warn", eventId, event, preliminary);
+    reportStripePartition("warn", eventId, event2, preliminary);
     return json({ ok: true, matched: false, disposition: preliminary });
   }
-  if (event.kind === "gift_paid" || event.kind === "gift_revoked") {
-    const intent = await firstRow2(db, "giftPurchaseIntents", { where: { id: event.giftIntentId }, limit: 1 });
+  if (event2.kind === "gift_paid" || event2.kind === "gift_revoked") {
+    const intent = await firstRow2(db, "giftPurchaseIntents", { where: { id: event2.giftIntentId }, limit: 1 });
     if (intent && typeof intent.runtime === "string" && intent.runtime !== target.runtime) {
-      reportStripePartition("warn", eventId, event, "ignore_sibling");
+      reportStripePartition("warn", eventId, event2, "ignore_sibling");
       return json({ ok: true, matched: false, disposition: "ignore_sibling" });
     }
-    const replay2 = await replayedStripeReceipt(db, eventId, digest, event, legacyDigest, ctx);
+    const replay2 = await replayedStripeReceipt(db, eventId, digest, event2, legacyDigest, ctx);
     if (replay2) return replay2;
     const localIntent = Boolean(intent && intent.chapterId === ctx.chapter.id && intent.environment === env.ODLA_ENV && (typeof intent.runtime !== "string" || intent.runtime === target.runtime));
-    const disposition2 = classifyMemberStripeEvent(identity, target, localIntent);
+    const disposition2 = classifyMemberStripeEvent(identity2, target, localIntent);
     if (!localIntent || disposition2 === "quarantine_unmatched") {
-      return quarantineStripeEvent(db, eventId, digest, event, ctx);
+      return quarantineStripeEvent(db, eventId, digest, event2, ctx);
     }
-    if (event.kind === "gift_paid") {
-      if (intent.providerObjectId !== event.providerObjectId || intent.status === "refunded" || intent.status === "canceled") {
-        return quarantineStripeEvent(db, eventId, digest, event, ctx);
+    if (event2.kind === "gift_paid") {
+      if (intent.providerObjectId !== event2.providerObjectId || intent.status === "refunded" || intent.status === "canceled") {
+        return quarantineStripeEvent(db, eventId, digest, event2, ctx);
       }
       try {
         const issued = await issueGiftClaim(db, intent, {
           eventId,
-          objectId: event.providerObjectId
+          objectId: event2.providerObjectId
         }, Date.now());
-        const stored3 = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event, disposition: disposition2, matched: true });
+        const stored3 = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event: event2, disposition: disposition2, matched: true });
         if (stored3 === "collision") {
-          await reportStripeCollision(db, ctx, eventId, event);
+          await reportStripeCollision(db, ctx, eventId, event2);
           return json({ ok: true, matched: false, collision: true });
         }
         return json({ ok: true, matched: true, claimId: issued.claimId });
@@ -3426,57 +3511,57 @@ async function reconcileChapterStripeEvent(input, env, ctx) {
         return json({ error: "gift issuance failed" }, 503);
       }
     }
-    await db.transact([{ t: "update", ns: "giftPurchaseIntents", id: event.giftIntentId, attrs: {
-      status: event.reason,
+    await db.transact([{ t: "update", ns: "giftPurchaseIntents", id: event2.giftIntentId, attrs: {
+      status: event2.reason,
       updatedAt: Date.now()
     } }], { mutationId: `gift-revoked-intent:${eventId}` });
-    const claim = await firstRow2(db, "giftClaims", { where: { intentId: event.giftIntentId }, limit: 1 });
-    if (claim) await revokeGiftClaim(db, claim, event.reason, Date.now());
-    const stored2 = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event, disposition: disposition2, matched: Boolean(claim) });
+    const claim = await firstRow2(db, "giftClaims", { where: { intentId: event2.giftIntentId }, limit: 1 });
+    if (claim) await revokeGiftClaim(db, claim, event2.reason, Date.now());
+    const stored2 = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event: event2, disposition: disposition2, matched: Boolean(claim) });
     if (stored2 === "collision") {
-      await reportStripeCollision(db, ctx, eventId, event);
+      await reportStripeCollision(db, ctx, eventId, event2);
       return json({ ok: true, matched: false, collision: true });
     }
     return json({ ok: true, matched: Boolean(claim) });
   }
-  const app = await findPaymentApplication(db, event);
+  const app = await findPaymentApplication(db, event2);
   if (app && typeof app.stripeRuntime === "string" && app.stripeRuntime !== target.runtime) {
-    reportStripePartition("warn", eventId, event, "ignore_sibling");
+    reportStripePartition("warn", eventId, event2, "ignore_sibling");
     return json({ ok: true, matched: false, disposition: "ignore_sibling" });
   }
-  const replay = await replayedStripeReceipt(db, eventId, digest, event, legacyDigest, ctx);
+  const replay = await replayedStripeReceipt(db, eventId, digest, event2, legacyDigest, ctx);
   if (replay) return replay;
   const localApplication = Boolean(app && String(app.groupId ?? ctx.chapter.id) === ctx.chapter.id && (typeof app.stripeRuntime !== "string" || app.stripeRuntime === target.runtime));
-  const disposition = classifyMemberStripeEvent(identity, target, localApplication);
+  const disposition = classifyMemberStripeEvent(identity2, target, localApplication);
   if (!localApplication || disposition === "quarantine_unmatched") {
-    return quarantineStripeEvent(db, eventId, digest, event, ctx);
+    return quarantineStripeEvent(db, eventId, digest, event2, ctx);
   }
   if (await archivedChapterMembershipEvent(db, rawBody, app, env, ctx)) {
-    await storeStripeReceipt(db, { eventId, digest, legacyDigest, event, disposition, matched: true });
+    await storeStripeReceipt(db, { eventId, digest, legacyDigest, event: event2, disposition, matched: true });
     return json({ ok: true, historical: true });
   }
-  if (event.kind === "seat_paid" || event.kind === "seat_refunded") {
+  if (event2.kind === "seat_paid" || event2.kind === "seat_refunded") {
     const seats = ctx.membershipAuthority?.namedSeats;
     if (!seats) return json({ error: "named seat reconciliation is not configured" }, 503);
     try {
       const intent = await firstRow2(db, "subscriptionCheckoutIntents", { where: { id: String(app.id) }, limit: 1 });
       if (!intent) return json({ error: "membership checkout reconciliation pending" }, 503);
       const target2 = await membershipTargetForIntent(intent, app, env, ctx);
-      const receipt = await seats[event.kind === "seat_paid" ? "confirmPayment" : "confirmRefund"]({ ...target2, seatId: event.seatId, eventId }, env);
-      if (receipt.seatId !== event.seatId || receipt.reconciled !== true) throw new Error("invalid seat receipt");
-      const stored2 = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event, disposition, matched: true });
+      const receipt = await seats[event2.kind === "seat_paid" ? "confirmPayment" : "confirmRefund"]({ ...target2, seatId: event2.seatId, eventId }, env);
+      if (receipt.seatId !== event2.seatId || receipt.reconciled !== true) throw new Error("invalid seat receipt");
+      const stored2 = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event: event2, disposition, matched: true });
       if (stored2 === "collision") {
-        await reportStripeCollision(db, ctx, eventId, event);
+        await reportStripeCollision(db, ctx, eventId, event2);
         return json({ ok: true, matched: false, collision: true });
       }
-      return json({ ok: true, seatId: event.seatId });
+      return json({ ok: true, seatId: event2.seatId });
     } catch {
       return json({ error: "named seat reconciliation pending" }, 503);
     }
   }
-  let authoritativeEvent = event;
+  let authoritativeEvent = event2;
   let membershipProjection = {};
-  if (ctx.membershipAuthority && ["renewal", "renewal_failed", "subscription_changed", "refunded"].includes(event.kind)) {
+  if (ctx.membershipAuthority && ["renewal", "renewal_failed", "subscription_changed", "refunded"].includes(event2.kind)) {
     try {
       const receipt = await renewChapterNetworkMembership(db, env, ctx, app, eventId);
       membershipProjection = { membershipStatus: receipt.status, membershipGraceEndsAt: receipt.graceEndsAt, membershipAutoRenew: receipt.autoRenew };
@@ -3485,13 +3570,13 @@ async function reconcileChapterStripeEvent(input, env, ctx) {
       return json({ error: "network membership renewal reconciliation pending" }, 503);
     }
   }
-  if (event.kind === "first_payment") {
+  if (event2.kind === "first_payment") {
     const intent = await firstRow2(db, "subscriptionCheckoutIntents", { where: { id: String(app.id) }, limit: 1 });
     if (intent) {
-      const evidence = verifyInitialMembershipInvoice(intent, event.invoice);
+      const evidence = verifyInitialMembershipInvoice(intent, event2.invoice);
       if (evidence.status === "retry") return json({ error: "checkout reconciliation pending" }, 503);
-      if (evidence.status === "mismatch") return quarantineStripeEvent(db, eventId, digest, event, ctx);
-      if (evidence.renewalAt !== void 0) authoritativeEvent = { ...event, renewalAt: evidence.renewalAt };
+      if (evidence.status === "mismatch") return quarantineStripeEvent(db, eventId, digest, event2, ctx);
+      if (evidence.renewalAt !== void 0) authoritativeEvent = { ...event2, renewalAt: evidence.renewalAt };
     }
     if (app.canceled !== true && !["refunded", "declined", "canceled"].includes(String(app.status))) {
       try {
@@ -3501,7 +3586,7 @@ async function reconcileChapterStripeEvent(input, env, ctx) {
       }
     }
   }
-  const invoiceEvent = event.kind === "first_payment" || event.kind === "renewal" || event.kind === "renewal_failed";
+  const invoiceEvent = event2.kind === "first_payment" || event2.kind === "renewal" || event2.kind === "renewal_failed";
   const patch = { ...invoiceEvent && app.canceled === true ? {} : paymentEventPatch(authoritativeEvent, String(app.status ?? "")), ...membershipProjection };
   if (invoiceEvent && typeof patch.renewalAt === "number" && patch.renewalAt > 0 && typeof app.renewalAt === "number" && patch.renewalAt < app.renewalAt) delete patch.renewalAt;
   let next = app;
@@ -3535,7 +3620,7 @@ async function reconcileChapterStripeEvent(input, env, ctx) {
       return json({ error: "refund account access reconciliation pending" }, 503);
     }
   }
-  if (event.kind === "first_payment" && next.status !== "refunded" && next.status !== "declined" && next.canceled !== true) {
+  if (event2.kind === "first_payment" && next.status !== "refunded" && next.status !== "declined" && next.canceled !== true) {
     try {
       await notifyPaymentConfirmed(db, env, eventId, next);
     } catch {
@@ -3554,9 +3639,9 @@ async function reconcileChapterStripeEvent(input, env, ctx) {
       if (!approval.ok) return json({ error: "membership approval reconciliation pending" }, 503);
     }
   }
-  const stored = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event, disposition, matched: true });
+  const stored = await storeStripeReceipt(db, { eventId, digest, legacyDigest, event: event2, disposition, matched: true });
   if (stored === "collision") {
-    await reportStripeCollision(db, ctx, eventId, event);
+    await reportStripeCollision(db, ctx, eventId, event2);
     return json({ ok: true, matched: false, collision: true });
   }
   return json({ ok: true });
@@ -3714,8 +3799,8 @@ var handlePaymentRecovery = async (req, url, env, ctx) => {
   if (!String(row2.disposition).startsWith("quarantine_") && row2.retryReady !== true) return json({ error: "event is already reconciled" }, 409);
   try {
     const provider = await readStripeRecoveryEvent(db, eventId);
-    const event = normalizeWebhookEvent(provider.event, { requireProviderPayment: Boolean(ctx.membershipAuthority) });
-    if (provider.event.livemode !== (env.ODLA_ENV === "prod") || classifyMemberStripeEvent(stripeEventIdentity(event), target, false) !== "apply") return json({ error: "provider event belongs to another or unknown runtime" }, 409);
+    const event2 = normalizeWebhookEvent(provider.event, { requireProviderPayment: Boolean(ctx.membershipAuthority) });
+    if (provider.event.livemode !== (env.ODLA_ENV === "prod") || classifyMemberStripeEvent(stripeEventIdentity(event2), target, false) !== "apply") return json({ error: "provider event belongs to another or unknown runtime" }, 409);
     const id6 = crypto.randomUUID();
     await db.transact([
       { t: "update", ns: "paymentRecoveryReviews", id: id6, attrs: {
@@ -3736,7 +3821,7 @@ var handlePaymentRecovery = async (req, url, env, ctx) => {
       equals: { digest: row2.digest, disposition: row2.disposition, ...row2.reviewId ? { reviewId: row2.reviewId } : {} },
       ...!row2.reviewId ? { absent: ["reviewId"] } : {}
     }] });
-    return reconcileChapterStripeEvent({ rawBody: provider.rawBody, eventId, event, origin: url.origin }, env, ctx);
+    return reconcileChapterStripeEvent({ rawBody: provider.rawBody, eventId, event: event2, origin: url.origin }, env, ctx);
   } catch {
     return json({ error: "Event recovery is pending. Check its provider evidence and retry." }, 503);
   }
@@ -4296,7 +4381,7 @@ function stateOf(item, all, now, window, rivals) {
   if (closed) dates.push(mine.until);
   return { state: "superseded", supersededAt: Math.min(...dates) };
 }
-var mechanism = (policy) => policy.percentOffBps === 0 || policy.discountEligibleSkuIds.length === 0 ? "none" : policy.benefitDuration.kind === "while_active" ? "stripe_coupon_forever" : policy.benefitDuration.kind === "first_term" ? "stripe_coupon_once" : "stripe_coupon_term_bound";
+var mechanism = (policy2) => policy2.percentOffBps === 0 || policy2.discountEligibleSkuIds.length === 0 ? "none" : policy2.benefitDuration.kind === "while_active" ? "stripe_coupon_forever" : policy2.benefitDuration.kind === "first_term" ? "stripe_coupon_once" : "stripe_coupon_term_bound";
 var sharesSku = (a, b) => a.cohortEligibleSkuIds.some((sku) => b.cohortEligibleSkuIds.includes(sku));
 var byChapter = (a, b) => a.chapterId.localeCompare(b.chapterId);
 function normalize(rows5, collection, parse, invalid2) {
@@ -4408,16 +4493,16 @@ var couponOf = (discount) => {
 async function retermPolicy(db, scope2, id6) {
   const row2 = await membershipLoad(db, "discountPolicyVersion", id6);
   if (!row2) membershipFail("membership_reterm_policy_unknown");
-  let policy;
+  let policy2;
   try {
-    policy = membershipDiscountPolicyVersion(row2.snapshot);
+    policy2 = membershipDiscountPolicyVersion(row2.snapshot);
   } catch {
     return membershipFail("membership_reterm_policy_ineligible");
   }
-  if (policy.id !== id6 || policy.chapterId !== scope2.chapterId || policy.status !== "published" || policy.benefitDuration.kind !== "while_active" || policy.percentOffBps <= 0 || policy.discountEligibleSkuIds.length === 0) membershipFail("membership_reterm_policy_ineligible");
-  return policy;
+  if (policy2.id !== id6 || policy2.chapterId !== scope2.chapterId || policy2.status !== "published" || policy2.benefitDuration.kind !== "while_active" || policy2.percentOffBps <= 0 || policy2.discountEligibleSkuIds.length === 0) membershipFail("membership_reterm_policy_ineligible");
+  return policy2;
 }
-async function attachProviderDiscount(sk, scope2, member, policy, couponId, productId) {
+async function attachProviderDiscount(sk, scope2, member, policy2, couponId, productId) {
   const subId = String(member.providerSubscriptionId), path = `/v1/subscriptions/${encodeURIComponent(subId)}`;
   const read2 = await stripeRequest6({ secretKey: sk }, "GET", path, { "expand[0]": "discounts" });
   const sub = read2.body, items = sub?.items?.data;
@@ -4433,8 +4518,8 @@ async function attachProviderDiscount(sk, scope2, member, policy, couponId, prod
   const written = await stripeRequest6({ secretKey: sk }, "POST", path, {
     "discounts[0][coupon]": couponId,
     "expand[0]": "discounts",
-    "metadata[discountPolicyVersionId]": policy.id
-  }, { idempotencyKey: `membership-reterm:${String(member.id)}:${policy.id}` });
+    "metadata[discountPolicyVersionId]": policy2.id
+  }, { idempotencyKey: `membership-reterm:${String(member.id)}:${policy2.id}` });
   const after = written.body?.discounts;
   if (!written.ok || written.body?.id !== subId || !Array.isArray(after) || after.length !== 1 || couponOf(after[0]) !== couponId) {
     membershipFail("membership_reterm_provider_unconfirmed");
@@ -4448,8 +4533,8 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
   if (typeof input.policyVersionId !== "string" || !SAFE.test(input.policyVersionId)) throw new TypeError("invalid policy version id");
   if (input.membershipIds !== void 0 && (!Array.isArray(input.membershipIds) || input.membershipIds.length === 0 || input.membershipIds.length > limit || input.membershipIds.some((id6) => typeof id6 !== "string" || !SAFE.test(id6)))) throw new TypeError("invalid membership ids");
   const state = await loadMembershipAuthorityState(db, scope2);
-  const policy = await retermPolicy(db, scope2, input.policyVersionId);
-  const receipt = { policyVersionId: policy.id, retermed: [], unchanged: [], skipped: [], more: false };
+  const policy2 = await retermPolicy(db, scope2, input.policyVersionId);
+  const receipt = { policyVersionId: policy2.id, retermed: [], unchanged: [], skipped: [], more: false };
   const skip = (membershipId, reason) => {
     receipt.skipped.push({ membershipId, reason });
   };
@@ -4470,7 +4555,7 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
   }
   for (const member of rows5) {
     const id6 = String(member.id);
-    if (member.discountPolicyVersionId === policy.id) {
+    if (member.discountPolicyVersionId === policy2.id) {
       receipt.unchanged.push(id6);
       continue;
     }
@@ -4482,22 +4567,22 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
       skip(id6, "not_founding");
       continue;
     }
-    if (member.cohort !== policy.cohortLabel) {
+    if (member.cohort !== policy2.cohortLabel) {
       skip(id6, "cohort_mismatch");
       continue;
     }
     const skuId = String(member.baseSkuId);
-    if (!policy.discountEligibleSkuIds.includes(skuId)) {
+    if (!policy2.discountEligibleSkuIds.includes(skuId)) {
       skip(id6, "sku_not_discounted");
       continue;
     }
     const base = Number(member.baseAmountCents), current = Number(member.renewalAmountCents);
-    const renewal = Math.round(base * (1e4 - policy.percentOffBps) / 1e4);
+    const renewal = Math.round(base * (1e4 - policy2.percentOffBps) / 1e4);
     if (!Number.isSafeInteger(base) || base <= 0 || !Number.isSafeInteger(current) || renewal > current) {
       skip(id6, "would_not_widen");
       continue;
     }
-    const couponId = await membershipDiscountCouponId({ ...scope2, skuId }, policy.id);
+    const couponId = await membershipDiscountCouponId({ ...scope2, skuId }, policy2.id);
     let providerUpdated;
     try {
       const productId = await verifySubscriptionPrice(stripeSecretKey, {
@@ -4515,10 +4600,10 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
         discountProductId: productId,
         billingTerms: {
           offeringVersionId: String(member.offeringVersionId),
-          discount: { policyVersionId: policy.id, couponId, percentOffBps: policy.percentOffBps, duration: "forever" }
+          discount: { policyVersionId: policy2.id, couponId, percentOffBps: policy2.percentOffBps, duration: "forever" }
         }
       }, false);
-      providerUpdated = await attachProviderDiscount(stripeSecretKey, scope2, member, policy, couponId, productId);
+      providerUpdated = await attachProviderDiscount(stripeSecretKey, scope2, member, policy2, couponId, productId);
     } catch (error) {
       const code = error.code;
       if (code === "provider_mismatch" || code === "stripe_contract_mismatch") {
@@ -4529,17 +4614,17 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
     }
     try {
       await db.transact([membershipUpdate("networkMembership", id6, {
-        discountPolicyVersionId: policy.id,
-        discountSnapshot: policy,
+        discountPolicyVersionId: policy2.id,
+        discountSnapshot: policy2,
         renewalAmountCents: renewal,
         revision: Number(member.revision) + 1,
         updatedAt: now
       })], {
-        mutationId: `membership-reterm:${id6}:${policy.id}:${member.revision}`,
+        mutationId: `membership-reterm:${id6}:${policy2.id}:${member.revision}`,
         guards: [
           { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision, status: member.status } },
           { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative" } },
-          { ns: "discountPolicyVersion", id: policy.id, exists: true }
+          { ns: "discountPolicyVersion", id: policy2.id, exists: true }
         ]
       });
     } catch (error) {
@@ -4785,18 +4870,18 @@ function memberApplication(app, meeting, defaultTimezone) {
 
 // src/member-session-application.ts
 var local = (row2, chapterId, runtime) => row2.groupId === chapterId && (runtime ? row2.stripeRuntime === runtime : row2.stripeRuntime === void 0 || row2.stripeRuntime === "default");
-async function memberSessionApplication(db, chapterId, runtime, identity) {
+async function memberSessionApplication(db, chapterId, runtime, identity2) {
   const lookup = async (where) => {
     const rows5 = (await db.query({ applications: { $: { where: { groupId: chapterId, ...where }, limit: 100 } } })).applications;
     if (!Array.isArray(rows5) || rows5.length >= 100) throw new Error("member identity lookup incomplete");
     return rows5.filter((row2) => local(row2, chapterId, runtime));
   };
-  let apps = await lookup({ clerkUserId: identity.userId });
+  let apps = await lookup({ clerkUserId: identity2.userId });
   let emailFallback = false;
-  if (!apps.length && identity.email) {
-    const normalized = normalizeChapterEmail(identity.email);
+  if (!apps.length && identity2.email) {
+    const normalized = normalizeChapterEmail(identity2.email);
     const normalizedRows = await lookup({ emailNormalized: normalized });
-    const legacyRows = await lookup({ email: identity.email });
+    const legacyRows = await lookup({ email: identity2.email });
     apps = [...new Map([...normalizedRows, ...legacyRows].map((row2) => [row2.id, row2])).values()];
     if (apps.length !== 1 || apps[0]?.clerkUserId !== void 0 || apps[0]?.clerkAccountPending === true || ["declined", "canceled", "refunded"].includes(String(apps[0]?.status))) return null;
     emailFallback = true;
@@ -4806,8 +4891,8 @@ async function memberSessionApplication(db, chapterId, runtime, identity) {
   if (emailFallback) {
     const keys3 = ["groupId", "stripeRuntime", "email", "emailNormalized", "status", "clerkAccountPending"];
     try {
-      await db.transact([{ t: "update", ns: "applications", id: String(app.id), attrs: { clerkUserId: identity.userId } }], {
-        mutationId: `member-account-link:${app.id}:${identity.userId}`,
+      await db.transact([{ t: "update", ns: "applications", id: String(app.id), attrs: { clerkUserId: identity2.userId } }], {
+        mutationId: `member-account-link:${app.id}:${identity2.userId}`,
         guards: [{
           ns: "applications",
           id: String(app.id),
@@ -4820,7 +4905,7 @@ async function memberSessionApplication(db, chapterId, runtime, identity) {
       if (error.code !== "transact_guard_failed") throw error;
     }
     const saved = (await db.query({ applications: { $: { where: { id: app.id }, limit: 1 } } })).applications?.[0];
-    if (!saved || !local(saved, chapterId, runtime) || saved.clerkUserId !== identity.userId || keys3.some((key3) => saved[key3] !== app[key3])) return null;
+    if (!saved || !local(saved, chapterId, runtime) || saved.clerkUserId !== identity2.userId || keys3.some((key3) => saved[key3] !== app[key3])) return null;
     app = saved;
   }
   const meeting = (await db.query({ meetings: { $: {
@@ -5760,7 +5845,7 @@ function foundingOf(offer) {
   return offer?.contract?.founding === true && offer.contract.discountPolicy ? { cohortLabel: offer.contract.discountPolicy.cohortLabel } : void 0;
 }
 async function createPaymentQuote(input) {
-  const { group, tier, policy } = input;
+  const { group, tier, policy: policy2 } = input;
   const terms2 = input.billingTerms ? subscriptionBillingTerms(input.billingTerms) : void 0;
   const compareAt = input.presentation?.compareAtPriceCents;
   const presentation = Number.isSafeInteger(compareAt) && Number(compareAt) > tier.priceCents ? { compareAtPriceCents: Number(compareAt) } : void 0;
@@ -5783,9 +5868,9 @@ async function createPaymentQuote(input) {
       dueTodayCents: lines.dueTodayCents
     } : lines,
     ...presentation ? { presentation } : {},
-    refundPolicyText: policy?.refundPolicyText ?? String(group.refundPolicyText ?? ""),
+    refundPolicyText: policy2?.refundPolicyText ?? String(group.refundPolicyText ?? ""),
     merchantDisclosureText: String(group.merchantDisclosureText ?? ""),
-    trustCopy: policy ? policy.trustCopy ?? "" : String(group.trustCopy ?? ""),
+    trustCopy: policy2 ? policy2.trustCopy ?? "" : String(group.trustCopy ?? ""),
     ...terms2 ? { commercial: {
       offeringVersionId: terms2.offeringVersionId,
       ...terms2.discount ? {
@@ -5857,13 +5942,13 @@ async function prepareMembershipQuote(db, input, issue) {
       if (error.code !== "membership_quote_expired") throw error;
     }
   }
-  const identity = ["groupId", "tierId", "stripeRuntime", "email", "emailNormalized", "status", "canceled", "membershipRestartId", "namedSeatId", "namedSeatClaimPending", "giftClaimId", "giftOfferId"];
+  const identity2 = ["groupId", "tierId", "stripeRuntime", "email", "emailNormalized", "status", "canceled", "membershipRestartId", "namedSeatId", "namedSeatClaimPending", "giftClaimId", "giftOfferId"];
   const guards = [{
     ns: "applications",
     id: id6,
     exists: true,
-    equals: Object.fromEntries(identity.filter((key3) => app[key3] !== void 0).map((key3) => [key3, app[key3]])),
-    absent: identity.filter((key3) => app[key3] === void 0)
+    equals: Object.fromEntries(identity2.filter((key3) => app[key3] !== void 0).map((key3) => [key3, app[key3]])),
+    absent: identity2.filter((key3) => app[key3] === void 0)
   }, { ns: "subscriptionCheckoutIntents", id: id6, exists: false }];
   if (!row2 || row2.status === "ready" || row2.status === "restart") {
     const revision = Number(row2?.revision ?? 0) + 1;
@@ -5999,11 +6084,11 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
   const tier = findTier(await loadTiers(db, group), typeof app.tierId === "string" ? app.tierId : null);
   if (!tier || tierIsFree(tier) || !tier.stripePriceId) throw Object.assign(new Error("tier unavailable"), { code: "tier_unresolved" });
   const control3 = await loadActiveSignupControl(db, ctx.chapter.id, env.ODLA_ENV);
-  const policy = control3?.document.policy?.tierPolicies?.[tier.id];
+  const policy2 = control3?.document.policy?.tierPolicies?.[tier.id];
   const presentation = tierPresentationFor(control3?.document, tier.id);
   if (ctx.membershipAuthority) return prepareMembershipQuote(
     db,
-    { ...target, app, group, tier, policy, presentation, now: Date.now() },
+    { ...target, app, group, tier, policy: policy2, presentation, now: Date.now() },
     (input) => ctx.membershipAuthority.issueOffer(input, env)
   );
   const quote = await createPaymentQuote({
@@ -6014,7 +6099,7 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
     runtime: stripeRuntimeIdentity(env.ODLA_RUNTIME),
     group,
     tier,
-    policy,
+    policy: policy2,
     presentation
   });
   return { tier, quote, billingTerms: void 0 };
@@ -7161,15 +7246,15 @@ function policyOf(value, errors, tiers) {
     if (!overrides || Object.keys(overrides).length > 20) errors.push("document.policy.tierPolicies must be a bounded tier map");
     else for (const [id6, raw2] of Object.entries(overrides)) {
       const path = `document.policy.tierPolicies.${id6}`;
-      const policy = recordOf(raw2);
-      if (!tiers.some((tier) => tier.id === id6) || !policy) {
+      const policy2 = recordOf(raw2);
+      if (!tiers.some((tier) => tier.id === id6) || !policy2) {
         errors.push(`${path} must name a declared tier and policy`);
         continue;
       }
-      unknownKeys(policy, /* @__PURE__ */ new Set(["refundPolicyText", "trustCopy"]), path, errors);
+      unknownKeys(policy2, /* @__PURE__ */ new Set(["refundPolicyText", "trustCopy"]), path, errors);
       tierPolicies[id6] = {
-        refundPolicyText: text4(policy.refundPolicyText, `${path}.refundPolicyText`, errors),
-        ...policy.trustCopy !== void 0 ? { trustCopy: text4(policy.trustCopy, `${path}.trustCopy`, errors) } : {}
+        refundPolicyText: text4(policy2.refundPolicyText, `${path}.refundPolicyText`, errors),
+        ...policy2.trustCopy !== void 0 ? { trustCopy: text4(policy2.trustCopy, `${path}.trustCopy`, errors) } : {}
       };
     }
   }
@@ -7224,7 +7309,7 @@ function validateSignupControlDocument(input) {
     errors.push("document.membershipPage.tiers must follow the available tier display order");
   }
   const application = applicationOf(root.application, errors);
-  const policy = policyOf(root.policy, errors, tiers);
+  const policy2 = policyOf(root.policy, errors, tiers);
   let scheduling;
   if (root.scheduling !== void 0) {
     const checked = validateScheduling(root.scheduling);
@@ -7244,7 +7329,7 @@ function validateSignupControlDocument(input) {
     tiers,
     membershipPage: page.value,
     ...application ? { application } : {},
-    ...policy ? { policy } : {},
+    ...policy2 ? { policy: policy2 } : {},
     ...scheduling ? { scheduling } : {},
     ...theme ? { theme } : {},
     ...giftOffers?.ok ? { giftOffers: giftOffers.value } : {}
@@ -8988,8 +9073,8 @@ function createStripeProvider(config) {
       if (!webhookSecret || !await verifyStripeSignature2(rawBody, sigHeader, webhookSecret)) {
         return { ok: false, reason: "bad_signature" };
       }
-      const event = JSON.parse(rawBody);
-      return { ok: true, eventId: event.id, event: normalizeWebhookEvent(event, { requireProviderPayment: config.requireProviderPayment }) };
+      const event2 = JSON.parse(rawBody);
+      return { ok: true, eventId: event2.id, event: normalizeWebhookEvent(event2, { requireProviderPayment: config.requireProviderPayment }) };
     },
     async refund(input) {
       return refundSubscriptionPayment(requireSecret(secretKey), input);
@@ -9103,7 +9188,7 @@ async function startGiftIntent(db, input) {
     throw new Error("gift purchase intent does not match this checkout");
   }
   if (stored.status === "paid") throw new Error("gift purchase is already paid");
-  const checkout = await startGiftProviderCheckout(
+  const checkout2 = await startGiftProviderCheckout(
     input.stripeSecret,
     stored,
     input.purchaserEmail,
@@ -9113,15 +9198,15 @@ async function startGiftIntent(db, input) {
   );
   await db.transact([{ t: "update", ns: "giftPurchaseIntents", id: input.id, attrs: {
     status: "checkout_ready",
-    providerObjectId: checkout.providerObjectId,
-    ...checkout.customerId ? { providerCustomerId: checkout.customerId } : {},
+    providerObjectId: checkout2.providerObjectId,
+    ...checkout2.customerId ? { providerCustomerId: checkout2.customerId } : {},
     checkoutStartedAt: input.now,
     updatedAt: input.now
-  } }], { mutationId: `gift-checkout-ready:${input.id}:${checkout.providerObjectId}` });
+  } }], { mutationId: `gift-checkout-ready:${input.id}:${checkout2.providerObjectId}` });
   return {
     gift: true,
     intentId: input.id,
-    clientSecret: checkout.clientSecret,
+    clientSecret: checkout2.clientSecret,
     publishableKey: input.publishableKey,
     lineItems: { standardCents: input.offer.priceCents, discountCents: 0, dueTodayCents: input.offer.priceCents },
     ...giftCode ? { giftCode } : {}
@@ -9379,15 +9464,15 @@ async function startSubscription(req, env, ctx) {
       return json({ error: error instanceof Error ? error.message : "gift checkout failed" }, 502);
     }
   }
-  let checkout;
+  let checkout2;
   try {
-    checkout = await checkoutQuoteForApplication(db, app, group, env, ctx);
+    checkout2 = await checkoutQuoteForApplication(db, app, group, env, ctx);
   } catch (error) {
     const expired = error.code === "membership_quote_expired";
     return json({ error: "payment quote unavailable", ...expired ? { code: "payment_quote_changed" } : {} }, expired ? 409 : 503);
   }
-  const { tier, quote, billingTerms } = checkout;
-  const membershipOffer = "membershipOffer" in checkout ? checkout.membershipOffer : void 0;
+  const { tier, quote, billingTerms } = checkout2;
+  const membershipOffer = "membershipOffer" in checkout2 ? checkout2.membershipOffer : void 0;
   if (ctx.membershipAuthority && !membershipOffer) return json({ error: "checkout requires reconciliation", code: "checkout_recovery_required" }, 409);
   if (!tier) return json({ error: "tier not found", code: "tier_unresolved" }, 400);
   if (tierIsFree(tier)) return json({ error: "tier is free", code: "tier_not_payable" }, 409);
@@ -9809,13 +9894,6 @@ var handleNamedSeat = async (req, url, env, ctx) => {
   }
 };
 
-// src/named-seat-accepted-template.ts
-var SEAT_ACCEPTED_TEMPLATE = {
-  enabled: true,
-  subject: "{{recipientName}} accepted your {{chapterName}} seat",
-  text: "Hi {{firstName}},\n\n{{recipientName}} has accepted the {{tierName}} seat you purchased at {{chapterName}}. They will complete their own application and any membership requirements from here; nothing more is needed from you.\n\nWarmly,\n{{chapterName}}"
-};
-
 // src/named-seat-accepted-notice.ts
 var text5 = (value) => typeof value === "string" ? value : "";
 async function notifyNamedSeatAccepted(db, env, ctx, input) {
@@ -9826,7 +9904,6 @@ async function notifyNamedSeatAccepted(db, env, ctx, input) {
   const group = await membershipLoad(db, "groups", ctx.chapter.id);
   if (!group) return { sent: false, reason: "group-missing" };
   const config = emailGroupFrom(group);
-  config.emailTemplates = { seatAccepted: SEAT_ACCEPTED_TEMPLATE, ...config.emailTemplates };
   const purchaserName = [purchaser.firstName, purchaser.lastName].map(text5).join(" ").replace(/\s+/g, " ").trim();
   return sendTemplated({
     db,
@@ -9842,6 +9919,7 @@ async function notifyNamedSeatAccepted(db, env, ctx, input) {
     to: text5(purchaser.email),
     dedupeKey: `named-seat-accepted:${input.seatId}`,
     applicationId: input.primaryApplicationId,
+    tierId: input.skuId,
     vars: {
       firstName: text5(purchaser.firstName),
       purchaserName,
@@ -9858,7 +9936,7 @@ async function tierName(db, group, skuId) {
     if (tier) return tier.name;
   } catch {
   }
-  return skuId;
+  return "";
 }
 
 // src/worker-routes-named-seat-recipient.ts
@@ -11073,7 +11151,122 @@ var handleAdminApplicationPatch = async (req, url, env, ctx) => {
   return patchApplication(db, env, ctx, app, body);
 };
 
+// src/email-admin-config.ts
+import { getConfig, saveConfig, validateEmailCopy as validateEmailCopy4 } from "@odla-ai/crm";
+
+// src/email-readiness.ts
+import { isEmailTierName as isEmailTierName2, validateEmailCopy as validateEmailCopy3 } from "@odla-ai/crm";
+function validateEmailReadiness(input) {
+  const issues = [];
+  for (const key3 of Object.keys(input.templates)) if (!input.events[key3]) {
+    issues.push({ code: "event-undeclared", message: `Stored email ${key3} has no declared event. Review its trigger before using it.` });
+  }
+  if (input.tiersUnavailable) issues.push({ code: "tiers-unavailable", message: "Tier names could not be checked. Membership emails cannot send until their tier is resolved." });
+  for (const tier of input.tiers ?? []) {
+    if (!isEmailTierName2(tier.name, tier.id)) issues.push({ code: "tier-name-invalid", message: `Tier ${tier.id} needs a recipient-facing display name.` });
+  }
+  const noTierNames = input.tiers !== void 0 && !input.tiers.some((tier) => isEmailTierName2(tier.name, tier.id));
+  if (noTierNames && !input.tiersUnavailable) issues.push({ code: "tiers-missing", message: "No membership tiers have a recipient-facing display name." });
+  const events = Object.entries(input.events).map(([key3, event2]) => {
+    const template = input.templates[key3];
+    const problems = !template ? [{ code: "template-missing", message: "No email is configured for this event." }] : validateEmailCopy3(template, { allowedVariables: event2.variables });
+    if (template && typeof template.enabled !== "boolean") problems.push({ code: "enabled-missing", message: "Choose explicitly whether this email is enabled. Sending is blocked until then." });
+    if (template) {
+      const used = [...`${template.subject ?? ""}
+${template.text ?? ""}`.matchAll(/\{\{(\w+)\}\}/g)].map((match) => match[1]);
+      for (const name of used) if (name in input.groupValues && !input.groupValues[name]?.trim()) {
+        problems.push({ code: "value-missing", variable: name, message: `Add the ${name} used by this email.` });
+      }
+    }
+    if (event2.requiresTier && input.tiersUnavailable) problems.push({ code: "tiers-unavailable", message: "Tier names are unavailable; delivery checks will block unresolved memberships." });
+    else if (event2.requiresTier && noTierNames) problems.push({ code: "tiers-missing", message: "Configure the membership tier names needed by this event." });
+    return { ...event2, key: key3, status: template?.enabled === false ? "disabled" : problems.length ? "blocked" : "ready", issues: problems };
+  });
+  return { checkedAt: input.now ?? Date.now(), events, issues };
+}
+
+// src/email-admin-config.ts
+var str2 = (value) => typeof value === "string" ? value : "";
+async function emailSettings(db, ctx, env) {
+  const hub = ctx.chapter.mode === "hub";
+  const crmDeps3 = { db, crm: ctx.chapter.crm };
+  const group = hub ? await getConfig(crmDeps3) : (await db.query({ groups: { $: { where: { id: ctx.chapter.id }, limit: 1 } } })).groups?.[0];
+  const raw2 = group?.emailTemplates;
+  const stored = raw2 && typeof raw2 === "object" && !Array.isArray(raw2) ? raw2 : {};
+  const events = chapterEmailEvents(ctx.chapter);
+  const emailTemplates = Object.fromEntries(Object.keys(events).filter((key3) => key3 in stored).map((key3) => [key3, {
+    subject: str2(stored[key3]?.subject),
+    text: str2(stored[key3]?.text),
+    enabled: stored[key3]?.enabled
+  }]));
+  let tiers = [], tiersUnavailable = false;
+  if (!hub) {
+    try {
+      tiers = await loadTiers(db, group ?? { id: ctx.chapter.id });
+    } catch {
+      tiersUnavailable = true;
+    }
+  }
+  const groupValues = Object.fromEntries(["refundPolicyText", "commitmentText", "normsText"].map((key3) => [key3, str2(group?.[key3])]));
+  const validation = validateEmailReadiness({ events, templates: stored, groupValues, tiers: hub ? void 0 : tiers, tiersUnavailable });
+  return { group, events, data: {
+    groupId: ctx.chapter.id,
+    name: ctx.chapter.name,
+    emailTemplates,
+    validation,
+    replyTo: str2(group?.replyTo),
+    fromName: str2(group?.fromName),
+    notificationEmail: str2(group?.notificationEmail),
+    debugEmail: str2(group?.debugEmail),
+    ...groupValues,
+    envName: env.ODLA_ENV,
+    testAvailable: !hub,
+    transport: env.SEND_EMAIL && env.EMAIL_FROM ? "cloudflare" : "log-only",
+    fromEmail: env.EMAIL_FROM ?? null
+  } };
+}
+async function updateEmailSettings(db, ctx, env, body) {
+  const { group, events } = await emailSettings(db, ctx, env);
+  if (!group && ctx.chapter.mode !== "hub") return json({ error: "Email settings have not been configured for this chapter." }, 409);
+  const templates = body.emailTemplates;
+  if (!templates || typeof templates !== "object" || Array.isArray(templates)) return json({ error: "emailTemplates object required" }, 400);
+  const clean = {};
+  for (const [key3, value] of Object.entries(templates)) {
+    if (!events[key3]) continue;
+    if (!value || typeof value !== "object" || Array.isArray(value)) return json({ error: `Invalid template: ${key3}` }, 400);
+    const t = value;
+    if (typeof t.enabled !== "boolean") return json({ error: `Choose whether ${key3} is enabled.` }, 400);
+    const subject = str2(t.subject).trim(), text8 = str2(t.text);
+    const issues = validateEmailCopy4({ subject, text: text8 }, { allowedVariables: events[key3].variables });
+    if (t.enabled && issues.length || issues.some((issue) => ["subject-invalid", "body-invalid"].includes(issue.code))) {
+      return json({ error: `${events[key3].label} is incomplete.`, errors: issues.map((issue) => issue.message) }, 400);
+    }
+    clean[key3] = { subject, text: text8, enabled: t.enabled };
+  }
+  const notificationEmail = str2(body.notificationEmail).trim(), replyTo = str2(body.replyTo).trim(), debugEmail = str2(body.debugEmail).trim();
+  const emailish = /^[^\s@,;<>]+@[^\s@,;<>]+\.[^\s@,;<>]+$/;
+  if (!emailish.test(notificationEmail)) return json({ error: "notification address must be a valid email" }, 400);
+  if (!emailish.test(replyTo)) return json({ error: "reply-to address must be a valid email" }, 400);
+  if (debugEmail && !emailish.test(debugEmail)) return json({ error: "debug address must be a valid email" }, 400);
+  const fromName = str2(body.fromName).trim();
+  if (/[\r\n<>]/.test(fromName) || fromName.length > 100) return json({ error: "from name must be one line of at most 100 characters with no angle brackets" }, 400);
+  const commitmentText = str2(body.commitmentText), normsText = str2(body.normsText);
+  if (commitmentText.length > 5e3 || normsText.length > 5e3) return json({ error: "commitment/norms text is too long" }, 400);
+  if (ctx.chapter.mode === "hub") {
+    const missing = Object.fromEntries(Object.keys(events).filter((key3) => !group?.emailTemplates?.[key3]).map((key3) => [key3, { subject: "", text: "", enabled: false }]));
+    await saveConfig({ db, crm: ctx.chapter.crm }, { emailTemplates: { ...missing, ...clean }, notificationEmail, replyTo, debugEmail });
+  } else {
+    const id6 = { ns: "groups", attr: "id", value: ctx.chapter.id };
+    await db.transact([
+      { t: "merge", ns: "groups", id: id6, attrs: { emailTemplates: clean } },
+      { t: "update", ns: "groups", id: id6, attrs: { commitmentText, normsText, notificationEmail, replyTo, debugEmail, fromName } }
+    ]);
+  }
+  return json({ ok: true });
+}
+
 // src/worker-routes-admin-comms.ts
+import { listEmailLog } from "@odla-ai/crm";
 async function gate5(req, env, ctx) {
   const rawDb = ctx.makeDb(env);
   const u = await ctx.verifyUser(req, env);
@@ -11085,39 +11278,13 @@ async function loadGroup2(db, id6) {
   const { groups } = await db.query({ groups: { $: { where: { id: id6 }, limit: 1 } } });
   return groups?.[0] ?? null;
 }
-var str2 = (v, d = "") => typeof v === "string" ? v : d;
+var str3 = (v, d = "") => typeof v === "string" ? v : d;
 var handleAdminGroupEmail = async (req, url, env, ctx) => {
   if (url.pathname !== "/api/admin/group/email" || req.method !== "GET" && req.method !== "PUT") return null;
   const got = await gate5(req, env, ctx);
   if (got instanceof Response) return got;
   const db = got;
-  const group = await loadGroup2(db, ctx.chapter.id);
-  if (!group) return json({ error: "not found" }, 404);
-  if (req.method === "GET") {
-    const stored = group.emailTemplates ?? {};
-    const emailTemplates = {};
-    for (const key3 of EMAIL_TEMPLATE_NAMES) {
-      const t = stored[key3];
-      if (t) emailTemplates[key3] = { subject: str2(t.subject), text: str2(t.text), enabled: t.enabled !== false };
-    }
-    return json({
-      groupId: group.id,
-      name: group.name,
-      replyTo: str2(group.replyTo),
-      fromName: str2(group.fromName),
-      notificationEmail: str2(group.notificationEmail),
-      debugEmail: str2(group.debugEmail),
-      emailTemplates,
-      commitmentText: str2(group.commitmentText),
-      normsText: str2(group.normsText),
-      refundPolicyText: str2(group.refundPolicyText),
-      // Read-only delivery wiring — surfaced so "why did this not send?" is
-      // answerable without logs.
-      envName: env.ODLA_ENV,
-      transport: env.SEND_EMAIL && env.EMAIL_FROM ? "cloudflare" : "log-only",
-      fromEmail: env.EMAIL_FROM ?? null
-    });
-  }
+  if (req.method === "GET") return json((await emailSettings(db, ctx, env)).data);
   let body;
   try {
     body = await req.json();
@@ -11125,41 +11292,16 @@ var handleAdminGroupEmail = async (req, url, env, ctx) => {
     return json({ error: "invalid JSON body" }, 400);
   }
   if (!body || typeof body !== "object" || Array.isArray(body)) return json({ error: "object body required" }, 400);
-  const templates = body.emailTemplates;
-  if (!templates || typeof templates !== "object") return json({ error: "emailTemplates object required" }, 400);
-  const clean = {};
-  for (const key3 of EMAIL_TEMPLATE_NAMES) {
-    const t = templates[key3];
-    const subject = typeof t?.subject === "string" ? t.subject.trim() : "";
-    const text8 = typeof t?.text === "string" ? t.text : "";
-    if (!subject || !text8.trim()) return json({ error: `template "${key3}" needs a subject and a body` }, 400);
-    if (/[\r\n]/.test(subject) || subject.length > 200) return json({ error: `template "${key3}" subject must be a single line under 200 characters` }, 400);
-    if (text8.length > 1e4) return json({ error: `template "${key3}" body is too long` }, 400);
-    clean[key3] = { subject, text: text8, enabled: t?.enabled !== false };
-  }
-  const emailish = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  const notificationEmail = str2(body.notificationEmail).trim();
-  const replyTo = str2(body.replyTo).trim();
-  const debugEmail = str2(body.debugEmail).trim();
-  if (!emailish.test(notificationEmail)) return json({ error: "notification address must be a valid email" }, 400);
-  if (!emailish.test(replyTo)) return json({ error: "reply-to address must be a valid email" }, 400);
-  if (debugEmail && !emailish.test(debugEmail)) return json({ error: "debug address must be a valid email" }, 400);
-  const fromName = str2(body.fromName).trim();
-  if (/[\r\n<>]/.test(fromName) || fromName.length > 100) return json({ error: "from name must be one line of at most 100 characters with no angle brackets" }, 400);
-  const commitmentText = str2(body.commitmentText);
-  const normsText = str2(body.normsText);
-  if (commitmentText.length > 5e3 || normsText.length > 5e3) return json({ error: "commitment/norms text is too long" }, 400);
-  const id6 = { ns: "groups", attr: "id", value: ctx.chapter.id };
-  await db.transact([
-    { t: "merge", ns: "groups", id: id6, attrs: { emailTemplates: clean } },
-    { t: "update", ns: "groups", id: id6, attrs: { commitmentText, normsText, notificationEmail, replyTo, debugEmail, fromName } }
-  ]);
-  return json({ ok: true });
+  return updateEmailSettings(db, ctx, env, body);
 };
 var handleAdminEmailLog = async (req, url, env, ctx) => {
   if (req.method !== "GET" || url.pathname !== "/api/admin/email/log") return null;
   const got = await gate5(req, env, ctx);
   if (got instanceof Response) return got;
+  if (ctx.chapter.mode === "hub") {
+    const rows5 = await listEmailLog({ db: got, crm: ctx.chapter.crm }, { limit: 50 });
+    return json({ sends: rows5.map((row2) => ({ ...row2, template: row2.templateId })) });
+  }
   const { emailLog } = await got.query({ emailLog: { $: { where: { groupId: ctx.chapter.id }, order: { sentAt: "desc" }, limit: 50 } } });
   const visible = [];
   for (const row2 of emailLog ?? []) {
@@ -11195,21 +11337,22 @@ var handleAdminEmailTest = async (req, url, env, ctx) => {
   } catch {
     return json({ error: "invalid JSON body" }, 400);
   }
-  const template = str2(body.template);
-  if (!EMAIL_TEMPLATE_NAMES.includes(template)) {
-    return json({ error: `template must be one of: ${EMAIL_TEMPLATE_NAMES.join(", ")}` }, 400);
-  }
+  if (ctx.chapter.mode === "hub") return json({ error: "Send CRM mail from a selected contact." }, 400);
+  const template = str3(body.template);
+  const events = chapterEmailEvents(ctx.chapter);
+  if (!events[template]) return json({ error: "Unknown email event." }, 400);
   const group = await loadGroup2(db, ctx.chapter.id);
   if (!group) return json({ error: "not found" }, 404);
   const res = await sendTemplated(lifecycleNotifyDeps(db, env), {
     group: emailGroupFrom(group),
     template,
-    to: str2(group.notificationEmail),
+    to: str3(group.notificationEmail),
     vars: sampleVariables(url.origin, resolveScheduling(group.schedulingJson).timezone),
     dedupeKey: `test:${template}:${Date.now()}`,
-    force: true
+    force: true,
+    event: events[template]
   });
-  return json({ ok: res.sent, reason: res.reason ?? null, to: str2(group.notificationEmail), redirected: env.ODLA_ENV !== "prod" && !!group.debugEmail });
+  return json({ ok: res.sent, reason: res.reason ?? null, to: str3(group.notificationEmail), redirected: env.ODLA_ENV !== "prod" && !!group.debugEmail });
 };
 var handleAdminComms = async (req, url, env, ctx) => {
   const m = url.pathname.match(/^\/api\/admin\/people\/([0-9a-fA-F-]+)\/comms$/);
@@ -11231,13 +11374,13 @@ var handleAdminComms = async (req, url, env, ctx) => {
   });
   const app = data.applications?.[0] ?? null;
   if (!app || !chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME)) return json({ error: "not found" }, 404);
-  const group = await loadGroup2(db, str2(app?.groupId, ctx.chapter.id));
-  const vars = app ? { firstName: str2(app.firstName), lastName: str2(app.lastName), email: str2(app.email), phone: str2(app.phone), state: str2(app.state), adminUrl: adminUrlFor(url.origin), membersUrl: membersUrlFor(url.origin) } : null;
+  const group = await loadGroup2(db, str3(app?.groupId, ctx.chapter.id));
+  const vars = app ? { firstName: str3(app.firstName), lastName: str3(app.lastName), email: str3(app.email), phone: str3(app.phone), state: str3(app.state), adminUrl: adminUrlFor(url.origin), membersUrl: membersUrlFor(url.origin) } : null;
   const emails = (data.emailLog ?? []).filter((r) => r.template !== "adminNotification").map((r) => {
     let mailBody = typeof r.body === "string" ? r.body : null;
     if (!mailBody && group && vars) mailBody = renderTemplateBody(emailGroupFrom(group), String(r.template), vars);
     const channel = r.error ? "email (failed)" : r.redirected ? "email (dev-redirected)" : r.transport === "log-only" ? "email (not delivered)" : "email";
-    return { kind: "email", channel, label: String(r.template), subject: str2(r.subject), to: r.to ?? null, body: mailBody, at: r.sentAt, error: r.error ?? null };
+    return { kind: "email", channel, label: String(r.template), subject: str3(r.subject), to: r.to ?? null, body: mailBody, at: r.sentAt, error: r.error ?? null };
   });
   const calendar = (data.meetings ?? []).map((m2) => ({
     kind: "calendar",
@@ -12239,13 +12382,13 @@ var handleAdminNetworkNotes = async (req, url, env, ctx) => {
   if (url.pathname !== "/api/admin/network/notes" || req.method !== "GET" && req.method !== "POST") return null;
   const got = await gate8(req, env, ctx);
   if ("response" in got) return got.response;
-  const identity = noteIdentity(url, ctx);
-  if (!identity) return json({ error: "valid targetId, type, and recordId are required" }, 400);
+  const identity2 = noteIdentity(url, ctx);
+  if (!identity2) return json({ error: "valid targetId, type, and recordId are required" }, 400);
   if (req.method === "GET") {
     const result = await got.db.query({
       networkNotes: {
         $: {
-          where: { recordKey: identity.recordKey },
+          where: { recordKey: identity2.recordKey },
           order: { createdAt: "desc" },
           limit: 100
         }
@@ -12266,9 +12409,9 @@ var handleAdminNetworkNotes = async (req, url, env, ctx) => {
   const id6 = crypto.randomUUID();
   const note = {
     id: id6,
-    targetId: identity.targetId,
-    recordType: identity.recordType,
-    recordId: identity.recordId,
+    targetId: identity2.targetId,
+    recordType: identity2.recordType,
+    recordId: identity2.recordId,
     body,
     authorId: got.user.userId,
     ...got.user.email ? { authorEmail: got.user.email } : {},
@@ -12278,7 +12421,7 @@ var handleAdminNetworkNotes = async (req, url, env, ctx) => {
     t: "update",
     ns: "networkNotes",
     id: id6,
-    attrs: { ...note, recordKey: identity.recordKey }
+    attrs: { ...note, recordKey: identity2.recordKey }
   }]);
   return json({ note }, 201);
 };
@@ -12544,8 +12687,8 @@ function validateNetworkPersonImport(input, allowedChapterIds) {
     }
   }
   const seen = /* @__PURE__ */ new Set();
-  for (const identity of identities) {
-    const key3 = `${identity.kind}:${identity.value}`;
+  for (const identity2 of identities) {
+    const key3 = `${identity2.kind}:${identity2.value}`;
     if (seen.has(key3)) errors.push("duplicate identity in import");
     seen.add(key3);
   }
@@ -12601,8 +12744,8 @@ async function networkChapterLinkId(personId, chapterId, chapterPersonId) {
 async function networkChapterPersonSourceKey(chapterId, chapterPersonId) {
   return `chapter_source_${await sha256(`${chapterId}\0${chapterPersonId}`)}`;
 }
-function projectNetworkContactPolicy(policy, links) {
-  return links.map((link) => ({ ...link, contactPolicy: { ...policy } }));
+function projectNetworkContactPolicy(policy2, links) {
+  return links.map((link) => ({ ...link, contactPolicy: { ...policy2 } }));
 }
 function canonicalNetworkPersonId(personId, persons) {
   const byId = new Map(persons.map((person) => [person.id, person]));
@@ -12908,11 +13051,11 @@ async function suppressNetworkPerson(db, input, mutationId, actor, now = Date.no
   if (!person || person.state !== "active" || canonicalNetworkPersonId(person.id, state.persons) !== person.id || person.revision !== input.expectedRevision) {
     throw new NetworkPersonRegistryError("stale_suppression", "active canonical Person changed; reload before updating suppression");
   }
-  const policy = { marketingSuppressed: input.marketingSuppressed, discretionarySuppressed: input.discretionarySuppressed, ...input.reason ? { reason: input.reason } : {}, updatedAt: now };
-  const next = { ...person, contactPolicy: policy, revision: person.revision + 1, updatedAt: now };
+  const policy2 = { marketingSuppressed: input.marketingSuppressed, discretionarySuppressed: input.discretionarySuppressed, ...input.reason ? { reason: input.reason } : {}, updatedAt: now };
+  const next = { ...person, contactPolicy: policy2, revision: person.revision + 1, updatedAt: now };
   await db.transact([
     { t: "update", ns: "networkPersons", id: person.id, attrs: { ...next } },
-    networkPersonEventOp("contact_suppression_changed", mutationId, actor, now, { marketingSuppressed: policy.marketingSuppressed, discretionarySuppressed: policy.discretionarySuppressed }, { personId: person.id })
+    networkPersonEventOp("contact_suppression_changed", mutationId, actor, now, { marketingSuppressed: policy2.marketingSuppressed, discretionarySuppressed: policy2.discretionarySuppressed }, { personId: person.id })
   ], { mutationId, guards: [{ ns: "networkPersons", id: person.id, exists: true, equals: { revision: person.revision } }] });
   return next;
 }
@@ -13037,13 +13180,13 @@ async function derivedMutationId(batchMutationId, part) {
   return `bulk_${await networkPersonBulkSha256(`${batchMutationId}\0${part}`)}`;
 }
 function matchingEvent(events, mutationId, kind) {
-  return events.find((event) => event.mutationId === mutationId && event.kind === kind);
+  return events.find((event2) => event2.mutationId === mutationId && event2.kind === kind);
 }
-function eventString(event, key3) {
-  return typeof event.detail[key3] === "string" ? String(event.detail[key3]) : "";
+function eventString(event2, key3) {
+  return typeof event2.detail[key3] === "string" ? String(event2.detail[key3]) : "";
 }
-function eventCounts(event) {
-  const value = event.detail.counts;
+function eventCounts(event2) {
+  const value = event2.detail.counts;
   return value && typeof value === "object" && !Array.isArray(value) ? { ...networkPersonBulkEmptyCounts(), ...value } : networkPersonBulkEmptyCounts();
 }
 async function applyNetworkPersonBulkImport(db, input, batchMutationId, actor, allowedChapterIds, now = Date.now()) {
@@ -13170,11 +13313,11 @@ var redactedNetworkPersonLink = async (link) => ({
   state: link.state,
   createdAt: link.createdAt
 });
-var safeNetworkContactPolicy = (policy) => ({
-  marketingSuppressed: policy.marketingSuppressed,
-  discretionarySuppressed: policy.discretionarySuppressed,
-  hasReason: Boolean(policy.reason),
-  updatedAt: policy.updatedAt
+var safeNetworkContactPolicy = (policy2) => ({
+  marketingSuppressed: policy2.marketingSuppressed,
+  discretionarySuppressed: policy2.discretionarySuppressed,
+  hasReason: Boolean(policy2.reason),
+  updatedAt: policy2.updatedAt
 });
 var safeNetworkPersonAlias = async (alias) => ({
   id: alias.id,
@@ -13229,14 +13372,14 @@ async function projectNetworkPersonRegistryState(state) {
     aliases,
     reviewQueue: aliases.filter((alias) => alias.status === "ambiguous"),
     excluded: aliases.filter((alias) => alias.status === "excluded"),
-    recentEvents: state.events.slice(0, 100).map((event) => ({
-      id: event.id,
-      kind: event.kind,
-      personId: event.personId ?? null,
-      aliasId: event.aliasId ?? null,
-      actorId: event.actorId,
-      mutationId: event.mutationId,
-      createdAt: event.createdAt
+    recentEvents: state.events.slice(0, 100).map((event2) => ({
+      id: event2.id,
+      kind: event2.kind,
+      personId: event2.personId ?? null,
+      aliasId: event2.aliasId ?? null,
+      actorId: event2.actorId,
+      mutationId: event2.mutationId,
+      createdAt: event2.createdAt
     }))
   };
 }
@@ -13251,7 +13394,7 @@ async function revealNetworkPersonRegistryRecord(db, input, mutationId, actor, n
   const target = input.kind === "person" ? state.persons.find((row2) => row2.id === input.id) : state.aliases.find((row2) => row2.id === input.id);
   if (!target) throw new NetworkPersonRegistryError("reveal_not_found", "registry record not found");
   const ids2 = input.kind === "person" ? { personId: input.id } : { aliasId: input.id };
-  const event = {
+  const event2 = {
     t: "update",
     ns: "networkPersonEvents",
     id: `network_person_event:${mutationId}`,
@@ -13265,7 +13408,7 @@ async function revealNetworkPersonRegistryRecord(db, input, mutationId, actor, n
       createdAt: now
     }
   };
-  await db.transact([event], {
+  await db.transact([event2], {
     mutationId,
     guards: [{ ns: "networkPersonEvents", id: `network_person_event:${mutationId}`, exists: false }]
   });
@@ -13849,8 +13992,8 @@ var handleNetworkCommercialStripeWebhook = async (req, url, env, ctx) => {
     return json({ error: "commercial webhook is not configured" }, 503);
   }
   try {
-    const event = await constructStripeEvent(body, signature, secret);
-    const fact = normalizeNetworkCommercialStripeEvent(event, await stripeEventDigest(body));
+    const event2 = await constructStripeEvent(body, signature, secret);
+    const fact = normalizeNetworkCommercialStripeEvent(event2, await stripeEventDigest(body));
     if (!fact.eventId || !fact.eventType || !fact.objectId) return json({ error: "Stripe event identity is invalid" }, 400);
     const result = await ingestNetworkCommercialFact(
       db,
@@ -15449,7 +15592,7 @@ async function handleMembershipSeatAction(action, db, peer, input, now, stripeSe
   };
   if (action === "seat-accept") return acceptNamedSeatRecipient(db, recipientInput, now);
   if (action === "seat-approve") return approveNamedSeatRecipient(db, recipientInput, now);
-  const checkout = {
+  const checkout2 = {
     ...target,
     priceId: peer.seatPriceId,
     recipientName: String(input.recipientName),
@@ -15457,7 +15600,7 @@ async function handleMembershipSeatAction(action, db, peer, input, now, stripeSe
     purchaserEmail: String(input.purchaserEmail),
     purchaserUserId: String(input.purchaserUserId)
   };
-  if (action === "seat-checkouts" && namedSeatIncluded(await reserveNamedMembershipSeat(db, checkout, now))) return grantIncludedNamedSeat(db, checkout, now);
+  if (action === "seat-checkouts" && namedSeatIncluded(await reserveNamedMembershipSeat(db, checkout2, now))) return grantIncludedNamedSeat(db, checkout2, now);
   const secret = await getVaultSecret(db, stripeSecretName);
   if (!secret) throw new Error("network Stripe provider is unavailable");
   if (action === "seat-decline") {
@@ -15473,7 +15616,7 @@ async function handleMembershipSeatAction(action, db, peer, input, now, stripeSe
     return { seatId: seat.id, status: "refunded", refundedCents: refunded.refundedCents, subscriptionCanceled: false };
   }
   if (action === "seat-operator-refund") return refundNamedSeatByOperator(db, { ...target, seatId: String(input.seatId) }, secret, now);
-  if (action === "seat-checkouts") return prepareNamedMembershipSeatPayment(db, checkout, secret, now);
+  if (action === "seat-checkouts") return prepareNamedMembershipSeatPayment(db, checkout2, secret, now);
   const evidence = { ...target, seatId: String(input.seatId), eventId: String(input.eventId) };
   if (action === "seat-payments") {
     const receipt = await confirmNamedMembershipSeatPayment(db, evidence, now);
@@ -15544,9 +15687,9 @@ function createMembershipAuthorityHandler(options) {
   const identities = /* @__PURE__ */ new Set();
   for (const peer of peers) {
     if (!/^[a-z0-9][a-z0-9-]{1,62}$/.test(peer.appId) || !SAFE2.test(peer.chapterId) || !/^[a-z0-9][a-z0-9-]{1,31}$/.test(peer.environment) || !/^[a-z0-9]{2,12}$/.test(peer.runtime) || !/^[A-Za-z][A-Za-z0-9_-]{1,127}$/.test(peer.secretName)) throw new TypeError("invalid authority peer");
-    const identity = `${peer.appId}:${peer.runtime}`;
-    if (identities.has(identity)) throw new TypeError("ambiguous authority peer");
-    identities.add(identity);
+    const identity2 = `${peer.appId}:${peer.runtime}`;
+    if (identities.has(identity2)) throw new TypeError("ambiguous authority peer");
+    identities.add(identity2);
     if (peer.seatPriceId !== void 0 && !/^price_[A-Za-z0-9]+$/.test(peer.seatPriceId)) throw new TypeError("invalid seat Price");
   }
   return async (req) => {
@@ -16150,6 +16293,9 @@ async function readBoundedJson(response, signal, maxBytes, label) {
   }
 }
 
+// src/membership-chapter-delivery.ts
+import { validateEmailCopy as validateEmailCopy5 } from "@odla-ai/crm";
+
 // src/invitation-test-delivery.ts
 function invitationDelivery(env, recipientEmail) {
   const normal = { sender: env.SEND_EMAIL, from: env.EMAIL_FROM, debugEmail: env.ODLA_DEBUG_EMAIL };
@@ -16212,16 +16358,13 @@ function createMembershipChapterEffectRoute(options) {
           const join = new URL(applicationPath, origin);
           join.searchParams.set("seat", effect.seatId);
           join.searchParams.set("tier", effect.skuId);
-          config.emailTemplates = { ...config.emailTemplates, namedSeatInvitation: config.emailTemplates?.namedSeatInvitation ?? {
-            enabled: true,
-            subject: "{{purchaserName}} invited you to {{chapterName}}",
-            text: "Hello {{firstName}},\n\n{{purchaserName}} has purchased a membership for you at {{chapterName}}. Your seat is already paid for.\n\nAccept your invitation here:\n{{joinUrl}}\n\nYou will complete your own application and membership requirements. You will not be asked to pay for this seat."
-          } };
           const template = config.emailTemplates.namedSeatInvitation;
-          if (!template.text.includes("{{purchaserName}}")) config.emailTemplates.namedSeatInvitation = {
-            ...template,
-            text: "{{purchaserName}} has purchased a membership for you at {{chapterName}}.\n\n" + template.text
-          };
+          if (template && !validateEmailCopy5(template).length && !template.text.includes("{{purchaserName}}")) {
+            config.emailTemplates = { ...config.emailTemplates, namedSeatInvitation: {
+              ...template,
+              text: "{{purchaserName}} has purchased a membership for you at {{chapterName}}.\n\n" + template.text
+            } };
+          }
           stage = "invitation_delivery";
           const result = await sendTemplated({
             db,
@@ -16241,7 +16384,8 @@ function createMembershipChapterEffectRoute(options) {
               joinUrl: join.href
             },
             dedupeKey: `membership-effect:${effect.effectId}`,
-            applicationId: input.applicationId
+            applicationId: input.applicationId,
+            tierId: effect.skuId
           });
           if (!result.sent) throw new Error("invitation delivery unconfirmed");
         } else {