@odla-ai/chapter 0.54.2 → 0.55.0

package/dist/worker/index.js

@@ -79,10 +79,10 @@ async function clerkGetUserByEmail(secretKey, email, fetchImpl = fetch, source =
   const user = Array.isArray(data) ? data[0] : void 0;
   return user ? toRecord(user, source) : null;
 }
-async function clerkGetUser(secretKey, id6, fetchImpl = fetch, source = "public") {
-  const data = await clerkGet(`/v1/users/${encodeURIComponent(id6)}`, secretKey, fetchImpl).catch(() => null);
+async function clerkGetUser(secretKey, id7, fetchImpl = fetch, source = "public") {
+  const data = await clerkGet(`/v1/users/${encodeURIComponent(id7)}`, secretKey, fetchImpl).catch(() => null);
   const record4 = data ? toRecord(data, source) : null;
-  return record4?.id === id6 ? record4 : null;
+  return record4?.id === id7 ? record4 : null;
 }
 async function clerkListUsers(secretKey, fetchImpl = fetch, source = "public") {
   const out = [];
@@ -98,8 +98,8 @@ async function clerkListUsers(secretKey, fetchImpl = fetch, source = "public") {
   }
   return out;
 }
-async function clerkSetRole(secretKey, id6, role, fetchImpl = fetch, source = "public") {
-  const res = await fetchImpl(`${CLERK_API}/v1/users/${encodeURIComponent(id6)}/metadata`, {
+async function clerkSetRole(secretKey, id7, role, fetchImpl = fetch, source = "public") {
+  const res = await fetchImpl(`${CLERK_API}/v1/users/${encodeURIComponent(id7)}/metadata`, {
     method: "PATCH",
     headers: { authorization: `Bearer ${secretKey}`, "content-type": "application/json" },
     redirect: "manual",
@@ -158,10 +158,10 @@ async function ensureProjectedPerson(deps, input, options = {}) {
   const existing = await find();
   if (existing) return { record: existing, created: false };
   const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`chapter:person:v1:${email}`)));
-  const id6 = `person-${Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  const id7 = `person-${Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
   try {
     const created = await createRecord({ ...deps, db: deps.db }, {
-      id: id6,
+      id: id7,
       type: "person",
       input: { ...input, email },
       ...options
@@ -614,7 +614,10 @@ function verifyInitialMembershipInvoice(intent, evidence) {
   if (!intent.providerSubscriptionId || !intent.providerCustomerId) return { status: "retry" };
   try {
     const terms2 = intent.billingTerms ? subscriptionBillingTerms(intent.billingTerms) : void 0;
-    const due = subscriptionAmountDue({ priceCents: Number(intent.priceCents), billingTerms: terms2 });
+    const quote = intent.paymentQuote;
+    const seatCents = quote?.namedSeat ? quote.lineItems.namedSeatCents : 0;
+    if (!Number.isSafeInteger(seatCents) || Number(seatCents) < 0 || quote?.namedSeat && quote.seatOffer?.amountCents !== seatCents) return { status: "mismatch" };
+    const due = subscriptionAmountDue({ priceCents: Number(intent.priceCents), billingTerms: terms2 }) + Number(seatCents);
     if (!evidence || !/^in_[A-Za-z0-9]+$/.test(evidence.invoiceId ?? "") || evidence.subscriptionId !== intent.providerSubscriptionId || evidence.customerId !== intent.providerCustomerId || evidence.currency !== intent.currency || evidence.total !== due || evidence.amountPaid !== due || due <= 0 || evidence.status !== "paid") return { status: "mismatch" };
     return { status: "verified", ...terms2?.initialTermEndsAt ? { renewalAt: terms2.initialTermEndsAt } : {} };
   } catch {
@@ -965,8 +968,8 @@ async function rebuildNetworkCommercialProjection(db, sources, mutationId, now =
   return projection;
 }
 async function collide(db, sources, stored, fact, now, legacyDigest, alerts) {
-  const id6 = exceptionId(fact.eventId, "collision");
-  const exception = (await db.query({ networkCommercialExceptions: { $: { where: { id: id6 }, limit: 1 } } })).networkCommercialExceptions?.[0];
+  const id7 = exceptionId(fact.eventId, "collision");
+  const exception = (await db.query({ networkCommercialExceptions: { $: { where: { id: id7 }, limit: 1 } } })).networkCommercialExceptions?.[0];
   const exact = stored.digest === fact.digest || stored.digest === legacyDigest;
   const canonical3 = !exact && sameNetworkCommercialFact(stored.fact, fact);
   if (exact || canonical3) {
@@ -987,7 +990,7 @@ async function collide(db, sources, stored, fact, now, legacyDigest, alerts) {
         action: "canonical_replay",
         reason: "a resend matched the retained canonical fact"
       } },
-      { t: "update", ns: "networkCommercialExceptions", id: id6, attrs: {
+      { t: "update", ns: "networkCommercialExceptions", id: id7, attrs: {
         status: "resolved",
         resolvedDigest: stored.digest,
         reviewedDigest: fact.digest,
@@ -996,7 +999,7 @@ async function collide(db, sources, stored, fact, now, legacyDigest, alerts) {
         updatedAt: now
       } }
     ], { mutationId: `network-commercial-resolve:${fact.eventId}:${fact.digest}`, guards: [
-      { ns: "networkCommercialExceptions", id: id6, exists: true, equals: { status: "active", updatedAt: exception.updatedAt } }
+      { ns: "networkCommercialExceptions", id: id7, exists: true, equals: { status: "active", updatedAt: exception.updatedAt } }
     ] });
     const projection2 = await rebuildNetworkCommercialProjection(db, sources, `network-commercial-resolve-rebuild:${fact.eventId}:${fact.digest}`, now, alerts);
     return { status: "replayed", resolvedCollision: true, projection: projection2 };
@@ -1006,9 +1009,9 @@ async function collide(db, sources, stored, fact, now, legacyDigest, alerts) {
   }
   const stale = RESOLUTION_ATTRS.filter((attr3) => exception !== void 0 && Object.hasOwn(exception, attr3));
   await db.transact([
-    ...stale.length ? [{ t: "retract", ns: "networkCommercialExceptions", id: id6, attrs: stale }] : [],
-    { t: "update", ns: "networkCommercialExceptions", id: id6, attrs: {
-      id: id6,
+    ...stale.length ? [{ t: "retract", ns: "networkCommercialExceptions", id: id7, attrs: stale }] : [],
+    { t: "update", ns: "networkCommercialExceptions", id: id7, attrs: {
+      id: id7,
       eventId: fact.eventId,
       kind: "collision",
       status: "active",
@@ -1028,12 +1031,12 @@ async function ingestNetworkCommercialFact(db, sources, fact, now = Date.now(),
   const found = await db.query({ networkCommercialEvents: { $: { where: { eventId: fact.eventId }, limit: 1 } } });
   const existing = found.networkCommercialEvents?.[0];
   if (existing) return collide(db, sources, existing, fact, now, legacyDigest, alerts);
-  const id6 = eventRowId(fact.eventId);
+  const id7 = eventRowId(fact.eventId);
   let lostRace = false;
   let duplicate = false;
   try {
-    const write = await db.transact([{ t: "update", ns: "networkCommercialEvents", id: id6, attrs: {
-      id: id6,
+    const write = await db.transact([{ t: "update", ns: "networkCommercialEvents", id: id7, attrs: {
+      id: id7,
       eventId: fact.eventId,
       digest: fact.digest,
       eventType: fact.eventType,
@@ -1043,7 +1046,7 @@ async function ingestNetworkCommercialFact(db, sources, fact, now = Date.now(),
       receivedAt: now
     } }], {
       mutationId: `network-commercial-ingest:${fact.eventId}:${fact.digest}`,
-      guards: [{ ns: "networkCommercialEvents", id: id6, exists: false }]
+      guards: [{ ns: "networkCommercialEvents", id: id7, exists: false }]
     });
     duplicate = write.duplicate;
   } catch (error) {
@@ -1087,10 +1090,10 @@ async function recoverNetworkCommercialEvent(db, sources, eventId, actorUserId,
   const provider = await readStripeRecoveryEvent(db, eventId);
   const fact = normalizeNetworkCommercialStripeEvent(provider.event, provider.digest);
   if (!sameNetworkCommercialFact(stored.fact, fact)) throw new Error("Stripe facts differ; collision requires investigation");
-  const id6 = crypto.randomUUID();
+  const id7 = crypto.randomUUID();
   await db.transact([
-    { t: "update", ns: "paymentRecoveryReviews", id: id6, attrs: {
-      id: id6,
+    { t: "update", ns: "paymentRecoveryReviews", id: id7, attrs: {
+      id: id7,
       eventId,
       actorUserId,
       reviewedAt: now,
@@ -1105,9 +1108,9 @@ async function recoverNetworkCommercialEvent(db, sources, eventId, actorUserId,
       t: "update",
       ns: "networkCommercialExceptions",
       id: exceptionId2,
-      attrs: { status: "resolved", resolvedDigest: provider.digest, resolvedBy: actorUserId, reviewId: id6, updatedAt: now }
+      attrs: { status: "resolved", resolvedDigest: provider.digest, resolvedBy: actorUserId, reviewId: id7, updatedAt: now }
     }] : []
-  ], { mutationId: `payment-recovery:${id6}`, guards: [
+  ], { mutationId: `payment-recovery:${id7}`, guards: [
     { ns: "networkCommercialEvents", id: eventRowId2, exists: true, equals: { digest: stored.digest } },
     {
       ns: "networkCommercialExceptions",
@@ -1116,8 +1119,8 @@ async function recoverNetworkCommercialEvent(db, sources, eventId, actorUserId,
       ...exception ? { equals: { status: exception.status, updatedAt: exception.updatedAt } } : {}
     }
   ] });
-  await rebuildNetworkCommercialProjection(db, sources, `payment-recovery-rebuild:${id6}`, now, alerts);
-  return { recovered: true, eventId, reviewId: id6 };
+  await rebuildNetworkCommercialProjection(db, sources, `payment-recovery-rebuild:${id7}`, now, alerts);
+  return { recovered: true, eventId, reviewId: id7 };
 }
 
 // src/payments.ts
@@ -1901,11 +1904,11 @@ async function sendTemplated(deps, input) {
   const previous = prior[0];
   if (previous && (previous.groupId !== input.group.id || previous.template !== input.template || previous.to !== decision.to || previous.transport !== decision.transport || previous.applicationId !== input.applicationId)) return { sent: false, reason: "delivery-identity-conflict" };
   const hash2 = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input.dedupeKey));
-  const id6 = previous ? String(previous.id) : `email_${Array.from(new Uint8Array(hash2), (b) => b.toString(16).padStart(2, "0")).join("")}`;
+  const id7 = previous ? String(previous.id) : `email_${Array.from(new Uint8Array(hash2), (b) => b.toString(16).padStart(2, "0")).join("")}`;
   const attempt = Number(previous?.deliveryAttempt ?? 0) + 1;
   if (!Number.isSafeInteger(attempt) || attempt < 1) return { sent: false, reason: "delivery-state-invalid" };
   const row2 = {
-    id: id6,
+    id: id7,
     groupId: input.group.id,
     to: decision.to,
     template: input.template,
@@ -1923,15 +1926,15 @@ async function sendTemplated(deps, input) {
   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}`,
+    const claim = await deps.db.transact([{ t: "update", ns: "emailLog", id: id7, attrs: row2 }], {
+      mutationId: `email-claim:${id7}:${attempt}`,
       guards: [previous ? {
         ns: "emailLog",
-        id: id6,
+        id: id7,
         exists: true,
         equals: { deliveryState: "retry_ready", ...previous.deliveryAttempt !== void 0 ? { deliveryAttempt: previous.deliveryAttempt } : {} },
         ...previous.deliveryAttempt === void 0 ? { absent: ["deliveryAttempt"] } : {}
-      } : { ns: "emailLog", id: id6, exists: false }]
+      } : { ns: "emailLog", id: id7, exists: false }]
     });
     if (claim.duplicate) return { sent: false, reason: "delivery-uncertain" };
   } catch (error) {
@@ -1951,16 +1954,16 @@ async function sendTemplated(deps, input) {
     if (!response || typeof response.messageId !== "string" || !response.messageId) throw new Error("missing delivery receipt");
     messageId = response.messageId;
   } catch {
-    await deps.db.transact([{ t: "update", ns: "emailLog", id: id6, attrs: { deliveryState: "uncertain", error: "delivery-uncertain" } }], {
-      guards: [{ ns: "emailLog", id: id6, exists: true, equals: { deliveryState: "sending", deliveryAttempt: attempt } }]
+    await deps.db.transact([{ t: "update", ns: "emailLog", id: id7, attrs: { deliveryState: "uncertain", error: "delivery-uncertain" } }], {
+      guards: [{ ns: "emailLog", id: id7, exists: true, equals: { deliveryState: "sending", deliveryAttempt: attempt } }]
     });
     return { sent: false, reason: "delivery-uncertain" };
   }
-  await deps.db.transact([{ t: "update", ns: "emailLog", id: id6, attrs: { deliveryState: "sent", error: "", messageId, sentAt: deps.now() } }], {
-    mutationId: `email-confirmed:${id6}:${attempt}`,
+  await deps.db.transact([{ t: "update", ns: "emailLog", id: id7, attrs: { deliveryState: "sent", error: "", messageId, sentAt: deps.now() } }], {
+    mutationId: `email-confirmed:${id7}:${attempt}`,
     guards: [{
       ns: "emailLog",
-      id: id6,
+      id: id7,
       exists: true,
       equals: { deliveryState: "sending", deliveryAttempt: attempt }
     }]
@@ -2145,8 +2148,8 @@ async function hash(value) {
 async function membershipDiscountCouponId(input, policyId) {
   return policyId ? `odla_m_${await hash([input.appId, input.chapterId, input.environment, input.runtime, input.skuId, policyId])}` : void 0;
 }
-async function load(db, ns, id6) {
-  return (await db.query({ [ns]: { $: { where: { id: id6 }, limit: 1 } } }))[ns]?.[0];
+async function load(db, ns, id7) {
+  return (await db.query({ [ns]: { $: { where: { id: id7 }, limit: 1 } } }))[ns]?.[0];
 }
 async function membershipOfferIdForRequest(input) {
   return `offer_${await hash([input.appId, input.chapterId, input.environment, input.runtime, input.applicationId, input.requestId])}`;
@@ -2280,20 +2283,20 @@ async function issueMembershipCommercialOffer(db, input) {
 
 // src/commercial-evidence-guard.ts
 async function commercialEvidenceGuard(db, eventId, digest, code = "membership_payment_evidence_quarantined") {
-  const ns = "networkCommercialExceptions", id6 = `network-commercial-exception:${eventId}:collision`;
-  const row2 = (await db.query({ [ns]: { $: { where: { id: id6 }, limit: 1 } } }))[ns]?.[0];
-  if (!row2) return { ns, id: id6, exists: false };
+  const ns = "networkCommercialExceptions", id7 = `network-commercial-exception:${eventId}:collision`;
+  const row2 = (await db.query({ [ns]: { $: { where: { id: id7 }, limit: 1 } } }))[ns]?.[0];
+  if (!row2) return { ns, id: id7, exists: false };
   if (row2.status !== "resolved" || row2.resolvedDigest !== digest || typeof digest !== "string") {
     throw Object.assign(new Error(code), { code });
   }
-  return { ns, id: id6, exists: true, equals: { status: "resolved", resolvedDigest: digest, updatedAt: row2.updatedAt } };
+  return { ns, id: id7, exists: true, equals: { status: "resolved", resolvedDigest: digest, updatedAt: row2.updatedAt } };
 }
 
 // src/membership-authority-state.ts
 var membershipFail = (code) => {
   throw Object.assign(new Error(code), { code });
 };
-var membershipLoad = async (db, ns, id6) => (await db.query({ [ns]: { $: { where: { id: id6 }, limit: 1 } } }))[ns]?.[0];
+var membershipLoad = async (db, ns, id7) => (await db.query({ [ns]: { $: { where: { id: id7 }, limit: 1 } } }))[ns]?.[0];
 var membershipScopeKeys = ["appId", "chapterId", "environment", "runtime", "applicationId", "skuId"];
 var membershipScope = (input) => Object.fromEntries(membershipScopeKeys.map((key3) => [key3, input[key3]]));
 function requireMembershipScope(row2, input) {
@@ -2304,18 +2307,18 @@ async function loadMembershipAuthorityState(db, input) {
   if (!row2 || row2.mode !== "authoritative" || row2.chapterId !== input.chapterId || row2.environment !== input.environment || !Number.isSafeInteger(row2.revision) || Number(row2.revision) < 1) return membershipFail("membership_authority_unavailable");
   return row2;
 }
-var membershipUpdate = (ns, id6, attrs) => ({ t: "update", ns, id: id6, attrs });
+var membershipUpdate = (ns, id7, attrs) => ({ t: "update", ns, id: id7, attrs });
 var membershipClock = (now) => {
   if (!Number.isSafeInteger(now) || now < 0) membershipFail("invalid_membership_clock");
 };
 
 // src/membership-restart-payment.ts
 async function membershipRestartPayment(db, target, member, now) {
-  const id6 = String(member.id), restart = await membershipLoad(db, "membershipRestart", id6);
+  const id7 = String(member.id), restart = await membershipLoad(db, "membershipRestart", id7);
   requireMembershipScope(restart, target);
-  const entitlement = await membershipLoad(db, "networkEntitlement", `${id6}:primary`);
+  const entitlement = await membershipLoad(db, "networkEntitlement", `${id7}:primary`);
   requireMembershipScope(entitlement, target);
-  if (entitlement.membershipId !== id6 || entitlement.kind !== "primary") membershipFail("membership_restart_conflict");
+  if (entitlement.membershipId !== id7 || entitlement.kind !== "primary") membershipFail("membership_restart_conflict");
   if (restart.status !== "ready" || member.status !== "restarting" || member.restartId !== restart.restartId || member.memberNumber !== restart.memberNumber || !Number.isSafeInteger(member.journeyApprovedAt)) membershipFail("membership_restart_conflict");
   return {
     restartId: String(restart.restartId),
@@ -2332,49 +2335,117 @@ async function membershipRestartPayment(db, target, member, now) {
       graceEndsAt: 0
     },
     ops: [
-      membershipUpdate("membershipRestart", id6, { status: "complete" }),
-      { t: "retract", ns: "networkMembership", id: id6, attrs: ["refundRequestedAt", "cancellationRequestedAt", "discountPolicyVersionId", "discountSnapshot"] }
+      membershipUpdate("membershipRestart", id7, { status: "complete" }),
+      { t: "retract", ns: "networkMembership", id: id7, attrs: ["refundRequestedAt", "cancellationRequestedAt", "discountPolicyVersionId", "discountSnapshot"] }
     ],
     guards: [
-      { ns: "networkMembership", id: id6, exists: true, equals: { status: "restarting", revision: member.revision, restartId: restart.restartId } },
-      { ns: "membershipRestart", id: id6, exists: true, equals: { status: "ready", restartId: restart.restartId } },
+      { ns: "networkMembership", id: id7, exists: true, equals: { status: "restarting", revision: member.revision, restartId: restart.restartId } },
+      { ns: "membershipRestart", id: id7, exists: true, equals: { status: "ready", restartId: restart.restartId } },
       { ns: "networkEntitlement", id: String(entitlement.id), exists: true, equals: { revision: entitlement.revision, status: entitlement.status } }
     ]
   };
 }
 
+// src/checkout-named-seat.ts
+function checkoutNamedSeatSelection(value, purchaserEmail) {
+  const row2 = value;
+  const name = typeof row2?.recipientName === "string" ? row2.recipientName.trim().replace(/\s+/g, " ") : "";
+  const email = normalizeChapterEmail(typeof row2?.recipientEmail === "string" ? row2.recipientEmail : "");
+  const purchaser = normalizeChapterEmail(purchaserEmail);
+  if (!row2 || typeof row2 !== "object" || Array.isArray(row2) || name.length < 2 || name.length > 160 || /[\u0000-\u001f\u007f]/.test(row2.recipientName) || email.length > 254 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(purchaser) || email === purchaser) {
+    throw Object.assign(new Error("Enter a different recipient's name and email."), { code: "invalid_named_seat_recipient" });
+  }
+  return { recipientName: name, recipientEmail: email };
+}
+async function checkoutNamedSeatIdentity(target, email) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify([
+    target.appId,
+    target.chapterId,
+    target.environment,
+    target.runtime,
+    email
+  ])));
+  return {
+    seatId: (await membershipOfferIdForRequest({ ...target, requestId: "named_seat" })).replace(/^offer_/, "seat_"),
+    membershipId: (await membershipOfferIdForRequest({ ...target, requestId: "checkout_binding" })).replace(/^offer_/, "membership_"),
+    recipientClaimId: `seat-recipient:${[...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`
+  };
+}
+
 // src/membership-checkout-binding.ts
 var keys = ["appId", "chapterId", "environment", "runtime", "applicationId", "skuId", "offerId", "offerDigest", "quoteDigest", "priceId"];
 var reject2 = (code) => {
   throw Object.assign(new Error(code), { code });
 };
-var load2 = async (db, ns, id6) => (await db.query({ [ns]: { $: { where: { id: id6 }, limit: 1 } } }))[ns]?.[0];
+var load2 = async (db, ns, id7) => (await db.query({ [ns]: { $: { where: { id: id7 }, limit: 1 } } }))[ns]?.[0];
 async function membershipCheckoutBindingId(input) {
   return (await membershipOfferIdForRequest({ ...input, requestId: "checkout_binding" })).replace(/^offer_/, "checkout_");
 }
 async function verifyMembershipCheckoutBinding(value, input) {
   const row2 = value;
   if (!row2 || typeof row2 !== "object" || row2.id !== await membershipCheckoutBindingId(input) || keys.some((key3) => row2[key3] !== input[key3]) || !Number.isSafeInteger(row2.boundAt) || row2.boundAt < 0) return reject2("membership_checkout_conflict");
-  return { id: row2.id, ...Object.fromEntries(keys.map((key3) => [key3, input[key3]])), boundAt: row2.boundAt };
+  if (Boolean(row2.namedSeat) !== Boolean(input.namedSeat)) return reject2("membership_checkout_conflict");
+  if (input.namedSeat) {
+    const expected = {
+      ...checkoutNamedSeatSelection(input.namedSeat, input.namedSeat.purchaserEmail),
+      purchaserEmail: normalizeChapterEmail(input.namedSeat.purchaserEmail)
+    };
+    const identity2 = await checkoutNamedSeatIdentity(input, expected.recipientEmail);
+    if (!row2.namedSeat || Object.entries({ ...expected, ...identity2 }).some(([key3, value2]) => row2.namedSeat[key3] !== value2) || !/^price_[A-Za-z0-9_]+$/.test(row2.namedSeat.priceId) || row2.namedSeat.priceId === input.priceId || !Number.isSafeInteger(row2.namedSeat.amountCents) || row2.namedSeat.amountCents < 0) return reject2("membership_checkout_conflict");
+  }
+  return {
+    id: row2.id,
+    ...Object.fromEntries(keys.map((key3) => [key3, input[key3]])),
+    boundAt: row2.boundAt,
+    ...row2.namedSeat ? { namedSeat: row2.namedSeat } : {}
+  };
 }
-async function bindMembershipCheckout(db, input, now) {
+async function bindMembershipCheckout(db, input, now, seatPriceId) {
   if (!Number.isSafeInteger(now) || now < 0 || !/^[a-f0-9]{64}$/.test(input.offerDigest) || !/^[a-f0-9]{64}$/.test(input.quoteDigest) || !/^price_[A-Za-z0-9_]+$/.test(input.priceId)) return reject2("invalid_membership_checkout");
   const stateId = `${input.chapterId}:${input.environment}`;
   const state = await load2(db, "membershipAuthorityState", stateId);
   if (!state || state.mode !== "authoritative" || state.chapterId !== input.chapterId || state.environment !== input.environment || !Number.isSafeInteger(state.revision) || Number(state.revision) < 1) return reject2("membership_authority_unavailable");
-  const id6 = await membershipCheckoutBindingId(input);
-  const existing = await load2(db, "membershipOfferCheckout", id6);
+  const id7 = await membershipCheckoutBindingId(input);
+  const existing = await load2(db, "membershipOfferCheckout", id7);
   if (existing) return verifyMembershipCheckoutBinding(existing, input);
   const row2 = await load2(db, "membershipCheckoutOffer", input.offerId);
   const offer = await verifyIssuedMembershipOffer(row2, { ...input, now, lifetimeMs: 6e4 });
   if (offer.digest !== input.offerDigest || offer.expiresAt <= now || offer.issuedAt > now) return reject2("membership_offer_expired");
-  const restart = await load2(db, "membershipRestart", id6.replace(/^checkout_/, "membership_"));
-  const receipt = { id: id6, ...Object.fromEntries(keys.map((key3) => [key3, input[key3]])), boundAt: now };
+  const restart = await load2(db, "membershipRestart", id7.replace(/^checkout_/, "membership_"));
+  let namedSeat;
+  if (input.namedSeat) {
+    if (!seatPriceId || !/^price_[A-Za-z0-9_]+$/.test(seatPriceId) || seatPriceId === input.priceId || restart) return reject2("named_seat_purchase_unavailable");
+    const selection = checkoutNamedSeatSelection(input.namedSeat, input.namedSeat.purchaserEmail);
+    namedSeat = {
+      ...selection,
+      purchaserEmail: normalizeChapterEmail(input.namedSeat.purchaserEmail),
+      ...await checkoutNamedSeatIdentity(input, selection.recipientEmail),
+      priceId: seatPriceId,
+      amountCents: offer.contract.offering.seatPriceCents
+    };
+  }
+  const receipt = { id: id7, ...Object.fromEntries(keys.map((key3) => [key3, input[key3]])), boundAt: now, ...namedSeat ? { namedSeat } : {} };
   try {
-    await db.transact([{ t: "update", ns: "membershipOfferCheckout", id: id6, attrs: receipt }], {
-      mutationId: `membership-checkout:${id6}${restart?.restartId ? `:${restart.restartId}` : ""}`,
+    await db.transact([
+      { t: "update", ns: "membershipOfferCheckout", id: id7, attrs: receipt },
+      ...namedSeat ? [{ t: "update", ns: "networkSeatRecipient", id: namedSeat.recipientClaimId, attrs: {
+        id: namedSeat.recipientClaimId,
+        appId: input.appId,
+        chapterId: input.chapterId,
+        environment: input.environment,
+        runtime: input.runtime,
+        seatId: namedSeat.seatId,
+        recipientEmailNormalized: namedSeat.recipientEmail,
+        createdAt: now
+      } }] : []
+    ], {
+      mutationId: `membership-checkout:${id7}${restart?.restartId ? `:${restart.restartId}` : ""}`,
       guards: [
-        { ns: "membershipOfferCheckout", id: id6, exists: false },
+        { ns: "membershipOfferCheckout", id: id7, exists: false },
+        ...namedSeat ? [
+          { ns: "networkSeat", id: namedSeat.seatId, exists: false },
+          { ns: "networkSeatRecipient", id: namedSeat.recipientClaimId, exists: false }
+        ] : [],
         { ns: "membershipCheckoutOffer", id: input.offerId, exists: true, equals: { digest: input.offerDigest } },
         { ns: "membershipAuthorityState", id: stateId, exists: true, equals: { mode: "authoritative", revision: state.revision } }
       ]
@@ -2382,11 +2453,78 @@ async function bindMembershipCheckout(db, input, now) {
   } catch (error) {
     if (error.code !== "transact_guard_failed") throw error;
   }
-  const saved = await load2(db, "membershipOfferCheckout", id6);
+  const saved = await load2(db, "membershipOfferCheckout", id7);
   if (!saved) return reject2("membership_binding_unconfirmed");
   return verifyMembershipCheckoutBinding(saved, input);
 }
 
+// src/membership-checkout-seat-payment.ts
+function checkoutSeatPaymentOperations(target, seat, input) {
+  const { now, paidAt, endsAt } = input;
+  const included = seat.amountCents === 0, entitlementId = `${seat.seatId}:entitlement`;
+  const effectId = `${seat.seatId}:${included ? "invite" : "attach-renewal"}`;
+  return [
+    membershipUpdate("networkSeat", seat.seatId, {
+      id: seat.seatId,
+      ...membershipScope(target),
+      primaryMembershipId: seat.membershipId,
+      purchaserEmailNormalized: seat.purchaserEmail,
+      recipientName: seat.recipientName,
+      recipientEmailNormalized: seat.recipientEmail,
+      recipientClaimId: seat.recipientClaimId,
+      priceId: seat.priceId,
+      primaryPriceId: input.primaryPriceId,
+      amountCents: seat.amountCents,
+      currency: input.offering.currency,
+      interval: input.offering.interval,
+      providerCustomerId: input.customerId,
+      providerSubscriptionId: input.subscriptionId,
+      combinedInvoice: { invoiceId: input.invoiceId, totalCents: input.invoiceTotalCents },
+      status: included ? "pending_acceptance" : "renewal_pending",
+      preparedAt: input.boundAt,
+      purchasedAt: paidAt,
+      termStartedAt: paidAt,
+      termEndsAt: endsAt,
+      acceptanceEndsAt: endsAt,
+      seatPurchaseEndsAt: seatPurchaseDeadline(input.offering, { initialTermStartedAt: paidAt, termEndsAt: endsAt }),
+      offeringSnapshot: input.offering,
+      paymentEventId: input.eventId,
+      ...included ? { entitlementId } : {},
+      revision: 1,
+      createdAt: now,
+      updatedAt: now
+    }),
+    ...included ? [membershipUpdate("networkEntitlement", entitlementId, {
+      id: entitlementId,
+      ...membershipScope(target),
+      membershipId: seat.membershipId,
+      seatId: seat.seatId,
+      kind: "named_seat",
+      status: "pending_acceptance",
+      termStartedAt: paidAt,
+      termEndsAt: endsAt,
+      offeringSnapshot: input.offering,
+      sourceEventId: input.eventId,
+      revision: 1,
+      createdAt: now,
+      updatedAt: now
+    })] : [],
+    membershipUpdate("membershipEffect", effectId, {
+      id: effectId,
+      chapterId: target.chapterId,
+      environment: target.environment,
+      runtime: target.runtime,
+      membershipId: seat.membershipId,
+      seatId: seat.seatId,
+      kind: included ? "invite_named_recipient" : "attach_seat_renewal",
+      status: "pending",
+      attempts: 0,
+      createdAt: now,
+      updatedAt: now
+    })
+  ];
+}
+
 // src/membership-payment-authority.ts
 async function networkMembershipId(input) {
   return (await membershipCheckoutBindingId(input)).replace(/^checkout_/, "membership_");
@@ -2402,11 +2540,14 @@ async function confirmMembershipPayment(db, input, now) {
     { ...input, offerId: String(binding.offerId), now, lifetimeMs: 6e4 }
   );
   if (binding.offerDigest !== offer.digest) membershipFail("membership_checkout_conflict");
+  const { namedSeat } = await verifyMembershipCheckoutBinding(binding, binding);
+  if (namedSeat && namedSeat.amountCents !== offer.contract.offering.seatPriceCents) membershipFail("membership_checkout_conflict");
+  const totalCents = offer.contract.dueTodayCents + (namedSeat?.amountCents ?? 0);
   const eventRow = await membershipLoad(db, "networkCommercialEvents", `network-commercial-event:${input.eventId}`);
   if (!eventRow) membershipFail("membership_payment_evidence_pending");
   const evidenceGuard = await commercialEvidenceGuard(db, input.eventId, eventRow.digest);
   const fact = eventRow.fact;
-  if (!fact || !fact.identity || !/^[a-f0-9]{64}$/.test(String(eventRow.digest)) || fact.digest !== eventRow.digest || fact.eventId !== input.eventId || fact.eventType !== "invoice.payment_succeeded" || fact.objectKind !== "invoice" || fact.billingReason !== "subscription_create" || fact.livemode !== (input.environment === "prod") || fact.status !== "paid" || fact.applicationId !== input.applicationId || fact.subscriptionId !== input.providerSubscriptionId || fact.customerId !== input.providerCustomerId || !/^in_[A-Za-z0-9_]+$/.test(fact.invoiceId ?? "") || fact.currency !== offer.contract.offering.currency || fact.invoiceTotalCents !== offer.contract.dueTodayCents || fact.amountPaidCents !== offer.contract.dueTodayCents || Object.entries({
+  if (!fact || !fact.identity || !/^[a-f0-9]{64}$/.test(String(eventRow.digest)) || fact.digest !== eventRow.digest || fact.eventId !== input.eventId || fact.eventType !== "invoice.payment_succeeded" || fact.objectKind !== "invoice" || fact.billingReason !== "subscription_create" || fact.livemode !== (input.environment === "prod") || fact.status !== "paid" || fact.applicationId !== input.applicationId || fact.subscriptionId !== input.providerSubscriptionId || fact.customerId !== input.providerCustomerId || !/^in_[A-Za-z0-9_]+$/.test(fact.invoiceId ?? "") || fact.currency !== offer.contract.offering.currency || fact.invoiceTotalCents !== totalCents || fact.amountPaidCents !== totalCents || Object.entries({
     appId: input.appId,
     chapterId: input.chapterId,
     environment: input.environment,
@@ -2418,14 +2559,14 @@ async function confirmMembershipPayment(db, input, now) {
   const paidAt = fact.invoicePaidAt;
   const endsAt = offer.contract.initialTermEndsAt ?? fact.invoicePeriodEndsAt;
   if (!Number.isSafeInteger(paidAt) || Number(paidAt) < Math.floor(Number(binding.boundAt) / 1e3) * 1e3 || Number(paidAt) > now + 3e4 || !Number.isSafeInteger(endsAt) || Number(endsAt) <= Number(paidAt)) membershipFail("membership_payment_period_mismatch");
-  const id6 = await networkMembershipId(input), entitlementId = `${id6}:primary`;
-  let member = await membershipLoad(db, "networkMembership", id6);
+  const id7 = await networkMembershipId(input), entitlementId = `${id7}:primary`;
+  let member = await membershipLoad(db, "networkMembership", id7);
   if (!member || member.status === "restarting") {
     const offering = offer.contract.offering;
     const restart = member ? await membershipRestartPayment(db, input, member, now) : null;
     const attrs = {
-      id: id6,
-      membershipId: id6,
+      id: id7,
+      membershipId: id7,
       ...membershipScope(input),
       baseSkuId: input.skuId,
       status: "paid_pending_approval",
@@ -2441,8 +2582,9 @@ async function confirmMembershipPayment(db, input, now) {
       founding: offer.contract.founding,
       cohort: offer.contract.founding ? offer.contract.discountPolicy.cohortLabel : "standard",
       baseAmountCents: offering.basePriceCents,
-      amountCents: offer.contract.dueTodayCents,
+      amountCents: totalCents,
       renewalAmountCents: offer.contract.renewalCents,
+      ...namedSeat ? { namedSeatId: namedSeat.seatId } : {},
       currency: offering.currency,
       interval: offering.interval,
       initialTermStartedAt: paidAt,
@@ -2459,11 +2601,11 @@ async function confirmMembershipPayment(db, input, now) {
     };
     try {
       await db.transact([
-        membershipUpdate("networkMembership", id6, attrs),
+        membershipUpdate("networkMembership", id7, attrs),
         membershipUpdate("networkEntitlement", entitlementId, {
           id: entitlementId,
           ...membershipScope(input),
-          membershipId: id6,
+          membershipId: id7,
           kind: "primary",
           status: restart?.attrs.status === "active" ? "active" : "pending_approval",
           termStartedAt: paidAt,
@@ -2475,23 +2617,45 @@ async function confirmMembershipPayment(db, input, now) {
           updatedAt: now,
           ...restart?.entitlementAttrs
         }),
-        ...restart?.ops ?? []
-      ], { mutationId: `membership-paid:${id6}${restart ? `:${restart.restartId}` : ""}`, guards: [
-        ...restart?.guards ?? [{ ns: "networkMembership", id: id6, exists: false }],
+        ...restart?.ops ?? [],
+        ...namedSeat ? checkoutSeatPaymentOperations(input, namedSeat, {
+          offering,
+          primaryPriceId: String(binding.priceId),
+          invoiceId: fact.invoiceId,
+          invoiceTotalCents: totalCents,
+          subscriptionId: input.providerSubscriptionId,
+          customerId: input.providerCustomerId,
+          eventId: input.eventId,
+          paidAt: Number(paidAt),
+          endsAt: Number(endsAt),
+          boundAt: Number(binding.boundAt),
+          now
+        }) : []
+      ], { mutationId: `membership-paid:${id7}${restart ? `:${restart.restartId}` : ""}`, guards: [
+        ...restart?.guards ?? [{ ns: "networkMembership", id: id7, exists: false }],
+        ...namedSeat ? [
+          { ns: "networkSeat", id: namedSeat.seatId, exists: false },
+          {
+            ns: "networkSeatRecipient",
+            id: namedSeat.recipientClaimId,
+            exists: true,
+            equals: { seatId: namedSeat.seatId, recipientEmailNormalized: namedSeat.recipientEmail }
+          }
+        ] : [],
         { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative", revision: state.revision } },
-        { ns: "membershipOfferCheckout", id: String(binding.id), exists: true, equals: { offerDigest: offer.digest } },
+        { ns: "membershipOfferCheckout", id: String(binding.id), exists: true, equals: { offerDigest: offer.digest, quoteDigest: binding.quoteDigest } },
         { ns: "networkCommercialEvents", id: String(eventRow.id), exists: true, equals: { digest: eventRow.digest } },
         evidenceGuard
       ] });
     } catch (error) {
       if (error.code !== "transact_guard_failed") throw error;
     }
-    member = await membershipLoad(db, "networkMembership", id6);
+    member = await membershipLoad(db, "networkMembership", id7);
   }
   requireMembershipScope(member, input);
   if (member.purchaseOfferDigest !== offer.digest || member.providerInitialInvoiceId !== fact.invoiceId || member.providerSubscriptionId !== fact.subscriptionId || member.providerCustomerId !== fact.customerId) membershipFail("membership_purchase_conflict");
   return {
-    membershipId: id6,
+    membershipId: id7,
     status: String(member.status),
     cohort: String(member.cohort),
     initialTermStartedAt: Number(member.initialTermStartedAt),
@@ -2562,19 +2726,19 @@ async function stopPreviousSubscription(member, target, secret) {
 async function prepareMembershipRestart(db, input, now, stripeSecret) {
   membershipClock(now);
   if (!/^sub_[A-Za-z0-9_]+$/.test(input.previousSubscriptionId)) membershipFail("membership_restart_conflict");
-  const id6 = await networkMembershipId(input), bindingId = await membershipCheckoutBindingId(input);
-  const restartId = `restart_${await stripePayloadDigest(JSON.stringify([id6, input.previousSubscriptionId]))}`;
+  const id7 = await networkMembershipId(input), bindingId = await membershipCheckoutBindingId(input);
+  const restartId = `restart_${await stripePayloadDigest(JSON.stringify([id7, input.previousSubscriptionId]))}`;
   const state = await loadMembershipAuthorityState(db, input);
-  const previous = await membershipLoad(db, "networkMembership", id6);
+  const previous = await membershipLoad(db, "networkMembership", id7);
   requireMembershipScope(previous, input);
   const receipt = {
     applicationId: input.applicationId,
-    membershipId: id6,
+    membershipId: id7,
     restartId,
     memberNumber: Number(previous.memberNumber),
     status: "ready"
   };
-  const existing = await membershipLoad(db, "membershipRestart", id6);
+  const existing = await membershipLoad(db, "membershipRestart", id7);
   if (existing?.restartId === restartId && existing.status === "ready") {
     requireMembershipScope(existing, input);
     return receipt;
@@ -2590,33 +2754,33 @@ async function prepareMembershipRestart(db, input, now, stripeSecret) {
       membershipUpdate("membershipPurchaseHistory", restartId, {
         id: restartId,
         ...membershipScope(input),
-        membershipId: id6,
+        membershipId: id7,
         providerSubscriptionId: input.previousSubscriptionId,
         memberSnapshot: previous,
         bindingSnapshot: binding2,
         archivedAt: now
       }),
-      membershipUpdate("networkMembership", id6, { status: "restarting", restartId, revision: Number(previous.revision) + 1, updatedAt: now })
+      membershipUpdate("networkMembership", id7, { status: "restarting", restartId, revision: Number(previous.revision) + 1, updatedAt: now })
     ], { mutationId: `membership-restart-reserve:${restartId}`, guards: [
       ...seats.guards,
-      { ns: "networkMembership", id: id6, exists: true, equals: { revision: previous.revision, status: previous.status } },
+      { ns: "networkMembership", id: id7, exists: true, equals: { revision: previous.revision, status: previous.status } },
       { ns: "membershipPurchaseHistory", id: restartId, exists: false },
       { ns: "membershipOfferCheckout", id: bindingId, exists: true, equals: { offerDigest: binding2.offerDigest } },
       { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative", revision: state.revision } }
     ] });
   } else if (previous.restartId !== restartId) membershipFail("membership_restart_conflict");
-  const reserved = await membershipLoad(db, "networkMembership", id6);
+  const reserved = await membershipLoad(db, "networkMembership", id7);
   requireMembershipScope(reserved, input);
   if (reserved.status !== "restarting" || reserved.restartId !== restartId) membershipFail("membership_restart_conflict");
   await stopPreviousSubscription(reserved, input, stripeSecret);
   const binding = await membershipLoad(db, "membershipOfferCheckout", bindingId);
   requireMembershipScope(binding, input);
   await db.transact([
-    membershipUpdate("membershipRestart", id6, { id: id6, ...membershipScope(input), ...receipt, previousSubscriptionId: input.previousSubscriptionId, createdAt: now }),
+    membershipUpdate("membershipRestart", id7, { id: id7, ...membershipScope(input), ...receipt, previousSubscriptionId: input.previousSubscriptionId, createdAt: now }),
     { t: "delete", ns: "membershipOfferCheckout", id: bindingId }
   ], { mutationId: `membership-restart-ready:${restartId}`, guards: [
-    { ns: "membershipRestart", id: id6, exists: Boolean(existing), ...existing ? { equals: { restartId: existing.restartId, status: existing.status } } : {} },
-    { ns: "networkMembership", id: id6, exists: true, equals: { revision: reserved.revision, status: "restarting", restartId } },
+    { ns: "membershipRestart", id: id7, exists: Boolean(existing), ...existing ? { equals: { restartId: existing.restartId, status: existing.status } } : {} },
+    { ns: "networkMembership", id: id7, exists: true, equals: { revision: reserved.revision, status: "restarting", restartId } },
     { ns: "membershipOfferCheckout", id: bindingId, exists: true, equals: { offerDigest: binding.offerDigest } }
   ] });
   return receipt;
@@ -2626,15 +2790,15 @@ async function prepareMembershipRestart(db, input, now, stripeSecret) {
 async function readMembershipAccess(db, input, now) {
   membershipClock(now);
   await loadMembershipAuthorityState(db, input);
-  const id6 = await networkMembershipId(input), member = await membershipLoad(db, "networkMembership", id6);
-  if (!member) return { membershipId: id6, allowed: false, status: "unpaid", accessEndsAt: 0, revision: 0 };
+  const id7 = await networkMembershipId(input), member = await membershipLoad(db, "networkMembership", id7);
+  if (!member) return { membershipId: id7, allowed: false, status: "unpaid", accessEndsAt: 0, revision: 0 };
   requireMembershipScope(member, input);
-  const entitlement = await membershipLoad(db, "networkEntitlement", `${id6}:primary`);
+  const entitlement = await membershipLoad(db, "networkEntitlement", `${id7}:primary`);
   requireMembershipScope(entitlement, input);
   const endsAt = member.status === "payment_grace" ? Number(member.graceEndsAt) : Number(member.termEndsAt);
-  const allowed2 = ["active", "cancel_at_term_end", "payment_grace"].includes(String(member.status)) && member.journeyApprovedAt !== void 0 && Number.isSafeInteger(member.memberNumber) && Number(member.memberNumber) > 0 && member.refundedCents === 0 && entitlement.status === "active" && entitlement.membershipId === id6 && entitlement.kind === "primary" && Number.isSafeInteger(endsAt) && endsAt > now && Number(member.termStartedAt) <= now;
+  const allowed2 = ["active", "cancel_at_term_end", "payment_grace"].includes(String(member.status)) && member.journeyApprovedAt !== void 0 && Number.isSafeInteger(member.memberNumber) && Number(member.memberNumber) > 0 && member.refundedCents === 0 && entitlement.status === "active" && entitlement.membershipId === id7 && entitlement.kind === "primary" && Number.isSafeInteger(endsAt) && endsAt > now && Number(member.termStartedAt) <= now;
   return {
-    membershipId: id6,
+    membershipId: id7,
     allowed: allowed2,
     status: String(member.status),
     accessEndsAt: Number.isSafeInteger(endsAt) ? endsAt : 0,
@@ -2752,7 +2916,7 @@ async function refundChapterNetworkMembership(db, env, ctx, app) {
   const target = await membershipTargetForIntent(intent, app, env, ctx);
   const receipt = await ctx.membershipAuthority.refundMembership(target, env);
   const offer = intent.membershipOffer;
-  if (receipt.membershipId !== await networkMembershipId(target) || receipt.status !== "refunded" || receipt.subscriptionCanceled !== true || receipt.refundedCents !== offer.contract?.dueTodayCents) throw new Error("membership refund unconfirmed");
+  if (receipt.membershipId !== await networkMembershipId(target) || receipt.status !== "refunded" || receipt.subscriptionCanceled !== true || receipt.refundedCents !== Number(offer.contract?.dueTodayCents) + Number(intent.paymentQuote?.lineItems?.namedSeatCents ?? 0)) throw new Error("membership refund unconfirmed");
   return receipt;
 }
 async function renewChapterNetworkMembership(db, env, ctx, app, eventId) {
@@ -2803,14 +2967,14 @@ function facts(snapshots) {
     ["payment_intent.updated", snapshots.payments?.objects ?? []]
   ];
   return groups.flatMap(([eventType, objects]) => objects.map((object2) => {
-    const id6 = typeof object2.id === "string" ? object2.id : "invalid";
+    const id7 = typeof object2.id === "string" ? object2.id : "invalid";
     return normalizeNetworkCommercialStripeEvent({
-      id: `evt_snapshot_${eventType.replaceAll(".", "_")}_${id6}`,
+      id: `evt_snapshot_${eventType.replaceAll(".", "_")}_${id7}`,
       type: eventType,
       created: typeof object2.created === "number" ? object2.created : 0,
       livemode: object2.livemode === true,
       data: { object: object2 }
-    }, `stripe-snapshot:${eventType}:${id6}`);
+    }, `stripe-snapshot:${eventType}:${id7}`);
   }));
 }
 var selected = (row2) => ({
@@ -2885,9 +3049,9 @@ async function chapterBillingSubscriptions(secretKey, chapterId, env) {
 // src/approve-application.ts
 async function approveApplication(input) {
   const { db, env, ctx } = input;
-  const id6 = String(input.app.id ?? "");
-  if (!id6) return { ok: false, status: 404, error: "not found" };
-  const app = (await db.query({ applications: { $: { where: { id: id6 }, limit: 1 } } })).applications?.[0];
+  const id7 = String(input.app.id ?? "");
+  if (!id7) return { ok: false, status: 404, error: "not found" };
+  const app = (await db.query({ applications: { $: { where: { id: id7 }, limit: 1 } } })).applications?.[0];
   if (!app || !chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME)) {
     return { ok: false, status: 404, error: "not found" };
   }
@@ -2921,10 +3085,10 @@ async function approveApplication(input) {
   try {
     if (!duplicate) {
       const write = await db.transact(
-        [{ t: "update", ns: "applications", id: id6, attrs: { status: "approved", approvalEffectsPending: true, approvalEffectsOrigin: input.origin } }],
-        { mutationId: `approve:${id6}`, guards: [{
+        [{ t: "update", ns: "applications", id: id7, attrs: { status: "approved", approvalEffectsPending: true, approvalEffectsOrigin: input.origin } }],
+        { mutationId: `approve:${id7}`, guards: [{
           ns: "applications",
-          id: id6,
+          id: id7,
           exists: true,
           equals: Object.fromEntries(guardFields.filter((key3) => app[key3] !== void 0).map((key3) => [key3, app[key3]])),
           absent: guardFields.filter((key3) => app[key3] === void 0)
@@ -2936,7 +3100,7 @@ async function approveApplication(input) {
     if (error.code !== "transact_guard_failed") throw error;
     return { ok: false, status: 409, error: "application changed; reload before approving" };
   }
-  const current = (await db.query({ applications: { $: { where: { id: id6 }, limit: 1 } } })).applications?.[0];
+  const current = (await db.query({ applications: { $: { where: { id: id7 }, limit: 1 } } })).applications?.[0];
   if (!current || current.status !== "approved" || current.canceled === true || guardFields.filter((key3) => key3 !== "status").some((key3) => current[key3] !== app[key3])) {
     return { ok: false, status: 409, error: "application changed; approval effects were not applied" };
   }
@@ -2946,7 +3110,7 @@ async function approveApplication(input) {
   } catch {
     return { ok: false, status: 503, error: "network membership approval reconciliation pending" };
   }
-  const afterAuthority = (await db.query({ applications: { $: { where: { id: id6 }, limit: 1 } } })).applications?.[0];
+  const afterAuthority = (await db.query({ applications: { $: { where: { id: id7 }, limit: 1 } } })).applications?.[0];
   if (!afterAuthority || afterAuthority.status !== "approved" || afterAuthority.canceled === true || guardFields.filter((key3) => key3 !== "status").some((key3) => afterAuthority[key3] !== app[key3])) {
     return { ok: false, status: 409, error: "application changed during network approval" };
   }
@@ -2959,7 +3123,7 @@ async function approveApplication(input) {
     if (!userId && typeof app.email === "string") {
       const found = await clerkGetUserByEmail(secret, app.email, fetch, clerkRoleMetadata(ctx.chapter.auth));
       userId = found?.id ?? null;
-      if (userId) await db.transact([{ t: "update", ns: "applications", id: id6, attrs: { clerkUserId: userId } }]);
+      if (userId) await db.transact([{ t: "update", ns: "applications", id: id7, attrs: { clerkUserId: userId } }]);
     }
     if (userId) {
       const user = await clerkGetUser(secret, userId, fetch, clerkRoleMetadata(ctx.chapter.auth));
@@ -2981,8 +3145,8 @@ async function approveApplication(input) {
         template: send,
         to: app.email,
         vars: { firstName: String(app.firstName ?? ""), membersUrl: `${input.origin}/members/` },
-        applicationId: id6,
-        dedupeKey: `approve:${id6}`
+        applicationId: id7,
+        dedupeKey: `approve:${id7}`
       }
     );
     emailLogged = result.sent;
@@ -2990,10 +3154,10 @@ async function approveApplication(input) {
       return { ok: false, status: 503, error: "approval notice reconciliation pending", rolePromoted, emailLogged };
     }
   }
-  await db.transact([{ t: "update", ns: "applications", id: id6, attrs: { approvalEffectsPending: false } }], {
+  await db.transact([{ t: "update", ns: "applications", id: id7, attrs: { approvalEffectsPending: false } }], {
     guards: [{
       ns: "applications",
-      id: id6,
+      id: id7,
       exists: true,
       equals: { status: "approved", ...app.canceled !== void 0 ? { canceled: app.canceled } : {} },
       ...app.canceled === void 0 ? { absent: ["canceled"] } : {}
@@ -3215,10 +3379,10 @@ async function redeemGiftClaim(db, claim, beneficiary, now) {
       tierId: target.tierId,
       ...typeof existing?.clerkUserId === "string" ? { clerkUserId: existing.clerkUserId } : {}
     };
-    const id6 = existing ? String(existing.id) : `gift-application:${String(claim.id)}`;
+    const id7 = existing ? String(existing.id) : `gift-application:${String(claim.id)}`;
     const status2 = existing && existing.status !== "submitted" ? String(existing.status) : "paid_pending_vetting";
-    ops.push({ t: "update", ns: "applications", id: id6, attrs: {
-      id: id6,
+    ops.push({ t: "update", ns: "applications", id: id7, attrs: {
+      id: id7,
       groupId: chapterId,
       email: beneficiary.email,
       emailNormalized,
@@ -3229,12 +3393,12 @@ async function redeemGiftClaim(db, claim, beneficiary, now) {
       clerkUserId: beneficiary.userId,
       ...existing ? {} : { createdAt: now }
     } });
-    result = { kind: "application", id: id6 };
+    result = { kind: "application", id: id7 };
   } else {
     if (beneficiary.applicationId) return null;
-    const id6 = `gift-entitlement:${String(claim.id)}`;
-    ops.push({ t: "update", ns: "giftEntitlements", id: id6, attrs: {
-      id: id6,
+    const id7 = `gift-entitlement:${String(claim.id)}`;
+    ops.push({ t: "update", ns: "giftEntitlements", id: id7, attrs: {
+      id: id7,
       claimId: String(claim.id),
       orderId: String(claim.orderId),
       chapterId,
@@ -3244,7 +3408,7 @@ async function redeemGiftClaim(db, claim, beneficiary, now) {
       active: true,
       createdAt: now
     } });
-    result = { kind: "entitlement", id: id6 };
+    result = { kind: "entitlement", id: id7 };
   }
   ops.unshift({ t: "update", ns: "giftClaims", id: String(claim.id), attrs: {
     status: "redeemed",
@@ -3418,9 +3582,9 @@ async function storeStripeReceipt(db, input) {
     return "stored";
   }
   if (existing) return existing.digest === input.digest || existing.digest === input.legacyDigest ? "replayed" : "collision";
-  const id6 = `stripe-event:${input.eventId}`;
-  const write = await db.transact([{ t: "update", ns: "stripeEventReceipts", id: id6, attrs: {
-    id: id6,
+  const id7 = `stripe-event:${input.eventId}`;
+  const write = await db.transact([{ t: "update", ns: "stripeEventReceipts", id: id7, attrs: {
+    id: id7,
     eventId: input.eventId,
     digest: input.digest,
     disposition: input.disposition,
@@ -3652,9 +3816,9 @@ var EVENT_ID = /^evt_[A-Za-z0-9_]{1,150}$/;
 var fail3 = (message, code) => Object.assign(new Error(message), { code });
 async function resolveNetworkCommercialCollision(db, sources, input, now = Date.now(), alerts) {
   if (!EVENT_ID.test(input.eventId)) throw fail3("invalid event reference", "invalid_event");
-  const id6 = exceptionId(input.eventId, "collision"), reviewId = `resolve:${input.mutationId}`;
+  const id7 = exceptionId(input.eventId, "collision"), reviewId = `resolve:${input.mutationId}`;
   const found = await db.query({
-    networkCommercialExceptions: { $: { where: { id: id6 }, limit: 1 } },
+    networkCommercialExceptions: { $: { where: { id: id7 }, limit: 1 } },
     networkCommercialEvents: { $: { where: { eventId: input.eventId }, limit: 1 } }
   });
   const exception = found.networkCommercialExceptions?.[0], stored = found.networkCommercialEvents?.[0];
@@ -3677,7 +3841,7 @@ async function resolveNetworkCommercialCollision(db, sources, input, now = Date.
       action: "resolve",
       reason: input.reason
     } },
-    { t: "update", ns: "networkCommercialExceptions", id: id6, attrs: {
+    { t: "update", ns: "networkCommercialExceptions", id: id7, attrs: {
       status: "resolved",
       resolvedDigest: stored.digest,
       ...dismissed ? { reviewedDigest: dismissed } : {},
@@ -3686,7 +3850,7 @@ async function resolveNetworkCommercialCollision(db, sources, input, now = Date.
       updatedAt: now
     } }
   ], { mutationId: input.mutationId, guards: [
-    { ns: "networkCommercialExceptions", id: id6, exists: true, equals: { status: "active", updatedAt: exception.updatedAt } }
+    { ns: "networkCommercialExceptions", id: id7, exists: true, equals: { status: "active", updatedAt: exception.updatedAt } }
   ] });
   if (write.duplicate) throw fail3("mutationId was already used for another change", "mutation_reused");
   const projection = await rebuildNetworkCommercialProjection(db, sources, `${input.mutationId}:rebuild`, now, alerts);
@@ -3801,10 +3965,10 @@ var handlePaymentRecovery = async (req, url, env, ctx) => {
     const provider = await readStripeRecoveryEvent(db, eventId);
     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();
+    const id7 = crypto.randomUUID();
     await db.transact([
-      { t: "update", ns: "paymentRecoveryReviews", id: id6, attrs: {
-        id: id6,
+      { t: "update", ns: "paymentRecoveryReviews", id: id7, attrs: {
+        id: id7,
         eventId,
         actorUserId: user.userId,
         reviewedAt: Date.now(),
@@ -3813,8 +3977,8 @@ var handlePaymentRecovery = async (req, url, env, ctx) => {
         scope: `${target.appId}:${target.environment}:${target.runtime}`,
         previousState: row2
       } },
-      { t: "update", ns: "stripeEventReceipts", id: String(row2.id), attrs: { retryReady: true, reviewedDigest: provider.digest, reviewId: id6 } }
-    ], { mutationId: `payment-recovery:${id6}`, guards: [{
+      { t: "update", ns: "stripeEventReceipts", id: String(row2.id), attrs: { retryReady: true, reviewedDigest: provider.digest, reviewId: id7 } }
+    ], { mutationId: `payment-recovery:${id7}`, guards: [{
       ns: "stripeEventReceipts",
       id: String(row2.id),
       exists: true,
@@ -3883,43 +4047,121 @@ async function closeRecipientApplication(db, env, ctx, seatId) {
 }
 
 // src/membership-seat-refund-stripe.ts
+import { stripeRequest as stripeRequest5 } from "@odla-ai/stripe";
+
+// src/membership-checkout-seat-refund.ts
 import { stripeRequest as stripeRequest4 } from "@odla-ai/stripe";
 var fail4 = (code = "named_seat_refund_mismatch") => {
   throw Object.assign(new Error(code), { code });
 };
+var id2 = (value) => typeof value === "string" ? value : value?.id ?? "";
+async function refundCheckoutNamedSeat(secretKey, seat) {
+  const invoiceRef = seat.combinedInvoice;
+  if (!invoiceRef || !/^in_[A-Za-z0-9_]+$/.test(invoiceRef.invoiceId) || !Number.isSafeInteger(invoiceRef.totalCents) || invoiceRef.totalCents <= seat.amountCents || seat.amountCents <= 0 || seat.status !== "refund_pending") fail4();
+  const call = async (method, path, params, key3) => {
+    const result = await stripeRequest4({ secretKey }, method, path, params, key3 ? { idempotencyKey: key3 } : {});
+    if (!result.ok || !result.body) return fail4("named_seat_refund_provider_unavailable");
+    return result.body;
+  };
+  const metadata = { ...stripePartitionMetadata(seat), applicationId: seat.applicationId };
+  const sub = await call("GET", `/v1/subscriptions/${encodeURIComponent(seat.providerSubscriptionId)}`);
+  if (sub.id !== seat.providerSubscriptionId || id2(sub.customer) !== seat.providerCustomerId || sub.livemode !== (seat.environment === "prod") || !Object.entries(metadata).every(([key3, value]) => sub.metadata?.[key3] === value) || !Array.isArray(sub.items?.data) || sub.items.has_more !== false) fail4();
+  const invoice = await call("GET", `/v1/invoices/${encodeURIComponent(invoiceRef.invoiceId)}`);
+  if (invoice.id !== invoiceRef.invoiceId || id2(invoice.subscription ?? invoice.parent?.subscription_details?.subscription) !== sub.id || id2(invoice.customer) !== seat.providerCustomerId || invoice.status !== "paid" || invoice.billing_reason !== "subscription_create" || invoice.total !== invoiceRef.totalCents || invoice.amount_paid !== invoiceRef.totalCents || invoice.currency !== seat.currency || invoice.livemode !== (seat.environment === "prod")) fail4();
+  let chargeId = id2(invoice.charge), paymentId = id2(invoice.payment_intent);
+  if (!chargeId && !paymentId) {
+    const payments = await call("GET", "/v1/invoice_payments", { invoice: invoice.id, status: "paid", limit: 100 });
+    if (!Array.isArray(payments.data) || payments.data.length !== 1 || payments.has_more !== false) fail4();
+    const payment = payments.data[0];
+    if (id2(payment.invoice) !== invoice.id || payment.status !== "paid" || payment.payment?.type !== "payment_intent") fail4();
+    paymentId = id2(payment.payment.payment_intent);
+  }
+  if (!chargeId) {
+    if (!/^pi_[A-Za-z0-9_]+$/.test(paymentId)) fail4();
+    const payment = await call("GET", `/v1/payment_intents/${encodeURIComponent(paymentId)}`);
+    if (payment.id !== paymentId || id2(payment.customer) !== seat.providerCustomerId || payment.status !== "succeeded" || payment.amount_received !== invoiceRef.totalCents || payment.currency !== seat.currency || payment.livemode !== (seat.environment === "prod")) fail4();
+    chargeId = id2(payment.latest_charge);
+  }
+  if (!/^ch_[A-Za-z0-9_]+$/.test(chargeId)) fail4();
+  const charge = await call("GET", `/v1/charges/${encodeURIComponent(chargeId)}`);
+  if (charge.id !== chargeId || id2(charge.customer) !== seat.providerCustomerId || charge.status !== "succeeded" || charge.livemode !== (seat.environment === "prod") || charge.amount !== invoiceRef.totalCents || charge.currency !== seat.currency || charge.invoice != null && id2(charge.invoice) !== invoice.id || paymentId && id2(charge.payment_intent) !== paymentId || !Number.isSafeInteger(charge.amount_refunded) || charge.amount_refunded < 0 || charge.amount_refunded > charge.amount) fail4();
+  const items = sub.items.data.filter((item) => item.metadata?.seatId === seat.id);
+  if (items.length > 1) fail4();
+  if (items.length && sub.status !== "canceled") {
+    const item = items[0];
+    if (!/^si_[A-Za-z0-9_]+$/.test(item.id) || item.quantity !== 1 || item.price?.id !== seat.priceId) fail4();
+    const removed = await call("DELETE", `/v1/subscription_items/${encodeURIComponent(item.id)}`, { proration_behavior: "none" });
+    if (removed.id !== item.id || removed.deleted !== true) fail4("named_seat_renewal_removal_unconfirmed");
+  }
+  if (charge.amount_refunded === charge.amount && charge.refunded === true) return { refundedCents: seat.amountCents, refundIds: [] };
+  const list = await call("GET", "/v1/refunds", { charge: chargeId, limit: 100 });
+  if (!Array.isArray(list.data) || list.has_more !== false || list.data.length >= 100) fail4("named_seat_refund_history_incomplete");
+  let refundedCents = 0;
+  const refundIds = [];
+  for (const refund of list.data) {
+    if (id2(refund.charge) !== chargeId || refund.currency !== seat.currency || !Number.isSafeInteger(refund.amount) || refund.amount <= 0 || !/^re_[A-Za-z0-9_]+$/.test(refund.id) || !["succeeded", "pending", "requires_action", "failed", "canceled"].includes(refund.status)) fail4();
+    if (["pending", "requires_action"].includes(refund.status)) fail4("named_seat_refund_pending");
+    if (refund.status === "succeeded") {
+      if (refund.metadata?.seatId !== seat.id || refund.metadata?.membershipId !== seat.primaryMembershipId) fail4("named_seat_refund_allocation_ambiguous");
+      refundedCents += refund.amount;
+      refundIds.push(refund.id);
+    }
+  }
+  if (refundedCents !== charge.amount_refunded || refundedCents > seat.amountCents) fail4();
+  if (refundedCents < seat.amountCents) {
+    const remaining = seat.amountCents - refundedCents;
+    const refund = await call("POST", "/v1/refunds", {
+      charge: chargeId,
+      amount: remaining,
+      reason: "requested_by_customer",
+      metadata: { ...metadata, membershipId: seat.primaryMembershipId, seatId: seat.id }
+    }, `combined-seat-refund:${seat.id}:${remaining}`);
+    if (id2(refund.charge) !== chargeId || refund.amount !== remaining || refund.currency !== seat.currency || !/^re_[A-Za-z0-9_]+$/.test(refund.id)) fail4();
+    if (refund.status !== "succeeded") fail4("named_seat_refund_pending");
+    refundedCents += remaining;
+    refundIds.push(refund.id);
+  }
+  return { refundedCents, refundIds };
+}
+
+// src/membership-seat-refund-stripe.ts
+var fail5 = (code = "named_seat_refund_mismatch") => {
+  throw Object.assign(new Error(code), { code });
+};
 async function refundNamedSeatStripePayment(secretKey, seat) {
-  if (!seat.providerPaymentIntentId || seat.status !== "refund_pending") fail4();
+  if (seat.combinedInvoice) return refundCheckoutNamedSeat(secretKey, seat);
+  if (!seat.providerPaymentIntentId || seat.status !== "refund_pending") fail5();
   const call = async (method, path, params, idempotencyKey) => {
-    const result = await stripeRequest4({ secretKey }, method, path, params, idempotencyKey ? { idempotencyKey } : {});
-    if (!result.ok || !result.body) return fail4("named_seat_refund_provider_unavailable");
+    const result = await stripeRequest5({ secretKey }, method, path, params, idempotencyKey ? { idempotencyKey } : {});
+    if (!result.ok || !result.body) return fail5("named_seat_refund_provider_unavailable");
     return result.body;
   };
   const metadata = { ...stripePartitionMetadata(seat), applicationId: seat.applicationId, membershipId: seat.primaryMembershipId, seatId: seat.id };
   const payment = await call("GET", `/v1/payment_intents/${encodeURIComponent(seat.providerPaymentIntentId)}`);
-  if (payment.id !== seat.providerPaymentIntentId || payment.customer !== seat.providerCustomerId || payment.amount !== seat.amountCents || payment.amount_received !== seat.amountCents || payment.currency !== seat.currency || payment.livemode !== (seat.environment === "prod") || payment.status !== "succeeded" || !Object.entries(metadata).every(([key3, value]) => payment.metadata?.[key3] === value)) fail4();
+  if (payment.id !== seat.providerPaymentIntentId || payment.customer !== seat.providerCustomerId || payment.amount !== seat.amountCents || payment.amount_received !== seat.amountCents || payment.currency !== seat.currency || payment.livemode !== (seat.environment === "prod") || payment.status !== "succeeded" || !Object.entries(metadata).every(([key3, value]) => payment.metadata?.[key3] === value)) fail5();
   const sub = await call("GET", `/v1/subscriptions/${encodeURIComponent(seat.providerSubscriptionId)}`);
-  if (sub.id !== seat.providerSubscriptionId || sub.customer !== seat.providerCustomerId || sub.livemode !== (seat.environment === "prod") || !Object.entries({ ...stripePartitionMetadata(seat), applicationId: seat.applicationId }).every(([key3, value]) => sub.metadata?.[key3] === value) || sub.items?.has_more !== false || !Array.isArray(sub.items?.data)) fail4();
+  if (sub.id !== seat.providerSubscriptionId || sub.customer !== seat.providerCustomerId || sub.livemode !== (seat.environment === "prod") || !Object.entries({ ...stripePartitionMetadata(seat), applicationId: seat.applicationId }).every(([key3, value]) => sub.metadata?.[key3] === value) || sub.items?.has_more !== false || !Array.isArray(sub.items?.data)) fail5();
   const items = sub.items.data.filter((item) => item.metadata?.seatId === seat.id);
-  if (items.length > 1) fail4();
+  if (items.length > 1) fail5();
   if (items.length && sub.status !== "canceled") {
     const item = items[0];
-    if (!/^si_[A-Za-z0-9_]+$/.test(item.id) || item.price?.id !== seat.priceId || item.quantity !== 1) fail4();
+    if (!/^si_[A-Za-z0-9_]+$/.test(item.id) || item.price?.id !== seat.priceId || item.quantity !== 1) fail5();
     const removed = await call("DELETE", `/v1/subscription_items/${encodeURIComponent(item.id)}`, { proration_behavior: "none" });
-    if (removed.id !== item.id || removed.deleted !== true) fail4("named_seat_renewal_removal_unconfirmed");
+    if (removed.id !== item.id || removed.deleted !== true) fail5("named_seat_renewal_removal_unconfirmed");
   }
   const list = await call("GET", "/v1/refunds", { payment_intent: seat.providerPaymentIntentId, limit: 100 });
-  if (!Array.isArray(list.data) || list.has_more !== false || list.data.length >= 100) fail4("named_seat_refund_history_incomplete");
+  if (!Array.isArray(list.data) || list.has_more !== false || list.data.length >= 100) fail5("named_seat_refund_history_incomplete");
   let refundedCents = 0, pendingCents = 0;
   const refundIds = [];
   for (const refund of list.data) {
-    if (!/^re_[A-Za-z0-9_]+$/.test(refund.id) || refund.payment_intent !== seat.providerPaymentIntentId || refund.currency !== seat.currency || !Number.isSafeInteger(refund.amount) || refund.amount <= 0 || !["succeeded", "pending", "requires_action", "failed", "canceled"].includes(refund.status)) fail4();
+    if (!/^re_[A-Za-z0-9_]+$/.test(refund.id) || refund.payment_intent !== seat.providerPaymentIntentId || refund.currency !== seat.currency || !Number.isSafeInteger(refund.amount) || refund.amount <= 0 || !["succeeded", "pending", "requires_action", "failed", "canceled"].includes(refund.status)) fail5();
     if (refund.status === "succeeded") {
       refundedCents += refund.amount;
       refundIds.push(refund.id);
     } else if (refund.status === "pending" || refund.status === "requires_action") pendingCents += refund.amount;
   }
-  if (refundedCents + pendingCents > seat.amountCents) fail4();
-  if (pendingCents) fail4("named_seat_refund_pending");
+  if (refundedCents + pendingCents > seat.amountCents) fail5();
+  if (pendingCents) fail5("named_seat_refund_pending");
   if (refundedCents < seat.amountCents) {
     const remaining = seat.amountCents - refundedCents;
     const refund = await call("POST", "/v1/refunds", {
@@ -3928,8 +4170,8 @@ async function refundNamedSeatStripePayment(secretKey, seat) {
       reason: "requested_by_customer",
       metadata
     }, `named-seat-refund:${seat.id}:${remaining}`);
-    if (refund.payment_intent !== seat.providerPaymentIntentId || refund.amount !== remaining || refund.currency !== seat.currency || !/^re_[A-Za-z0-9_]+$/.test(refund.id)) fail4();
-    if (refund.status !== "succeeded") fail4("named_seat_refund_pending");
+    if (refund.payment_intent !== seat.providerPaymentIntentId || refund.amount !== remaining || refund.currency !== seat.currency || !/^re_[A-Za-z0-9_]+$/.test(refund.id)) fail5();
+    if (refund.status !== "succeeded") fail5("named_seat_refund_pending");
     refundedCents += remaining;
     refundIds.push(refund.id);
   }
@@ -3951,8 +4193,8 @@ async function reserveNamedMembershipSeat(db, input, now) {
   const memberId = await networkMembershipId(input), member = await membershipLoad(db, "networkMembership", memberId);
   requireMembershipScope(member, input);
   if (!Number.isSafeInteger(member.revision) || !/^price_[A-Za-z0-9_]+$/.test(String(member.providerPriceId)) || member.providerPriceId === input.priceId) membershipFail("named_seat_purchase_unavailable");
-  const id6 = (await membershipOfferIdForRequest({ ...input, requestId: "named_seat" })).replace(/^offer_/, "seat_");
-  let seat = await membershipLoad(db, "networkSeat", id6);
+  const id7 = (await membershipOfferIdForRequest({ ...input, requestId: "named_seat" })).replace(/^offer_/, "seat_");
+  let seat = await membershipLoad(db, "networkSeat", id7);
   if (!seat) {
     const offering = membershipOfferingVersion(member.offeringSnapshot), claimId = await recipientKey(input, email);
     const purchaseEndsAt = seatPurchaseDeadline(offering, member);
@@ -3960,7 +4202,7 @@ async function reserveNamedMembershipSeat(db, input, now) {
       membershipFail("named_seat_purchase_unavailable");
     }
     const attrs = {
-      id: id6,
+      id: id7,
       ...membershipScope(input),
       primaryMembershipId: memberId,
       recipientName: name,
@@ -3985,20 +4227,20 @@ async function reserveNamedMembershipSeat(db, input, now) {
     };
     try {
       await db.transact([
-        membershipUpdate("networkSeat", id6, attrs),
+        membershipUpdate("networkSeat", id7, attrs),
         membershipUpdate("networkSeatRecipient", claimId, {
           id: claimId,
           appId: input.appId,
           chapterId: input.chapterId,
           environment: input.environment,
           runtime: input.runtime,
-          seatId: id6,
+          seatId: id7,
           recipientEmailNormalized: email,
           createdAt: now
         }),
-        membershipUpdate("networkMembership", memberId, { namedSeatId: id6, revision: Number(member.revision) + 1, updatedAt: now })
-      ], { mutationId: `named-seat-reserve:${id6}`, guards: [
-        { ns: "networkSeat", id: id6, exists: false },
+        membershipUpdate("networkMembership", memberId, { namedSeatId: id7, revision: Number(member.revision) + 1, updatedAt: now })
+      ], { mutationId: `named-seat-reserve:${id7}`, guards: [
+        { ns: "networkSeat", id: id7, exists: false },
         { ns: "networkSeatRecipient", id: claimId, exists: false },
         { ns: "networkMembership", id: memberId, exists: true, equals: { revision: member.revision }, absent: ["namedSeatId"] },
         { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative", revision: state.revision } }
@@ -4006,7 +4248,7 @@ async function reserveNamedMembershipSeat(db, input, now) {
     } catch (error) {
       if (error.code !== "transact_guard_failed") throw error;
     }
-    seat = await membershipLoad(db, "networkSeat", id6);
+    seat = await membershipLoad(db, "networkSeat", id7);
     if (!seat && await membershipLoad(db, "networkSeatRecipient", claimId)) membershipFail("named_seat_recipient_unavailable");
   }
   requireMembershipScope(seat, input);
@@ -4016,7 +4258,7 @@ async function reserveNamedMembershipSeat(db, input, now) {
 
 // src/membership-seat-included.ts
 var namedSeatIncluded = (seat) => Number(seat.amountCents) === 0;
-var namedSeatSettled = (seat) => namedSeatIncluded(seat) ? seat.purchasedAt !== void 0 : Boolean(seat.providerPaymentIntentId && seat.providerSubscriptionItemId);
+var namedSeatSettled = (seat) => namedSeatIncluded(seat) ? seat.purchasedAt !== void 0 : Boolean((seat.providerPaymentIntentId || seat.combinedInvoice) && seat.providerSubscriptionItemId);
 function namedSeatRecipientState(seat) {
   switch (String(seat.status)) {
     case "renewal_pending":
@@ -4120,7 +4362,7 @@ async function requestNamedSeatRefund(db, input, now) {
   const member = await membershipLoad(db, "networkMembership", String(seat.primaryMembershipId));
   requireMembershipScope(member, input);
   if (seat.status === "refunded" || seat.status === "refund_pending") return;
-  if (!seat.purchasedAt || !seat.providerPaymentIntentId && !namedSeatIncluded(seat) || input.reason === "declined" && seat.journeyApprovedAt !== void 0 || input.reason === "primary_closed" && !["refunded", "declined"].includes(String(member.status))) membershipFail("named_seat_refund_not_eligible");
+  if (!seat.purchasedAt || !seat.providerPaymentIntentId && !seat.combinedInvoice && !namedSeatIncluded(seat) || input.reason === "declined" && seat.journeyApprovedAt !== void 0 || input.reason === "primary_closed" && !["refunded", "declined"].includes(String(member.status))) membershipFail("named_seat_refund_not_eligible");
   const entitlement = seat.entitlementId ? await membershipLoad(db, "networkEntitlement", String(seat.entitlementId)) : void 0;
   await db.transact([
     membershipUpdate("networkSeat", input.seatId, { status: "refund_pending", refundReason: input.reason, revision: Number(seat.revision) + 1, updatedAt: now }),
@@ -4233,8 +4475,8 @@ async function lowerSeatPrice(db, scope2, now, limit = 100) {
   const receipt = { seatPriceCents: target, repriced: 0, skipped: [], more: rows5.length > limit };
   for (const member of rows5.slice(0, limit)) {
     if (Object.entries(scope2).some(([key3, value]) => member[key3] !== value)) throw new Error("membership reprice scope mismatch");
-    const id6 = String(member.id), skip = (reason) => {
-      receipt.skipped.push({ membershipId: id6, reason });
+    const id7 = String(member.id), skip = (reason) => {
+      receipt.skipped.push({ membershipId: id7, reason });
     };
     const offering = membershipOfferingVersion(member.offeringSnapshot);
     if (offering.seatPriceCents <= target) {
@@ -4250,16 +4492,16 @@ async function lowerSeatPrice(db, scope2, now, limit = 100) {
       skip(`seat is ${String(seat.status)}`);
       continue;
     }
-    const ops = [membershipUpdate("networkMembership", id6, { offeringSnapshot: { ...offering, seatPriceCents: target }, revision: Number(member.revision) + 1, updatedAt: now })];
+    const ops = [membershipUpdate("networkMembership", id7, { offeringSnapshot: { ...offering, seatPriceCents: target }, revision: Number(member.revision) + 1, updatedAt: now })];
     const guards = [
-      { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision } },
+      { ns: "networkMembership", id: id7, exists: true, equals: { revision: member.revision } },
       { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative" } }
     ];
     if (seat) {
       ops.push(membershipUpdate("networkSeat", String(seat.id), { amountCents: target, offeringSnapshot: { ...offering, seatPriceCents: target }, revision: Number(seat.revision) + 1, updatedAt: now }));
       guards.push({ ns: "networkSeat", id: String(seat.id), exists: true, equals: { revision: seat.revision, status: "payment_pending" } });
     }
-    await db.transact(ops, { mutationId: `seat-reprice:${id6}:${member.revision}`, guards });
+    await db.transact(ops, { mutationId: `seat-reprice:${id7}:${member.revision}`, guards });
     receipt.repriced++;
   }
   return receipt;
@@ -4460,25 +4702,28 @@ var handleAdminMembershipPolicyVersions = async (req, url, env, ctx) => {
 };
 
 // src/membership-discount-reterm.ts
-import { stripeRequest as stripeRequest6 } from "@odla-ai/stripe";
+import { stripeRequest as stripeRequest7 } from "@odla-ai/stripe";
 
 // src/subscription-provider-contract.ts
-import { stripeRequest as stripeRequest5 } from "@odla-ai/stripe";
+import { stripeRequest as stripeRequest6 } from "@odla-ai/stripe";
 function subscriptionContractMismatch() {
   throw Object.assign(new Error("Stripe subscription does not match the checkout contract"), { code: "stripe_contract_mismatch" });
 }
 async function verifySubscriptionPrice(secretKey, input, resume = false) {
   if (!/^price_[A-Za-z0-9]+$/.test(input.priceId) || !Number.isSafeInteger(input.priceCents) || input.priceCents <= 0 || !/^[a-z]{3}$/.test(input.currency) || !["month", "year"].includes(input.interval)) subscriptionContractMismatch();
-  const result = await stripeRequest5({ secretKey }, "GET", `/v1/prices/${encodeURIComponent(input.priceId)}`);
+  const result = await stripeRequest6({ secretKey }, "GET", `/v1/prices/${encodeURIComponent(input.priceId)}`);
   const price = result.body;
   if (!result.ok || !price || price.id !== input.priceId || !resume && price.active !== true || price.unit_amount !== input.priceCents || price.currency !== input.currency || price.type !== "recurring" || price.billing_scheme !== "per_unit" || price.custom_unit_amount || price.transform_quantity || price.recurring?.interval !== input.interval || price.recurring?.interval_count !== 1 || price.recurring?.usage_type !== "licensed" || price.livemode !== (input.environment === "prod")) subscriptionContractMismatch();
   return typeof price.product === "string" ? price.product : void 0;
 }
 function verifySubscriptionResult(sub, input, customerId, metadata) {
   const items = sub?.items;
-  if (!sub || !/^sub_[A-Za-z0-9]+$/.test(sub.id) || sub.customer !== customerId || input.existingSubscriptionId && sub.id !== input.existingSubscriptionId || !(input.billingTerms?.initialTermEndsAt ? ["incomplete", "active", "trialing"] : ["incomplete", "active"]).includes(sub.status) || sub.livemode !== (input.environment === "prod") || !Object.entries(metadata).every(([key3, value]) => sub.metadata?.[key3] === value) || !Array.isArray(items?.data) || items.has_more !== false || items.data.length !== 1 || items.data[0]?.price?.id !== input.priceId || items.data[0]?.quantity !== 1) subscriptionContractMismatch();
+  const seat = input.namedSeat?.amountCents ? input.namedSeat : void 0;
+  const primary = items?.data?.find((item) => item.price?.id === input.priceId);
+  const seatItem = seat && items?.data?.find((item) => item.price?.id === seat.priceId);
+  if (!sub || !/^sub_[A-Za-z0-9]+$/.test(sub.id) || sub.customer !== customerId || input.existingSubscriptionId && sub.id !== input.existingSubscriptionId || !(input.billingTerms?.initialTermEndsAt ? ["incomplete", "active", "trialing"] : ["incomplete", "active"]).includes(sub.status) || sub.livemode !== (input.environment === "prod") || !Object.entries(metadata).every(([key3, value]) => sub.metadata?.[key3] === value) || !Array.isArray(items?.data) || items.has_more !== false || items.data.length !== (seat ? 2 : 1) || primary?.quantity !== 1 || seat && (seatItem?.quantity !== 1 || seatItem.metadata?.seatId !== seat.seatId || seatItem.metadata?.membershipId !== seat.membershipId)) subscriptionContractMismatch();
   const invoice = sub.latest_invoice;
-  if (!invoice || typeof invoice !== "object" || invoice.customer !== customerId || invoice.currency !== input.currency || invoice.total !== subscriptionAmountDue(input) || invoice.billing_reason !== "subscription_create") subscriptionContractMismatch();
+  if (!invoice || typeof invoice !== "object" || invoice.customer !== customerId || invoice.currency !== input.currency || invoice.total !== subscriptionAmountDue(input) + (seat?.amountCents ?? 0) || invoice.billing_reason !== "subscription_create") subscriptionContractMismatch();
   verifySubscriptionBillingResult(sub, input);
 }
 
@@ -4490,8 +4735,8 @@ var couponOf = (discount) => {
   const ref = discount?.source?.coupon ?? discount?.coupon;
   return typeof ref === "string" ? ref : typeof ref?.id === "string" ? ref.id : void 0;
 };
-async function retermPolicy(db, scope2, id6) {
-  const row2 = await membershipLoad(db, "discountPolicyVersion", id6);
+async function retermPolicy(db, scope2, id7) {
+  const row2 = await membershipLoad(db, "discountPolicyVersion", id7);
   if (!row2) membershipFail("membership_reterm_policy_unknown");
   let policy2;
   try {
@@ -4499,12 +4744,12 @@ async function retermPolicy(db, scope2, id6) {
   } catch {
     return membershipFail("membership_reterm_policy_ineligible");
   }
-  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");
+  if (policy2.id !== id7 || 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, 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 read2 = await stripeRequest7({ secretKey: sk }, "GET", path, { "expand[0]": "discounts" });
   const sub = read2.body, items = sub?.items?.data;
   const metadata = { ...stripePartitionMetadata(scope2), applicationId: String(member.applicationId) };
   if (!read2.ok || sub.id !== subId || sub.customer !== member.providerCustomerId || sub.livemode !== (scope2.environment === "prod") || !PROVIDER_LIVE.has(sub.status) || !Object.entries(metadata).every(([key3, value]) => sub.metadata?.[key3] === value) || sub.items?.has_more !== false || !Array.isArray(items) || items.length < 1 || items.length > 2 || items.filter((item) => item.price?.id === member.providerPriceId && item.quantity === 1 && item.price?.product === productId).length !== 1) {
@@ -4515,7 +4760,7 @@ async function attachProviderDiscount(sk, scope2, member, policy2, couponId, pro
   const present = discounts.map(couponOf);
   if (present.length === 1 && present[0] === couponId) return false;
   if (present.length > 0) throw Object.assign(new Error("provider subscription carries an unrelated discount"), { code: "provider_mismatch" });
-  const written = await stripeRequest6({ secretKey: sk }, "POST", path, {
+  const written = await stripeRequest7({ secretKey: sk }, "POST", path, {
     "discounts[0][coupon]": couponId,
     "expand[0]": "discounts",
     "metadata[discountPolicyVersionId]": policy2.id
@@ -4531,7 +4776,7 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
   const limit = input.limit ?? 100;
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200) throw new TypeError("invalid reterm limit");
   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");
+  if (input.membershipIds !== void 0 && (!Array.isArray(input.membershipIds) || input.membershipIds.length === 0 || input.membershipIds.length > limit || input.membershipIds.some((id7) => typeof id7 !== "string" || !SAFE.test(id7)))) throw new TypeError("invalid membership ids");
   const state = await loadMembershipAuthorityState(db, scope2);
   const policy2 = await retermPolicy(db, scope2, input.policyVersionId);
   const receipt = { policyVersionId: policy2.id, retermed: [], unchanged: [], skipped: [], more: false };
@@ -4541,10 +4786,10 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
   let rows5;
   if (input.membershipIds) {
     rows5 = [];
-    for (const id6 of input.membershipIds) {
-      const member = await membershipLoad(db, "networkMembership", id6);
-      if (!member) skip(id6, "not_found");
-      else if (Object.entries(scope2).some(([key3, value]) => member[key3] !== value)) skip(id6, "scope_mismatch");
+    for (const id7 of input.membershipIds) {
+      const member = await membershipLoad(db, "networkMembership", id7);
+      if (!member) skip(id7, "not_found");
+      else if (Object.entries(scope2).some(([key3, value]) => member[key3] !== value)) skip(id7, "scope_mismatch");
       else rows5.push(member);
     }
   } else {
@@ -4554,32 +4799,32 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
     rows5 = found.slice(0, limit);
   }
   for (const member of rows5) {
-    const id6 = String(member.id);
+    const id7 = String(member.id);
     if (member.discountPolicyVersionId === policy2.id) {
-      receipt.unchanged.push(id6);
+      receipt.unchanged.push(id7);
       continue;
     }
     if (!RETERMABLE.has(String(member.status))) {
-      skip(id6, "status");
+      skip(id7, "status");
       continue;
     }
     if (member.founding !== true) {
-      skip(id6, "not_founding");
+      skip(id7, "not_founding");
       continue;
     }
     if (member.cohort !== policy2.cohortLabel) {
-      skip(id6, "cohort_mismatch");
+      skip(id7, "cohort_mismatch");
       continue;
     }
     const skuId = String(member.baseSkuId);
     if (!policy2.discountEligibleSkuIds.includes(skuId)) {
-      skip(id6, "sku_not_discounted");
+      skip(id7, "sku_not_discounted");
       continue;
     }
     const base = Number(member.baseAmountCents), current = Number(member.renewalAmountCents);
     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");
+      skip(id7, "would_not_widen");
       continue;
     }
     const couponId = await membershipDiscountCouponId({ ...scope2, skuId }, policy2.id);
@@ -4607,22 +4852,22 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
     } catch (error) {
       const code = error.code;
       if (code === "provider_mismatch" || code === "stripe_contract_mismatch") {
-        skip(id6, "provider_mismatch");
+        skip(id7, "provider_mismatch");
         continue;
       }
       throw error;
     }
     try {
-      await db.transact([membershipUpdate("networkMembership", id6, {
+      await db.transact([membershipUpdate("networkMembership", id7, {
         discountPolicyVersionId: policy2.id,
         discountSnapshot: policy2,
         renewalAmountCents: renewal,
         revision: Number(member.revision) + 1,
         updatedAt: now
       })], {
-        mutationId: `membership-reterm:${id6}:${policy2.id}:${member.revision}`,
+        mutationId: `membership-reterm:${id7}:${policy2.id}:${member.revision}`,
         guards: [
-          { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision, status: member.status } },
+          { ns: "networkMembership", id: id7, exists: true, equals: { revision: member.revision, status: member.status } },
           { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative" } },
           { ns: "discountPolicyVersion", id: policy2.id, exists: true }
         ]
@@ -4632,7 +4877,7 @@ async function retermMembershipDiscount(db, stripeSecretKey, scope2, input, now)
       return membershipFail("membership_reterm_retry_required");
     }
     receipt.retermed.push({
-      membershipId: id6,
+      membershipId: id7,
       ...typeof member.discountPolicyVersionId === "string" ? { previousPolicyVersionId: member.discountPolicyVersionId } : {},
       previousRenewalAmountCents: current,
       renewalAmountCents: renewal,
@@ -4668,7 +4913,7 @@ var handleAdminMembershipReterm = async (req, url, env, ctx) => {
     return json({ error: BAD }, 400);
   }
   const appId = body.appId ?? body.chapterId, runtime = body.runtime ?? env.ODLA_RUNTIME;
-  if (typeof body.chapterId !== "string" || !SCOPE3.test(body.chapterId) || typeof appId !== "string" || !SCOPE3.test(appId) || typeof runtime !== "string" || !/^[a-z0-9]{2,12}$/.test(runtime) || typeof body.policyVersionId !== "string" || !ID.test(body.policyVersionId) || body.membershipIds !== void 0 && (!Array.isArray(body.membershipIds) || body.membershipIds.length === 0 || body.membershipIds.length > 200 || body.membershipIds.some((id6) => typeof id6 !== "string" || !ID.test(id6))) || body.limit !== void 0 && (!Number.isSafeInteger(body.limit) || Number(body.limit) < 1 || Number(body.limit) > 200)) {
+  if (typeof body.chapterId !== "string" || !SCOPE3.test(body.chapterId) || typeof appId !== "string" || !SCOPE3.test(appId) || typeof runtime !== "string" || !/^[a-z0-9]{2,12}$/.test(runtime) || typeof body.policyVersionId !== "string" || !ID.test(body.policyVersionId) || body.membershipIds !== void 0 && (!Array.isArray(body.membershipIds) || body.membershipIds.length === 0 || body.membershipIds.length > 200 || body.membershipIds.some((id7) => typeof id7 !== "string" || !ID.test(id7))) || body.limit !== void 0 && (!Number.isSafeInteger(body.limit) || Number(body.limit) < 1 || Number(body.limit) > 200)) {
     return json({ error: BAD }, 400);
   }
   const secret = await getVaultSecret(db, operator.stripeSecretName ?? "stripe_secret_key");
@@ -4943,12 +5188,12 @@ var handleMembershipRestart = async (req, url, env, ctx) => {
   if (!app || app.clerkUserId !== user.userId || app.namedSeatId || app.giftClaimId) return json({ error: "membership is not eligible to restart" }, 409);
   if (app.membershipRestartId && app.status === "submitted") return json({ applicationId: app.id });
   try {
-    const id6 = String(app.id), intent = await membershipLoad(db, "subscriptionCheckoutIntents", id6);
+    const id7 = String(app.id), intent = await membershipLoad(db, "subscriptionCheckoutIntents", id7);
     if (!intent || !app.stripeSubscriptionId || intent.providerSubscriptionId !== app.stripeSubscriptionId) return json({ error: "membership history needs reconciliation" }, 409);
     const target = await membershipTargetForIntent(intent, app, env, ctx);
     const restart = await ctx.membershipAuthority.restart({ ...target, previousSubscriptionId: String(app.stripeSubscriptionId) }, env);
-    if (restart.status !== "ready" || restart.applicationId !== id6 || restart.membershipId !== await networkMembershipId(target) || !/^restart_[a-f0-9]{64}$/.test(restart.restartId) || !Number.isSafeInteger(restart.memberNumber) || restart.memberNumber < 1) throw new Error("invalid restart receipt");
-    const now = Date.now(), quote = await membershipLoad(db, "membershipQuoteProjections", id6);
+    if (restart.status !== "ready" || restart.applicationId !== id7 || restart.membershipId !== await networkMembershipId(target) || !/^restart_[a-f0-9]{64}$/.test(restart.restartId) || !Number.isSafeInteger(restart.memberNumber) || restart.memberNumber < 1) throw new Error("invalid restart receipt");
+    const now = Date.now(), quote = await membershipLoad(db, "membershipQuoteProjections", id7);
     const attrs = {
       status: "submitted",
       membershipRestartId: restart.restartId,
@@ -4968,8 +5213,8 @@ var handleMembershipRestart = async (req, url, env, ctx) => {
         quoteSnapshot: quote ?? {},
         archivedAt: now
       } },
-      { t: "delete", ns: "subscriptionCheckoutIntents", id: id6 },
-      { t: "retract", ns: "applications", id: id6, attrs: [
+      { t: "delete", ns: "subscriptionCheckoutIntents", id: id7 },
+      { t: "retract", ns: "applications", id: id7, attrs: [
         "stripeSubscriptionId",
         "canceled",
         "renewalAt",
@@ -4980,28 +5225,28 @@ var handleMembershipRestart = async (req, url, env, ctx) => {
         "approvalEffectsOrigin",
         "approvalEffectsLastAttemptAt"
       ] },
-      { t: "update", ns: "applications", id: id6, attrs },
-      ...quote ? [{ t: "update", ns: "membershipQuoteProjections", id: id6, attrs: { status: "restart", updatedAt: now } }] : []
+      { t: "update", ns: "applications", id: id7, attrs },
+      ...quote ? [{ t: "update", ns: "membershipQuoteProjections", id: id7, attrs: { status: "restart", updatedAt: now } }] : []
     ];
     try {
       await db.transact(ops, { mutationId: `membership-restart-application:${restart.restartId}`, guards: [
-        { ns: "applications", id: id6, exists: true, equals: {
+        { ns: "applications", id: id7, exists: true, equals: {
           clerkUserId: user.userId,
           groupId: ctx.chapter.id,
           status: app.status,
           stripeSubscriptionId: app.stripeSubscriptionId
         } },
-        { ns: "subscriptionCheckoutIntents", id: id6, exists: true, equals: { providerSubscriptionId: app.stripeSubscriptionId } },
+        { ns: "subscriptionCheckoutIntents", id: id7, exists: true, equals: { providerSubscriptionId: app.stripeSubscriptionId } },
         { ns: "membershipCheckoutHistory", id: restart.restartId, exists: false },
-        { ns: "membershipQuoteProjections", id: id6, exists: Boolean(quote), ...quote ? { equals: { revision: quote.revision, status: quote.status } } : {} }
+        { ns: "membershipQuoteProjections", id: id7, exists: Boolean(quote), ...quote ? { equals: { revision: quote.revision, status: quote.status } } : {} }
       ] });
     } catch (error) {
       if (error.code !== "transact_guard_failed") throw error;
     }
-    const saved = await membershipLoad(db, "applications", id6);
+    const saved = await membershipLoad(db, "applications", id7);
     if (!saved || saved.clerkUserId !== user.userId || saved.membershipRestartId !== restart.restartId || saved.groupId !== ctx.chapter.id || saved.stripeRuntime !== target.runtime) throw new Error("restart persistence pending");
     await syncApplicationToCrm(crmDeps(db, ctx), { app: saved, stage: String(saved.status) }).catch(() => void 0);
-    return json({ applicationId: id6 });
+    return json({ applicationId: id7 });
   } catch {
     return json({ error: "We could not prepare your new subscription. Your account is saved. Please retry." }, 503);
   }
@@ -5132,8 +5377,8 @@ async function submitApplication(db, chapter, fields, opts) {
   if (app.requireDisclaimerAck && !acked) {
     return { ok: false, error: "disclaimerAck is required" };
   }
-  const id6 = opts.submissionId ? await applicationIdForSubmission(opts.submissionId) : opts.newId();
-  const row2 = { id: id6, status: chapter.pipeline.initial, createdAt: opts.now };
+  const id7 = opts.submissionId ? await applicationIdForSubmission(opts.submissionId) : opts.newId();
+  const row2 = { id: id7, status: chapter.pipeline.initial, createdAt: opts.now };
   for (const f of [...app.required, ...app.optional]) {
     if (fieldStates[f]?.visible === false) continue;
     if (typeof fields[f] === "string") row2[f] = fields[f].trim();
@@ -5167,12 +5412,12 @@ async function submitApplication(db, chapter, fields, opts) {
   }
   if (acked) row2.disclaimerAckAt = opts.now;
   const ops = [
-    { t: "update", ns: "applications", id: id6, attrs: row2 }
+    { t: "update", ns: "applications", id: id7, attrs: row2 }
   ];
   if (opts.admissionGrant?.decision === "waive_interview") {
     ops.push({ t: "update", ns: "admissionGrants", id: opts.admissionGrant.id, attrs: {
       consumedAt: opts.now,
-      consumedApplicationId: id6
+      consumedApplicationId: id7
     } });
   }
   try {
@@ -5180,7 +5425,7 @@ async function submitApplication(db, chapter, fields, opts) {
       ops,
       opts.submissionId ? { mutationId: `join:${opts.submissionId}` } : void 0
     );
-    return { ok: true, id: id6, duplicate, status: chapter.pipeline.initial, disclaimerAckAt: acked ? opts.now : null };
+    return { ok: true, id: id7, duplicate, status: chapter.pipeline.initial, disclaimerAckAt: acked ? opts.now : null };
   } catch (error) {
     if (error.code === "unique_violation") return {
       ok: false,
@@ -5386,14 +5631,14 @@ function validateAdmissionGrantDocument(input) {
   const seenEmails = /* @__PURE__ */ new Set();
   for (const [index2, raw2] of rawGrants.slice(0, MAX_GRANTS).entries()) {
     const grant = raw2 && typeof raw2 === "object" ? raw2 : {};
-    const id6 = typeof grant.id === "string" ? grant.id : "";
+    const id7 = typeof grant.id === "string" ? grant.id : "";
     const email = typeof grant.email === "string" ? grant.email.trim() : "";
     const normalized = normalizeAdmissionEmail(email);
     const decision = grant.decision;
     const note = typeof grant.note === "string" ? grant.note.trim() : void 0;
     const expiresAt = grant.expiresAt === void 0 ? void 0 : Number(grant.expiresAt);
-    if (!ID2.test(id6)) errors.push(`document.grants[${index2}].id must be an identifier`);
-    if (seenIds.has(id6)) errors.push(`document.grants repeats id "${id6}"`);
+    if (!ID2.test(id7)) errors.push(`document.grants[${index2}].id must be an identifier`);
+    if (seenIds.has(id7)) errors.push(`document.grants repeats id "${id7}"`);
     if (!isAdmissionEmail(normalized)) errors.push(`document.grants[${index2}].email must be valid`);
     if (seenEmails.has(normalized)) errors.push(`document.grants repeats email "${normalized}"`);
     if (decision !== "waive_interview" && decision !== "require_interview") {
@@ -5403,10 +5648,10 @@ function validateAdmissionGrantDocument(input) {
     if (expiresAt !== void 0 && (!Number.isFinite(expiresAt) || expiresAt <= 0)) {
       errors.push(`document.grants[${index2}].expiresAt must be epoch milliseconds`);
     }
-    seenIds.add(id6);
+    seenIds.add(id7);
     seenEmails.add(normalized);
     grants.push({
-      id: id6,
+      id: id7,
       email,
       decision,
       ...note ? { note } : {},
@@ -5478,8 +5723,8 @@ async function materializeAdmissionGrants(db, envelope, previous, receivedAt) {
   const incomingIds = new Set(document.grants.map((grant) => `admission:parent:${document.source.appId}:${grant.id}`));
   const ops = [];
   for (const row2 of current) {
-    const id6 = String(row2.id ?? "");
-    if (id6 && !incomingIds.has(id6)) ops.push({ t: "update", ns: "admissionGrants", id: id6, attrs: {
+    const id7 = String(row2.id ?? "");
+    if (id7 && !incomingIds.has(id7)) ops.push({ t: "update", ns: "admissionGrants", id: id7, attrs: {
       active: false,
       revokedAt: receivedAt,
       revokedBy: document.source.actor,
@@ -5488,10 +5733,10 @@ async function materializeAdmissionGrants(db, envelope, previous, receivedAt) {
     } });
   }
   for (const grant of document.grants) {
-    const id6 = `admission:parent:${document.source.appId}:${grant.id}`;
-    const existing = current.find((row2) => row2.id === id6);
-    ops.push({ t: "update", ns: "admissionGrants", id: id6, attrs: {
-      id: id6,
+    const id7 = `admission:parent:${document.source.appId}:${grant.id}`;
+    const existing = current.find((row2) => row2.id === id7);
+    ops.push({ t: "update", ns: "admissionGrants", id: id7, attrs: {
+      id: id7,
       sourceGrantId: grant.id,
       sourceScope: "parent",
       sourceId: document.source.appId,
@@ -5512,7 +5757,7 @@ async function materializeAdmissionGrants(db, envelope, previous, receivedAt) {
       ...!grant.note && existing?.note !== void 0 ? ["note"] : [],
       ...grant.expiresAt === void 0 && existing?.expiresAt !== void 0 ? ["expiresAt"] : []
     ];
-    if (retract.length) ops.push({ t: "retract", ns: "admissionGrants", id: id6, attrs: retract });
+    if (retract.length) ops.push({ t: "retract", ns: "admissionGrants", id: id7, attrs: retract });
   }
   if (previous?.active) ops.push({ t: "update", ns: "admissionGrantRevisions", id: previous.id, attrs: { active: false } });
   const revisionId = `admission-revision:${document.source.appId}:${document.target.environment}:${document.revision}`;
@@ -5543,9 +5788,9 @@ var APPLICATION_LABELS = {
   phone: "Phone",
   state: "State"
 };
-function humanize(id6) {
-  const text8 = id6.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
-  return text8 ? `${text8[0].toUpperCase()}${text8.slice(1)}` : id6;
+function humanize(id7) {
+  const text8 = id7.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+  return text8 ? `${text8[0].toUpperCase()}${text8.slice(1)}` : id7;
 }
 function applicationDefs(chapter) {
   try {
@@ -5554,23 +5799,23 @@ function applicationDefs(chapter) {
     return {};
   }
 }
-function applicationType(id6, def) {
+function applicationType(id7, def) {
   if (def && ["string", "email", "url", "enum"].includes(def.type)) return def.type;
-  return id6 === "email" ? "email" : id6 === "linkedin" ? "url" : "string";
+  return id7 === "email" ? "email" : id7 === "linkedin" ? "url" : "string";
 }
 function applicationFlowFields(chapter, application = chapter.application) {
   const defs = applicationDefs(chapter);
-  return [...application.required, ...application.optional].map((id6, order2) => {
-    const def = defs[id6];
-    const conditions = application.conditions[id6];
-    const type = applicationType(id6, def);
+  return [...application.required, ...application.optional].map((id7, order2) => {
+    const def = defs[id7];
+    const conditions = application.conditions[id7];
+    const type = applicationType(id7, def);
     return {
-      id: id6,
-      label: def?.label ?? APPLICATION_LABELS[id6] ?? humanize(id6),
+      id: id7,
+      label: def?.label ?? APPLICATION_LABELS[id7] ?? humanize(id7),
       type,
-      required: application.required.includes(id6),
+      required: application.required.includes(id7),
       order: order2,
-      maxLength: application.maxLen[id6] ?? application.defaultMaxLen,
+      maxLength: application.maxLen[id7] ?? application.defaultMaxLen,
       ...type === "enum" && def?.options ? { options: [...def.options] } : {},
       ...conditions ? { conditions: { ...conditions } } : {},
       ...type === "email" ? { emailIdentity: "literal" } : {}
@@ -5580,17 +5825,17 @@ function applicationFlowFields(chapter, application = chapter.application) {
 function resolveFormationFlowFields(crm, formation) {
   if (!formation.enabled) return [];
   const def = crm.type(formation.type);
-  return [...formation.required, ...formation.optional].map((id6, order2) => {
-    const field = def.fields[id6];
+  return [...formation.required, ...formation.optional].map((id7, order2) => {
+    const field = def.fields[id7];
     return {
-      id: id6,
-      label: field.label ?? humanize(id6),
+      id: id7,
+      label: field.label ?? humanize(id7),
       type: field.type,
-      required: formation.required.includes(id6),
+      required: formation.required.includes(id7),
       order: order2,
-      maxLength: formation.maxLen[id6] ?? formation.defaultMaxLen,
+      maxLength: formation.maxLen[id7] ?? formation.defaultMaxLen,
       ...field.options ? { options: [...field.options] } : {},
-      ...id6 === def.emailField || field.type === "email" ? { emailIdentity: "literal" } : {}
+      ...id7 === def.emailField || field.type === "email" ? { emailIdentity: "literal" } : {}
     };
   });
 }
@@ -5640,10 +5885,10 @@ function validateGiftOfferCatalog(input, tierIds) {
     }
     const allowed2 = /* @__PURE__ */ new Set(["id", "target", "billingMode", "stripePriceId", "priceCents", "currency", "redemptionLifetimeHours", "activeFrom", "activeUntil", "title", "description", "ctaLabel"]);
     for (const key3 of Object.keys(item)) if (!allowed2.has(key3)) errors.push(`${path}.${key3} is not supported`);
-    const id6 = text3(item.id, `${path}.id`, errors, 80);
-    if (id6 && !ID3.test(id6)) errors.push(`${path}.id must be a lowercase kebab-case id`);
-    if (ids2.has(id6)) errors.push(`${path}.id duplicates "${id6}"`);
-    ids2.add(id6);
+    const id7 = text3(item.id, `${path}.id`, errors, 80);
+    if (id7 && !ID3.test(id7)) errors.push(`${path}.id must be a lowercase kebab-case id`);
+    if (ids2.has(id7)) errors.push(`${path}.id duplicates "${id7}"`);
+    ids2.add(id7);
     const targetRaw = record(item.target);
     let target = { type: "entitlement", entitlementKey: "invalid" };
     if (targetRaw?.type === "tier") {
@@ -5669,7 +5914,7 @@ function validateGiftOfferCatalog(input, tierIds) {
     if (activeUntil !== void 0 && (!Number.isSafeInteger(activeUntil) || activeUntil < 1)) errors.push(`${path}.activeUntil must be epoch milliseconds`);
     if (activeFrom !== void 0 && activeUntil !== void 0 && activeUntil <= activeFrom) errors.push(`${path}.activeUntil must follow activeFrom`);
     offers.push({
-      id: id6,
+      id: id7,
       target,
       billingMode: item.billingMode,
       stripePriceId,
@@ -5769,9 +6014,9 @@ async function materializeSignupControl(db, envelope, previous, receivedAt) {
   const ops = [];
   if (previous?.active) ops.push({ t: "update", ns: "signupControls", id: previous.id, attrs: { active: false } });
   for (const row2 of currentRows) {
-    const id7 = String(row2.id ?? "");
-    if (id7 && !incoming.has(id7)) {
-      ops.push({ t: "update", ns: "tiers", id: byPublicId("tiers", id7), attrs: { active: false } });
+    const id8 = String(row2.id ?? "");
+    if (id8 && !incoming.has(id8)) {
+      ops.push({ t: "update", ns: "tiers", id: byPublicId("tiers", id8), attrs: { active: false } });
     }
   }
   for (const tier of document.tiers) {
@@ -5806,9 +6051,9 @@ async function materializeSignupControl(db, envelope, previous, receivedAt) {
   if (!("stripePriceId" in attrs)) {
     ops.push({ t: "retract", ns: "groups", id: groupRef, attrs: ["stripePriceId"] });
   }
-  const id6 = `signup-control:${document.target.environment}:${document.revision}`;
-  ops.push({ t: "update", ns: "signupControls", id: id6, attrs: {
-    id: id6,
+  const id7 = `signup-control:${document.target.environment}:${document.revision}`;
+  ops.push({ t: "update", ns: "signupControls", id: id7, attrs: {
+    id: id7,
     sourceId: document.source.appId,
     targetId: document.target.chapterId,
     environment: document.target.environment,
@@ -5847,6 +6092,8 @@ function foundingOf(offer) {
 async function createPaymentQuote(input) {
   const { group, tier, policy: policy2 } = input;
   const terms2 = input.billingTerms ? subscriptionBillingTerms(input.billingTerms) : void 0;
+  if (input.seatOffer && (!terms2 || !Number.isSafeInteger(input.seatOffer.amountCents) || input.seatOffer.amountCents < 0) || input.namedSeat && !input.seatOffer) throw new Error("invalid checkout seat offer");
+  const seatCents = input.namedSeat ? input.seatOffer.amountCents : 0;
   const compareAt = input.presentation?.compareAtPriceCents;
   const presentation = Number.isSafeInteger(compareAt) && Number(compareAt) > tier.priceCents ? { compareAtPriceCents: Number(compareAt) } : void 0;
   const dueToday = terms2 ? subscriptionAmountDue({ priceCents: tier.priceCents, billingTerms: terms2 }) : void 0;
@@ -5855,6 +6102,7 @@ async function createPaymentQuote(input) {
     discountCents: tier.priceCents - dueToday,
     dueTodayCents: dueToday
   };
+  if (!Number.isSafeInteger(lines.dueTodayCents + seatCents) || !Number.isSafeInteger(tier.priceCents + seatCents)) throw new Error("invalid checkout total");
   const quote = {
     applicationId: input.applicationId,
     chapterId: input.chapterId,
@@ -5862,11 +6110,17 @@ async function createPaymentQuote(input) {
     tierName: tier.name,
     currency: tier.currency ?? String(group.currency ?? "usd"),
     interval: tier.interval ?? (group.interval === "month" ? "month" : "year"),
-    lineItems: presentation ? {
-      standardCents: presentation.compareAtPriceCents,
-      discountCents: presentation.compareAtPriceCents - lines.dueTodayCents,
-      dueTodayCents: lines.dueTodayCents
-    } : lines,
+    lineItems: {
+      ...presentation ? {
+        standardCents: presentation.compareAtPriceCents,
+        discountCents: presentation.compareAtPriceCents - lines.dueTodayCents,
+        dueTodayCents: lines.dueTodayCents
+      } : lines,
+      dueTodayCents: lines.dueTodayCents + seatCents,
+      ...input.namedSeat ? { namedSeatCents: seatCents } : {}
+    },
+    ...input.seatOffer ? { seatOffer: input.seatOffer } : {},
+    ...input.namedSeat ? { namedSeat: input.namedSeat } : {},
     ...presentation ? { presentation } : {},
     refundPolicyText: policy2?.refundPolicyText ?? String(group.refundPolicyText ?? ""),
     merchantDisclosureText: String(group.merchantDisclosureText ?? ""),
@@ -5878,7 +6132,7 @@ async function createPaymentQuote(input) {
         discountDuration: terms2.discount.duration === "once" ? "first_term" : "while_active"
       } : {},
       ...terms2.initialTermEndsAt !== void 0 ? { initialTermEndsAt: terms2.initialTermEndsAt } : {},
-      renewalCents: terms2.discount?.duration === "forever" ? dueToday : tier.priceCents,
+      renewalCents: (terms2.discount?.duration === "forever" ? dueToday : tier.priceCents) + seatCents,
       autoRenew: true
     } } : {}
   };
@@ -5898,22 +6152,23 @@ async function createPaymentQuote(input) {
 // src/membership-quote-projection.ts
 var MEMBERSHIP_QUOTE_NAMESPACE = "membershipQuoteProjections";
 var keys2 = ["appId", "chapterId", "environment", "runtime", "applicationId", "skuId"];
-var fail5 = (code) => {
+var fail6 = (code) => {
   throw Object.assign(new Error(code), { code });
 };
-var load3 = async (db, ns, id6) => (await db.query({ [ns]: { $: { where: { id: id6 }, limit: 1 } } }))[ns]?.[0];
+var load3 = async (db, ns, id7) => (await db.query({ [ns]: { $: { where: { id: id7 }, limit: 1 } } }))[ns]?.[0];
 async function restore2(row2, target, now, allowExpired = false) {
-  if (!row2 || keys2.some((key3) => row2[key3] !== target[key3]) || !Number.isSafeInteger(row2.revision) || Number(row2.revision) < 1 || typeof row2.requestId !== "string") return fail5("membership_quote_unavailable");
-  if (row2.status !== "ready") return fail5("membership_quote_pending");
+  if (!row2 || keys2.some((key3) => row2[key3] !== target[key3]) || !Number.isSafeInteger(row2.revision) || Number(row2.revision) < 1 || typeof row2.requestId !== "string") return fail6("membership_quote_unavailable");
+  if (row2.status !== "ready") return fail6("membership_quote_pending");
   const offer = await verifyIssuedMembershipOffer(row2.offer, { ...target, offerId: await membershipOfferIdForRequest({
     ...target,
     requestId: row2.requestId
   }), now, lifetimeMs: 6e4 });
-  if (offer.issuedAt > now + 3e4 || !allowExpired && offer.expiresAt <= now) return fail5("membership_quote_expired");
+  if (offer.issuedAt > now + 3e4 || !allowExpired && offer.expiresAt <= now) return fail6("membership_quote_expired");
   const tier = row2.tier, quote = row2.quote;
   const offering = offer.contract.offering;
+  if (quote?.seatOffer && quote.seatOffer.amountCents !== offering.seatPriceCents) return fail6("membership_quote_conflict");
   if (!tier || tier.id !== target.skuId || tier.groupId !== target.chapterId || !tier.stripePriceId || tier.priceCents !== offering.basePriceCents || tier.currency !== offering.currency || tier.interval !== offering.interval || !quote) {
-    return fail5("membership_catalog_mismatch");
+    return fail6("membership_catalog_mismatch");
   }
   const expected = await createPaymentQuote({
     ...target,
@@ -5922,19 +6177,21 @@ async function restore2(row2, target, now, allowExpired = false) {
     policy: { refundPolicyText: quote.refundPolicyText, trustCopy: quote.trustCopy },
     billingTerms: offer.contract.billingTerms,
     presentation: quote.presentation,
-    founding: foundingOf(offer)
+    founding: foundingOf(offer),
+    seatOffer: quote.seatOffer,
+    namedSeat: quote.namedSeat
   });
-  if (quote.digest !== expected.digest) return fail5("membership_quote_conflict");
+  if (quote.digest !== expected.digest) return fail6("membership_quote_conflict");
   return { tier, quote: expected, billingTerms: offer.contract.billingTerms, membershipOffer: offer, projectionRevision: Number(row2.revision) };
 }
 async function readMembershipQuote(db, target, now) {
   return restore2(await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, target.applicationId), target, now);
 }
 async function prepareMembershipQuote(db, input, issue) {
-  const { applicationId: id6, now, app } = input;
-  if (app.id !== id6 || app.groupId !== input.chapterId || app.tierId !== input.skuId || app.stripeRuntime !== input.runtime || app.status !== "submitted" || app.canceled === true || app.giftOfferId || app.giftClaimId || app.namedSeatId || app.namedSeatClaimPending) return fail5("membership_quote_unavailable");
-  let row2 = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id6);
-  if (row2 && keys2.some((key3) => row2[key3] !== input[key3])) return fail5("membership_quote_conflict");
+  const { applicationId: id7, now, app } = input;
+  if (app.id !== id7 || app.groupId !== input.chapterId || app.tierId !== input.skuId || app.stripeRuntime !== input.runtime || app.status !== "submitted" || app.canceled === true || app.giftOfferId || app.giftClaimId || app.namedSeatId || app.namedSeatClaimPending) return fail6("membership_quote_unavailable");
+  let row2 = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id7);
+  if (row2 && keys2.some((key3) => row2[key3] !== input[key3])) return fail6("membership_quote_conflict");
   if (row2?.status === "ready") {
     try {
       return await restore2(row2, input, now);
@@ -5945,15 +6202,15 @@ async function prepareMembershipQuote(db, input, issue) {
   const identity2 = ["groupId", "tierId", "stripeRuntime", "email", "emailNormalized", "status", "canceled", "membershipRestartId", "namedSeatId", "namedSeatClaimPending", "giftClaimId", "giftOfferId"];
   const guards = [{
     ns: "applications",
-    id: id6,
+    id: id7,
     exists: true,
     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 }];
+  }, { ns: "subscriptionCheckoutIntents", id: id7, exists: false }];
   if (!row2 || row2.status === "ready" || row2.status === "restart") {
     const revision = Number(row2?.revision ?? 0) + 1;
     const pending = {
-      id: id6,
+      id: id7,
       ...Object.fromEntries(keys2.map((key3) => [key3, input[key3]])),
       revision,
       status: "pending",
@@ -5961,25 +6218,25 @@ async function prepareMembershipQuote(db, input, issue) {
       updatedAt: now
     };
     try {
-      await db.transact([{ t: "update", ns: MEMBERSHIP_QUOTE_NAMESPACE, id: id6, attrs: pending }], {
-        mutationId: `membership-quote:${id6}:${revision}`,
+      await db.transact([{ t: "update", ns: MEMBERSHIP_QUOTE_NAMESPACE, id: id7, attrs: pending }], {
+        mutationId: `membership-quote:${id7}:${revision}`,
         guards: [...guards, {
           ns: MEMBERSHIP_QUOTE_NAMESPACE,
-          id: id6,
+          id: id7,
           exists: Boolean(row2),
           ...row2 ? { equals: { revision: row2.revision, status: row2.status } } : {}
         }]
       });
     } catch (error) {
       if (error.code !== "transact_guard_failed") throw error;
-      const winner = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id6);
+      const winner = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id7);
       if (!winner || winner.revision !== revision) throw error;
     }
-    row2 = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id6);
+    row2 = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id7);
   }
   if (row2?.status === "ready") return restore2(row2, input, now);
   if (!row2 || row2.status !== "pending" || keys2.some((key3) => row2[key3] !== input[key3]) || typeof row2.requestId !== "string") {
-    return fail5("membership_quote_pending");
+    return fail6("membership_quote_pending");
   }
   const target = Object.fromEntries(keys2.map((key3) => [key3, input[key3]]));
   const offer = await verifyIssuedMembershipOffer(await issue({ ...target, requestId: row2.requestId }), {
@@ -6000,7 +6257,8 @@ async function prepareMembershipQuote(db, input, issue) {
     policy: input.policy,
     billingTerms: offer.contract.billingTerms,
     presentation: input.presentation,
-    founding: foundingOf(offer)
+    founding: foundingOf(offer),
+    ...input.namedSeatsEnabled ? { seatOffer: { amountCents: offer.contract.offering.seatPriceCents } } : {}
   });
   const ready = { ...row2, offer, tier, quote, status: "ready", updatedAt: now };
   await restore2(ready, target, now, true);
@@ -6008,23 +6266,100 @@ async function prepareMembershipQuote(db, input, issue) {
     await db.transact([{
       t: "update",
       ns: MEMBERSHIP_QUOTE_NAMESPACE,
-      id: id6,
+      id: id7,
       attrs: { offer, offerDigest: offer.digest, tier, quote, status: "ready", updatedAt: now }
     }], {
-      mutationId: `membership-quote-ready:${id6}:${row2.revision}`,
+      mutationId: `membership-quote-ready:${id7}:${row2.revision}`,
       guards: [...guards, {
         ns: MEMBERSHIP_QUOTE_NAMESPACE,
-        id: id6,
+        id: id7,
         exists: true,
         equals: { status: "pending", revision: row2.revision, requestId: row2.requestId }
       }]
     });
   } catch (error) {
     if (error.code !== "transact_guard_failed") throw error;
-    const winner = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id6);
+    const winner = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id7);
     if (winner?.status !== "ready" || winner.requestId !== row2.requestId || winner.offerDigest !== offer.digest) throw error;
   }
-  return restore2(await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id6), target, now);
+  return restore2(await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id7), target, now);
+}
+async function selectCheckoutNamedSeat(db, target, input) {
+  if (!input.enabled) return fail6("named_seat_purchase_unavailable");
+  const row2 = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, target.applicationId);
+  const current = await restore2(row2, target, input.now);
+  const namedSeat = input.selection === null ? void 0 : checkoutNamedSeatSelection(input.selection, input.purchaserEmail);
+  const quote = await createPaymentQuote({
+    ...target,
+    tier: current.tier,
+    group: { merchantDisclosureText: current.quote.merchantDisclosureText },
+    policy: { refundPolicyText: current.quote.refundPolicyText, trustCopy: current.quote.trustCopy },
+    billingTerms: current.billingTerms,
+    presentation: current.quote.presentation,
+    founding: current.quote.founding,
+    seatOffer: { amountCents: current.membershipOffer.contract.offering.seatPriceCents },
+    namedSeat
+  });
+  if (quote.digest === current.quote.digest) return current;
+  await db.transact([{
+    t: "update",
+    ns: MEMBERSHIP_QUOTE_NAMESPACE,
+    id: target.applicationId,
+    attrs: { quote, revision: current.projectionRevision + 1, updatedAt: input.now }
+  }], {
+    mutationId: `membership-quote-selection:${target.applicationId}:${current.projectionRevision}:${quote.digest}`,
+    guards: [
+      {
+        ns: MEMBERSHIP_QUOTE_NAMESPACE,
+        id: target.applicationId,
+        exists: true,
+        equals: { revision: current.projectionRevision, status: "ready" }
+      },
+      { ns: "subscriptionCheckoutIntents", id: target.applicationId, exists: false }
+    ]
+  });
+  return restore2(await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, target.applicationId), target, input.now);
+}
+
+// src/bounded-request-text.ts
+async function readBoundedRequestText(req, maxBytes) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new TypeError("invalid request body cap");
+  const reader = req.body?.getReader();
+  const cancel = () => {
+    void reader?.cancel().catch(() => {
+    });
+  };
+  const invalid2 = () => json({ error: "invalid JSON body" }, 400);
+  let complete = false;
+  req.signal.addEventListener("abort", cancel, { once: true });
+  try {
+    if (req.signal.aborted) return invalid2();
+    const declared = req.headers.get("content-length");
+    if (declared && /^\d+$/.test(declared) && Number(declared) > maxBytes) {
+      return json({ error: "request body too large" }, 413);
+    }
+    if (!reader) return "";
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let text8 = "";
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (req.signal.aborted) return invalid2();
+      if (done) {
+        complete = true;
+        return text8 + decoder.decode();
+      }
+      bytes += value.byteLength;
+      if (bytes > maxBytes) return json({ error: "request body too large" }, 413);
+      text8 += decoder.decode(value, { stream: true });
+    }
+  } catch {
+    return invalid2();
+  } finally {
+    req.signal.removeEventListener("abort", cancel);
+    if (!complete) cancel();
+    reader?.releaseLock();
+  }
 }
 
 // src/payment-quote-route.ts
@@ -6058,8 +6393,11 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
         policy: { refundPolicyText: quote2.refundPolicyText, trustCopy: quote2.trustCopy },
         billingTerms,
         presentation: quote2.presentation,
-        founding: foundingOf(intent.membershipOffer)
+        founding: foundingOf(intent.membershipOffer),
+        seatOffer: quote2.seatOffer,
+        namedSeat: quote2.namedSeat
       });
+      if (quote2.seatOffer && quote2.seatOffer.amountCents !== intent.membershipOffer?.contract.offering.seatPriceCents) throw new Error("invalid seat snapshot");
       if (expected.digest !== quote2.digest) throw new Error("invalid commercial snapshot");
       return { tier: tier2, quote: expected, billingTerms, membershipOffer: intent.membershipOffer };
     }
@@ -6088,7 +6426,16 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
   const presentation = tierPresentationFor(control3?.document, tier.id);
   if (ctx.membershipAuthority) return prepareMembershipQuote(
     db,
-    { ...target, app, group, tier, policy: policy2, presentation, now: Date.now() },
+    {
+      ...target,
+      app,
+      group,
+      tier,
+      policy: policy2,
+      presentation,
+      namedSeatsEnabled: Boolean(ctx.membershipAuthority.namedSeats) && !app.membershipRestartId,
+      now: Date.now()
+    },
     (input) => ctx.membershipAuthority.issueOffer(input, env)
   );
   const quote = await createPaymentQuote({
@@ -6104,20 +6451,54 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
   });
   return { tier, quote, billingTerms: void 0 };
 }
-async function paymentQuoteRoute(url, env, ctx, prepare = false) {
-  const id6 = url.searchParams.get("application");
-  if (!id6 || id6.length > 160) return json({ error: "application required" }, 400);
+async function paymentQuoteRoute(url, env, ctx, prepare = false, request) {
+  let selection;
+  if (request?.body) {
+    try {
+      const text8 = await readBoundedRequestText(request, 2048);
+      if (text8 instanceof Response) return text8;
+      const body = JSON.parse(text8);
+      if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key3) => key3 !== "namedSeat")) throw new Error("invalid body");
+      selection = body.namedSeat;
+    } catch {
+      return json({ error: "invalid seat selection" }, 400);
+    }
+  }
+  const id7 = url.searchParams.get("application");
+  if (!id7 || id7.length > 160) return json({ error: "application required" }, 400);
   const db = ctx.makeDb(env);
-  const app = (await db.query({ applications: { $: { where: { id: id6 }, limit: 1 } } })).applications?.[0];
+  const app = (await db.query({ applications: { $: { where: { id: id7 }, limit: 1 } } })).applications?.[0];
   if (!app || String(app.groupId ?? ctx.chapter.id) !== ctx.chapter.id) return json({ error: "not found" }, 404);
   if (typeof app.stripeRuntime === "string" && app.stripeRuntime !== stripeRuntimeIdentity(env.ODLA_RUNTIME)) return json({ error: "not found" }, 404);
   if (app.status !== "submitted" || app.giftOfferId || app.namedSeatId || app.namedSeatClaimPending || app.giftClaimId || app.canceled === true) return json({ error: "membership checkout unavailable" }, 409);
   const group = (await db.query({ groups: { $: { where: { id: ctx.chapter.id }, limit: 1 } } })).groups?.[0];
   if (!group) return json({ error: "payments not configured" }, 503);
   try {
-    const { quote } = await checkoutQuoteForApplication(db, app, group, env, ctx, prepare);
-    return new Response(JSON.stringify(quote), { headers: { "content-type": "application/json", "cache-control": "no-store" } });
+    let { quote } = await checkoutQuoteForApplication(db, app, group, env, ctx, prepare);
+    const intent = (await db.query({ subscriptionCheckoutIntents: { $: { where: { id: id7 }, limit: 1 } } })).subscriptionCheckoutIntents?.[0];
+    if (prepare && !intent && !quote.seatOffer && ctx.membershipAuthority?.namedSeats && !app.membershipRestartId && selection === void 0) selection = null;
+    if (selection !== void 0) {
+      if (intent) return json({ error: "checkout has already started", code: "checkout_intent_mismatch" }, 409);
+      ({ quote } = await selectCheckoutNamedSeat(
+        db,
+        {
+          appId: env.ODLA_APP_ID,
+          chapterId: ctx.chapter.id,
+          environment: env.ODLA_ENV,
+          runtime: stripeRuntimeIdentity(env.ODLA_RUNTIME),
+          applicationId: id7,
+          skuId: String(app.tierId)
+        },
+        { selection, purchaserEmail: String(app.email ?? ""), now: Date.now(), enabled: Boolean(ctx.membershipAuthority?.namedSeats) && !app.membershipRestartId }
+      ));
+    }
+    return new Response(JSON.stringify(quote), { headers: {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+      "x-chapter-checkout-started": intent ? "true" : "false"
+    } });
   } catch (error) {
+    if (error.code === "invalid_named_seat_recipient") return json({ error: "Enter a different recipient's name and email." }, 400);
     const expired = error.code === "membership_quote_expired";
     return json({ error: "payment quote unavailable", ...expired ? { code: "payment_quote_expired" } : {} }, expired ? 409 : 503);
   }
@@ -6223,47 +6604,6 @@ async function resumeJoin(url, env, ctx) {
   return json({ error: "Application continuation is unavailable. Retry when its payment or membership configuration is restored." }, 409);
 }
 
-// src/bounded-request-text.ts
-async function readBoundedRequestText(req, maxBytes) {
-  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new TypeError("invalid request body cap");
-  const reader = req.body?.getReader();
-  const cancel = () => {
-    void reader?.cancel().catch(() => {
-    });
-  };
-  const invalid2 = () => json({ error: "invalid JSON body" }, 400);
-  let complete = false;
-  req.signal.addEventListener("abort", cancel, { once: true });
-  try {
-    if (req.signal.aborted) return invalid2();
-    const declared = req.headers.get("content-length");
-    if (declared && /^\d+$/.test(declared) && Number(declared) > maxBytes) {
-      return json({ error: "request body too large" }, 413);
-    }
-    if (!reader) return "";
-    const decoder = new TextDecoder();
-    let bytes = 0;
-    let text8 = "";
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (req.signal.aborted) return invalid2();
-      if (done) {
-        complete = true;
-        return text8 + decoder.decode();
-      }
-      bytes += value.byteLength;
-      if (bytes > maxBytes) return json({ error: "request body too large" }, 413);
-      text8 += decoder.decode(value, { stream: true });
-    }
-  } catch {
-    return invalid2();
-  } finally {
-    req.signal.removeEventListener("abort", cancel);
-    if (!complete) cancel();
-    reader?.releaseLock();
-  }
-}
-
 // src/named-seat-application.ts
 async function namedSeatPurchaserName(db, applicationId, chapterId, runtime) {
   const app = await membershipLoad(db, "applications", applicationId);
@@ -7158,10 +7498,10 @@ function tiersOf(value, errors) {
       return [];
     }
     unknownKeys(item, TIER_KEYS2, path, errors);
-    const id6 = text4(item.id, `${path}.id`, errors, 80);
-    if (id6 && !TIER.test(id6)) errors.push(`${path}.id must be a lowercase kebab-case id`);
-    if (seen.has(id6)) errors.push(`${path}.id duplicates "${id6}"`);
-    seen.add(id6);
+    const id7 = text4(item.id, `${path}.id`, errors, 80);
+    if (id7 && !TIER.test(id7)) errors.push(`${path}.id must be a lowercase kebab-case id`);
+    if (seen.has(id7)) errors.push(`${path}.id duplicates "${id7}"`);
+    seen.add(id7);
     const name = text4(item.name, `${path}.name`, errors, 160);
     if (typeof item.available !== "boolean") errors.push(`${path}.available must be boolean`);
     if (!Number.isInteger(item.sortOrder) || Number(item.sortOrder) < 0) errors.push(`${path}.sortOrder must be a non-negative integer`);
@@ -7182,7 +7522,7 @@ function tiersOf(value, errors) {
     }
     const blurb = item.blurb === void 0 ? void 0 : text4(item.blurb, `${path}.blurb`, errors, 4e3);
     return [{
-      id: id6,
+      id: id7,
       name,
       available: item.available === true,
       sortOrder: Number(item.sortOrder) || 0,
@@ -7244,15 +7584,15 @@ function policyOf(value, errors, tiers) {
   if (input.tierPolicies !== void 0) {
     const overrides = recordOf(input.tierPolicies);
     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}`;
+    else for (const [id7, raw2] of Object.entries(overrides)) {
+      const path = `document.policy.tierPolicies.${id7}`;
       const policy2 = recordOf(raw2);
-      if (!tiers.some((tier) => tier.id === id6) || !policy2) {
+      if (!tiers.some((tier) => tier.id === id7) || !policy2) {
         errors.push(`${path} must name a declared tier and policy`);
         continue;
       }
       unknownKeys(policy2, /* @__PURE__ */ new Set(["refundPolicyText", "trustCopy"]), path, errors);
-      tierPolicies[id6] = {
+      tierPolicies[id7] = {
         refundPolicyText: text4(policy2.refundPolicyText, `${path}.refundPolicyText`, errors),
         ...policy2.trustCopy !== void 0 ? { trustCopy: text4(policy2.trustCopy, `${path}.trustCopy`, errors) } : {}
       };
@@ -7545,14 +7885,14 @@ function validateMemberContentDocument(input, options = {}) {
       continue;
     }
     unknownKeys2(raw2, PAGE_KEYS, path, errors);
-    const id6 = textValue(raw2.id, `${path}.id`, errors, 80, true) ?? "";
+    const id7 = textValue(raw2.id, `${path}.id`, errors, 80, true) ?? "";
     const slug = textValue(raw2.slug, `${path}.slug`, errors, 120, true) ?? "";
     const title = textValue(raw2.title, `${path}.title`, errors, MAX_TEXT, true) ?? "";
-    if (id6 && !ID4.test(id6)) errors.push(`${path}.id must be a lowercase kebab-case id`);
+    if (id7 && !ID4.test(id7)) errors.push(`${path}.id must be a lowercase kebab-case id`);
     if (slug && !SLUG2.test(slug)) errors.push(`${path}.slug must be a lowercase URL slug`);
-    if (ids2.has(id6) || knownParentIds.has(id6)) errors.push(`${path}.id duplicates page "${id6}"`);
+    if (ids2.has(id7) || knownParentIds.has(id7)) errors.push(`${path}.id duplicates page "${id7}"`);
     if (slugs.has(slug) || (options.parentPages ?? []).some((page) => page.slug === slug)) errors.push(`${path}.slug duplicates "${slug}"`);
-    ids2.add(id6);
+    ids2.add(id7);
     slugs.add(slug);
     const navRaw = record2(raw2.navigation);
     let navigation = { section: "General", order: index2 };
@@ -7608,7 +7948,7 @@ function validateMemberContentDocument(input, options = {}) {
         else if (owner === "chapter") upsell = { owner, ...offer ? { offer } : {} };
       }
     }
-    pages.push({ id: id6, slug, title, ...summary ? { summary } : {}, navigation, audience, ...teaserMarkdown ? { teaserMarkdown } : {}, bodyMarkdown, ...upsell ? { upsell } : {} });
+    pages.push({ id: id7, slug, title, ...summary ? { summary } : {}, navigation, audience, ...teaserMarkdown ? { teaserMarkdown } : {}, bodyMarkdown, ...upsell ? { upsell } : {} });
   }
   const allIds = /* @__PURE__ */ new Set([...knownParentIds, ...ids2]);
   for (const [index2, page] of pages.entries()) {
@@ -7751,20 +8091,20 @@ async function loadLatestMemberContentControl(db, targetId, environment) {
   return control(Array.isArray(rows5) ? [...rows5].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
 }
 async function loadLocalMemberContent(db, chapterId, environment) {
-  const id6 = `member-content-local:${environment}`;
-  const rows5 = (await db.query({ memberContentLocal: { $: { where: { id: id6 }, limit: 1 } } })).memberContentLocal;
+  const id7 = `member-content-local:${environment}`;
+  const rows5 = (await db.query({ memberContentLocal: { $: { where: { id: id7 }, limit: 1 } } })).memberContentLocal;
   return local2(Array.isArray(rows5) ? rows5[0] : void 0);
 }
 async function materializeMemberContentControl(db, envelope, previous, receivedAt) {
   const { document, digest } = envelope;
   const target = document.target;
-  const id6 = `member-content-control:${target.environment}:${document.revision}`;
+  const id7 = `member-content-control:${target.environment}:${document.revision}`;
   const ops = [];
   if (previous?.active) {
     ops.push({ t: "update", ns: "memberContentControls", id: previous.id, attrs: { active: false } });
   }
-  ops.push({ t: "update", ns: "memberContentControls", id: id6, attrs: {
-    id: id6,
+  ops.push({ t: "update", ns: "memberContentControls", id: id7, attrs: {
+    id: id7,
     sourceId: document.source.appId,
     targetId: target.chapterId,
     environment: target.environment,
@@ -7777,11 +8117,11 @@ async function materializeMemberContentControl(db, envelope, previous, receivedA
   await db.transact(ops, { mutationId: `member-content-control:${target.environment}:${document.revision}:${digest}` });
 }
 async function saveLocalMemberContent(db, document, environment, expectedRevision, updatedAt, updatedBy) {
-  const id6 = `member-content-local:${environment}`;
+  const id7 = `member-content-local:${environment}`;
   const current = await loadLocalMemberContent(db, document.source.appId, environment);
   if ((current?.revision ?? 0) !== expectedRevision) throw new Error("member_content_revision_conflict");
   const row2 = {
-    id: id6,
+    id: id7,
     chapterId: document.source.appId,
     environment,
     revision: document.revision,
@@ -7789,9 +8129,9 @@ async function saveLocalMemberContent(db, document, environment, expectedRevisio
     updatedAt,
     ...updatedBy ? { updatedBy } : {}
   };
-  await db.transact([{ t: "update", ns: "memberContentLocal", id: id6, attrs: row2 }], {
+  await db.transact([{ t: "update", ns: "memberContentLocal", id: id7, attrs: row2 }], {
     mutationId: `member-content-local:${environment}:${document.revision}`,
-    guards: current ? [{ ns: "memberContentLocal", id: id6, exists: true, equals: { revision: expectedRevision } }] : [{ ns: "memberContentLocal", id: id6, exists: false }]
+    guards: current ? [{ ns: "memberContentLocal", id: id7, exists: true, equals: { revision: expectedRevision } }] : [{ ns: "memberContentLocal", id: id7, exists: false }]
   });
   return row2;
 }
@@ -7928,7 +8268,7 @@ var handleAdminMemberContent = async (req, url, env, ctx) => {
       parent: parent ? { revision: parent.revision, digest: parent.digest, document: parent.document } : null,
       chapter: chapter ? { revision: chapter.revision, document: chapter.document } : null,
       effective,
-      tiers: tiers.map(({ id: id6, name, priceCents, active }) => ({ id: id6, name, priceCents, active })),
+      tiers: tiers.map(({ id: id7, name, priceCents, active }) => ({ id: id7, name, priceCents, active })),
       localAuthoring: ctx.chapter.memberContent.localAuthoring
     });
   }
@@ -8086,11 +8426,11 @@ var handleAdminAdmissionGrants = async (req, url, env, ctx) => {
       return json({ error: "expiresAt must be a future epoch timestamp" }, 400);
     }
     const sourceGrantId = crypto.randomUUID();
-    const id6 = `admission:local:${ctx.chapter.id}:${sourceGrantId}`;
+    const id7 = `admission:local:${ctx.chapter.id}:${sourceGrantId}`;
     const createdAt = Date.now();
     const actor = auth.user.email ?? auth.user.userId;
-    await auth.db.transact([{ t: "update", ns: "admissionGrants", id: id6, attrs: {
-      id: id6,
+    await auth.db.transact([{ t: "update", ns: "admissionGrants", id: id7, attrs: {
+      id: id7,
       sourceGrantId,
       sourceScope: "local",
       sourceId: ctx.chapter.id,
@@ -8106,7 +8446,7 @@ var handleAdminAdmissionGrants = async (req, url, env, ctx) => {
       updatedAt: createdAt,
       updatedBy: actor
     } }], { mutationId: `admission-local-create:${sourceGrantId}` });
-    return json({ grant: { id: id6, sourceGrantId, sourceScope: "local", email, decision, active: true, createdAt, ...note ? { note } : {}, ...expiresAt ? { expiresAt } : {} } }, 201);
+    return json({ grant: { id: id7, sourceGrantId, sourceScope: "local", email, decision, active: true, createdAt, ...note ? { note } : {}, ...expiresAt ? { expiresAt } : {} } }, 201);
   }
   const prefix = "/api/admin/admission-grants/";
   let revokeId = "";
@@ -8120,20 +8460,20 @@ var handleAdminAdmissionGrants = async (req, url, env, ctx) => {
   if (/^admission:local:[a-z0-9-]+:[0-9a-f-]+$/.test(revokeId) && req.method === "DELETE") {
     const auth = await gate(req, env, ctx);
     if (auth instanceof Response) return auth;
-    const id6 = revokeId;
-    const found = await auth.db.query({ admissionGrants: { $: { where: { id: id6 }, limit: 1 } } });
+    const id7 = revokeId;
+    const found = await auth.db.query({ admissionGrants: { $: { where: { id: id7 }, limit: 1 } } });
     const row2 = Array.isArray(found.admissionGrants) ? found.admissionGrants[0] : void 0;
     if (!row2 || row2.targetId !== ctx.chapter.id || row2.sourceScope !== "local") return json({ error: "not found" }, 404);
     if (row2.active !== true) return json({ ok: true, replayed: true });
     const revokedAt = Date.now();
     const actor = auth.user.email ?? auth.user.userId;
-    await auth.db.transact([{ t: "update", ns: "admissionGrants", id: id6, attrs: {
+    await auth.db.transact([{ t: "update", ns: "admissionGrants", id: id7, attrs: {
       active: false,
       revokedAt,
       revokedBy: actor,
       updatedAt: revokedAt,
       updatedBy: actor
-    } }], { mutationId: `admission-local-revoke:${id6}` });
+    } }], { mutationId: `admission-local-revoke:${id7}` });
     return json({ ok: true, replayed: false });
   }
   return null;
@@ -8195,8 +8535,8 @@ async function loadLeaderAdmissionAssignments(db, targetId) {
   return await readAdmissionRows(db, "leaderAdmissionAssignments", { targetId }, MAX_ASSIGNMENTS);
 }
 async function loadLeaderAdmissionDelivery(db, targetId, environment) {
-  const id6 = deliveryId(targetId, environment);
-  const result = await db.query({ leaderAdmissionDeliveries: { $: { where: { id: id6 }, limit: 1 } } });
+  const id7 = deliveryId(targetId, environment);
+  const result = await db.query({ leaderAdmissionDeliveries: { $: { where: { id: id7 }, limit: 1 } } });
   return admissionRows(result.leaderAdmissionDeliveries)[0] ?? null;
 }
 function personAdmissionEmail(ctx, record4) {
@@ -8224,8 +8564,8 @@ async function persistLeaderAdmissionDesiredSet(opts) {
   const now = Date.now();
   const previous = await loadLeaderAdmissionDelivery(opts.db, opts.target.id, opts.env.ODLA_ENV);
   const current = await loadLeaderAdmissionAssignments(opts.db, opts.target.id);
-  const id6 = assignmentId(opts.target.id, opts.personId);
-  const existing = current.find((row2) => row2.id === id6);
+  const id7 = assignmentId(opts.target.id, opts.personId);
+  const existing = current.find((row2) => row2.id === id7);
   const digest = await signupControlDigest({
     targetId: opts.target.id,
     personId: opts.personId,
@@ -8255,7 +8595,7 @@ async function persistLeaderAdmissionDesiredSet(opts) {
     return { delivery: saved, duplicate: true };
   }
   const assignment = {
-    id: id6,
+    id: id7,
     targetId: opts.target.id,
     personId: opts.personId,
     grantId: existing?.grantId ?? crypto.randomUUID().replaceAll("-", ""),
@@ -8270,7 +8610,7 @@ async function persistLeaderAdmissionDesiredSet(opts) {
     updatedAt: now,
     updatedBy: opts.actor
   };
-  const desired = current.filter((row2) => row2.id !== id6 && row2.active).concat(assignment.active ? [assignment] : []);
+  const desired = current.filter((row2) => row2.id !== id7 && row2.active).concat(assignment.active ? [assignment] : []);
   const grants = await Promise.all(desired.map((row2) => grantInput(opts.db, opts.ctx, row2, opts.resolveEmail)));
   const revision = (previous?.revision ?? 0) + 1;
   const envelope = await createAdmissionGrantEnvelope({
@@ -8293,7 +8633,7 @@ async function persistLeaderAdmissionDesiredSet(opts) {
     updatedAt: now
   };
   const ops = [
-    { t: "update", ns: "leaderAdmissionAssignments", id: id6, attrs: assignment },
+    { t: "update", ns: "leaderAdmissionAssignments", id: id7, attrs: assignment },
     { t: "update", ns: "leaderAdmissionDeliveries", id: delivery.id, attrs: delivery },
     { t: "update", ns: "leaderAdmissionMutations", id: mutationReceiptId, attrs: {
       id: mutationReceiptId,
@@ -8308,7 +8648,7 @@ async function persistLeaderAdmissionDesiredSet(opts) {
     ...!opts.note && existing?.note !== void 0 ? ["note"] : [],
     ...opts.expiresAt === void 0 && existing?.expiresAt !== void 0 ? ["expiresAt"] : []
   ];
-  if (retract.length) ops.push({ t: "retract", ns: "leaderAdmissionAssignments", id: id6, attrs: retract });
+  if (retract.length) ops.push({ t: "retract", ns: "leaderAdmissionAssignments", id: id7, attrs: retract });
   const tx = await opts.db.transact(ops, {
     mutationId: `leader-admission:${opts.target.id}:${opts.mutationId}`,
     guards: previous ? [{ ns: "leaderAdmissionDeliveries", id: previous.id, exists: true, equals: { revision: previous.revision } }] : [{ ns: "leaderAdmissionDeliveries", id: delivery.id, exists: false }]
@@ -8368,11 +8708,11 @@ function projectRecord(record4, allowed2, editable, stagesEnabled, crm) {
     allowed2.flatMap((name) => Object.prototype.hasOwnProperty.call(record4.fields, name) ? [[name, record4.fields[name]]] : [])
   );
   const def = crm.type(record4.type);
-  const editFields = editable.map((id6) => {
-    const field = def.fields[id6];
+  const editFields = editable.map((id7) => {
+    const field = def.fields[id7];
     return {
-      id: id6,
-      label: field.label ?? id6,
+      id: id7,
+      label: field.label ?? id7,
       type: field.type,
       required: field.required ?? false,
       ...field.options ? { options: field.options } : {}
@@ -8489,8 +8829,8 @@ async function gate2(req, env, ctx) {
   if (!await networkWriteAllowed(req, db, user, ctx, true)) return { response: reject6(403, "super_admin_required", "super-admin required") };
   return { db, user };
 }
-function targetFor(ctx, id6) {
-  return ctx.chapter.network.targets.find((target) => target.id === id6 && target.admissionGrants);
+function targetFor(ctx, id7) {
+  return ctx.chapter.network.targets.find((target) => target.id === id7 && target.admissionGrants);
 }
 async function deliverSaved(db, env, ctx, target, delivery) {
   if (delivery.status === "acknowledged") return delivery;
@@ -8594,7 +8934,7 @@ var handleAdminNetworkAdmissions = async (req, url, env, ctx) => {
   if (!personId || !MUTATION_ID2.test(mutationId)) {
     return reject6(422, "invalid_request", "personId and a stable mutationId are required");
   }
-  const resolveEmail = (id6) => resolveAdmissionPersonEmail(db, env, ctx, target, id6);
+  const resolveEmail = (id7) => resolveAdmissionPersonEmail(db, env, ctx, target, id7);
   let email;
   try {
     email = await resolveEmail(personId);
@@ -8833,28 +9173,28 @@ var handleSchedule = async (req, url, env, ctx) => {
 };
 
 // src/payments-stripe.ts
-import { stripeRequest as stripeRequest9, verifyStripeSignature as verifyStripeSignature2 } from "@odla-ai/stripe";
+import { stripeRequest as stripeRequest10, verifyStripeSignature as verifyStripeSignature2 } from "@odla-ai/stripe";
 
 // src/payments-refund.ts
-import { stripeRequest as stripeRequest7 } from "@odla-ai/stripe";
+import { stripeRequest as stripeRequest8 } from "@odla-ai/stripe";
 var row = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-var id2 = (value) => typeof value === "string" ? value : String(row(value).id ?? "");
+var id3 = (value) => typeof value === "string" ? value : String(row(value).id ?? "");
 var providerId2 = (value, prefix) => new RegExp(`^${prefix}_[A-Za-z0-9]+$`).test(value);
-function fail6(code = "refund_target_mismatch") {
+function fail7(code = "refund_target_mismatch") {
   throw Object.assign(new Error(code), { code });
 }
 async function refundSubscriptionPayment(secretKey, input) {
-  if (!providerId2(input.customerId, "cus") || !providerId2(input.subscriptionId, "sub")) fail6();
+  if (!providerId2(input.customerId, "cus") || !providerId2(input.subscriptionId, "sub")) fail7();
   const call = async (method, path, params, key3) => {
-    const result = await stripeRequest7({ secretKey }, method, path, params, key3 ? { idempotencyKey: key3 } : {});
-    if (!result.ok) fail6("stripe_error");
-    if (!result.body || typeof result.body !== "object" || Array.isArray(result.body)) fail6("stripe_invalid_response");
+    const result = await stripeRequest8({ secretKey }, method, path, params, key3 ? { idempotencyKey: key3 } : {});
+    if (!result.ok) fail7("stripe_error");
+    if (!result.body || typeof result.body !== "object" || Array.isArray(result.body)) fail7("stripe_invalid_response");
     return result.body;
   };
   const sub = await call("GET", `/v1/subscriptions/${input.subscriptionId}`);
-  if (id2(sub) !== input.subscriptionId || id2(sub.customer) !== input.customerId) fail6();
+  if (id3(sub) !== input.subscriptionId || id3(sub.customer) !== input.customerId) fail7();
   for (const [key3, value] of Object.entries(input.metadata ?? {})) {
-    if (row(sub.metadata)[key3] !== value) fail6();
+    if (row(sub.metadata)[key3] !== value) fail7();
   }
   let cursor;
   let earliest;
@@ -8867,79 +9207,79 @@ async function refundSubscriptionPayment(secretKey, input) {
       limit: 100,
       ...cursor ? { starting_after: cursor } : {}
     });
-    if (!Array.isArray(list.data) || typeof list.has_more !== "boolean") fail6("stripe_invalid_response");
+    if (!Array.isArray(list.data) || typeof list.has_more !== "boolean") fail7("stripe_invalid_response");
     for (const value of list.data) {
       const invoice2 = row(value);
       const subscription = invoice2.subscription ?? row(row(invoice2.parent).subscription_details).subscription;
-      if (!providerId2(id2(invoice2), "in") || seen.has(id2(invoice2)) || id2(subscription) !== input.subscriptionId || id2(invoice2.customer) !== input.customerId || invoice2.status !== "paid" || !Number.isSafeInteger(invoice2.created) || !Number.isSafeInteger(invoice2.amount_paid) || Number(invoice2.amount_paid) < 0) fail6();
-      seen.add(id2(invoice2));
+      if (!providerId2(id3(invoice2), "in") || seen.has(id3(invoice2)) || id3(subscription) !== input.subscriptionId || id3(invoice2.customer) !== input.customerId || invoice2.status !== "paid" || !Number.isSafeInteger(invoice2.created) || !Number.isSafeInteger(invoice2.amount_paid) || Number(invoice2.amount_paid) < 0) fail7();
+      seen.add(id3(invoice2));
       if (Number(invoice2.amount_paid) > 0 && (!earliest || Number(invoice2.created) < Number(earliest.created))) earliest = invoice2;
     }
     if (!list.has_more) break;
-    if (!list.data.length || page === 9) fail6("refund_history_incomplete");
-    cursor = id2(list.data[list.data.length - 1]);
+    if (!list.data.length || page === 9) fail7("refund_history_incomplete");
+    cursor = id3(list.data[list.data.length - 1]);
   }
-  if (!earliest) fail6("no_charge");
+  if (!earliest) fail7("no_charge");
   const invoice = earliest;
-  if (input.expectedInvoiceId !== void 0 && id2(invoice) !== input.expectedInvoiceId || input.expectedAmountCents !== void 0 && invoice.amount_paid !== input.expectedAmountCents) fail6();
-  let chargeId = id2(invoice.charge);
-  let paymentIntentId = id2(invoice.payment_intent);
+  if (input.expectedInvoiceId !== void 0 && id3(invoice) !== input.expectedInvoiceId || input.expectedAmountCents !== void 0 && invoice.amount_paid !== input.expectedAmountCents) fail7();
+  let chargeId = id3(invoice.charge);
+  let paymentIntentId = id3(invoice.payment_intent);
   if (!chargeId && !paymentIntentId) {
-    const payments = await call("GET", "/v1/invoice_payments", { invoice: id2(invoice), status: "paid", limit: 100 });
-    if (payments.has_more !== false || !Array.isArray(payments.data) || payments.data.length !== 1) fail6("refund_payment_ambiguous");
+    const payments = await call("GET", "/v1/invoice_payments", { invoice: id3(invoice), status: "paid", limit: 100 });
+    if (payments.has_more !== false || !Array.isArray(payments.data) || payments.data.length !== 1) fail7("refund_payment_ambiguous");
     const payment = row(payments.data[0]);
-    if (id2(payment.invoice) !== id2(invoice) || payment.status !== "paid" || row(payment.payment).type !== "payment_intent") fail6();
-    paymentIntentId = id2(row(payment.payment).payment_intent);
+    if (id3(payment.invoice) !== id3(invoice) || payment.status !== "paid" || row(payment.payment).type !== "payment_intent") fail7();
+    paymentIntentId = id3(row(payment.payment).payment_intent);
   }
   if (!chargeId) {
-    if (!providerId2(paymentIntentId, "pi")) fail6();
+    if (!providerId2(paymentIntentId, "pi")) fail7();
     const payment = await call("GET", `/v1/payment_intents/${paymentIntentId}`);
-    if (id2(payment) !== paymentIntentId || id2(payment.customer) !== input.customerId || payment.status !== "succeeded") fail6();
-    chargeId = id2(payment.latest_charge);
+    if (id3(payment) !== paymentIntentId || id3(payment.customer) !== input.customerId || payment.status !== "succeeded") fail7();
+    chargeId = id3(payment.latest_charge);
   }
-  if (!providerId2(chargeId, "ch")) fail6();
+  if (!providerId2(chargeId, "ch")) fail7();
   const charge = await call("GET", `/v1/charges/${chargeId}`);
-  if (id2(charge) !== chargeId || id2(charge.customer) !== input.customerId || charge.status !== "succeeded" || charge.invoice != null && id2(charge.invoice) !== id2(invoice) || paymentIntentId && id2(charge.payment_intent) !== paymentIntentId || !Number.isSafeInteger(charge.amount) || Number(charge.amount) <= 0 || !Number.isSafeInteger(charge.amount_refunded) || Number(charge.amount_refunded) < 0 || Number(charge.amount_refunded) > Number(charge.amount) || charge.currency !== invoice.currency || Number(charge.amount) !== Number(invoice.amount_paid)) fail6();
-  if (input.alreadyRefundedChargeId !== void 0 && (chargeId !== input.alreadyRefundedChargeId || charge.amount_refunded !== charge.amount || charge.refunded !== true)) fail6();
+  if (id3(charge) !== chargeId || id3(charge.customer) !== input.customerId || charge.status !== "succeeded" || charge.invoice != null && id3(charge.invoice) !== id3(invoice) || paymentIntentId && id3(charge.payment_intent) !== paymentIntentId || !Number.isSafeInteger(charge.amount) || Number(charge.amount) <= 0 || !Number.isSafeInteger(charge.amount_refunded) || Number(charge.amount_refunded) < 0 || Number(charge.amount_refunded) > Number(charge.amount) || charge.currency !== invoice.currency || Number(charge.amount) !== Number(invoice.amount_paid)) fail7();
+  if (input.alreadyRefundedChargeId !== void 0 && (chargeId !== input.alreadyRefundedChargeId || charge.amount_refunded !== charge.amount || charge.refunded !== true)) fail7();
   if (charge.amount_refunded !== charge.amount) {
     const refund = await call("POST", "/v1/refunds", {
       charge: chargeId,
       ...input.metadata ? { metadata: input.metadata } : {}
     }, `chapter-initial-refund:${input.subscriptionId}:${chargeId}`);
-    if (id2(refund.charge) !== chargeId || !["succeeded", "pending"].includes(String(refund.status)) || !Number.isSafeInteger(refund.amount) || Number(refund.amount) !== Number(charge.amount) - Number(charge.amount_refunded)) fail6("refund_not_confirmed");
+    if (id3(refund.charge) !== chargeId || !["succeeded", "pending"].includes(String(refund.status)) || !Number.isSafeInteger(refund.amount) || Number(refund.amount) !== Number(charge.amount) - Number(charge.amount_refunded)) fail7("refund_not_confirmed");
   }
   let subscriptionCanceled = sub.status === "canceled";
   if (input.cancelSubscription !== false && !subscriptionCanceled) {
     const canceled = await call("DELETE", `/v1/subscriptions/${input.subscriptionId}`);
-    if (id2(canceled) !== input.subscriptionId || canceled.status !== "canceled") fail6("refund_cancel_incomplete");
+    if (id3(canceled) !== input.subscriptionId || canceled.status !== "canceled") fail7("refund_cancel_incomplete");
     subscriptionCanceled = true;
   }
   const confirmed = await call("GET", `/v1/charges/${chargeId}`);
-  if (id2(confirmed) !== chargeId || id2(confirmed.customer) !== input.customerId || confirmed.amount !== charge.amount || confirmed.currency !== charge.currency || confirmed.amount_refunded !== charge.amount || confirmed.refunded !== true) fail6("refund_not_confirmed");
+  if (id3(confirmed) !== chargeId || id3(confirmed.customer) !== input.customerId || confirmed.amount !== charge.amount || confirmed.currency !== charge.currency || confirmed.amount_refunded !== charge.amount || confirmed.refunded !== true) fail7("refund_not_confirmed");
   return { refundedCents: Number(charge.amount), subscriptionCanceled };
 }
 
 // src/subscription-payment-identity.ts
-import { stripeRequest as stripeRequest8 } from "@odla-ai/stripe";
-var id3 = (value) => typeof value === "string" ? value : String(value?.id ?? "");
+import { stripeRequest as stripeRequest9 } from "@odla-ai/stripe";
+var id4 = (value) => typeof value === "string" ? value : String(value?.id ?? "");
 async function tagSubscriptionPayment(secretKey, invoice, customerId, metadata, clientSecret2, applicationId) {
-  let paymentId = id3(invoice.payment_intent);
+  let paymentId = id4(invoice.payment_intent);
   if (!paymentId) {
-    if (!/^in_[A-Za-z0-9]+$/.test(id3(invoice))) subscriptionContractMismatch();
-    const result2 = await stripeRequest8({ secretKey }, "GET", "/v1/invoice_payments", { invoice: id3(invoice), limit: 100 });
+    if (!/^in_[A-Za-z0-9]+$/.test(id4(invoice))) subscriptionContractMismatch();
+    const result2 = await stripeRequest9({ secretKey }, "GET", "/v1/invoice_payments", { invoice: id4(invoice), limit: 100 });
     const list = result2.body;
     if (!result2.ok || list?.has_more !== false || !Array.isArray(list.data) || list.data.length !== 1) subscriptionContractMismatch();
     const link = list.data[0];
-    if (id3(link.invoice) !== id3(invoice) || !["open", "paid"].includes(link.status) || link.payment?.type !== "payment_intent") subscriptionContractMismatch();
-    paymentId = id3(link.payment.payment_intent);
+    if (id4(link.invoice) !== id4(invoice) || !["open", "paid"].includes(link.status) || link.payment?.type !== "payment_intent") subscriptionContractMismatch();
+    paymentId = id4(link.payment.payment_intent);
   }
   if (!/^pi_[A-Za-z0-9]+$/.test(paymentId)) subscriptionContractMismatch();
   const path = `/v1/payment_intents/${paymentId}`;
-  const result = await stripeRequest8({ secretKey }, "GET", path);
+  const result = await stripeRequest9({ secretKey }, "GET", path);
   const payment = result.body;
-  if (!result.ok || payment?.id !== paymentId || id3(payment.customer) !== customerId || payment.amount !== invoice.total || payment.currency !== invoice.currency || payment.client_secret !== clientSecret2 || payment.livemode !== (metadata.odlaEnvironment === "prod") || !Object.entries(metadata).every(([key3, value]) => payment.metadata?.[key3] === void 0 || payment.metadata[key3] === value)) subscriptionContractMismatch();
+  if (!result.ok || payment?.id !== paymentId || id4(payment.customer) !== customerId || payment.amount !== invoice.total || payment.currency !== invoice.currency || payment.client_secret !== clientSecret2 || payment.livemode !== (metadata.odlaEnvironment === "prod") || !Object.entries(metadata).every(([key3, value]) => payment.metadata?.[key3] === void 0 || payment.metadata[key3] === value)) subscriptionContractMismatch();
   if (Object.entries(metadata).every(([key3, value]) => payment.metadata?.[key3] === value)) return;
-  const tagged = await stripeRequest8(
+  const tagged = await stripeRequest9(
     { secretKey },
     "POST",
     path,
@@ -8951,7 +9291,7 @@ async function tagSubscriptionPayment(secretKey, invoice, customerId, metadata,
 
 // src/payments-stripe.ts
 async function stripeCall(sk, method, path, params, idempotencyKey) {
-  return stripeRequest9(
+  return stripeRequest10(
     { secretKey: sk },
     method,
     path,
@@ -8959,7 +9299,7 @@ async function stripeCall(sk, method, path, params, idempotencyKey) {
     idempotencyKey ? { idempotencyKey } : {}
   );
 }
-function fail7(op, r) {
+function fail8(op, r) {
   const err = new Error(`stripe ${op} failed: ${r.status}`);
   err.code = "stripe_error";
   throw err;
@@ -8998,6 +9338,15 @@ function createStripeProvider(config) {
       let customerId = input.existingCustomerId;
       if (customerId && !/^cus_[A-Za-z0-9]+$/.test(customerId) || input.existingSubscriptionId && (!customerId || !/^sub_[A-Za-z0-9]+$/.test(input.existingSubscriptionId))) subscriptionContractMismatch();
       const productId = await verifySubscriptionPrice(sk, input, Boolean(input.existingSubscriptionId));
+      const seat = input.namedSeat?.amountCents ? input.namedSeat : void 0;
+      const seatProductId = seat ? await verifySubscriptionPrice(sk, {
+        ...input,
+        priceId: seat.priceId,
+        priceCents: seat.amountCents,
+        billingTerms: void 0,
+        namedSeat: void 0
+      }, Boolean(input.existingSubscriptionId)) : void 0;
+      if (seat && (!seatProductId || !productId || seatProductId === productId)) subscriptionContractMismatch();
       if (input.billingTerms?.discount && !productId) subscriptionContractMismatch();
       await prepareSubscriptionBillingTerms(sk, { ...input, discountProductId: productId }, Boolean(input.existingSubscriptionId));
       const billingParams = subscriptionBillingParams(input, productId);
@@ -9009,7 +9358,7 @@ function createStripeProvider(config) {
           { email: input.email, name: input.name, metadata: meta },
           `cus:${input.applicationId}`
         );
-        if (!cust.ok) fail7("customer create", cust);
+        if (!cust.ok) fail8("customer create", cust);
         if (typeof cust.body.id !== "string" || !/^cus_[A-Za-z0-9]+$/.test(cust.body.id)) subscriptionContractMismatch();
         customerId = cust.body.id;
       }
@@ -9029,19 +9378,32 @@ function createStripeProvider(config) {
         {
           customer: customerId,
           "items[0][price]": input.priceId,
+          ...seat ? {
+            "items[1][price]": seat.priceId,
+            "items[1][quantity]": 1,
+            "items[1][metadata][seatId]": seat.seatId,
+            "items[1][metadata][membershipId]": seat.membershipId
+          } : {},
           payment_behavior: "default_incomplete",
           "payment_settings[save_default_payment_method]": "on_subscription",
           "payment_settings[payment_method_types][0]": "card",
           "expand[0]": "latest_invoice.confirmation_secret",
           "expand[1]": "latest_invoice.payment_intent",
           metadata: meta,
-          ...billingParams
+          ...billingParams,
+          ...seat && input.billingTerms?.initialTermEndsAt ? {
+            "add_invoice_items[1][price_data][product]": seatProductId,
+            "add_invoice_items[1][price_data][currency]": input.currency,
+            "add_invoice_items[1][price_data][unit_amount]": seat.amountCents,
+            "add_invoice_items[1][quantity]": 1,
+            "add_invoice_items[1][discountable]": false
+          } : {}
         },
         // Hardening: one subscription per application, so a client
         // retry between create and the db write can't orphan a second one.
         `sub:${input.applicationId}${input.purchaseAttemptId ? `:${input.purchaseAttemptId}` : ""}`
       );
-      if (!sub.ok) fail7("subscription create", sub);
+      if (!sub.ok) fail8("subscription create", sub);
       if (input.billingTerms?.discount?.duration === "once" && Array.isArray(sub.body.discounts) && sub.body.discounts.length === 0) {
         const subscriptionId = sub.body.id;
         if (typeof subscriptionId !== "string" || !/^sub_[A-Za-z0-9]+$/.test(subscriptionId)) subscriptionContractMismatch();
@@ -9051,14 +9413,14 @@ function createStripeProvider(config) {
           "expand[2]": "discounts",
           "expand[3]": "latest_invoice.discounts"
         });
-        if (!expanded.ok) fail7("subscription invoice evidence", expanded);
+        if (!expanded.ok) fail8("subscription invoice evidence", expanded);
         if (expanded.body.id !== subscriptionId) subscriptionContractMismatch();
         sub = expanded;
       }
       verifySubscriptionResult(sub.body, input, customerId, meta);
       const invoice = sub.body.latest_invoice;
       const clientSecret2 = clientSecretOf(sub.body);
-      if (!clientSecret2) fail7("subscription confirmation-secret missing", sub);
+      if (!clientSecret2) fail8("subscription confirmation-secret missing", sub);
       await tagSubscriptionPayment(
         sk,
         invoice,
@@ -9270,9 +9632,9 @@ function matchesIntent(stored, expected) {
     "purchaseAttemptId"
   ].every((key3) => stored[key3] === expected[key3]) && customerMatches && JSON.stringify(storedTerms) === JSON.stringify(expected.billingTerms) && stored.membershipOffer?.digest === expected.membershipOffer?.digest && stored.paymentQuote?.digest === expected.paymentQuote?.digest;
 }
-async function loadIntent(db, id6) {
+async function loadIntent(db, id7) {
   return first3((await db.query({
-    subscriptionCheckoutIntents: { $: { where: { id: id6 }, limit: 1 } }
+    subscriptionCheckoutIntents: { $: { where: { id: id7 }, limit: 1 } }
   })).subscriptionCheckoutIntents);
 }
 async function startSubscriptionCheckout(db, provider, input, authorizeNetworkCheckout) {
@@ -9293,16 +9655,22 @@ async function startSubscriptionCheckout(db, provider, input, authorizeNetworkCh
   if (input.purchaseAttemptId !== application?.membershipRestartId) mismatch();
   if (application?.namedSeatId || application?.namedSeatClaimPending || application?.giftClaimId) mismatch();
   if (input.membershipOffer && (!application || application.canceled === true || application.status !== "submitted")) mismatch();
+  if (input.paymentQuote?.namedSeat && application?.email !== input.email) mismatch();
   const applicationGuard = {
     ns: "applications",
     id: input.applicationId,
     exists: true,
-    equals: { status: "submitted", ...input.purchaseAttemptId ? { membershipRestartId: input.purchaseAttemptId } : {}, ...input.membershipOffer ? {
-      groupId: input.groupId,
-      tierId: input.tierId,
-      stripeRuntime: stripeRuntimeIdentity(input.runtime),
-      ...application?.canceled !== void 0 ? { canceled: application.canceled } : {}
-    } : {} },
+    equals: {
+      status: "submitted",
+      ...input.paymentQuote?.namedSeat ? { email: input.email } : {},
+      ...input.purchaseAttemptId ? { membershipRestartId: input.purchaseAttemptId } : {},
+      ...input.membershipOffer ? {
+        groupId: input.groupId,
+        tierId: input.tierId,
+        stripeRuntime: stripeRuntimeIdentity(input.runtime),
+        ...application?.canceled !== void 0 ? { canceled: application.canceled } : {}
+      } : {}
+    },
     absent: ["namedSeatId", "namedSeatClaimPending", "giftClaimId", ...!input.purchaseAttemptId ? ["membershipRestartId"] : [], ...input.membershipOffer && application?.canceled === void 0 ? ["canceled"] : []]
   };
   let stored = await loadIntent(db, input.applicationId);
@@ -9326,7 +9694,11 @@ async function startSubscriptionCheckout(db, provider, input, authorizeNetworkCh
               ns: MEMBERSHIP_QUOTE_NAMESPACE,
               id: input.applicationId,
               exists: true,
-              equals: { status: "ready", offerDigest: input.membershipOffer.digest }
+              equals: {
+                status: "ready",
+                offerDigest: input.membershipOffer.digest,
+                ...input.projectionRevision !== void 0 ? { revision: input.projectionRevision } : {}
+              }
             }
           ] : []
         ]
@@ -9341,7 +9713,8 @@ async function startSubscriptionCheckout(db, provider, input, authorizeNetworkCh
   if (!stored.providerSubscriptionId && input.now - Number(stored.createdAt) >= 23 * 60 * 6e4) {
     throw Object.assign(new Error("checkout requires provider reconciliation"), { code: "checkout_recovery_required" });
   }
-  if (input.membershipOffer) await authorizeNetworkCheckout();
+  const binding = input.membershipOffer ? await authorizeNetworkCheckout() : void 0;
+  if (input.paymentQuote?.namedSeat && (!binding?.namedSeat || binding.namedSeat.amountCents !== input.paymentQuote.lineItems.namedSeatCents || binding.namedSeat.recipientEmail !== input.paymentQuote.namedSeat.recipientEmail || binding.namedSeat.recipientName !== input.paymentQuote.namedSeat.recipientName || binding.namedSeat.purchaserEmail !== input.emailNormalized)) mismatch();
   const result = await provider.createSubscription({
     appId: input.appId,
     chapterId: input.chapterId,
@@ -9356,6 +9729,7 @@ async function startSubscriptionCheckout(db, provider, input, authorizeNetworkCh
     priceCents: input.priceCents,
     currency: input.currency,
     interval: input.interval,
+    ...binding?.namedSeat ? { namedSeat: binding.namedSeat } : {},
     ...stored.billingTerms ? { billingTerms: stored.billingTerms } : {},
     ...typeof stored.providerSubscriptionId === "string" ? { existingSubscriptionId: stored.providerSubscriptionId } : {},
     existingCustomerId: typeof stored.providerCustomerId === "string" ? stored.providerCustomerId : input.existingCustomerId
@@ -9472,6 +9846,7 @@ async function startSubscription(req, env, ctx) {
     return json({ error: "payment quote unavailable", ...expired ? { code: "payment_quote_changed" } : {} }, expired ? 409 : 503);
   }
   const { tier, quote, billingTerms } = checkout2;
+  if (quote.namedSeat && body.seatTermsAck !== true) return json({ error: "seatTermsAck required" }, 400);
   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);
@@ -9496,6 +9871,7 @@ async function startSubscription(req, env, ctx) {
       priceCents: billingTerms ? tier.priceCents : quote.lineItems.dueTodayCents,
       ...billingTerms ? { billingTerms } : {},
       ...membershipOffer ? { membershipOffer } : {},
+      ..."projectionRevision" in checkout2 ? { projectionRevision: checkout2.projectionRevision } : {},
       ...ctx.requirePaymentQuote || ctx.membershipAuthority || body.quoteDigest ? { paymentQuote: quote } : {},
       currency: tier.currency ?? String(group.currency ?? "usd"),
       interval: tier.interval ?? (group.interval === "month" ? "month" : "year"),
@@ -9517,9 +9893,10 @@ async function startSubscription(req, env, ctx) {
         offerId: membershipOffer.id,
         offerDigest: membershipOffer.digest,
         quoteDigest: quote.digest,
-        priceId: String(priceId)
+        priceId: String(priceId),
+        ...quote.namedSeat ? { namedSeat: { ...quote.namedSeat, purchaserEmail: normalizeChapterEmail(String(app.email ?? "")) } } : {}
       };
-      await verifyMembershipCheckoutBinding(await ctx.membershipAuthority.bindCheckout(binding, env), binding);
+      return verifyMembershipCheckoutBinding(await ctx.membershipAuthority.bindCheckout(binding, env), binding);
     } : void 0);
   } catch (err) {
     const code = paymentErrorCode(err);
@@ -9541,7 +9918,7 @@ async function ingestWebhook(req, env, ctx) {
 var handlePayments = async (req, url, env, ctx) => {
   if (ctx.chapter.mode !== "chapter") return null;
   if (req.method === "GET" && url.pathname === "/api/payments/quote") return paymentQuoteRoute(url, env, ctx);
-  if (req.method === "POST" && url.pathname === "/api/payments/quote") return paymentQuoteRoute(url, env, ctx, true);
+  if (req.method === "POST" && url.pathname === "/api/payments/quote") return paymentQuoteRoute(url, env, ctx, true, req);
   if (req.method === "POST" && url.pathname === "/api/payments/subscription") return startSubscription(req, env, ctx);
   if (req.method === "POST" && url.pathname === "/api/webhooks/stripe") return ingestWebhook(req, env, ctx);
   return null;
@@ -9555,16 +9932,16 @@ var userFor = async (req, env, ctx) => {
   const user = await ctx.verifyUser(req, env);
   return user?.email ? user : null;
 };
-var loadClaim = async (db, id6) => first4((await db.query({ giftClaims: { $: { where: { id: id6 }, limit: 1 } } })).giftClaims);
+var loadClaim = async (db, id7) => first4((await db.query({ giftClaims: { $: { where: { id: id7 }, limit: 1 } } })).giftClaims);
 async function consumeRateLimit(db, chapterId, requester, now) {
   const bucket = await giftRequesterBucket(chapterId, requester);
-  const id6 = `gift-rate:${chapterId}:${bucket}`;
-  const current = first4((await db.query({ giftRedemptionAttempts: { $: { where: { id: id6 }, limit: 1 } } })).giftRedemptionAttempts);
+  const id7 = `gift-rate:${chapterId}:${bucket}`;
+  const current = first4((await db.query({ giftRedemptionAttempts: { $: { where: { id: id7 }, limit: 1 } } })).giftRedemptionAttempts);
   const within = Boolean(current && now - Number(current.windowStartedAt) < 15 * 6e4);
   const attemptCount = within ? Number(current?.attemptCount ?? 0) + 1 : 1;
   if (attemptCount > 10) return false;
-  await db.transact([{ t: "update", ns: "giftRedemptionAttempts", id: id6, attrs: {
-    id: id6,
+  await db.transact([{ t: "update", ns: "giftRedemptionAttempts", id: id7, attrs: {
+    id: id7,
     chapterId,
     bucket,
     attemptCount,
@@ -9738,14 +10115,14 @@ var at = (value) => Number.isSafeInteger(value) ? Number(value) : void 0;
 async function readNamedSeatOffer(db, input, now) {
   membershipClock(now);
   await loadMembershipAuthorityState(db, input);
-  const id6 = await networkMembershipId(input), member = await membershipLoad(db, "networkMembership", id6);
+  const id7 = await networkMembershipId(input), member = await membershipLoad(db, "networkMembership", id7);
   requireMembershipScope(member, input);
   const offering = membershipOfferingVersion(member.offeringSnapshot);
   const seat = member.namedSeatId ? await membershipLoad(db, "networkSeat", String(member.namedSeatId)) : void 0;
   if (seat) requireMembershipScope(seat, input);
   const purchaseEndsAt = seatPurchaseDeadline(offering, member);
   const offer = {
-    membershipId: id6,
+    membershipId: id7,
     amountCents: offering.seatPriceCents,
     currency: offering.currency,
     interval: offering.interval,
@@ -10114,18 +10491,18 @@ var handleEmailDeliveryResolution = async (req, url, env, ctx) => {
   if (!user) return json({ error: "unauthorized" }, 401);
   if (!await ctx.isAdmin(db, user)) return json({ error: "forbidden" }, 403);
   try {
-    const id6 = decodeURIComponent(match[1]);
+    const id7 = decodeURIComponent(match[1]);
     const body = await namedSeatRequest(req);
     if (Object.keys(body).some((key3) => !["expectedAttempt", "expectedState", "decision", "reason", "messageId"].includes(key3)) || body.messageId !== void 0 && (typeof body.messageId !== "string" || body.messageId.length > 255 || /[\r\n]/.test(body.messageId))) {
       return json({ error: "invalid delivery evidence" }, 400);
     }
-    const chapterDb = db, row2 = await membershipLoad(chapterDb, "emailLog", id6);
+    const chapterDb = db, row2 = await membershipLoad(chapterDb, "emailLog", id7);
     if (!row2 || row2.groupId !== ctx.chapter.id) return json({ error: "not found" }, 404);
     if (row2.applicationId) {
       const app = await membershipLoad(chapterDb, "applications", String(row2.applicationId));
       if (!app || !chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME)) return json({ error: "not found" }, 404);
     }
-    await reconcileLifecycleDelivery(chapterDb, { ...body, id: id6, groupId: ctx.chapter.id, actorId: user.userId }, Date.now());
+    await reconcileLifecycleDelivery(chapterDb, { ...body, id: id7, groupId: ctx.chapter.id, actorId: user.userId }, Date.now());
     return json({ ok: true, sent: false });
   } catch {
     return json({ error: "delivery evidence is invalid, stale, or still in progress; reload the exact attempt" }, 409);
@@ -10228,13 +10605,13 @@ var handlePeopleProfile = async (req, url, env, ctx) => {
   const user = await ctx.verifyUser(req, env);
   if (!user) return json({ error: "unauthorized" }, 401);
   if (!await ctx.isAdmin(db, user)) return json({ error: "forbidden" }, 403);
-  let id6;
+  let id7;
   try {
-    id6 = dedicated ? url.searchParams.get("recordId") ?? "" : decodeURIComponent(match[1]);
+    id7 = dedicated ? url.searchParams.get("recordId") ?? "" : decodeURIComponent(match[1]);
   } catch {
     return json({ error: "invalid record id" }, 422);
   }
-  const record4 = await getRecord3({ crm: ctx.chapter.crm, db }, id6);
+  const record4 = await getRecord3({ crm: ctx.chapter.crm, db }, id7);
   if (!record4) return json({ error: "not found" }, 404);
   if (record4.type !== "person") return dedicated ? json({ error: "person required" }, 422) : null;
   if (match?.[2]) {
@@ -10249,9 +10626,9 @@ var handlePeopleProfile = async (req, url, env, ctx) => {
   }
   if (req.method === "GET" && dedicated) {
     const excluded = profileReadOnlyFields(record4, ctx);
-    const fields = Object.entries(ctx.chapter.crm.type(record4.type).fields).filter(([id7]) => !excluded.includes(id7)).map(([id7, field]) => ({
-      id: id7,
-      label: field.label ?? id7,
+    const fields = Object.entries(ctx.chapter.crm.type(record4.type).fields).filter(([id8]) => !excluded.includes(id8)).map(([id8, field]) => ({
+      id: id8,
+      label: field.label ?? id8,
       type: field.type,
       required: field.required ?? false,
       ...field.options ? { options: field.options } : {}
@@ -11022,12 +11399,12 @@ var readJson = async (req) => {
     return null;
   }
 };
-async function loadApp(db, id6) {
-  const { applications } = await db.query({ applications: { $: { where: { id: id6 }, limit: 1 } } });
+async function loadApp(db, id7) {
+  const { applications } = await db.query({ applications: { $: { where: { id: id7 }, limit: 1 } } });
   return applications?.[0] ?? null;
 }
-async function loadGroup(db, id6) {
-  const { groups } = await db.query({ groups: { $: { where: { id: id6 }, limit: 1 } } });
+async function loadGroup(db, id7) {
+  const { groups } = await db.query({ groups: { $: { where: { id: id7 }, limit: 1 } } });
   return groups?.[0] ?? null;
 }
 var handleAdminApplicationActions = async (req, url, env, ctx) => {
@@ -11113,8 +11490,8 @@ var handleAdminApprove = async (req, url, env, ctx) => {
   const got = await gate4(req, env, ctx);
   if (got instanceof Response) return got;
   const db = got;
-  const id6 = m[1];
-  const app = await loadApp(db, id6);
+  const id7 = m[1];
+  const app = await loadApp(db, id7);
   if (!app) return json({ error: "not found" }, 404);
   const result = await approveApplication({ db, env, ctx, app, origin: url.origin, reason: "manual" });
   if (!result.ok) return json({ error: result.error }, result.status);
@@ -11143,10 +11520,10 @@ var handleAdminApplicationPatch = async (req, url, env, ctx) => {
   const got = await gate4(req, env, ctx);
   if (got instanceof Response) return got;
   const db = got;
-  const id6 = m[1];
+  const id7 = m[1];
   const body = await readJson(req);
   if (!body) return json({ error: "invalid JSON body" }, 400);
-  const app = await loadApp(db, id6);
+  const app = await loadApp(db, id7);
   if (!app) return json({ error: "not found" }, 404);
   return patchApplication(db, env, ctx, app, body);
 };
@@ -11256,10 +11633,10 @@ async function updateEmailSettings(db, ctx, env, body) {
     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 };
+    const id7 = { 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 } }
+      { t: "merge", ns: "groups", id: id7, attrs: { emailTemplates: clean } },
+      { t: "update", ns: "groups", id: id7, attrs: { commitmentText, normsText, notificationEmail, replyTo, debugEmail, fromName } }
     ]);
   }
   return json({ ok: true });
@@ -11274,8 +11651,8 @@ async function gate5(req, env, ctx) {
   if (!await ctx.isAdmin(rawDb, u)) return json({ error: "forbidden" }, 403);
   return rawDb;
 }
-async function loadGroup2(db, id6) {
-  const { groups } = await db.query({ groups: { $: { where: { id: id6 }, limit: 1 } } });
+async function loadGroup2(db, id7) {
+  const { groups } = await db.query({ groups: { $: { where: { id: id7 }, limit: 1 } } });
   return groups?.[0] ?? null;
 }
 var str3 = (v, d = "") => typeof v === "string" ? v : d;
@@ -11529,7 +11906,7 @@ var handleAdminNetworkTargets = async (req, url, env, ctx) => {
   if ("response" in got) return got.response;
   return json({
     targets: ctx.chapter.network.targets.map(({
-      id: id6,
+      id: id7,
       name,
       url: targetUrl,
       fields,
@@ -11538,7 +11915,7 @@ var handleAdminNetworkTargets = async (req, url, env, ctx) => {
       stageTransitions,
       commercialParity
     }) => ({
-      id: id6,
+      id: id7,
       name,
       url: targetUrl,
       types: Object.keys(fields ?? DEFAULT_SHARE_FIELDS),
@@ -11700,7 +12077,7 @@ var handleAdminNetworkPush = async (req, url, env, ctx) => {
   if (typeof body.recordId !== "string" || !Array.isArray(body.targetIds) || body.targetIds.length === 0) {
     return json({ error: "recordId and a non-empty targetIds array are required" }, 400);
   }
-  const requested = new Set(body.targetIds.filter((id6) => typeof id6 === "string"));
+  const requested = new Set(body.targetIds.filter((id7) => typeof id7 === "string"));
   if (requested.size !== body.targetIds.length) return json({ error: "targetIds must contain unique strings" }, 400);
   const targets = ctx.chapter.network.targets.filter((target) => requested.has(target.id));
   if (targets.length !== requested.size) return json({ error: "one or more targetIds are not configured" }, 400);
@@ -11833,7 +12210,7 @@ async function operationalReaderRecord(record4, reader, db, env, ctx) {
   const appId = record4.fields.applicationId;
   const app = typeof appId === "string" ? (await db.query({ applications: { $: { where: { id: appId }, limit: 1 } } })).applications?.[0] : void 0;
   if (reader.stageTransitions.includes(record4.type)) {
-    result.edit.allowedStages = app ? applicationActionStages(app, env, ctx).map((id6) => ({ id: id6, label: id6.replaceAll("_", " ") })) : result.edit.allowedStages.filter((stage) => !isApplicationStage(ctx, stage.id));
+    result.edit.allowedStages = app ? applicationActionStages(app, env, ctx).map((id7) => ({ id: id7, label: id7.replaceAll("_", " ") })) : result.edit.allowedStages.filter((stage) => !isApplicationStage(ctx, stage.id));
     const lock = (await db.query({ crm_activity: { $: { where: { id: `network-action-lock:${record4.id}` }, limit: 1 } } })).crm_activity?.[0];
     const meta = lock?.meta;
     if (meta?.state === "pending" && typeof meta.activityId === "string") {
@@ -11938,9 +12315,9 @@ async function listReaderRecords(db, type, allowed2, emailField, window) {
 // src/network-mutation-receipt.ts
 import { CRM_NS as CRM_NS2 } from "@odla-ai/crm";
 var NETWORK_MUTATION_META = "chapterNetworkMutation";
-async function priorMutation(db, id6) {
+async function priorMutation(db, id7) {
   const result = await db.query({
-    [CRM_NS2.activity]: { $: { where: { id: id6 }, limit: 1 } }
+    [CRM_NS2.activity]: { $: { where: { id: id7 }, limit: 1 } }
   });
   const row2 = (result[CRM_NS2.activity] ?? [])[0];
   const meta = row2?.meta;
@@ -12200,8 +12577,8 @@ async function gate7(req, env, ctx) {
   if (!await networkWriteAllowed(req, db, user, ctx)) return { response: json({ error: "super-admin required", code: "super_admin_required" }, 403) };
   return { db, user };
 }
-function targetFor2(ctx, id6) {
-  return ctx.chapter.network.targets.find((target) => target.id === id6);
+function targetFor2(ctx, id7) {
+  return ctx.chapter.network.targets.find((target) => target.id === id7);
 }
 async function readTargetRecords(db, env, ctx, target, query) {
   const secret = await getVaultSecret(db, target.secretName);
@@ -12336,7 +12713,7 @@ var handleAdminNetworkRecords = async (req, url, env, ctx) => {
   if (ctx.chapter.network.requireSuperAdminWrites && !await ctx.isSuperAdminEmail(got.db, got.user.email, got.user.userId)) {
     return json({ ...result.page, records: result.page.records.map(({ edit: _edit, ...record4 }) => ({
       ...record4,
-      fields: Object.fromEntries(Object.entries(record4.fields).filter(([id6]) => id6 === "name" || id6 === "email"))
+      fields: Object.fromEntries(Object.entries(record4.fields).filter(([id7]) => id7 === "name" || id7 === "email"))
     })) });
   }
   return json(result.page);
@@ -12406,9 +12783,9 @@ var handleAdminNetworkNotes = async (req, url, env, ctx) => {
   }
   const body = typeof input.body === "string" ? input.body.trim() : "";
   if (!body || body.length > MAX_NOTE3) return json({ error: `note must be 1\u2013${MAX_NOTE3} characters` }, 400);
-  const id6 = crypto.randomUUID();
+  const id7 = crypto.randomUUID();
   const note = {
-    id: id6,
+    id: id7,
     targetId: identity2.targetId,
     recordType: identity2.recordType,
     recordId: identity2.recordId,
@@ -12420,7 +12797,7 @@ var handleAdminNetworkNotes = async (req, url, env, ctx) => {
   await got.db.transact([{
     t: "update",
     ns: "networkNotes",
-    id: id6,
+    id: id7,
     attrs: { ...note, recordKey: identity2.recordKey }
   }]);
   return json({ note }, 201);
@@ -12524,13 +12901,13 @@ var handleNetworkSharedNotes = async (req, url, env, ctx) => {
     return json({ error: `body must be 1\u2013${MAX_NOTE4} characters and mutationId must be valid` }, 400);
   }
   const createdAt = Date.now();
-  const id6 = `network:${verified.sender}:${mutationId}`;
+  const id7 = `network:${verified.sender}:${mutationId}`;
   const result = await addActivity(
     {
       crm: ctx.chapter.crm,
       db,
       now: () => createdAt,
-      newId: () => id6
+      newId: () => id7
     },
     {
       recordId,
@@ -12545,11 +12922,11 @@ var handleNetworkSharedNotes = async (req, url, env, ctx) => {
           body
         }
       },
-      mutationId: id6
+      mutationId: id7
     }
   );
   const note = {
-    id: id6,
+    id: id7,
     sourceId: verified.sender,
     recordType,
     recordId,
@@ -12558,8 +12935,8 @@ var handleNetworkSharedNotes = async (req, url, env, ctx) => {
   };
   return json({ version: 1, site: { id: ctx.chapter.id, name: ctx.chapter.name }, note, duplicate: result.duplicate }, 201);
 };
-function targetFor3(ctx, id6) {
-  return ctx.chapter.network.targets.find((target) => target.id === id6);
+function targetFor3(ctx, id7) {
+  return ctx.chapter.network.targets.find((target) => target.id === id7);
 }
 var handleAdminNetworkSharedNotes = async (req, url, env, ctx) => {
   if (url.pathname !== "/api/admin/network/shared-notes" || req.method !== "GET" && req.method !== "POST") return null;
@@ -12828,10 +13205,10 @@ async function linkNetworkChapterPerson(db, input, mutationId, actor, now = Date
   if (!state.claims.some((claim) => claim.id === expectedClaim.id && claim.personId === person.id && claim.kind === "email")) {
     throw new NetworkPersonRegistryError("identity_mismatch", "source email is not an exact verified identity on this Person");
   }
-  const id6 = await networkChapterLinkId(person.id, input.chapterId, input.chapterPersonId);
-  const previous = state.links.find((link2) => link2.id === id6);
+  const id7 = await networkChapterLinkId(person.id, input.chapterId, input.chapterPersonId);
+  const previous = state.links.find((link2) => link2.id === id7);
   const link = {
-    id: id6,
+    id: id7,
     personId: person.id,
     chapterId: input.chapterId,
     chapterPersonId: input.chapterPersonId,
@@ -12842,11 +13219,11 @@ async function linkNetworkChapterPerson(db, input, mutationId, actor, now = Date
   const nextPerson = { ...person, revision: person.revision + 1, updatedAt: now };
   await db.transact([
     { t: "update", ns: "networkPersons", id: person.id, attrs: { ...nextPerson } },
-    { t: "update", ns: "networkChapterPersonLinks", id: id6, attrs: { ...link } },
+    { t: "update", ns: "networkChapterPersonLinks", id: id7, attrs: { ...link } },
     networkPersonEventOp("chapter_source_linked", mutationId, actor, now, { chapterId: input.chapterId }, { personId: person.id })
   ], { mutationId, guards: [
     { ns: "networkPersons", id: person.id, exists: true, equals: { revision: person.revision, state: "active" } },
-    { ns: "networkChapterPersonLinks", id: id6, exists: Boolean(previous), ...previous ? { equals: { state: "revoked" } } : {} }
+    { ns: "networkChapterPersonLinks", id: id7, exists: Boolean(previous), ...previous ? { equals: { state: "revoked" } } : {} }
   ] });
   return { person: nextPerson, link };
 }
@@ -12883,9 +13260,9 @@ var defaultPolicy = (now, consent) => ({
 var isGuardConflict = (error) => error instanceof Error && error.code === "transact_guard_failed";
 async function linkOps(personId, links, now) {
   return Promise.all(links.map(async (link) => {
-    const id6 = await networkChapterLinkId(personId, link.chapterId, link.chapterPersonId);
+    const id7 = await networkChapterLinkId(personId, link.chapterId, link.chapterPersonId);
     const sourceKey = await networkChapterPersonSourceKey(link.chapterId, link.chapterPersonId);
-    return { t: "update", ns: "networkChapterPersonLinks", id: id6, attrs: { id: id6, personId, chapterId: link.chapterId, chapterPersonId: link.chapterPersonId, sourceKey, state: "shadow", createdAt: now } };
+    return { t: "update", ns: "networkChapterPersonLinks", id: id7, attrs: { id: id7, personId, chapterId: link.chapterId, chapterPersonId: link.chapterPersonId, sourceKey, state: "shadow", createdAt: now } };
   }));
 }
 async function ambiguousAlias(db, input, aliasId, claims, candidates, mutationId, actor, now) {
@@ -13104,10 +13481,10 @@ async function networkPersonBulkBatchDigest(rows5) {
 }
 async function networkPersonRegistryStateDigest(state) {
   const snapshot = {
-    persons: state.persons.map(({ id: id6, revision, state: personState, mergedIntoId }) => ({ id: id6, revision, state: personState, mergedIntoId })).sort((a, b) => a.id.localeCompare(b.id)),
-    claims: state.claims.map(({ id: id6, personId }) => ({ id: id6, personId })).sort((a, b) => a.id.localeCompare(b.id)),
-    aliases: state.aliases.map(({ id: id6, revision, status: status2, personId }) => ({ id: id6, revision, status: status2, personId })).sort((a, b) => a.id.localeCompare(b.id)),
-    links: state.links.map(({ id: id6, personId, state: linkState }) => ({ id: id6, personId, state: linkState })).sort((a, b) => a.id.localeCompare(b.id))
+    persons: state.persons.map(({ id: id7, revision, state: personState, mergedIntoId }) => ({ id: id7, revision, state: personState, mergedIntoId })).sort((a, b) => a.id.localeCompare(b.id)),
+    claims: state.claims.map(({ id: id7, personId }) => ({ id: id7, personId })).sort((a, b) => a.id.localeCompare(b.id)),
+    aliases: state.aliases.map(({ id: id7, revision, status: status2, personId }) => ({ id: id7, revision, status: status2, personId })).sort((a, b) => a.id.localeCompare(b.id)),
+    links: state.links.map(({ id: id7, personId, state: linkState }) => ({ id: id7, personId, state: linkState })).sort((a, b) => a.id.localeCompare(b.id))
   };
   return networkPersonBulkSha256(JSON.stringify(stableValue(snapshot)));
 }
@@ -13332,7 +13709,7 @@ var safeNetworkPersonAlias = async (alias) => ({
     recordedAt: alias.consent.recordedAt,
     hasBasis: Boolean(alias.consent.basis)
   },
-  identityClaims: alias.identityClaims.map(({ id: id6, kind, hint, verifiedAt }) => ({ id: id6, kind, hint: hint ?? null, verifiedAt })),
+  identityClaims: alias.identityClaims.map(({ id: id7, kind, hint, verifiedAt }) => ({ id: id7, kind, hint: hint ?? null, verifiedAt })),
   chapterIds: [...new Set(alias.chapterLinks.map((link) => link.chapterId))],
   chapterSources: await Promise.all(alias.chapterLinks.map(async (link) => ({
     chapterId: link.chapterId,
@@ -13361,7 +13738,7 @@ async function projectNetworkPersonRegistryState(state) {
     return {
       ...safeNetworkPerson(person, claims),
       canonicalPersonId: canonicalId,
-      identityClaims: claims.map(({ id: id6, kind, hint, verifiedAt }) => ({ id: id6, kind, hint: hint ?? null, verifiedAt })),
+      identityClaims: claims.map(({ id: id7, kind, hint, verifiedAt }) => ({ id: id7, kind, hint: hint ?? null, verifiedAt })),
       chapterLinks: safeLinks,
       chapterProjections: projectNetworkContactPolicy(canonical3.contactPolicy, safeLinks).map(({ contactPolicy, ...projection }) => ({ ...projection, contactPolicy: safeNetworkContactPolicy(contactPolicy) }))
     };
@@ -14154,14 +14531,14 @@ var handleFormation = async (req, url, env, ctx) => {
     }
   }
   const db = ctx.makeDb(env);
-  const id6 = submissionId ? await applicationIdForSubmission(`formation:${ctx.chapter.id}:${submissionId}`) : crypto.randomUUID();
+  const id7 = submissionId ? await applicationIdForSubmission(`formation:${ctx.chapter.id}:${submissionId}`) : crypto.randomUUID();
   try {
     const created = await createRecord3(
       {
         crm: ctx.chapter.crm,
         db,
         now: () => Date.now(),
-        newId: () => id6
+        newId: () => id7
       },
       {
         type: formation.type,
@@ -14170,7 +14547,7 @@ var handleFormation = async (req, url, env, ctx) => {
       }
     );
     return json({
-      id: id6,
+      id: id7,
       duplicate: created.duplicate,
       status: created.record.stage ?? null
     }, created.duplicate ? 200 : 201);
@@ -14247,8 +14624,8 @@ function resourceValue(value, path, errors) {
     return null;
   }
   unknownKeys3(raw2, RESOURCE_KEYS, path, errors);
-  const id6 = text7(raw2.id, `${path}.id`, errors, 80) ?? "";
-  if (id6 && !ID5.test(id6)) errors.push(`${path}.id must be lowercase kebab-case`);
+  const id7 = text7(raw2.id, `${path}.id`, errors, 80) ?? "";
+  if (id7 && !ID5.test(id7)) errors.push(`${path}.id must be lowercase kebab-case`);
   const kind = text7(raw2.kind, `${path}.kind`, errors) ?? "";
   if (!KINDS.has(kind)) errors.push(`${path}.kind is unsupported`);
   const title = text7(raw2.title, `${path}.title`, errors, 240) ?? "";
@@ -14305,7 +14682,7 @@ function resourceValue(value, path, errors) {
     updatedAt: integer4(provenanceRaw?.updatedAt, `${path}.provenance.updatedAt`, errors, 0),
     ...promotedFrom ? { promotedFrom } : {}
   };
-  return { id: id6, kind, title, ...summary ? { summary } : {}, tags, scope: scope2, status: status2, revision, ...bodyMarkdown ? { bodyMarkdown } : {}, ...url ? { url } : {}, ...brandAsset ? { brandAsset } : {}, provenance: provenance2 };
+  return { id: id7, kind, title, ...summary ? { summary } : {}, tags, scope: scope2, status: status2, revision, ...bodyMarkdown ? { bodyMarkdown } : {}, ...url ? { url } : {}, ...brandAsset ? { brandAsset } : {}, provenance: provenance2 };
 }
 function validateBuilderLibraryDocument(value, options = {}) {
   const errors = [];
@@ -14336,7 +14713,7 @@ function validateBuilderLibraryDocument(value, options = {}) {
   const inputs = Array.isArray(raw2.resources) ? raw2.resources : [];
   if (inputs.length > MAX_RESOURCES) errors.push(`document.resources may contain at most ${MAX_RESOURCES} items`);
   const resources = inputs.map((item, index2) => resourceValue(item, `document.resources[${index2}]`, errors)).filter(Boolean);
-  const ids2 = resources.map(({ id: id6 }) => id6);
+  const ids2 = resources.map(({ id: id7 }) => id7);
   if (new Set(ids2).size !== ids2.length) errors.push("document.resources ids must be unique");
   for (const resource of resources) {
     if (sourceType === "chapter" && (resource.scope.kind !== "chapter" || resource.scope.chapterId !== sourceAppId)) {
@@ -14425,18 +14802,18 @@ async function loadLatestBuilderLibraryControl(db, sourceId, targetId, environme
   return control2(Array.isArray(rows5) ? [...rows5].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
 }
 async function loadLocalBuilderLibrary(db, appId, environment) {
-  const id6 = `builder-library-local:${environment}`;
-  const rows5 = (await db.query({ builderLibraryLocal: { $: { where: { id: id6 }, limit: 1 } } })).builderLibraryLocal;
+  const id7 = `builder-library-local:${environment}`;
+  const rows5 = (await db.query({ builderLibraryLocal: { $: { where: { id: id7 }, limit: 1 } } })).builderLibraryLocal;
   return local3(Array.isArray(rows5) ? rows5[0] : void 0);
 }
 async function materializeBuilderLibraryControl(db, envelope, previous, receivedAt) {
   const { document, digest } = envelope;
   const target = document.target;
-  const id6 = `builder-library-control:${document.source.appId}:${target.environment}:${document.revision}`;
+  const id7 = `builder-library-control:${document.source.appId}:${target.environment}:${document.revision}`;
   const ops = [];
   if (previous?.active) ops.push({ t: "update", ns: "builderLibraryControls", id: previous.id, attrs: { active: false } });
-  ops.push({ t: "update", ns: "builderLibraryControls", id: id6, attrs: {
-    id: id6,
+  ops.push({ t: "update", ns: "builderLibraryControls", id: id7, attrs: {
+    id: id7,
     sourceId: document.source.appId,
     targetId: target.appId,
     environment: target.environment,
@@ -14449,13 +14826,13 @@ async function materializeBuilderLibraryControl(db, envelope, previous, received
   await db.transact(ops, { mutationId: `builder-library-control:${document.source.appId}:${target.environment}:${document.revision}:${digest}` });
 }
 async function saveLocalBuilderLibrary(db, document, environment, expectedRevision, updatedAt, updatedBy) {
-  const id6 = `builder-library-local:${environment}`;
+  const id7 = `builder-library-local:${environment}`;
   const current = await loadLocalBuilderLibrary(db, document.source.appId, environment);
   if ((current?.revision ?? 0) !== expectedRevision) throw new Error("builder_library_revision_conflict");
-  const row2 = { id: id6, appId: document.source.appId, environment, revision: document.revision, document, updatedAt, ...updatedBy ? { updatedBy } : {} };
-  await db.transact([{ t: "update", ns: "builderLibraryLocal", id: id6, attrs: row2 }], {
+  const row2 = { id: id7, appId: document.source.appId, environment, revision: document.revision, document, updatedAt, ...updatedBy ? { updatedBy } : {} };
+  await db.transact([{ t: "update", ns: "builderLibraryLocal", id: id7, attrs: row2 }], {
     mutationId: `builder-library-local:${environment}:${document.revision}`,
-    guards: current ? [{ ns: "builderLibraryLocal", id: id6, exists: true, equals: { revision: expectedRevision } }] : [{ ns: "builderLibraryLocal", id: id6, exists: false }]
+    guards: current ? [{ ns: "builderLibraryLocal", id: id7, exists: true, equals: { revision: expectedRevision } }] : [{ ns: "builderLibraryLocal", id: id7, exists: false }]
   });
   return row2;
 }
@@ -14670,30 +15047,30 @@ var handleAdminBuilderLibrary = async (req, url, env, ctx) => {
 };
 
 // src/membership-cancel-authority.ts
-import { stripeRequest as stripeRequest10 } from "@odla-ai/stripe";
+import { stripeRequest as stripeRequest11 } from "@odla-ai/stripe";
 async function cancelMembershipAtTermEnd(db, target, now, stripeSecret) {
   membershipClock(now);
-  const id6 = await networkMembershipId(target);
+  const id7 = await networkMembershipId(target);
   const state = await loadMembershipAuthorityState(db, target);
-  const member = await membershipLoad(db, "networkMembership", id6);
+  const member = await membershipLoad(db, "networkMembership", id7);
   requireMembershipScope(member, target);
   if (!["active", "cancel_at_term_end", "payment_grace", "paid_pending_approval", "lapsed"].includes(String(member.status))) {
     membershipFail("membership_cancellation_unavailable");
   }
   const path = `/v1/subscriptions/${encodeURIComponent(String(member.providerSubscriptionId))}`;
-  const read2 = await stripeRequest10({ secretKey: stripeSecret }, "GET", path);
+  const read2 = await stripeRequest11({ secretKey: stripeSecret }, "GET", path);
   const sub = read2.body;
   if (!read2.ok || sub.id !== member.providerSubscriptionId || sub.customer !== member.providerCustomerId || sub.livemode !== (target.environment === "prod") || !Object.entries({
     ...stripePartitionMetadata(target),
     applicationId: target.applicationId
   }).every(([key3, value]) => sub.metadata?.[key3] === value)) membershipFail("membership_cancellation_provider_mismatch");
   if (sub.status !== "canceled" && sub.cancel_at_period_end !== true) {
-    const write = await stripeRequest10(
+    const write = await stripeRequest11(
       { secretKey: stripeSecret },
       "POST",
       path,
       { cancel_at_period_end: true, proration_behavior: "none" },
-      { idempotencyKey: `membership-cancel-at-term:${id6}:${member.providerSubscriptionId}` }
+      { idempotencyKey: `membership-cancel-at-term:${id7}:${member.providerSubscriptionId}` }
     );
     if (!write.ok || write.body.id !== member.providerSubscriptionId || write.body.cancel_at_period_end !== true) {
       membershipFail("membership_cancellation_pending");
@@ -14701,7 +15078,7 @@ async function cancelMembershipAtTermEnd(db, target, now, stripeSecret) {
   }
   const status2 = Number(member.termEndsAt) <= now ? "lapsed" : member.journeyApprovedAt ? "cancel_at_term_end" : "paid_pending_approval";
   if (member.status !== status2 || member.autoRenew !== false || Number(member.graceEndsAt ?? 0) !== 0) {
-    await db.transact([membershipUpdate("networkMembership", id6, {
+    await db.transact([membershipUpdate("networkMembership", id7, {
       status: status2,
       autoRenew: false,
       graceEndsAt: 0,
@@ -14710,12 +15087,12 @@ async function cancelMembershipAtTermEnd(db, target, now, stripeSecret) {
       updatedAt: now
     })], {
       guards: [
-        { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision } },
+        { ns: "networkMembership", id: id7, exists: true, equals: { revision: member.revision } },
         { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { revision: state.revision, mode: "authoritative" } }
       ]
     });
   }
-  return { membershipId: id6, status: status2, termEndsAt: Number(member.termEndsAt), graceEndsAt: 0, autoRenew: false };
+  return { membershipId: id7, status: status2, termEndsAt: Number(member.termEndsAt), graceEndsAt: 0, autoRenew: false };
 }
 
 // src/membership-authority-handler.ts
@@ -14754,17 +15131,17 @@ async function namedSeatPrimaryActivation(db, member, now) {
 // src/membership-approval-authority.ts
 async function approveNetworkMembership(db, input, now) {
   membershipClock(now);
-  const id6 = await networkMembershipId(input), entitlementId = `${id6}:primary`;
+  const id7 = await networkMembershipId(input), entitlementId = `${id7}:primary`;
   for (let attempt = 0; attempt < 8; attempt++) {
     const state = await loadMembershipAuthorityState(db, input);
-    const member = await membershipLoad(db, "networkMembership", id6);
+    const member = await membershipLoad(db, "networkMembership", id7);
     requireMembershipScope(member, input);
     const entitlement = await membershipLoad(db, "networkEntitlement", entitlementId);
     requireMembershipScope(entitlement, input);
-    if (entitlement.membershipId !== id6 || entitlement.kind !== "primary") membershipFail("membership_entitlement_conflict");
+    if (entitlement.membershipId !== id7 || entitlement.kind !== "primary") membershipFail("membership_entitlement_conflict");
     if (["active", "cancel_at_term_end"].includes(String(member.status)) && entitlement.status === "active" && Number(member.refundedCents) === 0 && Number.isSafeInteger(member.memberNumber) && Number(member.memberNumber) > 0 && Number(member.termEndsAt) > now) {
       return {
-        membershipId: id6,
+        membershipId: id7,
         status: String(member.status),
         cohort: String(member.cohort),
         memberNumber: Number(member.memberNumber),
@@ -14784,7 +15161,7 @@ async function approveNetworkMembership(db, input, now) {
     const seatActivation = await namedSeatPrimaryActivation(db, member, now);
     try {
       await db.transact([
-        membershipUpdate("networkMembership", id6, {
+        membershipUpdate("networkMembership", id7, {
           status: member.autoRenew ? "active" : "cancel_at_term_end",
           memberNumber,
           journeyApprovedAt: now,
@@ -14799,8 +15176,8 @@ async function approveNetworkMembership(db, input, now) {
           updatedAt: now
         }),
         ...seatActivation.ops
-      ], { mutationId: `membership-approve:${id6}`, guards: [
-        { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision, status: "paid_pending_approval" }, absent: ["memberNumber"] },
+      ], { mutationId: `membership-approve:${id7}`, guards: [
+        { ns: "networkMembership", id: id7, exists: true, equals: { revision: member.revision, status: "paid_pending_approval" }, absent: ["memberNumber"] },
         { ns: "networkEntitlement", id: entitlementId, exists: true, equals: { revision: entitlement.revision, status: "pending_approval" } },
         { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { revision: state.revision, mode: "authoritative" } },
         ...seatActivation.guards
@@ -14815,41 +15192,41 @@ async function approveNetworkMembership(db, input, now) {
 // src/membership-refund-authority.ts
 async function refundNetworkMembership(db, input, secretKey, now) {
   membershipClock(now);
-  const id6 = await networkMembershipId(input), entitlementId = `${id6}:primary`;
-  let state = await loadMembershipAuthorityState(db, input), member = await membershipLoad(db, "networkMembership", id6);
+  const id7 = await networkMembershipId(input), entitlementId = `${id7}:primary`;
+  let state = await loadMembershipAuthorityState(db, input), member = await membershipLoad(db, "networkMembership", id7);
   requireMembershipScope(member, input);
-  if (member.status === "refunded") return { membershipId: id6, status: "refunded", refundedCents: Number(member.refundedCents), subscriptionCanceled: true };
+  if (member.status === "refunded") return { membershipId: id7, status: "refunded", refundedCents: Number(member.refundedCents), subscriptionCanceled: true };
   if (!["paid_pending_approval", "active", "cancel_at_term_end", "payment_grace", "lapsed", "refund_pending"].includes(String(member.status))) membershipFail("membership_refund_not_eligible");
   if (member.status !== "refund_pending") {
     const entitlement = await membershipLoad(db, "networkEntitlement", entitlementId);
     requireMembershipScope(entitlement, input);
     await db.transact([
-      membershipUpdate("networkMembership", id6, {
+      membershipUpdate("networkMembership", id7, {
         status: "refund_pending",
         refundRequestedAt: now,
         revision: Number(member.revision) + 1,
         updatedAt: now
       }),
       membershipUpdate("networkEntitlement", entitlementId, { status: "closed", revision: Number(entitlement.revision) + 1, updatedAt: now }),
-      membershipUpdate("membershipEffect", `${id6}:refund`, {
-        id: `${id6}:refund`,
+      membershipUpdate("membershipEffect", `${id7}:refund`, {
+        id: `${id7}:refund`,
         chapterId: input.chapterId,
         environment: input.environment,
         runtime: input.runtime,
-        membershipId: id6,
+        membershipId: id7,
         kind: "refund_membership",
         status: "pending",
         attempts: 0,
         createdAt: now,
         updatedAt: now
       })
-    ], { mutationId: `membership-refund-request:${id6}`, guards: [
-      { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision } },
+    ], { mutationId: `membership-refund-request:${id7}`, guards: [
+      { ns: "networkMembership", id: id7, exists: true, equals: { revision: member.revision } },
       { ns: "networkEntitlement", id: entitlementId, exists: true, equals: { revision: entitlement.revision } },
       { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { revision: state.revision, mode: "authoritative" } }
     ] });
   }
-  member = await membershipLoad(db, "networkMembership", id6);
+  member = await membershipLoad(db, "networkMembership", id7);
   requireMembershipScope(member, input);
   if (member.status !== "refund_pending") membershipFail("membership_refund_retry_required");
   const result = await refundSubscriptionPayment(secretKey, {
@@ -14863,23 +15240,23 @@ async function refundNetworkMembership(db, input, secretKey, now) {
   if (!result.subscriptionCanceled || result.refundedCents !== member.amountCents) membershipFail("membership_refund_unconfirmed");
   for (let attempt = 0; attempt < 8; attempt++) {
     state = await loadMembershipAuthorityState(db, input);
-    member = await membershipLoad(db, "networkMembership", id6);
+    member = await membershipLoad(db, "networkMembership", id7);
     requireMembershipScope(member, input);
-    if (member.status === "refunded") return { membershipId: id6, status: "refunded", refundedCents: Number(member.refundedCents), subscriptionCanceled: true };
+    if (member.status === "refunded") return { membershipId: id7, status: "refunded", refundedCents: Number(member.refundedCents), subscriptionCanceled: true };
     if (member.status !== "refund_pending") membershipFail("membership_refund_retry_required");
     const counted = member.founding === true && member.memberNumber !== void 0;
     const counts = state.cohortCounts;
     if (!counts || counted && (!Number.isSafeInteger(counts[String(member.cohort)]) || counts[String(member.cohort)] < 1)) membershipFail("invalid_cohort_count");
     try {
       await db.transact([
-        membershipUpdate("networkMembership", id6, {
+        membershipUpdate("networkMembership", id7, {
           status: "refunded",
           refundedCents: result.refundedCents,
           autoRenew: false,
           revision: Number(member.revision) + 1,
           updatedAt: now
         }),
-        membershipUpdate("membershipEffect", `${id6}:refund`, { status: "complete", updatedAt: now }),
+        membershipUpdate("membershipEffect", `${id7}:refund`, { status: "complete", updatedAt: now }),
         ...counted ? [membershipUpdate("membershipAuthorityState", String(state.id), {
           cohortCounts: { ...counts, [String(member.cohort)]: counts[String(member.cohort)] - 1 },
           revision: Number(state.revision) + 1,
@@ -14890,7 +15267,7 @@ async function refundNetworkMembership(db, input, secretKey, now) {
           chapterId: input.chapterId,
           environment: input.environment,
           runtime: input.runtime,
-          membershipId: id6,
+          membershipId: id7,
           seatId: member.namedSeatId,
           kind: "refund_seat_with_primary",
           status: "pending",
@@ -14898,8 +15275,8 @@ async function refundNetworkMembership(db, input, secretKey, now) {
           createdAt: now,
           updatedAt: now
         })] : []
-      ], { mutationId: `membership-refunded:${id6}`, guards: [
-        { ns: "networkMembership", id: id6, exists: true, equals: { status: "refund_pending", revision: member.revision } },
+      ], { mutationId: `membership-refunded:${id7}`, guards: [
+        { ns: "networkMembership", id: id7, exists: true, equals: { status: "refund_pending", revision: member.revision } },
         { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative", revision: state.revision } }
       ] });
     } catch (error) {
@@ -14910,12 +15287,12 @@ async function refundNetworkMembership(db, input, secretKey, now) {
 }
 
 // src/membership-provider-lifecycle.ts
-import { stripeRequest as stripeRequest11 } from "@odla-ai/stripe";
+import { stripeRequest as stripeRequest12 } from "@odla-ai/stripe";
 
 // src/membership-renewal-authority.ts
 async function reconcileMembershipRenewal(db, input, now) {
   membershipClock(now);
-  const id6 = await networkMembershipId(input), eventRow = await membershipLoad(db, "networkCommercialEvents", `network-commercial-event:${input.eventId}`);
+  const id7 = await networkMembershipId(input), eventRow = await membershipLoad(db, "networkCommercialEvents", `network-commercial-event:${input.eventId}`);
   const evidenceGuard = await commercialEvidenceGuard(db, input.eventId, eventRow?.digest, "membership_renewal_evidence_pending");
   const fact = eventRow?.fact;
   if (!fact || !/^evt_[A-Za-z0-9_]+$/.test(input.eventId) || !/^[a-f0-9]{64}$/.test(String(eventRow.digest)) || fact.digest !== eventRow.digest || fact.eventId !== input.eventId || fact.objectKind !== "invoice" || !["invoice.payment_succeeded", "invoice.payment_failed"].includes(fact.eventType) || fact.billingReason !== "subscription_cycle" || fact.livemode !== (input.environment === "prod") || fact.applicationId !== input.applicationId || Object.entries({
@@ -14928,10 +15305,10 @@ async function reconcileMembershipRenewal(db, input, now) {
     return membershipFail("membership_renewal_evidence_pending");
   }
   for (let attempt = 0; attempt < 8; attempt++) {
-    const state = await loadMembershipAuthorityState(db, input), member = await membershipLoad(db, "networkMembership", id6);
+    const state = await loadMembershipAuthorityState(db, input), member = await membershipLoad(db, "networkMembership", id7);
     requireMembershipScope(member, input);
     const receipt = () => ({
-      membershipId: id6,
+      membershipId: id7,
       status: String(member.status),
       termEndsAt: Number(member.termEndsAt),
       graceEndsAt: Number(member.graceEndsAt ?? 0),
@@ -14956,13 +15333,13 @@ async function reconcileMembershipRenewal(db, input, now) {
     const paid = fact.eventType === "invoice.payment_succeeded";
     if (!paid && (fact.status !== "open" || !Number.isSafeInteger(fact.amountPaidCents) || Number(fact.amountPaidCents) < 0 || Number(fact.amountPaidCents) >= amount)) membershipFail("membership_renewal_failure_mismatch");
     if (paid && (fact.status !== "paid" || fact.amountPaidCents !== amount || !Number.isSafeInteger(fact.invoicePaidAt) || Number(fact.invoicePaidAt) < start || Number(fact.invoicePaidAt) > now + 3e4)) membershipFail("membership_renewal_unpaid");
-    const entitlement = await membershipLoad(db, "networkEntitlement", `${id6}:primary`);
+    const entitlement = await membershipLoad(db, "networkEntitlement", `${id7}:primary`);
     requireMembershipScope(entitlement, input);
     const graceEndsAt = paid ? 0 : start + 14 * 864e5;
     const status2 = paid ? member.journeyApprovedAt ? member.autoRenew ? "active" : "cancel_at_term_end" : "paid_pending_approval" : now < graceEndsAt ? "payment_grace" : "lapsed";
     const entitlementStatus = member.journeyApprovedAt && (paid || now < graceEndsAt) ? "active" : member.journeyApprovedAt ? "closed" : "pending_approval";
     const ops = [
-      membershipUpdate("networkMembership", id6, {
+      membershipUpdate("networkMembership", id7, {
         status: status2,
         graceEndsAt,
         ...paid ? {
@@ -14973,7 +15350,7 @@ async function reconcileMembershipRenewal(db, input, now) {
         revision: Number(member.revision) + 1,
         updatedAt: now
       }),
-      membershipUpdate("networkEntitlement", `${id6}:primary`, {
+      membershipUpdate("networkEntitlement", `${id7}:primary`, {
         status: entitlementStatus,
         ...paid ? { termStartedAt: start, termEndsAt: end } : {},
         sourceEventId: input.eventId,
@@ -14982,8 +15359,8 @@ async function reconcileMembershipRenewal(db, input, now) {
       })
     ];
     const guards = [
-      { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision } },
-      { ns: "networkEntitlement", id: `${id6}:primary`, exists: true, equals: { revision: entitlement.revision } },
+      { ns: "networkMembership", id: id7, exists: true, equals: { revision: member.revision } },
+      { ns: "networkEntitlement", id: `${id7}:primary`, exists: true, equals: { revision: entitlement.revision } },
       { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { revision: state.revision, mode: "authoritative" } },
       { ns: "networkCommercialEvents", id: String(eventRow.id), exists: true, equals: { digest: eventRow.digest } },
       evidenceGuard
@@ -15008,15 +15385,15 @@ async function reconcileMembershipRenewal(db, input, now) {
       );
     }
     try {
-      await db.transact(ops, { mutationId: `membership-renewal:${id6}:${input.eventId}`, guards });
+      await db.transact(ops, { mutationId: `membership-renewal:${id7}:${input.eventId}`, guards });
     } catch (error) {
       if (error.code !== "transact_guard_failed") throw error;
       continue;
     }
-    const saved = await membershipLoad(db, "networkMembership", id6);
+    const saved = await membershipLoad(db, "networkMembership", id7);
     requireMembershipScope(saved, input);
     return {
-      membershipId: id6,
+      membershipId: id7,
       status: String(saved.status),
       termEndsAt: Number(saved.termEndsAt),
       graceEndsAt: Number(saved.graceEndsAt ?? 0),
@@ -15042,12 +15419,12 @@ async function reconcileMembershipBilling(db, input, now, stripeSecretName = "st
   }).some(([key3, value]) => fact.identity[key3] !== value)) membershipFail("membership_billing_evidence_pending");
   const sk = await getVaultSecret(db, stripeSecretName);
   if (!sk) membershipFail("membership_billing_provider_unavailable");
-  const id6 = await networkMembershipId(input);
+  const id7 = await networkMembershipId(input);
   for (let attempt = 0; attempt < 8; attempt++) {
-    const state = await loadMembershipAuthorityState(db, input), member = await membershipLoad(db, "networkMembership", id6);
+    const state = await loadMembershipAuthorityState(db, input), member = await membershipLoad(db, "networkMembership", id7);
     requireMembershipScope(member, input);
     const receipt = (value = member) => ({
-      membershipId: id6,
+      membershipId: id7,
       status: String(value.status),
       termEndsAt: Number(value.termEndsAt),
       graceEndsAt: Number(value.graceEndsAt ?? 0),
@@ -15068,13 +15445,13 @@ async function reconcileMembershipBilling(db, input, now, stripeSecretName = "st
       });
       await commercialEvidenceGuard(db, input.eventId, row2?.digest, "membership_billing_evidence_pending");
       await refundNetworkMembership(db, input, sk, now);
-      const saved2 = await membershipLoad(db, "networkMembership", id6);
+      const saved2 = await membershipLoad(db, "networkMembership", id7);
       requireMembershipScope(saved2, input);
       return receipt(saved2);
     }
     if (fact.subscriptionId !== member.providerSubscriptionId || fact.objectKind !== "subscription") membershipFail("membership_billing_scope_mismatch");
     if (["refund_pending", "refunded", "declined", "canceled", "restarting"].includes(String(member.status))) return receipt();
-    const result = await stripeRequest11({ secretKey: sk }, "GET", `/v1/subscriptions/${encodeURIComponent(String(member.providerSubscriptionId))}`);
+    const result = await stripeRequest12({ secretKey: sk }, "GET", `/v1/subscriptions/${encodeURIComponent(String(member.providerSubscriptionId))}`);
     const sub = result.body;
     if (!result.ok || sub.id !== member.providerSubscriptionId || sub.customer !== member.providerCustomerId || sub.livemode !== (input.environment === "prod") || typeof sub.cancel_at_period_end !== "boolean" || !["active", "trialing", "past_due", "unpaid", "canceled"].includes(sub.status) || !Object.entries({ ...stripePartitionMetadata(input), applicationId: input.applicationId }).every(([key3, value]) => sub.metadata?.[key3] === value)) {
       membershipFail("membership_billing_provider_mismatch");
@@ -15083,18 +15460,18 @@ async function reconcileMembershipBilling(db, input, now, stripeSecretName = "st
     const status2 = autoRenew ? member.status === "cancel_at_term_end" ? "active" : String(member.status) : now >= Number(member.termEndsAt) ? "lapsed" : member.journeyApprovedAt ? "cancel_at_term_end" : "paid_pending_approval";
     const graceEndsAt = autoRenew ? Number(member.graceEndsAt ?? 0) : 0;
     if (member.autoRenew === autoRenew && member.status === status2 && Number(member.graceEndsAt ?? 0) === graceEndsAt) return receipt();
-    const entitlement = await membershipLoad(db, "networkEntitlement", `${id6}:primary`);
+    const entitlement = await membershipLoad(db, "networkEntitlement", `${id7}:primary`);
     requireMembershipScope(entitlement, input);
     try {
       await db.transact([
-        membershipUpdate("networkMembership", id6, { status: status2, autoRenew, graceEndsAt, revision: Number(member.revision) + 1, updatedAt: now }),
+        membershipUpdate("networkMembership", id7, { status: status2, autoRenew, graceEndsAt, revision: Number(member.revision) + 1, updatedAt: now }),
         membershipUpdate("networkEntitlement", String(entitlement.id), {
           status: status2 === "lapsed" ? "closed" : entitlement.status,
           revision: Number(entitlement.revision) + 1,
           updatedAt: now
         })
       ], { guards: [
-        { ns: "networkMembership", id: id6, exists: true, equals: { revision: member.revision } },
+        { ns: "networkMembership", id: id7, exists: true, equals: { revision: member.revision } },
         { ns: "networkEntitlement", id: String(entitlement.id), exists: true, equals: { revision: entitlement.revision } },
         { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative", revision: state.revision } },
         { ns: "networkCommercialEvents", id: String(row2.id), exists: true, equals: { digest: fact.digest } },
@@ -15104,7 +15481,7 @@ async function reconcileMembershipBilling(db, input, now, stripeSecretName = "st
       if (error.code !== "transact_guard_failed") throw error;
       continue;
     }
-    const saved = await membershipLoad(db, "networkMembership", id6);
+    const saved = await membershipLoad(db, "networkMembership", id7);
     requireMembershipScope(saved, input);
     return receipt(saved);
   }
@@ -15112,7 +15489,7 @@ async function reconcileMembershipBilling(db, input, now, stripeSecretName = "st
 }
 
 // src/membership-seat-stripe.ts
-import { stripeRequest as stripeRequest12 } from "@odla-ai/stripe";
+import { stripeRequest as stripeRequest13 } from "@odla-ai/stripe";
 var reject7 = () => {
   throw Object.assign(new Error("named seat provider contract mismatch"), { code: "named_seat_provider_mismatch" });
 };
@@ -15124,7 +15501,7 @@ var metadataFor = (seat) => ({
 });
 var matches = (value, expected) => value && Object.entries(expected).every(([key3, item]) => value[key3] === item);
 async function read(sk, path, params) {
-  const response = await stripeRequest12({ secretKey: sk }, "GET", path, params);
+  const response = await stripeRequest13({ secretKey: sk }, "GET", path, params);
   if (!response.ok) return reject7();
   return response.body;
 }
@@ -15135,7 +15512,7 @@ async function subscriptionForSeat(sk, seat) {
     currency: seat.currency,
     interval: seat.interval,
     environment: seat.environment
-  }, Boolean(seat.providerPaymentIntentId));
+  }, Boolean(seat.providerPaymentIntentId || seat.combinedInvoice));
   if (!productId) reject7();
   const sub = await read(sk, `/v1/subscriptions/${encodeURIComponent(seat.providerSubscriptionId)}?expand[]=discounts`);
   const items = sub.items?.data;
@@ -15161,11 +15538,11 @@ async function createNamedSeatStripePayment(sk, seat, now) {
   }
   await subscriptionForSeat(sk, seat);
   const metadata = metadataFor(seat);
-  const result = seat.providerPaymentIntentId ? await stripeRequest12(
+  const result = seat.providerPaymentIntentId ? await stripeRequest13(
     { secretKey: sk },
     "GET",
     `/v1/payment_intents/${encodeURIComponent(seat.providerPaymentIntentId)}`
-  ) : await stripeRequest12({ secretKey: sk }, "POST", "/v1/payment_intents", {
+  ) : await stripeRequest13({ secretKey: sk }, "POST", "/v1/payment_intents", {
     amount: seat.amountCents,
     currency: seat.currency,
     customer: seat.providerCustomerId,
@@ -15179,11 +15556,15 @@ async function createNamedSeatStripePayment(sk, seat, now) {
   return { paymentIntentId: pi.id, clientSecret: pi.client_secret, status: pi.status };
 }
 async function attachNamedSeatStripeRenewal(sk, seat) {
-  if (!seat.providerPaymentIntentId || !["renewal_pending", "pending_acceptance", "pending_approval", "active"].includes(seat.status)) reject7();
+  if (!seat.providerPaymentIntentId && !seat.combinedInvoice || !["renewal_pending", "pending_acceptance", "pending_approval", "active"].includes(seat.status)) reject7();
   const sub = await subscriptionForSeat(sk, seat);
   const existing = sub.items.data.find((item2) => item2.metadata?.seatId === seat.id);
-  if (existing) return String(existing.id);
-  const result = await stripeRequest12({ secretKey: sk }, "POST", "/v1/subscription_items", {
+  if (existing) {
+    if (!/^si_[A-Za-z0-9_]+$/.test(existing.id)) reject7();
+    return String(existing.id);
+  }
+  if (seat.combinedInvoice) reject7();
+  const result = await stripeRequest13({ secretKey: sk }, "POST", "/v1/subscription_items", {
     subscription: seat.providerSubscriptionId,
     price: seat.priceId,
     quantity: 1,
@@ -15400,7 +15781,7 @@ async function recordRecipient(db, input, now, approve) {
     const state = await loadMembershipAuthorityState(db, input);
     const seat = await membershipLoad(db, "networkSeat", input.seatId);
     requireMembershipScope(seat, input);
-    if (!seat.purchaserUserId || seat.purchaserUserId === input.recipientUserId) membershipFail("named_seat_recipient_must_differ_from_purchaser");
+    if (!seat.purchaserUserId && !seat.purchaserEmailNormalized || seat.purchaserUserId === input.recipientUserId || seat.purchaserEmailNormalized === normalizeChapterEmail(input.verifiedRecipientEmail)) membershipFail("named_seat_recipient_must_differ_from_purchaser");
     const member = await membershipLoad(db, "networkMembership", String(seat.primaryMembershipId));
     requireMembershipScope(member, input);
     const entitlement = await membershipLoad(db, "networkEntitlement", String(seat.entitlementId));
@@ -15720,9 +16101,14 @@ function createMembershipAuthorityHandler(options) {
       try {
         input = JSON.parse(verified.body);
         const fields = action === "seat-invitation" ? MEMBERSHIP_SEAT_ACTION_FIELDS[action] : action === "offer-preview" ? ["skuId"] : ["applicationId", "skuId", ...action === "offers" ? ["requestId"] : action === "checkouts" ? ["offerId", "offerDigest", "quoteDigest", "priceId"] : action === "payments" ? ["eventId", "providerSubscriptionId", "providerCustomerId"] : action === "renewals" ? ["eventId"] : action === "restarts" ? ["previousSubscriptionId"] : MEMBERSHIP_SEAT_ACTION_FIELDS[action] ?? []];
-        if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key3) => !fields.includes(key3)) || !fields.every((key3) => typeof input[key3] === "string" && (["recipientName", "recipientEmail", "purchaserEmail", "verifiedRecipientEmail"].includes(key3) ? input[key3].length > 0 && input[key3].length <= 254 && !/[\u0000-\u001f\u007f]/.test(input[key3]) : SAFE2.test(input[key3])))) {
+        if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key3) => !fields.includes(key3) && !(action === "checkouts" && key3 === "namedSeat")) || !fields.every((key3) => typeof input[key3] === "string" && (["recipientName", "recipientEmail", "purchaserEmail", "verifiedRecipientEmail"].includes(key3) ? input[key3].length > 0 && input[key3].length <= 254 && !/[\u0000-\u001f\u007f]/.test(input[key3]) : SAFE2.test(input[key3])))) {
           throw new TypeError("invalid request");
         }
+        if (action === "checkouts" && input.namedSeat !== void 0) {
+          const seat = input.namedSeat;
+          if (!seat || Object.keys(seat).some((key3) => !["recipientName", "recipientEmail", "purchaserEmail"].includes(key3)) || typeof seat.purchaserEmail !== "string" || seat.purchaserEmail.length > 254) throw new TypeError("invalid seat");
+          checkoutNamedSeatSelection(seat, seat.purchaserEmail);
+        }
       } catch {
         return respond({ error: "invalid_offer_request" }, 400);
       }
@@ -15795,8 +16181,9 @@ function createMembershipAuthorityHandler(options) {
           offerId: String(input.offerId),
           offerDigest: String(input.offerDigest),
           quoteDigest: String(input.quoteDigest),
-          priceId: String(input.priceId)
-        }, options.now?.() ?? Date.now());
+          priceId: String(input.priceId),
+          ...input.namedSeat ? { namedSeat: input.namedSeat } : {}
+        }, options.now?.() ?? Date.now(), peer.seatPriceId);
         return respond({ ok: true, binding });
       }
       const offerId = await membershipOfferIdForRequest({ ...peer, applicationId: String(input.applicationId), requestId: String(input.requestId) });
@@ -15824,13 +16211,13 @@ function createMembershipAuthorityHandler(options) {
 
 // src/schema-membership-authority.ts
 var attr = (type, optional = false, unique = false, indexed = false) => ({ type, optional, unique, indexed });
-var id4 = () => attr("string", false, true, true);
+var id5 = () => attr("string", false, true, true);
 var key = (optional = false) => attr("string", optional, false, true);
 var scope = () => ({ appId: key(), chapterId: key(), environment: key(), runtime: key(), applicationId: key(), skuId: key() });
 var times = () => ({ revision: attr("number"), createdAt: attr("number"), updatedAt: attr("number") });
 var membershipAuthorityEntities = {
   networkMembership: { attrs: {
-    id: id4(),
+    id: id5(),
     membershipId: key(),
     ...scope(),
     personId: key(true),
@@ -15870,7 +16257,7 @@ var membershipAuthorityEntities = {
     restartId: key(true)
   } },
   membershipRestart: { attrs: {
-    id: id4(),
+    id: id5(),
     ...scope(),
     membershipId: key(),
     restartId: key(),
@@ -15880,7 +16267,7 @@ var membershipAuthorityEntities = {
     createdAt: attr("number")
   } },
   membershipPurchaseHistory: { attrs: {
-    id: id4(),
+    id: id5(),
     ...scope(),
     membershipId: key(),
     providerSubscriptionId: key(),
@@ -15889,7 +16276,7 @@ var membershipAuthorityEntities = {
     archivedAt: attr("number")
   } },
   networkEntitlement: { attrs: {
-    id: id4(),
+    id: id5(),
     ...scope(),
     membershipId: key(),
     seatId: key(true),
@@ -15906,10 +16293,12 @@ var membershipAuthorityEntities = {
     journeyApprovedAt: attr("number", true)
   } },
   networkSeat: { attrs: {
-    id: id4(),
+    id: id5(),
     ...scope(),
     primaryMembershipId: key(),
-    purchaserUserId: key(),
+    purchaserUserId: key(true),
+    purchaserEmailNormalized: key(true),
+    combinedInvoice: attr("json", true),
     recipientName: attr("string"),
     recipientEmailNormalized: key(),
     recipientClaimId: key(),
@@ -15941,9 +16330,9 @@ var membershipAuthorityEntities = {
     refundedCents: attr("number", true),
     providerRefundIds: attr("json", true)
   } },
-  networkSeatRecipient: { attrs: { id: id4(), appId: key(), chapterId: key(), environment: key(), runtime: key(), seatId: key(), recipientEmailNormalized: key(), createdAt: attr("number") } },
+  networkSeatRecipient: { attrs: { id: id5(), appId: key(), chapterId: key(), environment: key(), runtime: key(), seatId: key(), recipientEmailNormalized: key(), createdAt: attr("number") } },
   membershipEffect: { attrs: {
-    id: id4(),
+    id: id5(),
     chapterId: key(),
     environment: key(),
     runtime: key(),
@@ -15962,11 +16351,11 @@ var membershipAuthorityRules = Object.fromEntries(Object.keys(membershipAuthorit
 
 // src/schema-membership-offers.ts
 var attr2 = (type, optional = false, unique = false, indexed = false) => ({ type, optional, unique, indexed });
-var id5 = () => attr2("string", false, true, true);
+var id6 = () => attr2("string", false, true, true);
 var key2 = () => attr2("string", false, false, true);
 var membershipOfferEntities = {
   membershipAuthorityState: { attrs: {
-    id: id5(),
+    id: id6(),
     chapterId: key2(),
     environment: key2(),
     mode: key2(),
@@ -15976,7 +16365,7 @@ var membershipOfferEntities = {
     updatedAt: attr2("number")
   } },
   membershipCheckoutOffer: { attrs: {
-    id: id5(),
+    id: id6(),
     applicationId: key2(),
     appId: key2(),
     chapterId: key2(),
@@ -15991,7 +16380,7 @@ var membershipOfferEntities = {
     authorityRevision: attr2("number")
   } },
   membershipOfferCheckout: { attrs: {
-    id: id5(),
+    id: id6(),
     appId: key2(),
     chapterId: key2(),
     environment: key2(),
@@ -16002,7 +16391,8 @@ var membershipOfferEntities = {
     offerDigest: attr2("string"),
     quoteDigest: attr2("string"),
     priceId: attr2("string"),
-    boundAt: attr2("number")
+    boundAt: attr2("number"),
+    namedSeat: attr2("json", true)
   } }
 };
 var membershipOfferRules = Object.fromEntries(Object.keys(membershipOfferEntities).map((ns) => [ns, { view: "false", create: "false", update: "false", delete: "false" }]));
@@ -16057,7 +16447,7 @@ function createMembershipAuthorityStorage(db, secretNames) {
 }
 
 // src/membership-seat-cancel.ts
-import { initStripe as initStripe3, stripeRequest as stripeRequest13 } from "@odla-ai/stripe";
+import { initStripe as initStripe3, stripeRequest as stripeRequest14 } from "@odla-ai/stripe";
 async function cancelUnpaidNamedSeat(db, target, secretKey, now) {
   membershipClock(now);
   const state = await loadMembershipAuthorityState(db, target);
@@ -16085,7 +16475,7 @@ async function cancelUnpaidNamedSeat(db, target, secretKey, now) {
   }
   const metadata = { ...stripePartitionMetadata(target), applicationId: target.applicationId, membershipId: seat.primaryMembershipId, seatId: seat.id };
   const request = async (method, path, params) => {
-    const result = await stripeRequest13(
+    const result = await stripeRequest14(
       { secretKey },
       method,
       path,
@@ -16111,9 +16501,9 @@ async function cancelUnpaidNamedSeat(db, target, secretKey, now) {
   if (payment.status === "succeeded" || payment.amount_received > 0) throw new Error("paid seat requires payment evidence and full refund");
   if (payment.status !== "canceled") {
     if (!["requires_payment_method", "requires_confirmation", "requires_action", "processing"].includes(payment.status)) throw new Error("seat payment outcome unresolved");
-    const id6 = payment.id;
-    payment = await request("POST", `/v1/payment_intents/${encodeURIComponent(id6)}/cancel`, { cancellation_reason: "abandoned" });
-    if (payment.id !== id6) throw new Error("seat cancellation receipt mismatch");
+    const id7 = payment.id;
+    payment = await request("POST", `/v1/payment_intents/${encodeURIComponent(id7)}/cancel`, { cancellation_reason: "abandoned" });
+    if (payment.id !== id7) throw new Error("seat cancellation receipt mismatch");
   }
   if (!valid(payment) || payment.status !== "canceled" || payment.amount_received !== 0) throw new Error("seat cancellation unconfirmed");
   await db.transact([membershipUpdate("networkSeat", target.seatId, { status: "canceled", revision: Number(seat.revision) + 1, updatedAt: now })], {
@@ -16445,7 +16835,8 @@ async function requestMembershipCheckoutBinding(options) {
     offerId: options.offerId,
     offerDigest: options.offerDigest,
     quoteDigest: options.quoteDigest,
-    priceId: options.priceId
+    priceId: options.priceId,
+    ...options.namedSeat ? { namedSeat: options.namedSeat } : {}
   });
   return verifyMembershipCheckoutBinding(result.binding, options);
 }