@odla-ai/chapter 0.49.0 → 0.51.0

package/dist/worker/index.cjs

@@ -36,6 +36,7 @@ __export(worker_exports, {
   deliverMembershipChapterEffect: () => deliverMembershipChapterEffect,
   deliverSignupControl: () => deliverSignupControl,
   drainMembershipEffects: () => drainMembershipEffects,
+  refundNamedSeatByOperator: () => refundNamedSeatByOperator,
   renderActiveSignupControlHtml: () => renderActiveSignupControlHtml,
   resolveNetworkTargetTransport: () => resolveNetworkTargetTransport,
   retryChapterApprovalEffects: () => retryChapterApprovalEffects,
@@ -375,6 +376,7 @@ function createWorkerContext(options) {
     crmBase,
     requirePaymentQuote: options.requirePaymentQuote === true,
     membershipAuthority: options.membershipAuthority,
+    membershipAuthorityOperator: options.membershipAuthorityOperator,
     getPublicConfig,
     verifyUser,
     makeDb,
@@ -1700,6 +1702,11 @@ function canApprove(status2, p) {
 }
 
 // src/membership-policy.ts
+function seatPurchaseDeadline(offering, member) {
+  if (offering.seatPurchaseWindowCalendarMonths === void 0) return Number(member.termEndsAt);
+  if (Number.isSafeInteger(member.seatPurchaseEndsAt)) return Number(member.seatPurchaseEndsAt);
+  return addMembershipCalendarMonths(Number(member.initialTermStartedAt ?? member.termStartedAt), offering.seatPurchaseWindowCalendarMonths);
+}
 var fail2 = (field) => {
   throw new TypeError(`invalid membership policy: ${field}`);
 };
@@ -1756,7 +1763,7 @@ function membershipOfferingVersion(value) {
     autoRenew: true,
     paymentGraceDays: integer2(input.paymentGraceDays, 0, 60),
     seatPriceCents: integer2(input.seatPriceCents, 1, Number.MAX_SAFE_INTEGER),
-    seatPurchaseWindowCalendarMonths: integer2(input.seatPurchaseWindowCalendarMonths, 1, 120),
+    ...input.seatPurchaseWindowCalendarMonths === void 0 || input.seatPurchaseWindowCalendarMonths === null ? {} : { seatPurchaseWindowCalendarMonths: integer2(input.seatPurchaseWindowCalendarMonths, 1, 120) },
     requiredDisclosures: ids(input.requiredDisclosures)
   };
 }
@@ -1883,24 +1890,63 @@ async function verifyIssuedMembershipOffer(value, expected) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return reject("invalid_offer_snapshot");
   return restore({ ...value, approvedFoundingCount: 0 }, expected);
 }
-async function issueMembershipCommercialOffer(db, input) {
-  validate(input);
-  const stateId = `${input.chapterId}:${input.environment}`;
-  const state = await load(db, "membershipAuthorityState", stateId);
+async function previewMembershipCommercialOffer(db, input) {
+  for (const key3 of ["appId", "chapterId", "environment", "runtime", "skuId"]) {
+    if (typeof input[key3] !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{1,159}$/.test(input[key3])) reject("invalid_offer_identity");
+  }
+  if (!Number.isSafeInteger(input.now) || input.now < 0) reject("invalid_offer_window");
+  const state = await authoritativeState(db, input);
+  const { offering, policy } = await currentPolicy(db, input, false, state);
+  const approvedFoundingCount = policy ? state.cohortCounts[policy.cohortLabel] ?? 0 : 0;
+  if (!Number.isSafeInteger(approvedFoundingCount) || Number(approvedFoundingCount) < 0) reject("invalid_cohort_count");
+  const contract = createMembershipCommercialOffer({
+    offering,
+    discountPolicy: policy,
+    approvedFoundingCount: Number(approvedFoundingCount),
+    now: input.now,
+    couponId: await couponId(input, policy?.id)
+  });
+  const discount = contract.billingTerms.discount;
+  return {
+    skuId: input.skuId,
+    offeringVersionId: offering.id,
+    basePriceCents: offering.basePriceCents,
+    currency: offering.currency,
+    interval: offering.interval,
+    founding: contract.founding,
+    ...contract.founding && contract.discountPolicy ? { cohortLabel: contract.discountPolicy.cohortLabel } : {},
+    dueTodayCents: contract.dueTodayCents,
+    renewalCents: contract.renewalCents,
+    ...discount ? { discountDuration: discount.duration === "once" ? "first_term" : "while_active" } : {},
+    ...contract.initialTermEndsAt !== void 0 ? { initialTermEndsAt: contract.initialTermEndsAt } : {}
+  };
+}
+async function authoritativeState(db, input) {
+  const state = await load(db, "membershipAuthorityState", `${input.chapterId}:${input.environment}`);
   if (!state || state.mode !== "authoritative" || state.chapterId !== input.chapterId || state.environment !== input.environment || !Number.isSafeInteger(state.revision) || Number(state.revision) < 1 || !state.cohortCounts || typeof state.cohortCounts !== "object" || Array.isArray(state.cohortCounts)) return reject("membership_authority_unavailable");
-  const existing = await load(db, "membershipCheckoutOffer", input.offerId);
-  if (existing) return restore(existing, input);
+  return state;
+}
+async function currentPolicy(db, input, restartAware, state) {
   const rows5 = await db.query({
     membershipOfferingVersion: { $: { where: { chapterId: input.chapterId }, limit: 200 } },
     discountPolicyVersion: { $: { where: { chapterId: input.chapterId }, limit: 200 } }
   });
   if (!Array.isArray(rows5.membershipOfferingVersion) || !Array.isArray(rows5.discountPolicyVersion) || rows5.membershipOfferingVersion.length >= 200 || rows5.discountPolicyVersion.length >= 200) return reject("policy_history_incomplete");
-  const offerings = rows5.membershipOfferingVersion.map((row3) => membershipOfferingVersion(row3.snapshot)).filter((offer) => offer.chapterId === input.chapterId && offer.baseSkuId === input.skuId && offer.status === "published" && input.now >= offer.effectiveFrom && (offer.effectiveUntil === void 0 || input.now < offer.effectiveUntil));
-  const policies = rows5.discountPolicyVersion.map((row3) => membershipDiscountPolicyVersion(row3.snapshot)).filter((policy2) => policy2.chapterId === input.chapterId && policy2.status === "published" && policy2.cohortEligibleSkuIds.includes(input.skuId) && input.now >= policy2.qualifyingStartsAt && input.now < policy2.qualifyingEndsAt);
+  const offerings = rows5.membershipOfferingVersion.map((row2) => membershipOfferingVersion(row2.snapshot)).filter((offer) => offer.chapterId === input.chapterId && offer.baseSkuId === input.skuId && offer.status === "published" && input.now >= offer.effectiveFrom && (offer.effectiveUntil === void 0 || input.now < offer.effectiveUntil));
+  const policies = rows5.discountPolicyVersion.map((row2) => membershipDiscountPolicyVersion(row2.snapshot)).filter((policy2) => policy2.chapterId === input.chapterId && policy2.status === "published" && policy2.cohortEligibleSkuIds.includes(input.skuId) && input.now >= policy2.qualifyingStartsAt && input.now < policy2.qualifyingEndsAt);
   const offering = offerings.sort((a, b) => b.version - a.version)[0];
-  const restart = await load(db, "membershipRestart", (await membershipOfferIdForRequest({ ...input, requestId: "checkout_binding" })).replace(/^offer_/, "membership_"));
+  const restart = restartAware && input.applicationId ? await load(db, "membershipRestart", (await membershipOfferIdForRequest({ ...input, applicationId: input.applicationId, requestId: "checkout_binding" })).replace(/^offer_/, "membership_")) : void 0;
   const policy = restart ? void 0 : policies.sort((a, b) => b.version - a.version)[0];
   if (!offering || offerings.filter((item) => item.version === offering.version).length !== 1 || policy && policies.filter((item) => item.version === policy.version).length !== 1) reject("ambiguous_membership_policy");
+  return { offering, policy };
+}
+async function issueMembershipCommercialOffer(db, input) {
+  validate(input);
+  const stateId = `${input.chapterId}:${input.environment}`;
+  const state = await authoritativeState(db, input);
+  const existing = await load(db, "membershipCheckoutOffer", input.offerId);
+  if (existing) return restore(existing, input);
+  const { offering, policy } = await currentPolicy(db, input, true, state);
   const approvedFoundingCount = policy ? state.cohortCounts[policy.cohortLabel] ?? 0 : 0;
   if (!Number.isSafeInteger(approvedFoundingCount) || Number(approvedFoundingCount) < 0) reject("invalid_cohort_count");
   const contract = createMembershipCommercialOffer({
@@ -2108,7 +2154,7 @@ async function confirmMembershipPayment(db, input, now) {
       initialTermEndsAt: endsAt,
       termStartedAt: paidAt,
       termEndsAt: endsAt,
-      seatPurchaseEndsAt: addMembershipCalendarMonths(Number(paidAt), offering.seatPurchaseWindowCalendarMonths),
+      seatPurchaseEndsAt: seatPurchaseDeadline(offering, { initialTermStartedAt: paidAt, termEndsAt: endsAt }),
       autoRenew: true,
       refundedCents: 0,
       revision: 1,
@@ -2208,7 +2254,7 @@ function findTier(tiers, tierId) {
   if (!tierId) return tiers.length === 1 ? tiers[0] : null;
   return tiers.find((tier) => tier.id === tierId) ?? null;
 }
-function joinConfigTiers(tiers, defaults = {}) {
+function joinConfigTiers(tiers, defaults = {}, founding = /* @__PURE__ */ new Map()) {
   return tiers.map((tier) => ({
     id: tier.id,
     name: tier.name,
@@ -2216,7 +2262,8 @@ function joinConfigTiers(tiers, defaults = {}) {
     currency: tier.currency ?? defaults.currency ?? "usd",
     interval: tier.interval ?? defaults.interval ?? "year",
     blurb: tier.blurb ?? "",
-    free: tierIsFree(tier)
+    free: tierIsFree(tier),
+    ...founding.has(tier.id) ? { founding: founding.get(tier.id) } : {}
   }));
 }
 
@@ -3451,6 +3498,313 @@ var handlePaymentRecovery = async (req, url, env, ctx) => {
   }
 };
 
+// src/worker-routes-admin-named-seat.ts
+var PATH = /^\/api\/admin\/applications\/([0-9a-f-]+)\/named-seat(\/refund)?$/;
+var REFUNDABLE = /* @__PURE__ */ new Set(["renewal_pending", "pending_acceptance", "pending_approval", "pending_primary", "active"]);
+var handleAdminNamedSeat = async (req, url, env, ctx) => {
+  const match = url.pathname.match(PATH);
+  if (!match) return null;
+  const seats = ctx.membershipAuthority?.namedSeats;
+  if (ctx.chapter.mode !== "chapter" || !seats) return json({ error: "named seats are not configured" }, 404);
+  const refund = Boolean(match[2]);
+  if (req.method !== (refund ? "POST" : "GET")) return json({ error: "method not allowed" }, 405);
+  const raw2 = ctx.makeDb(env), user = await ctx.verifyUser(req, env);
+  if (!user) return json({ error: "unauthorized" }, 401);
+  if (!await ctx.isSuperAdminEmail(raw2, user.email, user.userId)) return json({ error: "super-admin required", code: "super_admin_required" }, 403);
+  const db = raw2, app = await membershipLoad(db, "applications", match[1]);
+  if (!app || !chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME) || app.namedSeatId) return json({ error: "not found" }, 404);
+  const intent = await membershipLoad(db, "subscriptionCheckoutIntents", String(app.id));
+  if (!intent) return json({ error: "paid membership required" }, 409);
+  try {
+    const target = await membershipTargetForIntent(intent, app, env, ctx);
+    const offer = await seats.offer(target, env);
+    const seat = offer.seat ?? null, refundable = Boolean(seat && REFUNDABLE.has(seat.status));
+    if (!refund) {
+      return json({
+        seat,
+        amountCents: offer.amountCents,
+        currency: offer.currency,
+        termEndsAt: offer.termEndsAt,
+        purchaseEndsAt: offer.purchaseEndsAt,
+        refundable
+      });
+    }
+    if (!seat) return json({ error: "no purchased seat", code: "seat_not_found" }, 409);
+    if (seat.status === "refunded") {
+      await closeRecipientApplication(db, env, ctx, seat.seatId);
+      return json({ ok: true, seatId: seat.seatId, status: "refunded", replayed: true });
+    }
+    if (!refundable) return json({ error: `seat is ${seat.status.replaceAll("_", " ")}`, code: "seat_not_refundable" }, 409);
+    const receipt = await seats.operatorRefund({ ...target, seatId: seat.seatId }, env);
+    await closeRecipientApplication(db, env, ctx, seat.seatId);
+    return json({ ok: true, ...receipt });
+  } catch {
+    return json({ error: "named seat service unavailable; retry to confirm" }, 503);
+  }
+};
+async function closeRecipientApplication(db, env, ctx, seatId) {
+  const recipient2 = (await db.query({ applications: { $: { where: { namedSeatId: seatId }, limit: 1 } } })).applications?.[0];
+  if (!recipient2 || !chapterBillingApplication(recipient2, ctx.chapter.id, env.ODLA_RUNTIME) || recipient2.status === "refunded") return;
+  const attrs = { status: "refunded", renewalAt: 0, canceled: true };
+  await db.transact(
+    [{ t: "update", ns: "applications", id: String(recipient2.id), attrs }],
+    { mutationId: `verified-refund:${String(recipient2.id)}:${seatId}` }
+  );
+  await syncApplicationToCrm(crmDeps(db, ctx), { app: { ...recipient2, ...attrs }, stage: "refunded" }).catch(() => void 0);
+}
+
+// src/membership-seat-refund-stripe.ts
+var import_stripe6 = require("@odla-ai/stripe");
+var fail3 = (code = "named_seat_refund_mismatch") => {
+  throw Object.assign(new Error(code), { code });
+};
+async function refundNamedSeatStripePayment(secretKey, seat) {
+  if (!seat.providerPaymentIntentId || seat.status !== "refund_pending") fail3();
+  const call = async (method, path, params, idempotencyKey) => {
+    const result = await (0, import_stripe6.stripeRequest)({ secretKey }, method, path, params, idempotencyKey ? { idempotencyKey } : {});
+    if (!result.ok || !result.body) return fail3("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)) fail3();
+  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)) fail3();
+  const items = sub.items.data.filter((item) => item.metadata?.seatId === seat.id);
+  if (items.length > 1) fail3();
+  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) fail3();
+    const removed = await call("DELETE", `/v1/subscription_items/${encodeURIComponent(item.id)}`, { proration_behavior: "none" });
+    if (removed.id !== item.id || removed.deleted !== true) fail3("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) fail3("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)) fail3();
+    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) fail3();
+  if (pendingCents) fail3("named_seat_refund_pending");
+  if (refundedCents < seat.amountCents) {
+    const remaining = seat.amountCents - refundedCents;
+    const refund = await call("POST", "/v1/refunds", {
+      payment_intent: seat.providerPaymentIntentId,
+      amount: remaining,
+      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)) fail3();
+    if (refund.status !== "succeeded") fail3("named_seat_refund_pending");
+    refundedCents += remaining;
+    refundIds.push(refund.id);
+  }
+  return { refundedCents, refundIds };
+}
+
+// src/membership-seat-refund.ts
+async function requestNamedSeatRefund(db, input, now) {
+  membershipClock(now);
+  const state = await loadMembershipAuthorityState(db, input);
+  const seat = await membershipLoad(db, "networkSeat", input.seatId);
+  requireMembershipScope(seat, input);
+  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 || 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 }),
+    ...entitlement ? [membershipUpdate("networkEntitlement", String(entitlement.id), { status: "closed", revision: Number(entitlement.revision) + 1, updatedAt: now })] : [],
+    membershipUpdate("membershipEffect", `${seat.id}:refund`, {
+      id: `${seat.id}:refund`,
+      chapterId: input.chapterId,
+      environment: input.environment,
+      runtime: input.runtime,
+      membershipId: member.id,
+      seatId: seat.id,
+      kind: "refund_seat",
+      status: "pending",
+      attempts: 0,
+      createdAt: now,
+      updatedAt: now
+    }),
+    ...seat.recipientUserId ? [membershipUpdate("membershipEffect", `${seat.id}:revoke`, {
+      id: `${seat.id}:revoke`,
+      chapterId: input.chapterId,
+      environment: input.environment,
+      runtime: input.runtime,
+      membershipId: member.id,
+      seatId: seat.id,
+      kind: "revoke_named_recipient_access",
+      status: "pending",
+      attempts: 0,
+      createdAt: now,
+      updatedAt: now
+    })] : []
+  ], { mutationId: `named-seat-refund-request:${seat.id}`, guards: [
+    { ns: "networkSeat", id: input.seatId, exists: true, equals: { revision: seat.revision } },
+    { ns: "networkMembership", id: String(member.id), exists: true, equals: { revision: member.revision } },
+    { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative", revision: state.revision } },
+    ...entitlement ? [{ ns: "networkEntitlement", id: String(entitlement.id), exists: true, equals: { revision: entitlement.revision } }] : []
+  ] });
+}
+async function completeNamedSeatRefund(db, seatId, secretKey, now) {
+  membershipClock(now);
+  const seat = await membershipLoad(db, "networkSeat", seatId);
+  if (!seat) return membershipFail("named_seat_not_found");
+  await loadMembershipAuthorityState(db, seat);
+  if (seat.status === "refunded") return;
+  if (seat.status !== "refund_pending") membershipFail("named_seat_refund_not_ready");
+  const result = await refundNamedSeatStripePayment(secretKey, seat);
+  await db.transact([
+    membershipUpdate("networkSeat", seatId, {
+      status: "refunded",
+      refundedCents: result.refundedCents,
+      providerRefundIds: result.refundIds,
+      revision: Number(seat.revision) + 1,
+      updatedAt: now
+    }),
+    membershipUpdate("membershipEffect", `${seatId}:refund`, { status: "complete", updatedAt: now })
+  ], { mutationId: `named-seat-refunded:${seatId}`, guards: [
+    { ns: "networkSeat", id: seatId, exists: true, equals: { status: "refund_pending", revision: seat.revision } }
+  ] });
+}
+
+// src/membership-seat-operator-refund.ts
+async function refundNamedSeatByOperator(db, input, stripeSecretKey, now) {
+  const seat = await membershipLoad(db, "networkSeat", input.seatId);
+  requireMembershipScope(seat, input);
+  await requestNamedSeatRefund(db, { ...input, reason: "operator" }, now);
+  await completeNamedSeatRefund(db, input.seatId, stripeSecretKey, now);
+  const refunded = await membershipLoad(db, "networkSeat", input.seatId);
+  if (refunded?.status !== "refunded" || !Number.isSafeInteger(refunded.refundedCents) || Number(refunded.refundedCents) <= 0) {
+    throw new Error("named seat refund unconfirmed");
+  }
+  return { seatId: String(seat.id), status: "refunded", refundedCents: Number(refunded.refundedCents), subscriptionCanceled: false };
+}
+
+// src/membership-seat-window.ts
+async function liftSeatPurchaseWindow(db, scope2, now, limit = 100) {
+  membershipClock(now);
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200) throw new TypeError("invalid lift limit");
+  const state = await loadMembershipAuthorityState(db, scope2);
+  const rows5 = (await db.query({ networkMembership: { $: { where: { ...scope2 }, order: { updatedAt: "asc" }, limit: limit + 1 } } })).networkMembership ?? [];
+  let lifted = 0;
+  for (const member of rows5.slice(0, limit)) {
+    if (Object.entries(scope2).some(([key3, value]) => member[key3] !== value)) throw new Error("membership lift scope mismatch");
+    const offering = membershipOfferingVersion(member.offeringSnapshot);
+    if (offering.seatPurchaseWindowCalendarMonths === void 0) continue;
+    const { seatPurchaseWindowCalendarMonths: _window, ...windowless } = offering;
+    await db.transact([membershipUpdate("networkMembership", String(member.id), {
+      offeringSnapshot: windowless,
+      seatPurchaseEndsAt: Number(member.termEndsAt),
+      revision: Number(member.revision) + 1,
+      updatedAt: now
+    })], { mutationId: `seat-window-lift:${member.id}:${member.revision}`, guards: [
+      { ns: "networkMembership", id: String(member.id), exists: true, equals: { revision: member.revision } },
+      { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative" } }
+    ] });
+    lifted++;
+  }
+  return { lifted, more: rows5.length > limit };
+}
+
+// src/worker-routes-admin-membership-seats.ts
+var LIST = "/api/admin/membership-seats";
+var LIFT = "/api/admin/membership-seats/lift-purchase-window";
+var ONE = /^\/api\/admin\/membership-seats\/([A-Za-z0-9][A-Za-z0-9_.:-]{2,159})\/refund$/;
+var SCOPE = /^[a-z0-9][a-z0-9-]{1,62}$/;
+var PUBLIC = [
+  "id",
+  "appId",
+  "chapterId",
+  "environment",
+  "runtime",
+  "applicationId",
+  "skuId",
+  "status",
+  "amountCents",
+  "currency",
+  "recipientName",
+  "recipientEmailNormalized",
+  "purchaserUserId",
+  "purchasedAt",
+  "acceptedAt",
+  "journeyApprovedAt",
+  "refundedCents",
+  "refundReason",
+  "termEndsAt",
+  "updatedAt"
+];
+var project = (row2) => Object.fromEntries(PUBLIC.filter((key3) => row2[key3] !== void 0).map((key3) => [key3, row2[key3]]));
+var handleAdminMembershipSeats = async (req, url, env, ctx) => {
+  const one = url.pathname.match(ONE), lift = url.pathname === LIFT;
+  if (url.pathname !== LIST && !one && !lift) return null;
+  const operator = ctx.membershipAuthorityOperator;
+  if (!operator) return json({ error: "not found" }, 404);
+  if (req.method !== (one || lift ? "POST" : "GET")) return json({ error: "method not allowed" }, 405);
+  const raw2 = ctx.makeDb(env), user = await ctx.verifyUser(req, env);
+  if (!user) return json({ error: "unauthorized" }, 401);
+  if (!await ctx.isSuperAdminEmail(raw2, user.email, user.userId)) return json({ error: "super-admin required", code: "super_admin_required" }, 403);
+  let db;
+  try {
+    db = operator.makeDb(env);
+  } catch {
+    return json({ error: "the membership authority is not hosted by this deployment" }, 404);
+  }
+  if (lift) {
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return json({ error: "chapterId and runtime are required" }, 400);
+    }
+    const appId = body.appId ?? body.chapterId;
+    if (typeof body.chapterId !== "string" || !SCOPE.test(body.chapterId) || typeof appId !== "string" || !SCOPE.test(appId) || typeof body.runtime !== "string" || !/^[a-z0-9]{2,12}$/.test(body.runtime)) {
+      return json({ error: "chapterId and runtime are required" }, 400);
+    }
+    try {
+      return json({ ok: true, ...await liftSeatPurchaseWindow(db, { appId, chapterId: body.chapterId, environment: env.ODLA_ENV, runtime: body.runtime }, Date.now()) });
+    } catch (error) {
+      const code = error.code;
+      return json({ error: "purchase window lift is pending; retry to confirm", ...code ? { code } : {} }, code ? 409 : 503);
+    }
+  }
+  if (!one) {
+    const rows5 = (await db.query({ networkSeat: { $: { where: { environment: env.ODLA_ENV }, order: { updatedAt: "desc" }, limit: 201 } } })).networkSeat ?? [];
+    return json({ seats: rows5.slice(0, 200).map(project), truncated: rows5.length > 200 });
+  }
+  const seat = await membershipLoad(db, "networkSeat", one[1]);
+  if (!seat || seat.environment !== env.ODLA_ENV) return json({ error: "not found" }, 404);
+  if (seat.status === "refunded") {
+    return json({ ok: true, seatId: seat.id, status: "refunded", refundedCents: seat.refundedCents, subscriptionCanceled: false, replayed: true });
+  }
+  if (!seat.purchasedAt) return json({ error: "seat has no completed payment to refund", code: "seat_not_refundable" }, 409);
+  const secret = await getVaultSecret(db, operator.stripeSecretName ?? "stripe_secret_key");
+  if (!secret) return json({ error: "network payment provider unavailable" }, 503);
+  try {
+    const receipt = await refundNamedSeatByOperator(db, {
+      appId: String(seat.appId),
+      chapterId: String(seat.chapterId),
+      environment: String(seat.environment),
+      runtime: String(seat.runtime),
+      applicationId: String(seat.applicationId),
+      skuId: String(seat.skuId),
+      seatId: String(seat.id)
+    }, secret, Date.now());
+    return json({ ok: true, ...receipt });
+  } catch (error) {
+    const code = error.code;
+    return json({ error: "seat refund is pending; retry to confirm", ...code ? { code } : {} }, code ? 409 : 503);
+  }
+};
+
 // src/worker-routes-membership-cancel.ts
 var handleMembershipCancellation = async (req, url, env, ctx) => {
   const match = url.pathname.match(/^\/api\/admin\/applications\/([0-9a-f-]+)\/cancel-renewal$/);
@@ -4047,6 +4401,29 @@ async function authorizeCrmDiscussionReference(req, env, fetcher = fetch) {
   }
 }
 
+// src/join-founding-preview.ts
+async function foundingPreviews(tiers, env, ctx) {
+  const result = /* @__PURE__ */ new Map();
+  const preview = ctx.membershipAuthority?.previewOffer;
+  if (!preview) return result;
+  const scope2 = { appId: env.ODLA_APP_ID, chapterId: ctx.chapter.id, environment: env.ODLA_ENV, runtime: stripeRuntimeIdentity(env.ODLA_RUNTIME) };
+  await Promise.all(tiers.filter((tier) => !tierIsFree(tier) && tier.stripePriceId).map(async (tier) => {
+    try {
+      const offer = await preview({ ...scope2, skuId: tier.id }, env);
+      if (!offer.founding || !offer.cohortLabel || offer.basePriceCents !== tier.priceCents || offer.dueTodayCents >= offer.basePriceCents) return;
+      result.set(tier.id, {
+        cohortLabel: offer.cohortLabel,
+        dueTodayCents: offer.dueTodayCents,
+        discountCents: offer.basePriceCents - offer.dueTodayCents,
+        renewalCents: offer.renewalCents,
+        ...offer.discountDuration ? { discountDuration: offer.discountDuration } : {}
+      });
+    } catch {
+    }
+  }));
+  return result;
+}
+
 // src/admission-grants-contract.ts
 var ADMISSION_GRANTS_SCHEMA_VERSION = 1;
 var ADMISSION_GRANTS_PATH = "/api/admission-grants";
@@ -4573,10 +4950,24 @@ async function materializeSignupControl(db, envelope, previous, receivedAt) {
 }
 
 // src/payment-quote.ts
+function tierPresentationFor(document, tierId) {
+  const compareAt = document?.membershipPage?.tiers?.find((tier) => tier.tierId === tierId)?.compareAtPriceCents;
+  return Number.isSafeInteger(compareAt) && Number(compareAt) > 0 ? { compareAtPriceCents: Number(compareAt) } : void 0;
+}
+function foundingOf(offer) {
+  return offer?.contract?.founding === true && offer.contract.discountPolicy ? { cohortLabel: offer.contract.discountPolicy.cohortLabel } : void 0;
+}
 async function createPaymentQuote(input) {
   const { group, tier, policy } = input;
   const terms2 = input.billingTerms ? subscriptionBillingTerms(input.billingTerms) : void 0;
+  const compareAt = input.presentation?.compareAtPriceCents;
+  const presentation = Number.isSafeInteger(compareAt) && Number(compareAt) > tier.priceCents ? { compareAtPriceCents: Number(compareAt) } : void 0;
   const dueToday = terms2 ? subscriptionAmountDue({ priceCents: tier.priceCents, billingTerms: terms2 }) : void 0;
+  const lines = dueToday === void 0 ? paymentLineItems(group, tier) : {
+    standardCents: tier.priceCents,
+    discountCents: tier.priceCents - dueToday,
+    dueTodayCents: dueToday
+  };
   const quote = {
     applicationId: input.applicationId,
     chapterId: input.chapterId,
@@ -4584,11 +4975,12 @@ async function createPaymentQuote(input) {
     tierName: tier.name,
     currency: tier.currency ?? String(group.currency ?? "usd"),
     interval: tier.interval ?? (group.interval === "month" ? "month" : "year"),
-    lineItems: dueToday === void 0 ? paymentLineItems(group, tier) : {
-      standardCents: tier.priceCents,
-      discountCents: tier.priceCents - dueToday,
-      dueTodayCents: dueToday
-    },
+    lineItems: presentation ? {
+      standardCents: presentation.compareAtPriceCents,
+      discountCents: presentation.compareAtPriceCents - lines.dueTodayCents,
+      dueTodayCents: lines.dueTodayCents
+    } : lines,
+    ...presentation ? { presentation } : {},
     refundPolicyText: policy?.refundPolicyText ?? String(group.refundPolicyText ?? ""),
     merchantDisclosureText: String(group.merchantDisclosureText ?? ""),
     trustCopy: policy ? policy.trustCopy ?? "" : String(group.trustCopy ?? ""),
@@ -4613,37 +5005,39 @@ async function createPaymentQuote(input) {
   });
   const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(contract));
   const digest = [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  return { ...quote, digest };
+  return { ...quote, digest, ...input.founding ? { founding: input.founding } : {} };
 }
 
 // src/membership-quote-projection.ts
 var MEMBERSHIP_QUOTE_NAMESPACE = "membershipQuoteProjections";
 var keys2 = ["appId", "chapterId", "environment", "runtime", "applicationId", "skuId"];
-var fail3 = (code) => {
+var fail4 = (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];
 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 fail3("membership_quote_unavailable");
-  if (row2.status !== "ready") return fail3("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 fail4("membership_quote_unavailable");
+  if (row2.status !== "ready") return fail4("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 fail3("membership_quote_expired");
+  if (offer.issuedAt > now + 3e4 || !allowExpired && offer.expiresAt <= now) return fail4("membership_quote_expired");
   const tier = row2.tier, quote = row2.quote;
   const offering = offer.contract.offering;
   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 fail3("membership_catalog_mismatch");
+    return fail4("membership_catalog_mismatch");
   }
   const expected = await createPaymentQuote({
     ...target,
     tier,
     group: { merchantDisclosureText: quote.merchantDisclosureText },
     policy: { refundPolicyText: quote.refundPolicyText, trustCopy: quote.trustCopy },
-    billingTerms: offer.contract.billingTerms
+    billingTerms: offer.contract.billingTerms,
+    presentation: quote.presentation,
+    founding: foundingOf(offer)
   });
-  if (quote.digest !== expected.digest) return fail3("membership_quote_conflict");
+  if (quote.digest !== expected.digest) return fail4("membership_quote_conflict");
   return { tier, quote: expected, billingTerms: offer.contract.billingTerms, membershipOffer: offer, projectionRevision: Number(row2.revision) };
 }
 async function readMembershipQuote(db, target, now) {
@@ -4651,9 +5045,9 @@ async function readMembershipQuote(db, 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 fail3("membership_quote_unavailable");
+  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 fail4("membership_quote_unavailable");
   let row2 = await load3(db, MEMBERSHIP_QUOTE_NAMESPACE, id6);
-  if (row2 && keys2.some((key3) => row2[key3] !== input[key3])) return fail3("membership_quote_conflict");
+  if (row2 && keys2.some((key3) => row2[key3] !== input[key3])) return fail4("membership_quote_conflict");
   if (row2?.status === "ready") {
     try {
       return await restore2(row2, input, now);
@@ -4698,7 +5092,7 @@ async function prepareMembershipQuote(db, input, issue) {
   }
   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 fail3("membership_quote_pending");
+    return fail4("membership_quote_pending");
   }
   const target = Object.fromEntries(keys2.map((key3) => [key3, input[key3]]));
   const offer = await verifyIssuedMembershipOffer(await issue({ ...target, requestId: row2.requestId }), {
@@ -4712,7 +5106,15 @@ async function prepareMembershipQuote(db, input, issue) {
     currency: input.tier.currency ?? String(input.group.currency ?? "usd"),
     interval: input.tier.interval ?? (input.group.interval === "month" ? "month" : "year")
   };
-  const quote = await createPaymentQuote({ ...target, tier, group: input.group, policy: input.policy, billingTerms: offer.contract.billingTerms });
+  const quote = await createPaymentQuote({
+    ...target,
+    tier,
+    group: input.group,
+    policy: input.policy,
+    billingTerms: offer.contract.billingTerms,
+    presentation: input.presentation,
+    founding: foundingOf(offer)
+  });
   const ready = { ...row2, offer, tier, quote, status: "ready", updatedAt: now };
   await restore2(ready, target, now, true);
   try {
@@ -4767,7 +5169,9 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
         group: { merchantDisclosureText: quote2.merchantDisclosureText },
         tier: tier2,
         policy: { refundPolicyText: quote2.refundPolicyText, trustCopy: quote2.trustCopy },
-        billingTerms
+        billingTerms,
+        presentation: quote2.presentation,
+        founding: foundingOf(intent.membershipOffer)
       });
       if (expected.digest !== quote2.digest) throw new Error("invalid commercial snapshot");
       return { tier: tier2, quote: expected, billingTerms, membershipOffer: intent.membershipOffer };
@@ -4794,9 +5198,10 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
   if (!tier || tierIsFree(tier) || !tier.stripePriceId) throw Object.assign(new Error("tier unavailable"), { code: "tier_unresolved" });
   const control3 = await loadActiveSignupControl(db, ctx.chapter.id, env.ODLA_ENV);
   const policy = control3?.document.policy?.tierPolicies?.[tier.id];
+  const presentation = tierPresentationFor(control3?.document, tier.id);
   if (ctx.membershipAuthority) return prepareMembershipQuote(
     db,
-    { ...target, app, group, tier, policy, now: Date.now() },
+    { ...target, app, group, tier, policy, presentation, now: Date.now() },
     (input) => ctx.membershipAuthority.issueOffer(input, env)
   );
   const quote = await createPaymentQuote({
@@ -4807,7 +5212,8 @@ async function checkoutQuoteForApplication(db, app, group, env, ctx, prepare = f
     runtime: stripeRuntimeIdentity(env.ODLA_RUNTIME),
     group,
     tier,
-    policy
+    policy,
+    presentation
   });
   return { tier, quote, billingTerms: void 0 };
 }
@@ -5461,10 +5867,11 @@ var handleMember = async (req, url, env, ctx) => {
       group,
       Boolean(stripeKey)
     );
+    const founding = await foundingPreviews(offered, env, ctx);
     const activeControl = chapter.signupControl ? await loadActiveSignupControl(db, chapter.id, env.ODLA_ENV) : null;
     const application = controlledApplication(chapter.application, activeControl?.document);
     return json({
-      ...joinConfig(group, paymentsReady, joinConfigTiers(offered, { currency: typeof group.currency === "string" ? group.currency : void 0, interval: group.interval === "month" ? "month" : "year" }), application.conditions),
+      ...joinConfig(group, paymentsReady, joinConfigTiers(offered, { currency: typeof group.currency === "string" ? group.currency : void 0, interval: group.interval === "month" ? "month" : "year" }, founding), application.conditions),
       fieldContract: chapterFlowFieldContract(chapter, "join", application),
       copy: { ...chapter.copy.join, ...activeControl?.document.application?.copy ?? {} },
       ...activeControl ? { signupControl: {
@@ -7157,7 +7564,7 @@ async function deliverAdmissionGrants(options) {
 }
 
 // src/worker-routes-network-admission.ts
-var PATH = "/api/admin/network/admissions";
+var PATH2 = "/api/admin/network/admissions";
 var RETRY_PATH = "/api/admin/network/admissions/retry";
 var REVOKE_PATH = "/api/admin/network/admissions/revoke";
 var MUTATION_ID2 = /^[A-Za-z0-9_-]{16,128}$/;
@@ -7237,11 +7644,11 @@ async function parseBody(req) {
   }
 }
 var handleAdminNetworkAdmissions = async (req, url, env, ctx) => {
-  if (![PATH, RETRY_PATH, REVOKE_PATH].includes(url.pathname)) return null;
+  if (![PATH2, RETRY_PATH, REVOKE_PATH].includes(url.pathname)) return null;
   const auth = await gate2(req, env, ctx);
   if ("response" in auth) return auth.response;
   const db = auth.db;
-  if (url.pathname === PATH && req.method === "GET") {
+  if (url.pathname === PATH2 && req.method === "GET") {
     const targetId2 = url.searchParams.get("targetId") ?? "";
     const target2 = targetFor(ctx, targetId2);
     if (!target2) return reject6(404, "unknown_target", "admission target is not configured");
@@ -7485,28 +7892,28 @@ var handleSchedule = async (req, url, env, ctx) => {
 };
 
 // src/payments-stripe.ts
-var import_stripe9 = require("@odla-ai/stripe");
+var import_stripe10 = require("@odla-ai/stripe");
 
 // src/payments-refund.ts
-var import_stripe6 = require("@odla-ai/stripe");
+var import_stripe7 = require("@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 providerId2 = (value, prefix) => new RegExp(`^${prefix}_[A-Za-z0-9]+$`).test(value);
-function fail4(code = "refund_target_mismatch") {
+function fail5(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")) fail4();
+  if (!providerId2(input.customerId, "cus") || !providerId2(input.subscriptionId, "sub")) fail5();
   const call = async (method, path, params, key3) => {
-    const result = await (0, import_stripe6.stripeRequest)({ secretKey }, method, path, params, key3 ? { idempotencyKey: key3 } : {});
-    if (!result.ok) fail4("stripe_error");
-    if (!result.body || typeof result.body !== "object" || Array.isArray(result.body)) fail4("stripe_invalid_response");
+    const result = await (0, import_stripe7.stripeRequest)({ secretKey }, method, path, params, key3 ? { idempotencyKey: key3 } : {});
+    if (!result.ok) fail5("stripe_error");
+    if (!result.body || typeof result.body !== "object" || Array.isArray(result.body)) fail5("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) fail4();
+  if (id2(sub) !== input.subscriptionId || id2(sub.customer) !== input.customerId) fail5();
   for (const [key3, value] of Object.entries(input.metadata ?? {})) {
-    if (row(sub.metadata)[key3] !== value) fail4();
+    if (row(sub.metadata)[key3] !== value) fail5();
   }
   let cursor;
   let earliest;
@@ -7519,69 +7926,69 @@ async function refundSubscriptionPayment(secretKey, input) {
       limit: 100,
       ...cursor ? { starting_after: cursor } : {}
     });
-    if (!Array.isArray(list.data) || typeof list.has_more !== "boolean") fail4("stripe_invalid_response");
+    if (!Array.isArray(list.data) || typeof list.has_more !== "boolean") fail5("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) fail4();
+      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) fail5();
       seen.add(id2(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) fail4("refund_history_incomplete");
+    if (!list.data.length || page === 9) fail5("refund_history_incomplete");
     cursor = id2(list.data[list.data.length - 1]);
   }
-  if (!earliest) fail4("no_charge");
+  if (!earliest) fail5("no_charge");
   const invoice = earliest;
-  if (input.expectedInvoiceId !== void 0 && id2(invoice) !== input.expectedInvoiceId || input.expectedAmountCents !== void 0 && invoice.amount_paid !== input.expectedAmountCents) fail4();
+  if (input.expectedInvoiceId !== void 0 && id2(invoice) !== input.expectedInvoiceId || input.expectedAmountCents !== void 0 && invoice.amount_paid !== input.expectedAmountCents) fail5();
   let chargeId = id2(invoice.charge);
   let paymentIntentId = id2(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) fail4("refund_payment_ambiguous");
+    if (payments.has_more !== false || !Array.isArray(payments.data) || payments.data.length !== 1) fail5("refund_payment_ambiguous");
     const payment = row(payments.data[0]);
-    if (id2(payment.invoice) !== id2(invoice) || payment.status !== "paid" || row(payment.payment).type !== "payment_intent") fail4();
+    if (id2(payment.invoice) !== id2(invoice) || payment.status !== "paid" || row(payment.payment).type !== "payment_intent") fail5();
     paymentIntentId = id2(row(payment.payment).payment_intent);
   }
   if (!chargeId) {
-    if (!providerId2(paymentIntentId, "pi")) fail4();
+    if (!providerId2(paymentIntentId, "pi")) fail5();
     const payment = await call("GET", `/v1/payment_intents/${paymentIntentId}`);
-    if (id2(payment) !== paymentIntentId || id2(payment.customer) !== input.customerId || payment.status !== "succeeded") fail4();
+    if (id2(payment) !== paymentIntentId || id2(payment.customer) !== input.customerId || payment.status !== "succeeded") fail5();
     chargeId = id2(payment.latest_charge);
   }
-  if (!providerId2(chargeId, "ch")) fail4();
+  if (!providerId2(chargeId, "ch")) fail5();
   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)) fail4();
-  if (input.alreadyRefundedChargeId !== void 0 && (chargeId !== input.alreadyRefundedChargeId || charge.amount_refunded !== charge.amount || charge.refunded !== true)) fail4();
+  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)) fail5();
+  if (input.alreadyRefundedChargeId !== void 0 && (chargeId !== input.alreadyRefundedChargeId || charge.amount_refunded !== charge.amount || charge.refunded !== true)) fail5();
   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)) fail4("refund_not_confirmed");
+    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)) fail5("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") fail4("refund_cancel_incomplete");
+    if (id2(canceled) !== input.subscriptionId || canceled.status !== "canceled") fail5("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) fail4("refund_not_confirmed");
+  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) fail5("refund_not_confirmed");
   return { refundedCents: Number(charge.amount), subscriptionCanceled };
 }
 
 // src/subscription-payment-identity.ts
-var import_stripe8 = require("@odla-ai/stripe");
+var import_stripe9 = require("@odla-ai/stripe");
 
 // src/subscription-provider-contract.ts
-var import_stripe7 = require("@odla-ai/stripe");
+var import_stripe8 = require("@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 (0, import_stripe7.stripeRequest)({ secretKey }, "GET", `/v1/prices/${encodeURIComponent(input.priceId)}`);
+  const result = await (0, import_stripe8.stripeRequest)({ 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;
@@ -7600,7 +8007,7 @@ async function tagSubscriptionPayment(secretKey, invoice, customerId, metadata,
   let paymentId = id3(invoice.payment_intent);
   if (!paymentId) {
     if (!/^in_[A-Za-z0-9]+$/.test(id3(invoice))) subscriptionContractMismatch();
-    const result2 = await (0, import_stripe8.stripeRequest)({ secretKey }, "GET", "/v1/invoice_payments", { invoice: id3(invoice), limit: 100 });
+    const result2 = await (0, import_stripe9.stripeRequest)({ secretKey }, "GET", "/v1/invoice_payments", { invoice: id3(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];
@@ -7609,11 +8016,11 @@ async function tagSubscriptionPayment(secretKey, invoice, customerId, metadata,
   }
   if (!/^pi_[A-Za-z0-9]+$/.test(paymentId)) subscriptionContractMismatch();
   const path = `/v1/payment_intents/${paymentId}`;
-  const result = await (0, import_stripe8.stripeRequest)({ secretKey }, "GET", path);
+  const result = await (0, import_stripe9.stripeRequest)({ 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 (Object.entries(metadata).every(([key3, value]) => payment.metadata?.[key3] === value)) return;
-  const tagged = await (0, import_stripe8.stripeRequest)(
+  const tagged = await (0, import_stripe9.stripeRequest)(
     { secretKey },
     "POST",
     path,
@@ -7625,7 +8032,7 @@ async function tagSubscriptionPayment(secretKey, invoice, customerId, metadata,
 
 // src/payments-stripe.ts
 async function stripeCall(sk, method, path, params, idempotencyKey) {
-  return (0, import_stripe9.stripeRequest)(
+  return (0, import_stripe10.stripeRequest)(
     { secretKey: sk },
     method,
     path,
@@ -7633,7 +8040,7 @@ async function stripeCall(sk, method, path, params, idempotencyKey) {
     idempotencyKey ? { idempotencyKey } : {}
   );
 }
-function fail5(op, r) {
+function fail6(op, r) {
   const err = new Error(`stripe ${op} failed: ${r.status}`);
   err.code = "stripe_error";
   throw err;
@@ -7683,7 +8090,7 @@ function createStripeProvider(config) {
           { email: input.email, name: input.name, metadata: meta },
           `cus:${input.applicationId}`
         );
-        if (!cust.ok) fail5("customer create", cust);
+        if (!cust.ok) fail6("customer create", cust);
         if (typeof cust.body.id !== "string" || !/^cus_[A-Za-z0-9]+$/.test(cust.body.id)) subscriptionContractMismatch();
         customerId = cust.body.id;
       }
@@ -7715,7 +8122,7 @@ function createStripeProvider(config) {
         // retry between create and the db write can't orphan a second one.
         `sub:${input.applicationId}${input.purchaseAttemptId ? `:${input.purchaseAttemptId}` : ""}`
       );
-      if (!sub.ok) fail5("subscription create", sub);
+      if (!sub.ok) fail6("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();
@@ -7725,14 +8132,14 @@ function createStripeProvider(config) {
           "expand[2]": "discounts",
           "expand[3]": "latest_invoice.discounts"
         });
-        if (!expanded.ok) fail5("subscription invoice evidence", expanded);
+        if (!expanded.ok) fail6("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) fail5("subscription confirmation-secret missing", sub);
+      if (!clientSecret2) fail6("subscription confirmation-secret missing", sub);
       await tagSubscriptionPayment(
         sk,
         invoice,
@@ -7744,7 +8151,7 @@ function createStripeProvider(config) {
       return { customerId, subscriptionId: String(sub.body.id), clientSecret: clientSecret2 };
     },
     async ingestWebhook(rawBody, sigHeader) {
-      if (!webhookSecret || !await (0, import_stripe9.verifyStripeSignature)(rawBody, sigHeader, webhookSecret)) {
+      if (!webhookSecret || !await (0, import_stripe10.verifyStripeSignature)(rawBody, sigHeader, webhookSecret)) {
         return { ok: false, reason: "bad_signature" };
       }
       const event = JSON.parse(rawBody);
@@ -8404,7 +8811,7 @@ async function namedSeatOfferDigest(offer) {
     "named-only",
     "full-upfront",
     "auto-renew-coterm",
-    "30-day-unaccepted-full-refund"
+    "no-automatic-refund"
   ])));
   return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
@@ -8416,15 +8823,16 @@ async function readNamedSeatOffer(db, input, now) {
   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,
     amountCents: offering.seatPriceCents,
     currency: offering.currency,
     interval: offering.interval,
     termEndsAt: Number(member.termEndsAt),
-    purchaseEndsAt: Number(member.seatPurchaseEndsAt),
+    purchaseEndsAt,
     autoRenew: member.autoRenew === true,
-    eligible: ["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) && member.refundedCents === 0 && now >= Number(member.initialTermStartedAt) && now < Number(member.termEndsAt) && now <= Number(member.seatPurchaseEndsAt) && (!seat || ["payment_pending", "payment_processing"].includes(String(seat.status))),
+    eligible: ["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) && member.refundedCents === 0 && now >= Number(member.initialTermStartedAt) && now < Number(member.termEndsAt) && now <= purchaseEndsAt && (!seat || ["payment_pending", "payment_processing"].includes(String(seat.status))),
     ...seat ? { seat: {
       seatId: String(seat.id),
       status: String(seat.status),
@@ -8432,7 +8840,7 @@ async function readNamedSeatOffer(db, input, now) {
       recipientEmail: String(seat.recipientEmailNormalized)
     } } : {}
   };
-  return { ...offer, digest: await namedSeatOfferDigest(offer) };
+  return { ...offer, digest: await namedSeatOfferDigest(offer), purchaseWindowed: offering.seatPurchaseWindowCalendarMonths !== void 0 };
 }
 
 // src/named-seat-request.ts
@@ -8809,6 +9217,23 @@ async function updateChapterPerson(opts) {
   });
 }
 
+// src/application-actions.ts
+function isApplicationStage(ctx, stage) {
+  return ctx.chapter.pipeline.stages.includes(stage);
+}
+function applicationActionStages(app, env, ctx) {
+  if (!chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME)) return [];
+  const from = String(app.status ?? "");
+  if (app.canceled === true || ["refunded", "canceled"].includes(from)) return [];
+  return ctx.chapter.pipeline.stages.filter((to) => {
+    if (to === from) return false;
+    if (to === "approved") return canApprove(from, ctx.chapter.pipeline) && from !== "declined";
+    if (to === "refunded") return Boolean(app.namedSeatId || app.stripeCustomerId && app.stripeSubscriptionId) && (!ctx.chapter.operations.refund.allowedFrom || ctx.chapter.operations.refund.allowedFrom.includes(from));
+    if (ctx.membershipAuthority && ["submitted", "paid_pending_vetting", "declined", "canceled"].includes(to)) return false;
+    return canTransition(from, to, ctx.chapter.pipeline);
+  });
+}
+
 // src/worker-routes-people-profile.ts
 var handlePeopleProfile = async (req, url, env, ctx) => {
   if (ctx.chapter.mode !== "chapter") return null;
@@ -8830,7 +9255,16 @@ var handlePeopleProfile = async (req, url, env, ctx) => {
   const record4 = await (0, import_crm10.getRecord)({ crm: ctx.chapter.crm, db }, id6);
   if (!record4) return json({ error: "not found" }, 404);
   if (record4.type !== "person") return dedicated ? json({ error: "person required" }, 422) : null;
-  if (match?.[2]) return json({ error: "use the application lifecycle workflow", code: "application_workflow_required" }, 409);
+  if (match?.[2]) {
+    const linked = typeof record4.fields.applicationId === "string" && record4.fields.applicationId !== "";
+    let to = "";
+    try {
+      to = String((await req.clone().json()).to ?? "");
+    } catch {
+    }
+    if (!linked && to && !isApplicationStage(ctx, to)) return null;
+    return json({ error: "use the application lifecycle workflow", code: "application_workflow_required" }, 409);
+  }
   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]) => ({
@@ -9521,20 +9955,6 @@ var handleAdminBilling = async (req, url, env, ctx) => {
 // src/worker-routes-admin-lifecycle.ts
 var import_calendar3 = require("@odla-ai/calendar");
 
-// src/application-actions.ts
-function applicationActionStages(app, env, ctx) {
-  if (!chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME)) return [];
-  const from = String(app.status ?? "");
-  if (app.canceled === true || ["refunded", "canceled"].includes(from)) return [];
-  return ctx.chapter.pipeline.stages.filter((to) => {
-    if (to === from) return false;
-    if (to === "approved") return canApprove(from, ctx.chapter.pipeline) && from !== "declined";
-    if (to === "refunded") return Boolean(app.namedSeatId || app.stripeCustomerId && app.stripeSubscriptionId) && (!ctx.chapter.operations.refund.allowedFrom || ctx.chapter.operations.refund.allowedFrom.includes(from));
-    if (ctx.membershipAuthority && ["submitted", "paid_pending_vetting", "declined", "canceled"].includes(to)) return false;
-    return canTransition(from, to, ctx.chapter.pipeline);
-  });
-}
-
 // src/refund-application.ts
 async function refundApplication(db, env, ctx, app) {
   if (!chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME)) return json({ error: "not found" }, 404);
@@ -9725,6 +10145,12 @@ var handleAdminRefund = async (req, url, env, ctx) => {
   const app = await loadApp(db, m[1]);
   if (!app) return json({ error: "not found" }, 404);
   if (!chapterBillingApplication(app, ctx.chapter.id, env.ODLA_RUNTIME)) return json({ error: "not found" }, 404);
+  if (app.namedSeatId) {
+    const actor = await ctx.verifyUser(req, env);
+    if (!actor || !await ctx.isSuperAdminEmail(db, actor.email, actor.userId)) {
+      return json({ error: "super-admin required", code: "super_admin_required" }, 403);
+    }
+  }
   return refundApplication(db, env, ctx, app);
 };
 var handleAdminApplicationPatch = async (req, url, env, ctx) => {
@@ -10334,7 +10760,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 = app ? applicationActionStages(app, env, ctx).map((id6) => ({ id: id6, label: id6.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") {
@@ -10552,7 +10978,7 @@ var handleNetworkRecords = async (req, url, env, ctx) => {
       }
     };
     try {
-      if (hasStage && ctx.chapter.mode === "chapter" && record4.type === "person") {
+      if (hasStage && ctx.chapter.mode === "chapter" && record4.type === "person" && (record4.fields.applicationId || isApplicationStage(ctx, input.stage))) {
         const updated2 = await networkApplicationAction({
           db,
           env,
@@ -11908,7 +12334,7 @@ async function revealNetworkPersonRegistryRecord(db, input, mutationId, actor, n
 }
 
 // src/worker-routes-network-person-registry.ts
-var PATH2 = "/api/admin/network-person-registry";
+var PATH3 = "/api/admin/network-person-registry";
 var MAX_BODY2 = 8 * 1024 * 1024;
 var MUTATION_ID4 = /^[A-Za-z0-9_-]{16,128}$/;
 var positiveRevision = (value) => {
@@ -11933,7 +12359,7 @@ function registryError(error) {
   return null;
 }
 var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
-  if (url.pathname !== PATH2) return null;
+  if (url.pathname !== PATH3) return null;
   if (!ctx.chapter.networkPersonRegistry) return json({ error: "not found" }, 404);
   if (req.method !== "GET" && req.method !== "POST") return json({ error: "method not allowed" }, 405);
   if (req.method === "POST" && Number(req.headers.get("content-length") ?? 0) > MAX_BODY2) {
@@ -12108,7 +12534,7 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
 };
 
 // src/worker-routes-network-commercial.ts
-var import_stripe10 = require("@odla-ai/stripe");
+var import_stripe11 = require("@odla-ai/stripe");
 
 // src/worker-routes-network-commercial-parity.ts
 var import_db13 = require("@odla-ai/db");
@@ -12484,7 +12910,7 @@ var handleNetworkCommercialStripeWebhook = async (req, url, env, ctx) => {
     return json({ error: "commercial webhook is not configured" }, 503);
   }
   try {
-    const event = await (0, import_stripe10.constructStripeEvent)(body, signature, secret);
+    const event = await (0, import_stripe11.constructStripeEvent)(body, signature, secret);
     const fact = normalizeNetworkCommercialStripeEvent(event, await stripeEventDigest(body));
     if (!fact.eventId || !fact.eventType || !fact.objectId) return json({ error: "Stripe event identity is invalid" }, 400);
     const result = await ingestNetworkCommercialFact(db, ctx.chapter.networkCommercialReadModel.sources, fact, Date.now(), await stripePayloadDigest(body));
@@ -12493,7 +12919,7 @@ var handleNetworkCommercialStripeWebhook = async (req, url, env, ctx) => {
     }
     return json({ ok: true, status: result.status, eventId: fact.eventId });
   } catch (error) {
-    if (error instanceof import_stripe10.StripeError) return json({ error: error.message, code: error.code }, 400);
+    if (error instanceof import_stripe11.StripeError) return json({ error: error.message, code: error.code }, 400);
     throw error;
   }
 };
@@ -12535,7 +12961,7 @@ var handleAdminNetworkCommercialReadModel = async (req, url, env, ctx) => {
       const secretKey = await getVaultSecret(db, "stripe_secret_key");
       if (!secretKey) return json({ error: "Stripe reconciliation is not configured" }, 503);
       try {
-        const stripe = (0, import_stripe10.initStripe)({ secretKey });
+        const stripe = (0, import_stripe11.initStripe)({ secretKey });
         const [customers, subscriptions, invoices, refunds, payments] = await Promise.all([
           listStripeObjects(stripe, "/v1/customers"),
           listStripeObjects(stripe, "/v1/subscriptions", { status: "all" }),
@@ -12549,7 +12975,7 @@ var handleAdminNetworkCommercialReadModel = async (req, url, env, ctx) => {
           ...reconcileStripeSnapshot(projection2, { customers, subscriptions, invoices, refunds, payments }, ctx.chapter.networkCommercialReadModel.sources)
         });
       } catch (error) {
-        if (error instanceof import_stripe10.StripeError) return json({ error: "Stripe reconciliation failed", code: error.code }, 502);
+        if (error instanceof import_stripe11.StripeError) return json({ error: "Stripe reconciliation failed", code: error.code }, 502);
         return json({ error: "Stripe reconciliation failed" }, 502);
       }
     }
@@ -13129,7 +13555,7 @@ var handleAdminBuilderLibrary = async (req, url, env, ctx) => {
 };
 
 // src/membership-cancel-authority.ts
-var import_stripe11 = require("@odla-ai/stripe");
+var import_stripe12 = require("@odla-ai/stripe");
 async function cancelMembershipAtTermEnd(db, target, now, stripeSecret) {
   membershipClock(now);
   const id6 = await networkMembershipId(target);
@@ -13140,14 +13566,14 @@ async function cancelMembershipAtTermEnd(db, target, now, stripeSecret) {
     membershipFail("membership_cancellation_unavailable");
   }
   const path = `/v1/subscriptions/${encodeURIComponent(String(member.providerSubscriptionId))}`;
-  const read2 = await (0, import_stripe11.stripeRequest)({ secretKey: stripeSecret }, "GET", path);
+  const read2 = await (0, import_stripe12.stripeRequest)({ 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 (0, import_stripe11.stripeRequest)(
+    const write = await (0, import_stripe12.stripeRequest)(
       { secretKey: stripeSecret },
       "POST",
       path,
@@ -13369,7 +13795,7 @@ async function refundNetworkMembership(db, input, secretKey, now) {
 }
 
 // src/membership-provider-lifecycle.ts
-var import_stripe12 = require("@odla-ai/stripe");
+var import_stripe13 = require("@odla-ai/stripe");
 
 // src/membership-renewal-authority.ts
 async function reconcileMembershipRenewal(db, input, now) {
@@ -13422,7 +13848,11 @@ async function reconcileMembershipRenewal(db, input, now) {
       membershipUpdate("networkMembership", id6, {
         status: status2,
         graceEndsAt,
-        ...paid ? { termStartedAt: start, termEndsAt: end } : {},
+        ...paid ? {
+          termStartedAt: start,
+          termEndsAt: end,
+          ...membershipOfferingVersion(member.offeringSnapshot).seatPurchaseWindowCalendarMonths === void 0 ? { seatPurchaseEndsAt: end } : {}
+        } : {},
         revision: Number(member.revision) + 1,
         updatedAt: now
       }),
@@ -13527,7 +13957,7 @@ async function reconcileMembershipBilling(db, input, now, stripeSecretName = "st
     }
     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 (0, import_stripe12.stripeRequest)({ secretKey: sk }, "GET", `/v1/subscriptions/${encodeURIComponent(String(member.providerSubscriptionId))}`);
+    const result = await (0, import_stripe13.stripeRequest)({ 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");
@@ -13582,10 +14012,11 @@ async function reserveNamedMembershipSeat(db, input, now) {
   const id6 = (await membershipOfferIdForRequest({ ...input, requestId: "named_seat" })).replace(/^offer_/, "seat_");
   let seat = await membershipLoad(db, "networkSeat", id6);
   if (!seat) {
-    if (!["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) || Number(member.refundedCents) !== 0 || now < Number(member.initialTermStartedAt) || now >= Number(member.termEndsAt) || now > Number(member.seatPurchaseEndsAt) || !Number.isSafeInteger(member.seatPurchaseEndsAt) || member.namedSeatId !== void 0) {
+    const offering = membershipOfferingVersion(member.offeringSnapshot), claimId = await recipientKey(input, email);
+    const purchaseEndsAt = seatPurchaseDeadline(offering, member);
+    if (!["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) || Number(member.refundedCents) !== 0 || now < Number(member.initialTermStartedAt) || now >= Number(member.termEndsAt) || now > purchaseEndsAt || !Number.isSafeInteger(purchaseEndsAt) || member.namedSeatId !== void 0) {
       membershipFail("named_seat_purchase_unavailable");
     }
-    const offering = membershipOfferingVersion(member.offeringSnapshot), claimId = await recipientKey(input, email);
     const attrs = {
       id: id6,
       ...membershipScope(input),
@@ -13604,7 +14035,7 @@ async function reserveNamedMembershipSeat(db, input, now) {
       status: "payment_pending",
       preparedAt: now,
       termEndsAt: member.termEndsAt,
-      seatPurchaseEndsAt: member.seatPurchaseEndsAt,
+      seatPurchaseEndsAt: purchaseEndsAt,
       offeringSnapshot: offering,
       revision: 1,
       createdAt: now,
@@ -13642,7 +14073,7 @@ async function reserveNamedMembershipSeat(db, input, now) {
 }
 
 // src/membership-seat-stripe.ts
-var import_stripe13 = require("@odla-ai/stripe");
+var import_stripe14 = require("@odla-ai/stripe");
 var reject7 = () => {
   throw Object.assign(new Error("named seat provider contract mismatch"), { code: "named_seat_provider_mismatch" });
 };
@@ -13654,7 +14085,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 (0, import_stripe13.stripeRequest)({ secretKey: sk }, "GET", path, params);
+  const response = await (0, import_stripe14.stripeRequest)({ secretKey: sk }, "GET", path, params);
   if (!response.ok) return reject7();
   return response.body;
 }
@@ -13691,11 +14122,11 @@ async function createNamedSeatStripePayment(sk, seat, now) {
   }
   await subscriptionForSeat(sk, seat);
   const metadata = metadataFor(seat);
-  const result = seat.providerPaymentIntentId ? await (0, import_stripe13.stripeRequest)(
+  const result = seat.providerPaymentIntentId ? await (0, import_stripe14.stripeRequest)(
     { secretKey: sk },
     "GET",
     `/v1/payment_intents/${encodeURIComponent(seat.providerPaymentIntentId)}`
-  ) : await (0, import_stripe13.stripeRequest)({ secretKey: sk }, "POST", "/v1/payment_intents", {
+  ) : await (0, import_stripe14.stripeRequest)({ secretKey: sk }, "POST", "/v1/payment_intents", {
     amount: seat.amountCents,
     currency: seat.currency,
     customer: seat.providerCustomerId,
@@ -13713,7 +14144,7 @@ async function attachNamedSeatStripeRenewal(sk, seat) {
   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 (0, import_stripe13.stripeRequest)({ secretKey: sk }, "POST", "/v1/subscription_items", {
+  const result = await (0, import_stripe14.stripeRequest)({ secretKey: sk }, "POST", "/v1/subscription_items", {
     subscription: seat.providerSubscriptionId,
     price: seat.priceId,
     quantity: 1,
@@ -13806,14 +14237,14 @@ async function confirmNamedMembershipSeatPayment(db, input, now) {
   }
   if (seat.purchasedAt === void 0) {
     if (!["payment_processing", "payment_canceling"].includes(String(seat.status))) membershipFail("named_seat_payment_not_expected");
-    const eligible = seat.status !== "payment_canceling" && ["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) && Number(member.refundedCents) === 0 && paidAt <= Number(member.seatPurchaseEndsAt) && now < Number(member.termEndsAt);
+    const eligible = seat.status !== "payment_canceling" && ["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) && Number(member.refundedCents) === 0 && paidAt <= seatPurchaseDeadline(membershipOfferingVersion(member.offeringSnapshot), member) && now < Number(member.termEndsAt);
     const status2 = eligible ? "renewal_pending" : "refund_pending", effectId = `${seat.id}:${eligible ? "attach-renewal" : "refund"}`;
     try {
       await db.transact([
         membershipUpdate("networkSeat", input.seatId, {
           status: status2,
           purchasedAt: paidAt,
-          acceptanceEndsAt: Math.min(paidAt + 30 * 864e5, Number(member.termEndsAt)),
+          acceptanceEndsAt: Number(member.termEndsAt),
           termStartedAt: paidAt,
           termEndsAt: member.termEndsAt,
           paymentEventId: input.eventId,
@@ -13861,7 +14292,7 @@ async function completeNamedSeatRenewal(db, seatId, secretKey, now) {
   if (seat.status !== "renewal_pending" || !seat.purchasedAt) membershipFail("named_seat_renewal_not_ready");
   const member = await membershipLoad(db, "networkMembership", target.primaryMembershipId);
   requireMembershipScope(member, target);
-  if (now >= Number(seat.acceptanceEndsAt) || now >= Number(member.termEndsAt) || Number(member.refundedCents) !== 0 || !["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status))) membershipFail("named_seat_refund_required");
+  if (now >= Number(member.termEndsAt) || Number(member.refundedCents) !== 0 || !["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status))) membershipFail("named_seat_refund_required");
   const itemId = await attachNamedSeatStripeRenewal(secretKey, target);
   const entitlementId = `${seatId}:entitlement`, effectId = `${seatId}:attach-renewal`;
   try {
@@ -13936,7 +14367,7 @@ async function recordRecipient(db, input, now, approve) {
     requireMembershipScope(entitlement, input);
     if (!["pending_acceptance", "pending_approval", "pending_primary", "active"].includes(String(seat.status)) || !["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) || Number(member.refundedCents) !== 0 || now >= Number(member.termEndsAt) || !seat.providerPaymentIntentId || !seat.providerSubscriptionItemId) membershipFail("named_seat_acceptance_unavailable");
     if (seat.acceptedAt === void 0) {
-      if (approve || now >= Number(seat.acceptanceEndsAt) || normalizeChapterEmail(input.verifiedRecipientEmail) !== seat.recipientEmailNormalized) {
+      if (approve || normalizeChapterEmail(input.verifiedRecipientEmail) !== seat.recipientEmailNormalized) {
         membershipFail("named_seat_recipient_verification_required");
       }
     } else if (seat.recipientUserId !== input.recipientUserId || seat.recipientApplicationId !== input.recipientApplicationId) {
@@ -13986,129 +14417,6 @@ async function recordRecipient(db, input, now, approve) {
   return membershipFail("named_seat_recipient_retry_required");
 }
 
-// src/membership-seat-refund-stripe.ts
-var import_stripe14 = require("@odla-ai/stripe");
-var fail6 = (code = "named_seat_refund_mismatch") => {
-  throw Object.assign(new Error(code), { code });
-};
-async function refundNamedSeatStripePayment(secretKey, seat) {
-  if (!seat.providerPaymentIntentId || seat.status !== "refund_pending") fail6();
-  const call = async (method, path, params, idempotencyKey) => {
-    const result = await (0, import_stripe14.stripeRequest)({ secretKey }, method, path, params, idempotencyKey ? { idempotencyKey } : {});
-    if (!result.ok || !result.body) return fail6("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)) fail6();
-  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)) fail6();
-  const items = sub.items.data.filter((item) => item.metadata?.seatId === seat.id);
-  if (items.length > 1) fail6();
-  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) fail6();
-    const removed = await call("DELETE", `/v1/subscription_items/${encodeURIComponent(item.id)}`, { proration_behavior: "none" });
-    if (removed.id !== item.id || removed.deleted !== true) fail6("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) fail6("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)) fail6();
-    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) fail6();
-  if (pendingCents) fail6("named_seat_refund_pending");
-  if (refundedCents < seat.amountCents) {
-    const remaining = seat.amountCents - refundedCents;
-    const refund = await call("POST", "/v1/refunds", {
-      payment_intent: seat.providerPaymentIntentId,
-      amount: remaining,
-      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)) fail6();
-    if (refund.status !== "succeeded") fail6("named_seat_refund_pending");
-    refundedCents += remaining;
-    refundIds.push(refund.id);
-  }
-  return { refundedCents, refundIds };
-}
-
-// src/membership-seat-refund.ts
-async function requestNamedSeatRefund(db, input, now) {
-  membershipClock(now);
-  const state = await loadMembershipAuthorityState(db, input);
-  const seat = await membershipLoad(db, "networkSeat", input.seatId);
-  requireMembershipScope(seat, input);
-  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 || input.reason === "declined" && seat.journeyApprovedAt !== void 0 || input.reason === "expired" && (seat.acceptedAt !== void 0 || !Number.isSafeInteger(seat.acceptanceEndsAt) || now < Number(seat.acceptanceEndsAt)) || 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 }),
-    ...entitlement ? [membershipUpdate("networkEntitlement", String(entitlement.id), { status: "closed", revision: Number(entitlement.revision) + 1, updatedAt: now })] : [],
-    membershipUpdate("membershipEffect", `${seat.id}:refund`, {
-      id: `${seat.id}:refund`,
-      chapterId: input.chapterId,
-      environment: input.environment,
-      runtime: input.runtime,
-      membershipId: member.id,
-      seatId: seat.id,
-      kind: "refund_seat",
-      status: "pending",
-      attempts: 0,
-      createdAt: now,
-      updatedAt: now
-    }),
-    ...seat.recipientUserId ? [membershipUpdate("membershipEffect", `${seat.id}:revoke`, {
-      id: `${seat.id}:revoke`,
-      chapterId: input.chapterId,
-      environment: input.environment,
-      runtime: input.runtime,
-      membershipId: member.id,
-      seatId: seat.id,
-      kind: "revoke_named_recipient_access",
-      status: "pending",
-      attempts: 0,
-      createdAt: now,
-      updatedAt: now
-    })] : []
-  ], { mutationId: `named-seat-refund-request:${seat.id}`, guards: [
-    { ns: "networkSeat", id: input.seatId, exists: true, equals: { revision: seat.revision } },
-    { ns: "networkMembership", id: String(member.id), exists: true, equals: { revision: member.revision } },
-    { ns: "membershipAuthorityState", id: String(state.id), exists: true, equals: { mode: "authoritative", revision: state.revision } },
-    ...entitlement ? [{ ns: "networkEntitlement", id: String(entitlement.id), exists: true, equals: { revision: entitlement.revision } }] : []
-  ] });
-}
-async function completeNamedSeatRefund(db, seatId, secretKey, now) {
-  membershipClock(now);
-  const seat = await membershipLoad(db, "networkSeat", seatId);
-  if (!seat) return membershipFail("named_seat_not_found");
-  await loadMembershipAuthorityState(db, seat);
-  if (seat.status === "refunded") return;
-  if (seat.status !== "refund_pending") membershipFail("named_seat_refund_not_ready");
-  const result = await refundNamedSeatStripePayment(secretKey, seat);
-  await db.transact([
-    membershipUpdate("networkSeat", seatId, {
-      status: "refunded",
-      refundedCents: result.refundedCents,
-      providerRefundIds: result.refundIds,
-      revision: Number(seat.revision) + 1,
-      updatedAt: now
-    }),
-    membershipUpdate("membershipEffect", `${seatId}:refund`, { status: "complete", updatedAt: now })
-  ], { mutationId: `named-seat-refunded:${seatId}`, guards: [
-    { ns: "networkSeat", id: seatId, exists: true, equals: { status: "refund_pending", revision: seat.revision } }
-  ] });
-}
-
 // src/membership-seat-provider-refund.ts
 async function confirmNamedSeatProviderRefund(db, input, now) {
   const seat = await membershipLoad(db, "networkSeat", input.seatId);
@@ -14130,7 +14438,7 @@ async function readNamedSeatInvitation(db, input, now) {
   await loadMembershipAuthorityState(db, target);
   const member = await membershipLoad(db, "networkMembership", String(seat.primaryMembershipId));
   requireMembershipScope(member, target);
-  if (!["pending_acceptance", "pending_approval", "pending_primary", "active"].includes(String(seat.status)) || !["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) || now >= Number(member.termEndsAt) || !seat.acceptedAt && now >= Number(seat.acceptanceEndsAt)) membershipFail("named_seat_invitation_unavailable");
+  if (!["pending_acceptance", "pending_approval", "pending_primary", "active"].includes(String(seat.status)) || !["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status)) || now >= Number(member.termEndsAt)) membershipFail("named_seat_invitation_unavailable");
   return {
     seatId: input.seatId,
     primaryApplicationId: target.applicationId,
@@ -14160,7 +14468,7 @@ async function readMembershipChapterEffect(db, input, now) {
   requireMembershipScope(member, input);
   if (!effect || effect.kind !== input.kind || effect.seatId !== seat.id || effect.membershipId !== member.id || ["chapterId", "environment", "runtime"].some((key3) => effect[key3] !== seat[key3]) || !["invite_named_recipient", "grant_named_recipient_access", "revoke_named_recipient_access"].includes(input.kind)) throw new Error("invalid chapter effect");
   let applicable;
-  if (input.kind === "invite_named_recipient") applicable = seat.status === "pending_acceptance" && seat.acceptedAt === void 0 && now < Number(seat.acceptanceEndsAt) && now < Number(member.termEndsAt) && ["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status));
+  if (input.kind === "invite_named_recipient") applicable = seat.status === "pending_acceptance" && seat.acceptedAt === void 0 && now < Number(member.termEndsAt) && ["paid_pending_approval", "active", "cancel_at_term_end"].includes(String(member.status));
   else if (input.kind === "revoke_named_recipient_access") applicable = ["refund_pending", "refunded"].includes(String(seat.status));
   else applicable = (await readNamedSeatAccess(db, {
     ...input,
@@ -14189,6 +14497,7 @@ var MEMBERSHIP_SEAT_ACTION_FIELDS = {
   "seat-reservations": ["recipientName", "recipientEmail", "purchaserEmail", "purchaserUserId"],
   "seat-payments": ["seatId", "eventId"],
   "seat-refunds": ["seatId", "eventId"],
+  "seat-operator-refund": ["seatId"],
   "seat-accept": recipient,
   "seat-approve": recipient,
   "seat-decline": recipient,
@@ -14257,6 +14566,7 @@ async function handleMembershipSeatAction(action, db, peer, input, now, stripeSe
     if (refunded?.status !== "refunded" || refunded.refundedCents !== seat.amountCents) throw new Error("named seat refund unconfirmed");
     return { seatId: seat.id, status: "refunded", refundedCents: refunded.refundedCents, subscriptionCanceled: false };
   }
+  if (action === "seat-operator-refund") return refundNamedSeatByOperator(db, { ...target, seatId: String(input.seatId) }, secret, now);
   if (action === "seat-checkouts") return prepareNamedMembershipSeatPayment(db, {
     ...target,
     priceId: peer.seatPriceId,
@@ -14345,7 +14655,7 @@ function createMembershipAuthorityHandler(options) {
     if (req.method !== "POST") return respond({ error: "method_not_allowed" }, 405);
     const sender = req.headers.get(import_db15.FEDERATION_HEADERS.sender);
     const action = url.pathname.split("/").at(-1);
-    if (!["offers", "checkouts", "payments", "approvals", "refunds", "renewals", "access", "restarts", "cancel-renewal", ...Object.keys(MEMBERSHIP_SEAT_ACTION_FIELDS)].includes(action ?? "")) return respond({ error: "unauthorized" }, 401);
+    if (!["offers", "offer-preview", "checkouts", "payments", "approvals", "refunds", "renewals", "access", "restarts", "cancel-renewal", ...Object.keys(MEMBERSHIP_SEAT_ACTION_FIELDS)].includes(action ?? "")) return respond({ error: "unauthorized" }, 401);
     const peer = peers.find((candidate) => candidate.appId === sender && url.pathname === `${MEMBERSHIP_AUTHORITY_PATH}/${candidate.runtime}/${action}` && !url.search);
     if (!peer) return respond({ error: "unauthorized" }, 401);
     let body;
@@ -14367,13 +14677,23 @@ function createMembershipAuthorityHandler(options) {
       let input;
       try {
         input = JSON.parse(verified.body);
-        const fields = action === "seat-invitation" ? MEMBERSHIP_SEAT_ACTION_FIELDS[action] : ["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] ?? []];
+        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]) : SAFE.test(input[key3])))) {
           throw new TypeError("invalid request");
         }
       } catch {
         return respond({ error: "invalid_offer_request" }, 400);
       }
+      if (action === "offer-preview") {
+        return respond({ ok: true, preview: await previewMembershipCommercialOffer(db, {
+          appId: peer.appId,
+          chapterId: peer.chapterId,
+          environment: peer.environment,
+          runtime: peer.runtime,
+          skuId: String(input.skuId),
+          now: options.now?.() ?? Date.now()
+        }) });
+      }
       if (Object.hasOwn(MEMBERSHIP_SEAT_ACTION_FIELDS, action)) {
         return respond({ ok: true, seat: await handleMembershipSeatAction(
           action,
@@ -14767,7 +15087,7 @@ async function drainMembershipEffects(db, options, now) {
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !options.stripeSecretKey) throw new TypeError("invalid membership recovery configuration");
   await loadMembershipAuthorityState(db, scope2);
   const matches2 = (row2) => Object.entries(scope2).every(([key3, value]) => row2[key3] === value);
-  let expired = 0, pending = 0, complete = 0, more = false;
+  let pending = 0, complete = 0, more = false;
   for (const status2 of ["payment_pending", "payment_processing", "payment_canceling"]) {
     const seats = (await db.query({ networkSeat: { $: { where: { ...scope2, status: status2 }, order: { updatedAt: "asc" }, limit: limit + 1 } } })).networkSeat ?? [];
     more ||= seats.length > limit;
@@ -14785,26 +15105,6 @@ async function drainMembershipEffects(db, options, now) {
       }
     }
   }
-  for (const status2 of ["renewal_pending", "pending_acceptance"]) {
-    const seats = (await db.query({ networkSeat: { $: { where: { ...scope2, status: status2 }, order: { acceptanceEndsAt: "asc" }, limit: limit + 1 } } })).networkSeat ?? [];
-    more ||= seats.length > limit;
-    for (const seat of seats.slice(0, limit)) {
-      if (!matches2(seat)) throw new Error("membership recovery scope mismatch");
-      if (seat.acceptedAt !== void 0 || now < Number(seat.acceptanceEndsAt)) continue;
-      try {
-        await requestNamedSeatRefund(db, {
-          ...scope2,
-          applicationId: String(seat.applicationId),
-          skuId: String(seat.skuId),
-          seatId: String(seat.id),
-          reason: "expired"
-        }, now);
-        expired++;
-      } catch {
-        pending++;
-      }
-    }
-  }
   const effects = (await db.query({ membershipEffect: { $: { where: {
     chapterId: scope2.chapterId,
     environment: scope2.environment,
@@ -14866,7 +15166,7 @@ async function drainMembershipEffects(db, options, now) {
       pending++;
     }
   }
-  return { complete, pending, expired, more };
+  return { complete, pending, more };
 }
 
 // src/approval-effects-retry.ts
@@ -15016,7 +15316,7 @@ function createMembershipChapterEffectRoute(options) {
           config.emailTemplates = { ...config.emailTemplates, namedSeatInvitation: config.emailTemplates?.namedSeatInvitation ?? {
             enabled: true,
             subject: "{{purchaserName}} invited you to {{chapterName}}",
-            text: "Hello {{firstName}},\n\n{{purchaserName}} has purchased a membership for you at {{chapterName}}. Your seat is already paid for.\n\nAccept your invitation by {{acceptBy}}:\n{{joinUrl}}\n\nYou will complete your own application and membership requirements. You will not be asked to pay for this seat."
+            text: "Hello {{firstName}},\n\n{{purchaserName}} has purchased a membership for you at {{chapterName}}. Your seat is already paid for.\n\nAccept your invitation here:\n{{joinUrl}}\n\nYou will complete your own application and membership requirements. You will not be asked to pay for this seat."
           } };
           const template = config.emailTemplates.namedSeatInvitation;
           if (!template.text.includes("{{purchaserName}}")) config.emailTemplates.namedSeatInvitation = {
@@ -15089,6 +15389,12 @@ async function requestMembershipCommercialOffer(options) {
     lifetimeMs: 6e4
   });
 }
+async function requestMembershipOfferPreview(options) {
+  const result = await requestAuthority(options, "offer-preview", { skuId: options.skuId });
+  const preview = result.preview;
+  if (!preview || preview.skuId !== options.skuId || typeof preview.founding !== "boolean" || !Number.isSafeInteger(preview.basePriceCents) || !Number.isSafeInteger(preview.dueTodayCents) || preview.dueTodayCents < 0 || preview.dueTodayCents > preview.basePriceCents || !Number.isSafeInteger(preview.renewalCents) || !/^[a-z]{3}$/.test(preview.currency) || !["month", "year"].includes(preview.interval) || preview.cohortLabel !== void 0 && typeof preview.cohortLabel !== "string" || preview.discountDuration !== void 0 && !["first_term", "while_active"].includes(preview.discountDuration)) throw new Error("invalid offer preview");
+  return preview;
+}
 async function requestMembershipCheckoutBinding(options) {
   const result = await requestAuthority(options, "checkouts", {
     applicationId: options.applicationId,
@@ -15127,6 +15433,12 @@ async function requestNamedSeatDecline(options) {
   if (!seat || seat.seatId !== options.seatId || seat.status !== "refunded" || seat.subscriptionCanceled !== false || !Number.isSafeInteger(seat.refundedCents) || seat.refundedCents <= 0) throw new Error("invalid named seat refund receipt");
   return seat;
 }
+async function requestNamedSeatOperatorRefund(options) {
+  const result = await requestAuthority(options, "seat-operator-refund", { applicationId: options.applicationId, skuId: options.skuId, seatId: options.seatId });
+  const seat = result.seat;
+  if (!seat || seat.seatId !== options.seatId || seat.status !== "refunded" || seat.subscriptionCanceled !== false || !Number.isSafeInteger(seat.refundedCents) || seat.refundedCents <= 0) throw new Error("invalid named seat refund receipt");
+  return seat;
+}
 async function requestNamedSeatReservation(options) {
   const result = await requestAuthority(options, "seat-reservations", {
     applicationId: options.applicationId,
@@ -15144,7 +15456,7 @@ async function requestNamedSeatReservation(options) {
 async function requestNamedSeatOffer(options) {
   const result = await requestAuthority(options, "seat-offer", { applicationId: options.applicationId, skuId: options.skuId });
   const offer = result.seat;
-  if (!offer || offer.membershipId !== await networkMembershipId(options) || !Number.isSafeInteger(offer.amountCents) || offer.amountCents <= 0 || !/^[a-z]{3}$/.test(offer.currency) || !["month", "year"].includes(offer.interval) || typeof offer.eligible !== "boolean" || typeof offer.autoRenew !== "boolean" || !Number.isSafeInteger(offer.termEndsAt) || !Number.isSafeInteger(offer.purchaseEndsAt) || offer.digest !== await namedSeatOfferDigest(offer)) throw new Error("invalid named seat offer");
+  if (!offer || offer.membershipId !== await networkMembershipId(options) || !Number.isSafeInteger(offer.amountCents) || offer.amountCents <= 0 || !/^[a-z]{3}$/.test(offer.currency) || !["month", "year"].includes(offer.interval) || typeof offer.eligible !== "boolean" || typeof offer.autoRenew !== "boolean" || !Number.isSafeInteger(offer.termEndsAt) || !Number.isSafeInteger(offer.purchaseEndsAt) || offer.purchaseWindowed !== void 0 && typeof offer.purchaseWindowed !== "boolean" || offer.digest !== await namedSeatOfferDigest(offer)) throw new Error("invalid named seat offer");
   return offer;
 }
 async function requestNamedSeatInvitation(options) {
@@ -15312,6 +15624,7 @@ function createMembershipWorkerAdapter(options) {
   return {
     authority: {
       issueOffer: async (input, env) => requestMembershipCommercialOffer({ ...input, ...await transport(input, env) }),
+      previewOffer: async (input, env) => requestMembershipOfferPreview({ ...input, ...await transport(input, env) }),
       bindCheckout: async (input, env) => requestMembershipCheckoutBinding({ ...input, ...await transport(input, env) }),
       confirmPayment: async (input, env) => requestMembershipPayment({ ...input, ...await transport(input, env) }),
       approveMembership: async (input, env) => requestMembershipApproval({ ...input, ...await transport(input, env) }),
@@ -15330,7 +15643,8 @@ function createMembershipWorkerAdapter(options) {
         confirmRefund: async (input, env) => requestNamedSeatRefund2({ ...input, ...await transport(input, env) }),
         accept: async (input, env) => requestNamedSeatAcceptance({ ...input, ...await transport(input, env) }),
         approve: async (input, env) => requestNamedSeatApproval({ ...input, ...await transport(input, env) }),
-        decline: async (input, env) => requestNamedSeatDecline({ ...input, ...await transport(input, env) })
+        decline: async (input, env) => requestNamedSeatDecline({ ...input, ...await transport(input, env) }),
+        operatorRefund: async (input, env) => requestNamedSeatOperatorRefund({ ...input, ...await transport(input, env) })
       } } : {}
     },
     readEffect: async (input, env) => requestMembershipChapterEffect({ ...input, ...await transport(input, env) })
@@ -15585,6 +15899,8 @@ var BUILTIN_ROUTES = [
   handleMembershipRestart,
   handleMembershipCancellation,
   handlePaymentRecovery,
+  handleAdminNamedSeat,
+  handleAdminMembershipSeats,
   handleAdminMeetings,
   handleAdminScheduling,
   // Roster + identity