@odla-ai/chapter 0.34.0 → 0.36.0

package/dist/index.js

@@ -15,6 +15,213 @@ async function applicationIdForSubmission(submissionId) {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
+// src/admission-grants-contract.ts
+var ADMISSION_GRANTS_SCHEMA_VERSION = 1;
+var ADMISSION_GRANTS_PATH = "/api/admission-grants";
+
+// src/signup-control-canonical.ts
+var encoder = new TextEncoder();
+function canonicalValue(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalValue).join(",")}]`;
+  if (typeof value !== "object") throw new TypeError("signup control contains an unsupported value");
+  const record2 = value;
+  const entries = Object.keys(record2).sort().flatMap((key) => {
+    const item = record2[key];
+    return item === void 0 ? [] : [`${JSON.stringify(key)}:${canonicalValue(item)}`];
+  });
+  return `{${entries.join(",")}}`;
+}
+function canonicalSignupControl(value) {
+  return canonicalValue(value);
+}
+async function signupControlDigest(document) {
+  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(canonicalSignupControl(document)));
+  return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+async function createSignupControlEnvelope(document) {
+  return { document, digest: await signupControlDigest(document) };
+}
+
+// src/admission-grants.ts
+var ID = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/;
+var MAX_GRANTS = 2e3;
+var MAX_NOTE = 2e3;
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var isAdmissionEmail = (value) => EMAIL_RE.test(value);
+function normalizeAdmissionEmail(email) {
+  return email.trim().toLowerCase();
+}
+function validateAdmissionGrantDocument(input) {
+  const errors = [];
+  const root = input && typeof input === "object" ? input : {};
+  if (root.schemaVersion !== ADMISSION_GRANTS_SCHEMA_VERSION) errors.push("document.schemaVersion must be 1");
+  const revision = Number(root.revision);
+  const generatedAt = Number(root.generatedAt);
+  if (!Number.isSafeInteger(revision) || revision < 1) errors.push("document.revision must be a positive integer");
+  if (!Number.isFinite(generatedAt) || generatedAt <= 0) errors.push("document.generatedAt must be epoch milliseconds");
+  const source = root.source && typeof root.source === "object" ? root.source : {};
+  const target = root.target && typeof root.target === "object" ? root.target : {};
+  const sourceId = typeof source.appId === "string" ? source.appId : "";
+  const sourceActor = typeof source.actor === "string" ? source.actor.trim() : "";
+  const chapterId = typeof target.chapterId === "string" ? target.chapterId : "";
+  const environment = typeof target.environment === "string" ? target.environment : "";
+  if (!ID.test(sourceId)) errors.push("document.source.appId must be an identifier");
+  if (!sourceActor || sourceActor.length > 256) errors.push("document.source.actor must be 1-256 characters");
+  if (!ID.test(chapterId)) errors.push("document.target.chapterId must be an identifier");
+  if (!ID.test(environment)) errors.push("document.target.environment must be an identifier");
+  if (!Array.isArray(root.grants)) errors.push("document.grants must be an array");
+  const rawGrants = Array.isArray(root.grants) ? root.grants : [];
+  if (rawGrants.length > MAX_GRANTS) errors.push(`document.grants supports at most ${MAX_GRANTS} entries`);
+  const grants = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenEmails = /* @__PURE__ */ new Set();
+  for (const [index, raw] of rawGrants.slice(0, MAX_GRANTS).entries()) {
+    const grant = raw && typeof raw === "object" ? raw : {};
+    const id4 = typeof grant.id === "string" ? grant.id : "";
+    const email = typeof grant.email === "string" ? grant.email.trim() : "";
+    const normalized = normalizeAdmissionEmail(email);
+    const decision = grant.decision;
+    const note = typeof grant.note === "string" ? grant.note.trim() : void 0;
+    const expiresAt = grant.expiresAt === void 0 ? void 0 : Number(grant.expiresAt);
+    if (!ID.test(id4)) errors.push(`document.grants[${index}].id must be an identifier`);
+    if (seenIds.has(id4)) errors.push(`document.grants repeats id "${id4}"`);
+    if (!isAdmissionEmail(normalized)) errors.push(`document.grants[${index}].email must be valid`);
+    if (seenEmails.has(normalized)) errors.push(`document.grants repeats email "${normalized}"`);
+    if (decision !== "waive_interview" && decision !== "require_interview") {
+      errors.push(`document.grants[${index}].decision is invalid`);
+    }
+    if (note && note.length > MAX_NOTE) errors.push(`document.grants[${index}].note is too long`);
+    if (expiresAt !== void 0 && (!Number.isFinite(expiresAt) || expiresAt <= 0)) {
+      errors.push(`document.grants[${index}].expiresAt must be epoch milliseconds`);
+    }
+    seenIds.add(id4);
+    seenEmails.add(normalized);
+    grants.push({
+      id: id4,
+      email,
+      decision,
+      ...note ? { note } : {},
+      ...expiresAt !== void 0 ? { expiresAt } : {}
+    });
+  }
+  if (errors.length) return { ok: false, errors };
+  return {
+    ok: true,
+    value: {
+      schemaVersion: ADMISSION_GRANTS_SCHEMA_VERSION,
+      revision,
+      generatedAt,
+      source: { appId: sourceId, actor: sourceActor },
+      target: { chapterId, environment },
+      grants
+    }
+  };
+}
+async function createAdmissionGrantEnvelope(document) {
+  const checked = validateAdmissionGrantDocument(document);
+  if (!checked.ok) throw new TypeError(`Invalid admission grant document: ${checked.errors.join("; ")}`);
+  return { document: checked.value, digest: await signupControlDigest(checked.value) };
+}
+var rows = (value) => Array.isArray(value) ? value : [];
+function asGrant(row) {
+  if (typeof row.id !== "string" || typeof row.emailNormalized !== "string") return null;
+  if (row.sourceScope !== "local" && row.sourceScope !== "parent") return null;
+  if (row.decision !== "waive_interview" && row.decision !== "require_interview") return null;
+  return row;
+}
+async function findAdmissionGrant(db, targetId, email, now) {
+  const emailNormalized = normalizeAdmissionEmail(email);
+  if (!isAdmissionEmail(emailNormalized)) return null;
+  const result = await db.query({ admissionGrants: { $: { where: { emailNormalized }, limit: 100 } } });
+  const active = rows(result.admissionGrants).map(asGrant).filter((grant) => Boolean(
+    grant && grant.targetId === targetId && grant.active === true && !grant.revokedAt && (!grant.expiresAt || grant.expiresAt > now) && !grant.consumedApplicationId
+  )).sort((a, b) => {
+    const scope = Number(b.sourceScope === "local") - Number(a.sourceScope === "local");
+    return scope || b.createdAt - a.createdAt;
+  });
+  return active[0] ?? null;
+}
+async function hasAdmissionRevision(db, sourceId, targetId, environment) {
+  const where = { sourceId, targetId, environment };
+  if (db.aggregate) {
+    return Number((await db.aggregate("admissionGrantRevisions", { count: true }, { where })).count ?? 0) > 0;
+  }
+  const found = await db.query({ admissionGrantRevisions: {} });
+  return rows(found.admissionGrantRevisions).some((row) => row.sourceId === sourceId && row.targetId === targetId && row.environment === environment);
+}
+async function loadLatestAdmissionRevision(db, sourceId, targetId, environment) {
+  if (!await hasAdmissionRevision(db, sourceId, targetId, environment)) return null;
+  const result = await db.query({ admissionGrantRevisions: { $: {
+    where: { sourceId, targetId, environment },
+    order: { revision: "desc" },
+    limit: 1
+  } } });
+  const row = rows(result.admissionGrantRevisions).sort((a, b) => Number(b.revision ?? 0) - Number(a.revision ?? 0))[0];
+  return row ? row : null;
+}
+async function materializeAdmissionGrants(db, envelope, previous, receivedAt) {
+  const { document, digest } = envelope;
+  const current = rows((await db.query({ admissionGrants: { $: {
+    where: { sourceScope: "parent", sourceId: document.source.appId, targetId: document.target.chapterId },
+    limit: MAX_GRANTS
+  } } })).admissionGrants);
+  const incomingIds = new Set(document.grants.map((grant) => `admission:parent:${document.source.appId}:${grant.id}`));
+  const ops = [];
+  for (const row of current) {
+    const id4 = String(row.id ?? "");
+    if (id4 && !incomingIds.has(id4)) ops.push({ t: "update", ns: "admissionGrants", id: id4, attrs: {
+      active: false,
+      revokedAt: receivedAt,
+      revokedBy: document.source.actor,
+      updatedAt: receivedAt,
+      updatedBy: document.source.actor
+    } });
+  }
+  for (const grant of document.grants) {
+    const id4 = `admission:parent:${document.source.appId}:${grant.id}`;
+    const existing = current.find((row) => row.id === id4);
+    ops.push({ t: "update", ns: "admissionGrants", id: id4, attrs: {
+      id: id4,
+      sourceGrantId: grant.id,
+      sourceScope: "parent",
+      sourceId: document.source.appId,
+      targetId: document.target.chapterId,
+      email: grant.email,
+      emailNormalized: normalizeAdmissionEmail(grant.email),
+      decision: grant.decision,
+      ...grant.note ? { note: grant.note } : {},
+      ...grant.expiresAt ? { expiresAt: grant.expiresAt } : {},
+      active: true,
+      sourceRevision: document.revision,
+      createdAt: Number(existing?.createdAt ?? receivedAt),
+      createdBy: String(existing?.createdBy ?? document.source.actor),
+      updatedAt: receivedAt,
+      updatedBy: document.source.actor
+    } });
+    const retract = [
+      ...!grant.note && existing?.note !== void 0 ? ["note"] : [],
+      ...grant.expiresAt === void 0 && existing?.expiresAt !== void 0 ? ["expiresAt"] : []
+    ];
+    if (retract.length) ops.push({ t: "retract", ns: "admissionGrants", id: id4, attrs: retract });
+  }
+  if (previous?.active) ops.push({ t: "update", ns: "admissionGrantRevisions", id: previous.id, attrs: { active: false } });
+  const revisionId = `admission-revision:${document.source.appId}:${document.target.environment}:${document.revision}`;
+  ops.push({ t: "update", ns: "admissionGrantRevisions", id: revisionId, attrs: {
+    id: revisionId,
+    sourceId: document.source.appId,
+    targetId: document.target.chapterId,
+    environment: document.target.environment,
+    revision: document.revision,
+    digest,
+    active: true,
+    receivedAt
+  } });
+  await db.transact(ops, { mutationId: `admission-grants:${document.source.appId}:${document.target.environment}:${document.revision}:${digest}` });
+}
+
 // src/member.ts
 var DEFAULT_REQUIRED = ["firstName", "lastName", "email", "referral", "whoYouAre", "message"];
 var DEFAULT_OPTIONAL = ["referralName", "linkedin", "phone", "state"];
@@ -66,9 +273,9 @@ function resolveApplication(a) {
     validateEmail: a?.validateEmail ?? true
   };
 }
-var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var EMAIL_RE2 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 function isValidEmail(value) {
-  return typeof value === "string" && EMAIL_RE.test(value);
+  return typeof value === "string" && EMAIL_RE2.test(value);
 }
 function clampArray(value, max) {
   if (!Array.isArray(value)) return value;
@@ -110,14 +317,23 @@ async function submitApplication(db, chapter, fields, opts) {
   if (app.requireDisclaimerAck && !acked) {
     return { ok: false, error: "disclaimerAck is required" };
   }
-  const id2 = opts.submissionId ? await applicationIdForSubmission(opts.submissionId) : opts.newId();
-  const row = { id: id2, status: chapter.pipeline.initial, createdAt: opts.now };
+  const id4 = opts.submissionId ? await applicationIdForSubmission(opts.submissionId) : opts.newId();
+  const row = { id: id4, status: chapter.pipeline.initial, createdAt: opts.now };
   for (const f of [...app.required, ...app.optional]) {
     if (fieldStates[f]?.visible === false) continue;
     if (typeof fields[f] === "string") row[f] = fields[f].trim();
   }
   if (fields.focus !== void 0) row.focus = clampArray(fields.focus, app.maxArrayLen);
   if (opts.groupId) row.groupId = opts.groupId;
+  if (typeof fields.email === "string" && isValidEmail(fields.email.trim())) {
+    row.emailNormalized = normalizeAdmissionEmail(fields.email);
+  }
+  if (opts.admissionGrant?.decision === "waive_interview") {
+    row.admissionGrantId = opts.admissionGrant.id;
+    row.admissionSource = opts.admissionGrant.sourceScope;
+    row.interviewWaivedAt = opts.now;
+  }
+  if (opts.giftOfferId) row.giftOfferId = opts.giftOfferId;
   if (typeof fields.tierId === "string" && fields.tierId) {
     if (opts.tierIds && !opts.tierIds.includes(fields.tierId)) {
       return { ok: false, error: "tierId is not an offered tier" };
@@ -125,11 +341,20 @@ async function submitApplication(db, chapter, fields, opts) {
     row.tierId = fields.tierId;
   }
   if (acked) row.disclaimerAckAt = opts.now;
+  const ops = [
+    { t: "update", ns: "applications", id: id4, attrs: row }
+  ];
+  if (opts.admissionGrant?.decision === "waive_interview") {
+    ops.push({ t: "update", ns: "admissionGrants", id: opts.admissionGrant.id, attrs: {
+      consumedAt: opts.now,
+      consumedApplicationId: id4
+    } });
+  }
   const { duplicate } = await db.transact(
-    [{ t: "update", ns: "applications", id: id2, attrs: row }],
+    ops,
     opts.submissionId ? { mutationId: `join:${opts.submissionId}` } : void 0
   );
-  return { ok: true, id: id2, duplicate, status: chapter.pipeline.initial, disclaimerAckAt: acked ? opts.now : null };
+  return { ok: true, id: id4, duplicate, status: chapter.pipeline.initial, disclaimerAckAt: acked ? opts.now : null };
 }
 function joinConfig(group, paymentsReady2, tiers2 = [], conditions = {}) {
   return {
@@ -149,93 +374,13 @@ function joinConfig(group, paymentsReady2, tiers2 = [], conditions = {}) {
   };
 }
 
-// src/schema.ts
-function attr(type, flags = {}) {
-  return {
-    type,
-    unique: flags.unique ?? false,
-    indexed: flags.indexed ?? false,
-    optional: flags.optional ?? false
-  };
-}
-var id = () => attr("string", { unique: true, indexed: true });
-var admins = {
-  attrs: {
-    id: id(),
-    email: attr("string", { unique: true, indexed: true }),
-    name: attr("string", { optional: true }),
-    note: attr("string", { optional: true })
-  }
-};
-var superAdmins = {
-  attrs: {
-    id: id(),
-    email: attr("string", { unique: true, indexed: true }),
-    note: attr("string", { optional: true }),
-    createdAt: attr("number", { indexed: true })
-  }
-};
-var networkNotes = {
-  attrs: {
-    id: id(),
-    recordKey: attr("string", { indexed: true }),
-    targetId: attr("string", { indexed: true }),
-    recordType: attr("string", { indexed: true }),
-    recordId: attr("string", { indexed: true }),
-    body: attr("string"),
-    authorId: attr("string", { indexed: true }),
-    authorEmail: attr("string", { optional: true }),
-    createdAt: attr("number", { indexed: true })
-  }
-};
-var signupControls = {
-  attrs: {
-    id: id(),
-    sourceId: attr("string", { indexed: true }),
-    targetId: attr("string", { indexed: true }),
-    environment: attr("string", { indexed: true }),
-    revision: attr("number", { indexed: true }),
-    digest: attr("string", { indexed: true }),
-    document: attr("json"),
-    active: attr("boolean", { indexed: true }),
-    receivedAt: attr("number", { indexed: true })
-  }
-};
-var applications = {
-  attrs: {
-    id: id(),
-    firstName: attr("string"),
-    lastName: attr("string"),
-    email: attr("string", { indexed: true }),
-    referral: attr("string"),
-    referralName: attr("string", { optional: true }),
-    whoYouAre: attr("string"),
-    focus: attr("json"),
-    linkedin: attr("string", { optional: true }),
-    message: attr("string"),
-    status: attr("string", { indexed: true }),
-    createdAt: attr("number", { indexed: true }),
-    meetingAt: attr("number", { indexed: true, optional: true }),
-    meetingLink: attr("string", { optional: true }),
-    clerkUserId: attr("string", { indexed: true, optional: true }),
-    // One-time/effect-repair marker. Absent means /api/me should copy the
-    // allowlisted application snapshot into Clerk private_metadata and remove
-    // the former public_metadata copy.
-    clerkPrivateMetadataSyncedAt: attr("number", { optional: true }),
-    phone: attr("string", { optional: true }),
-    state: attr("string", { optional: true }),
-    groupId: attr("string", { indexed: true, optional: true }),
-    // The tier this application joined on. Absent on rows that predate tiers.
-    tierId: attr("string", { indexed: true, optional: true }),
-    stripeCustomerId: attr("string", { indexed: true, optional: true }),
-    stripeSubscriptionId: attr("string", { indexed: true, optional: true }),
-    renewalAt: attr("number", { optional: true }),
-    disclaimerAckAt: attr("number", { optional: true }),
-    refundPolicyAckAt: attr("number", { optional: true }),
-    prepEmailSentAt: attr("number", { optional: true }),
-    canceled: attr("boolean", { optional: true })
-  }
-};
+// src/schema-applications.ts
+var attr = (type, flags = {}) => ({
+  type,
+  unique: flags.unique ?? false,
+  indexed: flags.indexed ?? false,
+  optional: flags.optional ?? false
+});
 var APPLICATION_INPUT_FIELDS = /* @__PURE__ */ new Set([
   "firstName",
   "lastName",
@@ -249,25 +394,57 @@ var APPLICATION_INPUT_FIELDS = /* @__PURE__ */ new Set([
   "phone",
   "state"
 ]);
+var applicationAttrs = {
+  id: attr("string", { unique: true, indexed: true }),
+  firstName: attr("string"),
+  lastName: attr("string"),
+  email: attr("string", { indexed: true }),
+  referral: attr("string"),
+  referralName: attr("string", { optional: true }),
+  whoYouAre: attr("string"),
+  focus: attr("json"),
+  linkedin: attr("string", { optional: true }),
+  message: attr("string"),
+  status: attr("string", { indexed: true }),
+  createdAt: attr("number", { indexed: true }),
+  meetingAt: attr("number", { indexed: true, optional: true }),
+  meetingLink: attr("string", { optional: true }),
+  clerkUserId: attr("string", { indexed: true, optional: true }),
+  clerkPrivateMetadataSyncedAt: attr("number", { optional: true }),
+  phone: attr("string", { optional: true }),
+  state: attr("string", { optional: true }),
+  groupId: attr("string", { indexed: true, optional: true }),
+  tierId: attr("string", { indexed: true, optional: true }),
+  stripeCustomerId: attr("string", { indexed: true, optional: true }),
+  stripeSubscriptionId: attr("string", { indexed: true, optional: true }),
+  renewalAt: attr("number", { optional: true }),
+  disclaimerAckAt: attr("number", { optional: true }),
+  refundPolicyAckAt: attr("number", { optional: true }),
+  prepEmailSentAt: attr("number", { optional: true }),
+  canceled: attr("boolean", { optional: true }),
+  emailNormalized: attr("string", { indexed: true, optional: true }),
+  admissionGrantId: attr("string", { unique: true, indexed: true, optional: true }),
+  admissionSource: attr("string", { indexed: true, optional: true }),
+  interviewWaivedAt: attr("number", { optional: true }),
+  giftOfferId: attr("string", { optional: true, indexed: true }),
+  giftIntentId: attr("string", { optional: true, unique: true, indexed: true }),
+  giftClaimId: attr("string", { optional: true, unique: true, indexed: true }),
+  giftOrderId: attr("string", { optional: true, indexed: true }),
+  giftPaidAt: attr("number", { optional: true, indexed: true }),
+  giftRevokedAt: attr("number", { optional: true, indexed: true }),
+  giftCheckoutStartedAt: attr("number", { optional: true, indexed: true })
+};
 function applicationsFor(application) {
   const attrs = {};
-  for (const [name, spec] of Object.entries(applications.attrs)) {
-    attrs[name] = {
-      ...spec,
-      optional: APPLICATION_INPUT_FIELDS.has(name) ? true : spec.optional
-    };
+  for (const [name, spec] of Object.entries(applicationAttrs)) {
+    attrs[name] = { ...spec, optional: APPLICATION_INPUT_FIELDS.has(name) ? true : spec.optional };
   }
   const apply = (field, optional) => {
     const existing = Object.hasOwn(attrs, field) ? attrs[field] : void 0;
-    if (existing && !APPLICATION_INPUT_FIELDS.has(field)) {
-      throw new Error(`defineChapter.application: field "${field}" is reserved by the applications schema`);
-    }
-    if (existing && existing.type !== "string") {
-      throw new Error(`defineChapter.application: field "${field}" is not a configurable string field`);
-    }
-    const spec = existing ? { ...existing, optional } : attr("string", { optional });
+    if (existing && !APPLICATION_INPUT_FIELDS.has(field)) throw new Error(`defineChapter.application: field "${field}" is reserved by the applications schema`);
+    if (existing && existing.type !== "string") throw new Error(`defineChapter.application: field "${field}" is not a configurable string field`);
     Object.defineProperty(attrs, field, {
-      value: spec,
+      value: existing ? { ...existing, optional } : attr("string", { optional }),
       enumerable: true,
       configurable: true,
       writable: true
@@ -277,75 +454,270 @@ function applicationsFor(application) {
   for (const field of application.optional) apply(field, true);
   return { attrs };
 }
-var groups = {
+
+// src/schema-admission.ts
+var attr2 = (type, flags = {}) => ({
+  type,
+  unique: flags.unique ?? false,
+  indexed: flags.indexed ?? false,
+  optional: flags.optional ?? false
+});
+var id = () => attr2("string", { unique: true, indexed: true });
+var admissionGrantsEntity = {
   attrs: {
     id: id(),
-    name: attr("string"),
-    standardPriceCents: attr("number"),
-    foundingDiscountCents: attr("number"),
-    stripePriceId: attr("string", { optional: true }),
-    stripePublishableKey: attr("string", { optional: true }),
-    notificationEmail: attr("string"),
-    replyTo: attr("string"),
-    debugEmail: attr("string", { optional: true }),
-    calendarLink: attr("string", { optional: true }),
-    disclaimerText: attr("string"),
-    refundPolicyText: attr("string"),
-    trustCopy: attr("string"),
-    commitmentText: attr("string", { optional: true }),
-    normsText: attr("string", { optional: true }),
-    emailTemplates: attr("json"),
-    schedulingJson: attr("json", { optional: true }),
-    createdAt: attr("number", { indexed: true })
+    sourceGrantId: attr2("string", { indexed: true }),
+    sourceScope: attr2("string", { indexed: true }),
+    sourceId: attr2("string", { indexed: true }),
+    targetId: attr2("string", { indexed: true }),
+    email: attr2("string"),
+    emailNormalized: attr2("string", { indexed: true }),
+    decision: attr2("string", { indexed: true }),
+    note: attr2("string", { optional: true }),
+    active: attr2("boolean", { indexed: true }),
+    sourceRevision: attr2("number", { optional: true, indexed: true }),
+    createdAt: attr2("number", { indexed: true }),
+    createdBy: attr2("string", { optional: true, indexed: true }),
+    updatedAt: attr2("number", { optional: true, indexed: true }),
+    updatedBy: attr2("string", { optional: true, indexed: true }),
+    expiresAt: attr2("number", { optional: true, indexed: true }),
+    revokedAt: attr2("number", { optional: true, indexed: true }),
+    revokedBy: attr2("string", { optional: true, indexed: true }),
+    consumedAt: attr2("number", { optional: true, indexed: true }),
+    consumedApplicationId: attr2("string", { optional: true, indexed: true })
   }
 };
-var tiers = {
+var admissionGrantRevisionsEntity = {
   attrs: {
     id: id(),
-    groupId: attr("string", { indexed: true }),
-    name: attr("string"),
-    priceCents: attr("number"),
-    stripePriceId: attr("string", { optional: true }),
-    blurb: attr("string", { optional: true }),
-    sortOrder: attr("number", { indexed: true }),
-    active: attr("boolean", { indexed: true }),
-    createdAt: attr("number", { indexed: true })
+    sourceId: attr2("string", { indexed: true }),
+    targetId: attr2("string", { indexed: true }),
+    environment: attr2("string", { indexed: true }),
+    revision: attr2("number", { indexed: true }),
+    digest: attr2("string", { indexed: true }),
+    active: attr2("boolean", { indexed: true }),
+    receivedAt: attr2("number", { indexed: true })
+  }
+};
+
+// src/schema-gifts.ts
+var attr3 = (type, flags = {}) => ({
+  type,
+  unique: flags.unique ?? false,
+  indexed: flags.indexed ?? false,
+  optional: flags.optional ?? false
+});
+var id2 = () => attr3("string", { unique: true, indexed: true });
+var giftPurchaseIntentsEntity = { attrs: {
+  id: id2(),
+  chapterId: attr3("string", { indexed: true }),
+  environment: attr3("string", { indexed: true }),
+  purchaserType: attr3("string", { indexed: true }),
+  purchaserApplicationId: attr3("string", { optional: true, indexed: true }),
+  purchaserUserId: attr3("string", { optional: true, indexed: true }),
+  purchaserEmailNormalized: attr3("string", { indexed: true }),
+  offerId: attr3("string", { indexed: true }),
+  offerSnapshot: attr3("json"),
+  status: attr3("string", { indexed: true }),
+  codeHash: attr3("string", { indexed: true }),
+  codeVersion: attr3("number"),
+  codeIssuedAt: attr3("number"),
+  providerObjectId: attr3("string", { optional: true, unique: true, indexed: true }),
+  providerCustomerId: attr3("string", { optional: true, indexed: true }),
+  checkoutStartedAt: attr3("number", { optional: true }),
+  paidAt: attr3("number", { optional: true, indexed: true }),
+  claimId: attr3("string", { optional: true, unique: true, indexed: true }),
+  createdAt: attr3("number", { indexed: true }),
+  updatedAt: attr3("number", { indexed: true })
+} };
+var giftOrdersEntity = { attrs: {
+  id: id2(),
+  intentId: attr3("string", { unique: true, indexed: true }),
+  chapterId: attr3("string", { indexed: true }),
+  environment: attr3("string", { indexed: true }),
+  offerId: attr3("string", { indexed: true }),
+  offerSnapshot: attr3("json"),
+  purchaserType: attr3("string", { indexed: true }),
+  purchaserApplicationId: attr3("string", { optional: true, indexed: true }),
+  purchaserUserId: attr3("string", { optional: true, indexed: true }),
+  purchaserEmailNormalized: attr3("string", { indexed: true }),
+  providerEventId: attr3("string", { unique: true, indexed: true }),
+  providerObjectId: attr3("string", { indexed: true }),
+  amountCents: attr3("number"),
+  currency: attr3("string"),
+  billingMode: attr3("string"),
+  createdAt: attr3("number", { indexed: true })
+} };
+var giftClaimsEntity = { attrs: {
+  id: id2(),
+  orderId: attr3("string", { unique: true, indexed: true }),
+  intentId: attr3("string", { unique: true, indexed: true }),
+  chapterId: attr3("string", { indexed: true }),
+  offerId: attr3("string", { indexed: true }),
+  target: attr3("json"),
+  purchaserApplicationId: attr3("string", { optional: true, indexed: true }),
+  purchaserUserId: attr3("string", { optional: true, indexed: true }),
+  purchaserEmailNormalized: attr3("string", { indexed: true }),
+  codeHash: attr3("string", { unique: true, indexed: true }),
+  codeVersion: attr3("number"),
+  rotationCount: attr3("number"),
+  codeIssuedAt: attr3("number"),
+  codeExpiresAt: attr3("number", { indexed: true }),
+  attemptCount: attr3("number"),
+  attemptWindowStartedAt: attr3("number"),
+  status: attr3("string", { indexed: true }),
+  redeemedAt: attr3("number", { optional: true, indexed: true }),
+  beneficiaryEmailNormalized: attr3("string", { optional: true, indexed: true }),
+  beneficiaryUserId: attr3("string", { optional: true, indexed: true }),
+  applicationId: attr3("string", { optional: true, unique: true, indexed: true }),
+  entitlementId: attr3("string", { optional: true, unique: true, indexed: true }),
+  rotatedAt: attr3("number", { optional: true }),
+  revokedAt: attr3("number", { optional: true, indexed: true }),
+  revokedReason: attr3("string", { optional: true }),
+  createdAt: attr3("number", { indexed: true })
+} };
+var giftEntitlementsEntity = { attrs: {
+  id: id2(),
+  claimId: attr3("string", { unique: true, indexed: true }),
+  orderId: attr3("string", { indexed: true }),
+  chapterId: attr3("string", { indexed: true }),
+  entitlementKey: attr3("string", { indexed: true }),
+  beneficiaryEmailNormalized: attr3("string", { indexed: true }),
+  beneficiaryUserId: attr3("string", { optional: true, indexed: true }),
+  active: attr3("boolean", { indexed: true }),
+  createdAt: attr3("number", { indexed: true }),
+  revokedAt: attr3("number", { optional: true })
+} };
+var giftRedemptionAttemptsEntity = { attrs: {
+  id: id2(),
+  chapterId: attr3("string", { indexed: true }),
+  bucket: attr3("string", { indexed: true }),
+  attemptCount: attr3("number"),
+  windowStartedAt: attr3("number", { indexed: true }),
+  updatedAt: attr3("number")
+} };
+
+// src/schema.ts
+function attr4(type, flags = {}) {
+  return {
+    type,
+    unique: flags.unique ?? false,
+    indexed: flags.indexed ?? false,
+    optional: flags.optional ?? false
+  };
+}
+var id3 = () => attr4("string", { unique: true, indexed: true });
+var admins = {
+  attrs: {
+    id: id3(),
+    email: attr4("string", { unique: true, indexed: true }),
+    name: attr4("string", { optional: true }),
+    note: attr4("string", { optional: true })
+  }
+};
+var superAdmins = {
+  attrs: {
+    id: id3(),
+    email: attr4("string", { unique: true, indexed: true }),
+    note: attr4("string", { optional: true }),
+    createdAt: attr4("number", { indexed: true })
+  }
+};
+var networkNotes = {
+  attrs: {
+    id: id3(),
+    recordKey: attr4("string", { indexed: true }),
+    targetId: attr4("string", { indexed: true }),
+    recordType: attr4("string", { indexed: true }),
+    recordId: attr4("string", { indexed: true }),
+    body: attr4("string"),
+    authorId: attr4("string", { indexed: true }),
+    authorEmail: attr4("string", { optional: true }),
+    createdAt: attr4("number", { indexed: true })
+  }
+};
+var signupControls = {
+  attrs: {
+    id: id3(),
+    sourceId: attr4("string", { indexed: true }),
+    targetId: attr4("string", { indexed: true }),
+    environment: attr4("string", { indexed: true }),
+    revision: attr4("number", { indexed: true }),
+    digest: attr4("string", { indexed: true }),
+    document: attr4("json"),
+    active: attr4("boolean", { indexed: true }),
+    receivedAt: attr4("number", { indexed: true })
+  }
+};
+var groups = {
+  attrs: {
+    id: id3(),
+    name: attr4("string"),
+    standardPriceCents: attr4("number"),
+    foundingDiscountCents: attr4("number"),
+    stripePriceId: attr4("string", { optional: true }),
+    stripePublishableKey: attr4("string", { optional: true }),
+    notificationEmail: attr4("string"),
+    replyTo: attr4("string"),
+    debugEmail: attr4("string", { optional: true }),
+    calendarLink: attr4("string", { optional: true }),
+    disclaimerText: attr4("string"),
+    refundPolicyText: attr4("string"),
+    trustCopy: attr4("string"),
+    commitmentText: attr4("string", { optional: true }),
+    normsText: attr4("string", { optional: true }),
+    emailTemplates: attr4("json"),
+    schedulingJson: attr4("json", { optional: true }),
+    createdAt: attr4("number", { indexed: true })
+  }
+};
+var tiers = {
+  attrs: {
+    id: id3(),
+    groupId: attr4("string", { indexed: true }),
+    name: attr4("string"),
+    priceCents: attr4("number"),
+    stripePriceId: attr4("string", { optional: true }),
+    blurb: attr4("string", { optional: true }),
+    sortOrder: attr4("number", { indexed: true }),
+    active: attr4("boolean", { indexed: true }),
+    createdAt: attr4("number", { indexed: true })
   }
 };
 var meetings = {
   attrs: {
-    id: id(),
-    applicationId: attr("string", { indexed: true }),
-    groupId: attr("string", { indexed: true }),
-    startAt: attr("number", { indexed: true }),
-    endAt: attr("number"),
-    timezone: attr("string"),
-    status: attr("string", { indexed: true }),
-    googleEventId: attr("string", { indexed: true, optional: true }),
-    meetUrl: attr("string", { optional: true }),
-    htmlLink: attr("string", { optional: true }),
-    drift: attr("string", { indexed: true, optional: true }),
-    driftGoogleStartAt: attr("number", { optional: true }),
-    driftDetectedAt: attr("number", { optional: true }),
-    adoptedFromGoogleAt: attr("number", { optional: true }),
-    createdAt: attr("number", { indexed: true })
+    id: id3(),
+    applicationId: attr4("string", { indexed: true }),
+    groupId: attr4("string", { indexed: true }),
+    startAt: attr4("number", { indexed: true }),
+    endAt: attr4("number"),
+    timezone: attr4("string"),
+    status: attr4("string", { indexed: true }),
+    googleEventId: attr4("string", { indexed: true, optional: true }),
+    meetUrl: attr4("string", { optional: true }),
+    htmlLink: attr4("string", { optional: true }),
+    drift: attr4("string", { indexed: true, optional: true }),
+    driftGoogleStartAt: attr4("number", { optional: true }),
+    driftDetectedAt: attr4("number", { optional: true }),
+    adoptedFromGoogleAt: attr4("number", { optional: true }),
+    createdAt: attr4("number", { indexed: true })
   }
 };
 var emailLog = {
   attrs: {
-    id: id(),
-    groupId: attr("string", { indexed: true }),
-    applicationId: attr("string", { indexed: true, optional: true }),
-    to: attr("string", { indexed: true }),
-    template: attr("string", { indexed: true }),
-    subject: attr("string"),
-    body: attr("string", { optional: true }),
-    transport: attr("string"),
-    messageId: attr("string", { optional: true }),
-    redirected: attr("boolean", { optional: true }),
-    dedupeKey: attr("string", { indexed: true, optional: true }),
-    error: attr("string", { optional: true }),
-    sentAt: attr("number", { indexed: true })
+    id: id3(),
+    groupId: attr4("string", { indexed: true }),
+    applicationId: attr4("string", { indexed: true, optional: true }),
+    to: attr4("string", { indexed: true }),
+    template: attr4("string", { indexed: true }),
+    subject: attr4("string"),
+    body: attr4("string", { optional: true }),
+    transport: attr4("string"),
+    messageId: attr4("string", { optional: true }),
+    redirected: attr4("boolean", { optional: true }),
+    dedupeKey: attr4("string", { indexed: true, optional: true }),
+    error: attr4("string", { optional: true }),
+    sentAt: attr4("number", { indexed: true })
   }
 };
 function chapterDb(mode, auth, includeNetworkNotes = false, application = resolveApplication(void 0), includeSignupControl = false) {
@@ -356,6 +728,13 @@ function chapterDb(mode, auth, includeNetworkNotes = false, application = resolv
     entities.tiers = tiers;
     entities.meetings = meetings;
     entities.emailLog = emailLog;
+    entities.admissionGrants = admissionGrantsEntity;
+    entities.admissionGrantRevisions = admissionGrantRevisionsEntity;
+    entities.giftPurchaseIntents = giftPurchaseIntentsEntity;
+    entities.giftOrders = giftOrdersEntity;
+    entities.giftClaims = giftClaimsEntity;
+    entities.giftEntitlements = giftEntitlementsEntity;
+    entities.giftRedemptionAttempts = giftRedemptionAttemptsEntity;
     if (includeSignupControl) entities.signupControls = signupControls;
   }
   if (auth.source === "table") entities.admins = admins;
@@ -640,6 +1019,7 @@ var DEFAULT_ADMIN_COPY = {
     overview: "Overview",
     billing: "Billing",
     people: "People",
+    admission: "Admission",
     network: "Network",
     portfolio: "Portfolio",
     settings: "Settings",
@@ -750,6 +1130,26 @@ var DEFAULT_ADMIN_COPY = {
     reschedule: "Reschedule",
     cancel: "Cancel"
   },
+  admission: {
+    title: "Interview decisions",
+    description: "Local decisions override Parent decisions. Requiring an interview locally suppresses a Parent waiver for the same email.",
+    email: "Email",
+    decision: "Decision",
+    expires: "Expires",
+    note: "Internal note",
+    waive: "Waive interview",
+    require: "Require interview",
+    add: "Add decision",
+    ledger: "Effective grant ledger",
+    loading: "Loading\u2026",
+    consumed: "consumed",
+    revoked: "revoked",
+    expired: "expired",
+    active: "active",
+    local: "local",
+    parent: "Parent",
+    revoke: "Revoke"
+  },
   network: {
     title: "Share to a follower",
     allowlistDescription: "Sends the target's allowlisted fields. Its pipeline and account state remain local.",
@@ -848,6 +1248,19 @@ var DEFAULT_JOIN_COPY = {
     label: "You're booked",
     calendarInvite: "A calendar invitation with the video call link is on its way to your email.",
     memberArea: "Go to your member area"
+  },
+  accepted: {
+    label: "You're approved",
+    body: "Your membership is approved. No introduction call is required."
+  },
+  gift: {
+    chooseSelf: "Buy membership for myself",
+    optionsLabel: "Or give access to someone else",
+    label: "Your gift code",
+    body: "Share this one-time code with the recipient. It becomes active after payment is confirmed.",
+    save: "Save it now. For security, this code is shown only once.",
+    rotate: "Generate a new code",
+    rotateFailed: "A new code could not be generated."
   }
 };
 var DEFAULT_MEMBERS_COPY = {
@@ -875,6 +1288,26 @@ var DEFAULT_MEMBERS_COPY = {
   full: {
     welcome: "Welcome back."
   },
+  gifts: {
+    title: "Give access",
+    body: "Purchase access for someone else and share the one-time claim code.",
+    noneAvailable: "No gift options are available right now.",
+    paid: "Payment submitted. Save the code below while it is visible.",
+    saveCode: "This code is shown once. Save it before leaving this page.",
+    purchases: "Your gifts",
+    noPurchases: "No gift purchases yet.",
+    pending: "Pending",
+    redeemed: "Redeemed",
+    expired: "Expired",
+    revoked: "Revoked",
+    rotate: "Rotate code",
+    rotated: "A new code was generated. Save it now.",
+    rotateFailed: "The code could not be rotated.",
+    redeemTitle: "Redeem a gift",
+    code: "One-time code",
+    redeem: "Redeem",
+    redeemFailed: "The code is invalid or unavailable."
+  },
   reschedule: {
     changeTime: "Change your time",
     unavailable: "Scheduling is briefly unavailable. We'll reach out by email to arrange your call.",
@@ -990,13 +1423,13 @@ function resolveLeaderFormation(input, crm) {
 }
 function formationFields(crm, formation) {
   const def = crm.type(formation.type);
-  return [...formation.required, ...formation.optional].map((id2) => {
-    const field = def.fields[id2];
+  return [...formation.required, ...formation.optional].map((id4) => {
+    const field = def.fields[id4];
     return {
-      id: id2,
-      label: field.label ?? id2,
+      id: id4,
+      label: field.label ?? id4,
       type: field.type,
-      required: formation.required.includes(id2),
+      required: formation.required.includes(id4),
       ...field.options ? { options: field.options } : {}
     };
   });
@@ -1155,9 +1588,9 @@ function isResolvedCrm(x) {
 }
 function defineChapter(config) {
   if (!config || typeof config !== "object") throw new Error("defineChapter: a config object is required");
-  const { id: id2, name } = config;
-  if (typeof id2 !== "string" || !SLUG3.test(id2)) {
-    throw new Error(`defineChapter.id: must be a lowercase slug [a-z0-9-] (2-63 chars) \u2014 got ${JSON.stringify(id2)}`);
+  const { id: id4, name } = config;
+  if (typeof id4 !== "string" || !SLUG3.test(id4)) {
+    throw new Error(`defineChapter.id: must be a lowercase slug [a-z0-9-] (2-63 chars) \u2014 got ${JSON.stringify(id4)}`);
   }
   if (typeof name !== "string" || name.trim() === "") throw new Error("defineChapter.name: a non-empty name is required");
   const mode = config.mode ?? "chapter";
@@ -1240,7 +1673,7 @@ function defineChapter(config) {
   };
   const chapter = {
     config,
-    id: id2,
+    id: id4,
     name,
     mode,
     brand,
@@ -1454,8 +1887,8 @@ function tierPayable(tier, group, hasSecretKey) {
 function byOrder(a, b) {
   return a.sortOrder - b.sortOrder || a.id.localeCompare(b.id);
 }
-function resolveTiers(group, rows = []) {
-  const stored = rows.filter((tier) => tier.active);
+function resolveTiers(group, rows2 = []) {
+  const stored = rows2.filter((tier) => tier.active);
   if (stored.length) return [...stored].sort(byOrder);
   return [{
     id: "standard",
@@ -1577,10 +2010,10 @@ function planDelivery(input) {
   const transport = !isProd && !redirect ? "log-only" : input.cloudflareReady ? "cloudflare" : "log-only";
   const to = redirect ? input.group.debugEmail : input.to;
   const subject = (redirect ? "[dev] " : "") + render(tpl.subject, vars);
-  const text2 = redirect ? `(dev redirect; original recipient: ${input.to})
+  const text3 = redirect ? `(dev redirect; original recipient: ${input.to})
 
 ` + render(tpl.text, vars) : render(tpl.text, vars);
-  return { deliver: true, transport, to, subject, text: text2, redirected: redirect };
+  return { deliver: true, transport, to, subject, text: text3, redirected: redirect };
 }
 
 // src/notify.ts
@@ -1615,9 +2048,9 @@ async function sendTemplated(deps, input) {
       error = e instanceof Error ? e.message : String(e);
     }
   }
-  const id2 = deps.newId();
+  const id4 = deps.newId();
   const row = {
-    id: id2,
+    id: id4,
     groupId: input.group.id,
     to: decision.to,
     template: input.template,
@@ -1631,7 +2064,7 @@ async function sendTemplated(deps, input) {
     ...messageId ? { messageId } : {},
     ...error ? { error } : {}
   };
-  await deps.db.transact([{ t: "update", ns: "emailLog", id: id2, attrs: row }], error ? void 0 : { mutationId: `email:${input.dedupeKey}` });
+  await deps.db.transact([{ t: "update", ns: "emailLog", id: id4, attrs: row }], error ? void 0 : { mutationId: `email:${input.dedupeKey}` });
   return error ? { sent: false, reason: error } : { sent: true };
 }
 function emailGroupFrom(row) {
@@ -1667,8 +2100,26 @@ function findApplicationRef(obj) {
   const customerId = typeof obj.customer === "string" ? obj.customer : void 0;
   return { ...applicationId ? { applicationId } : {}, ...customerId ? { customerId } : {} };
 }
+function findGiftRef(obj) {
+  const metaOf = (value) => value && typeof value === "object" ? value.metadata ?? {} : {};
+  const pick = (metadata) => typeof metadata.giftIntentId === "string" ? metadata.giftIntentId : void 0;
+  const parent = obj.parent;
+  const subscription = obj.subscription_details ?? parent?.subscription_details;
+  const giftIntentId = pick(metaOf(obj)) ?? pick(metaOf(subscription));
+  const subscriptionId = typeof obj.subscription === "string" ? obj.subscription : typeof subscription?.subscription === "string" ? String(subscription.subscription) : void 0;
+  return { ...giftIntentId ? { giftIntentId } : {}, providerObjectId: subscriptionId ?? String(obj.id ?? "") };
+}
 function normalizeWebhookEvent(event) {
   const obj = event.data?.object ?? {};
+  const gift = findGiftRef(obj);
+  if (gift.giftIntentId) {
+    if (event.type === "payment_intent.succeeded" || event.type === "invoice.paid" && obj.billing_reason === "subscription_create") {
+      return { kind: "gift_paid", giftIntentId: gift.giftIntentId, providerObjectId: gift.providerObjectId };
+    }
+    if (event.type === "charge.refunded") return { kind: "gift_revoked", giftIntentId: gift.giftIntentId, reason: "refunded" };
+    if (event.type === "customer.subscription.deleted") return { kind: "gift_revoked", giftIntentId: gift.giftIntentId, reason: "canceled" };
+    return { kind: "ignored", type: event.type };
+  }
   const ref = findApplicationRef(obj);
   switch (event.type) {
     case "invoice.paid": {
@@ -1702,6 +2153,112 @@ function canceledPatch() {
   return { canceled: true };
 }
 
+// src/join-continuation.ts
+function resolveJoinContinuation(input) {
+  if (input.status === "approved") return "accepted";
+  if (input.interviewWaived) {
+    if (!input.payable) return "approve";
+    if (input.status === input.initialStatus) {
+      return input.subscriptionStarted ? "paymentPending" : "payment";
+    }
+    return "approve";
+  }
+  if (!input.payable) return "booking";
+  if (input.status === input.initialStatus) {
+    return input.subscriptionStarted ? "paymentPending" : "payment";
+  }
+  if (canBook(input.status, input.pipeline)) return "booking";
+  return null;
+}
+
+// src/gift-offers.ts
+var GIFT_OFFER_CATALOG_VERSION = 1;
+var MAX_GIFT_OFFERS = 20;
+var ID2 = /^[a-z][a-z0-9-]{1,79}$/;
+var PRICE = /^price_[A-Za-z0-9]{12,}$/;
+var CURRENCY = /^[a-z]{3}$/;
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var text = (value, path, errors, max) => {
+  if (typeof value !== "string" || !value.trim()) {
+    errors.push(`${path} is required`);
+    return "";
+  }
+  if (value.trim().length > max) errors.push(`${path} must be at most ${max} characters`);
+  return value.trim();
+};
+function validateGiftOfferCatalog(input, tierIds) {
+  const errors = [];
+  const root = record(input);
+  if (!root) return { ok: false, errors: ["document.giftOffers must be an object"] };
+  for (const key of Object.keys(root)) if (key !== "schemaVersion" && key !== "offers") errors.push(`document.giftOffers.${key} is not supported`);
+  if (root.schemaVersion !== GIFT_OFFER_CATALOG_VERSION) errors.push("document.giftOffers.schemaVersion must be 1");
+  if (!Array.isArray(root.offers)) errors.push("document.giftOffers.offers must be an array");
+  const rawOffers = Array.isArray(root.offers) ? root.offers : [];
+  if (rawOffers.length > MAX_GIFT_OFFERS) errors.push(`document.giftOffers.offers supports at most ${MAX_GIFT_OFFERS} entries`);
+  const ids = /* @__PURE__ */ new Set();
+  const offers = [];
+  for (const [index, raw] of rawOffers.slice(0, MAX_GIFT_OFFERS).entries()) {
+    const path = `document.giftOffers.offers[${index}]`;
+    const item = record(raw);
+    if (!item) {
+      errors.push(`${path} must be an object`);
+      continue;
+    }
+    const allowed = /* @__PURE__ */ new Set(["id", "target", "billingMode", "stripePriceId", "priceCents", "currency", "redemptionLifetimeHours", "activeFrom", "activeUntil", "title", "description", "ctaLabel"]);
+    for (const key of Object.keys(item)) if (!allowed.has(key)) errors.push(`${path}.${key} is not supported`);
+    const id4 = text(item.id, `${path}.id`, errors, 80);
+    if (id4 && !ID2.test(id4)) errors.push(`${path}.id must be a lowercase kebab-case id`);
+    if (ids.has(id4)) errors.push(`${path}.id duplicates "${id4}"`);
+    ids.add(id4);
+    const targetRaw = record(item.target);
+    let target = { type: "entitlement", entitlementKey: "invalid" };
+    if (targetRaw?.type === "tier") {
+      const tierId = text(targetRaw.tierId, `${path}.target.tierId`, errors, 80);
+      if (!tierIds.has(tierId)) errors.push(`${path}.target.tierId must reference a declared tier`);
+      target = { type: "tier", tierId };
+    } else if (targetRaw?.type === "entitlement") {
+      const entitlementKey = text(targetRaw.entitlementKey, `${path}.target.entitlementKey`, errors, 80);
+      if (entitlementKey && !ID2.test(entitlementKey)) errors.push(`${path}.target.entitlementKey must be a lowercase kebab-case id`);
+      target = { type: "entitlement", entitlementKey };
+    } else errors.push(`${path}.target.type must be tier or entitlement`);
+    if (item.billingMode !== "one_time" && item.billingMode !== "subscription") errors.push(`${path}.billingMode must be one_time or subscription`);
+    const stripePriceId = text(item.stripePriceId, `${path}.stripePriceId`, errors, 128);
+    if (stripePriceId && !PRICE.test(stripePriceId)) errors.push(`${path}.stripePriceId must be a real Stripe Price id`);
+    if (!Number.isSafeInteger(item.priceCents) || Number(item.priceCents) < 1 || Number(item.priceCents) > 1e8) errors.push(`${path}.priceCents must be an integer from 1 to 100,000,000`);
+    const currency = typeof item.currency === "string" ? item.currency.trim().toLowerCase() : "";
+    if (!CURRENCY.test(currency)) errors.push(`${path}.currency must be a lowercase ISO currency code`);
+    const lifetime = Number(item.redemptionLifetimeHours);
+    if (!Number.isSafeInteger(lifetime) || lifetime < 1 || lifetime > 8760) errors.push(`${path}.redemptionLifetimeHours must be an integer from 1 to 8760`);
+    const activeFrom = item.activeFrom === void 0 ? void 0 : Number(item.activeFrom);
+    const activeUntil = item.activeUntil === void 0 ? void 0 : Number(item.activeUntil);
+    if (activeFrom !== void 0 && (!Number.isSafeInteger(activeFrom) || activeFrom < 1)) errors.push(`${path}.activeFrom must be epoch milliseconds`);
+    if (activeUntil !== void 0 && (!Number.isSafeInteger(activeUntil) || activeUntil < 1)) errors.push(`${path}.activeUntil must be epoch milliseconds`);
+    if (activeFrom !== void 0 && activeUntil !== void 0 && activeUntil <= activeFrom) errors.push(`${path}.activeUntil must follow activeFrom`);
+    offers.push({
+      id: id4,
+      target,
+      billingMode: item.billingMode,
+      stripePriceId,
+      priceCents: Number(item.priceCents),
+      currency,
+      redemptionLifetimeHours: lifetime,
+      ...activeFrom !== void 0 ? { activeFrom } : {},
+      ...activeUntil !== void 0 ? { activeUntil } : {},
+      title: text(item.title, `${path}.title`, errors, 160),
+      description: text(item.description, `${path}.description`, errors, 2e3),
+      ctaLabel: text(item.ctaLabel, `${path}.ctaLabel`, errors, 120)
+    });
+  }
+  return errors.length ? { ok: false, errors } : { ok: true, value: { schemaVersion: 1, offers } };
+}
+var giftOfferActive = (offer, now) => (!offer.activeFrom || offer.activeFrom <= now) && (!offer.activeUntil || offer.activeUntil > now);
+function publicGiftOffers(catalog, now) {
+  return (catalog?.offers ?? []).filter((offer) => giftOfferActive(offer, now)).map(({ stripePriceId: _stripe, target: _target, ...offer }) => offer);
+}
+function findGiftOffer(catalog, offerId, now) {
+  return catalog?.offers.find((offer) => offer.id === offerId && giftOfferActive(offer, now)) ?? null;
+}
+
 // src/network.ts
 import {
   createRecord,
@@ -1746,34 +2303,34 @@ function networkSourceTag(type, hubRecordId, sourceId) {
   if (readable && raw.length <= 64) return raw;
   return `network:${typeKey.slice(0, 16)}:${shortHash(`${sourceId ?? ""}\0${type}\0${hubRecordId}`)}`;
 }
-function normalizeSharedRecord(record, fallbackSourceId = "legacy-source") {
-  if ("input" in record && record.version === 2) {
+function normalizeSharedRecord(record2, fallbackSourceId = "legacy-source") {
+  if ("input" in record2 && record2.version === 2) {
     return {
       version: 2,
-      sourceId: record.source.siteId,
-      sourceRecordId: record.source.recordId,
-      type: record.type,
-      input: record.input
+      sourceId: record2.source.siteId,
+      sourceRecordId: record2.source.recordId,
+      type: record2.type,
+      input: record2.input
     };
   }
-  if ("input" in record) {
+  if ("input" in record2) {
     return {
       version: 1,
       sourceId: fallbackSourceId,
-      sourceRecordId: record.hubRecordId,
-      type: record.type,
-      input: record.input
+      sourceRecordId: record2.hubRecordId,
+      type: record2.type,
+      input: record2.input
     };
   }
-  if ("type" in record && record.type === "company") {
-    const input = { name: record.name };
+  if ("type" in record2 && record2.type === "company") {
+    const input = { name: record2.name };
     for (const key of ["domain", "industry", "location", "linkedin", "notes"]) {
-      if (record[key]) input[key] = record[key];
+      if (record2[key]) input[key] = record2[key];
     }
     return {
       version: 1,
       sourceId: fallbackSourceId,
-      sourceRecordId: record.hubRecordId,
+      sourceRecordId: record2.hubRecordId,
       type: "company",
       input
     };
@@ -1781,28 +2338,28 @@ function normalizeSharedRecord(record, fallbackSourceId = "legacy-source") {
   return {
     version: 1,
     sourceId: fallbackSourceId,
-    sourceRecordId: record.hubRecordId,
+    sourceRecordId: record2.hubRecordId,
     type: "person",
-    input: sharedPersonInput(record)
+    input: sharedPersonInput(record2)
   };
 }
-function sharedRecordFromCrm(crm, record, target, sourceId) {
-  if (target.fields && !target.fields[record.type]) {
-    throw new Error(`${target.name} does not accept "${record.type}" records`);
+function sharedRecordFromCrm(crm, record2, target, sourceId) {
+  if (target.fields && !target.fields[record2.type]) {
+    throw new Error(`${target.name} does not accept "${record2.type}" records`);
   }
-  const def = crm.type(record.type);
-  const fields = target.fields?.[record.type] ?? DEFAULT_SHARE_FIELDS[record.type];
+  const def = crm.type(record2.type);
+  const fields = target.fields?.[record2.type] ?? DEFAULT_SHARE_FIELDS[record2.type];
   if (!fields) {
-    throw new Error(`${target.name} requires an explicit field allowlist for "${record.type}" records`);
+    throw new Error(`${target.name} requires an explicit field allowlist for "${record2.type}" records`);
   }
   const nameField = def.nameField ?? "name";
   const input = {};
   for (const field of /* @__PURE__ */ new Set([nameField, ...fields])) {
-    const value = record.fields?.[field];
+    const value = record2.fields?.[field];
     if (value !== void 0) input[field] = value;
   }
-  if (input[nameField] === void 0) input[nameField] = record.name;
-  return sourceId ? { version: 2, source: { siteId: sourceId, recordId: record.id }, type: record.type, input } : { version: 1, type: record.type, hubRecordId: record.id, input };
+  if (input[nameField] === void 0) input[nameField] = record2.name;
+  return sourceId ? { version: 2, source: { siteId: sourceId, recordId: record2.id }, type: record2.type, input } : { version: 1, type: record2.type, hubRecordId: record2.id, input };
 }
 async function upsertPerson(deps, opts) {
   const email = opts.email.toLowerCase();
@@ -1816,11 +2373,11 @@ async function upsertPerson(deps, opts) {
   const created = await createRecord(crmDeps, { type: "person", input: opts.input, mutationId: opts.mutationId });
   return { recordId: created.id };
 }
-async function findSharedRecord(deps, record, tag) {
+async function findSharedRecord(deps, record2, tag) {
   const structured = await getRecordByOrigin(
     { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId },
-    record.sourceId,
-    record.sourceRecordId
+    record2.sourceId,
+    record2.sourceRecordId
   );
   if (structured) return structured;
   const mapped = await deps.db.query({ crm_tag: { $: { where: { tag }, limit: 1 } } });
@@ -1829,53 +2386,53 @@ async function findSharedRecord(deps, record, tag) {
     const found = await deps.db.query({ crm_record: { $: { where: { id: mappedId }, limit: 1 } } });
     if (found.crm_record?.[0]) return found.crm_record[0];
   }
-  const def = deps.crm.type(record.type);
+  const def = deps.crm.type(record2.type);
   const emailField = def.emailField;
-  if (emailField && typeof record.input[emailField] === "string") {
-    const primaryEmail = record.input[emailField].toLowerCase();
+  if (emailField && typeof record2.input[emailField] === "string") {
+    const primaryEmail = record2.input[emailField].toLowerCase();
     const found = await deps.db.query({
-      crm_record: { $: { where: { type: record.type, primaryEmail }, limit: 1 } }
+      crm_record: { $: { where: { type: record2.type, primaryEmail }, limit: 1 } }
     });
     if (found.crm_record?.[0]) return found.crm_record[0];
   }
-  const domain = record.input.domain;
+  const domain = record2.input.domain;
   const domainSlot = def.fields.domain?.slot;
   if (typeof domain === "string" && domainSlot) {
     const found = await deps.db.query({
-      crm_record: { $: { where: { type: record.type, [domainSlot]: domain }, limit: 1 } }
+      crm_record: { $: { where: { type: record2.type, [domainSlot]: domain }, limit: 1 } }
     });
     if (found.crm_record?.[0]) return found.crm_record[0];
   }
   const nameField = def.nameField ?? "name";
-  const name = record.input[nameField];
-  if (record.type === "company" && typeof name === "string" && name.trim()) {
+  const name = record2.input[nameField];
+  if (record2.type === "company" && typeof name === "string" && name.trim()) {
     const found = await deps.db.query({
-      crm_record: { $: { where: { type: record.type, name: name.trim() }, limit: 1 } }
+      crm_record: { $: { where: { type: record2.type, name: name.trim() }, limit: 1 } }
     });
     if (found.crm_record?.[0]) return found.crm_record[0];
   }
   return void 0;
 }
 async function projectSharedRecord(deps, shared, options = {}) {
-  const record = normalizeSharedRecord(shared, options.sourceId);
-  if (!record.type.trim() || !record.sourceId.trim() || !record.sourceRecordId.trim()) {
+  const record2 = normalizeSharedRecord(shared, options.sourceId);
+  if (!record2.type.trim() || !record2.sourceId.trim() || !record2.sourceRecordId.trim()) {
     throw new Error("type, source site id, and source record id must be non-empty");
   }
-  if (options.sourceId && options.sourceId !== record.sourceId) {
+  if (options.sourceId && options.sourceId !== record2.sourceId) {
     throw new Error("signed sender does not match payload source");
   }
-  const tag = networkSourceTag(record.type, record.sourceRecordId, record.version === 2 ? record.sourceId : void 0);
+  const tag = networkSourceTag(record2.type, record2.sourceRecordId, record2.version === 2 ? record2.sourceId : void 0);
   const crmDeps = { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId };
-  const existing = await findSharedRecord(deps, record, tag);
+  const existing = await findSharedRecord(deps, record2, tag);
   let recordId;
   if (existing && typeof existing.id === "string") {
-    await updateRecord(crmDeps, { id: existing.id, input: record.input });
+    await updateRecord(crmDeps, { id: existing.id, input: record2.input });
     recordId = existing.id;
   } else {
-    recordId = `network_${shortHash(`${record.sourceId}\0${record.type}\0${record.sourceRecordId}`)}`;
+    recordId = `network_${shortHash(`${record2.sourceId}\0${record2.type}\0${record2.sourceRecordId}`)}`;
     await createRecord({ ...crmDeps, newId: () => recordId }, {
-      type: record.type,
-      input: record.input,
+      type: record2.type,
+      input: record2.input,
       mutationId: `share-create:${tag}`
     });
   }
@@ -1885,10 +2442,10 @@ async function projectSharedRecord(deps, shared, options = {}) {
   );
   await upsertRecordOrigin(crmDeps, {
     recordId,
-    sourceId: record.sourceId,
-    sourceRecordId: record.sourceRecordId,
+    sourceId: record2.sourceId,
+    sourceRecordId: record2.sourceRecordId,
     ...options.sourceUrl ? { sourceUrl: options.sourceUrl } : {},
-    payloadVersion: record.version
+    payloadVersion: record2.version
   });
   return { recordId };
 }
@@ -2104,9 +2661,9 @@ async function updateClerkUserMetadataByEmail(secretKey, email, input, fetchImpl
   const found = await fetchImpl(`https://api.clerk.com/v1/users?email_address=${encodeURIComponent(email)}&limit=1`, { headers: auth });
   if (!found.ok) return false;
   const users = await found.json().catch(() => null);
-  const id2 = Array.isArray(users) && typeof users[0]?.id === "string" ? users[0].id : void 0;
-  if (!id2) return false;
-  return updateClerkUserMetadata(secretKey, id2, input, fetchImpl);
+  const id4 = Array.isArray(users) && typeof users[0]?.id === "string" ? users[0].id : void 0;
+  if (!id4) return false;
+  return updateClerkUserMetadata(secretKey, id4, input, fetchImpl);
 }
 async function createClerkUser(secretKey, input, fetchImpl = fetch) {
   const { path, body } = clerkUserRequest(input);
@@ -2162,8 +2719,8 @@ async function clerkGetUserByEmail(secretKey, email, fetchImpl = fetch) {
   const user = Array.isArray(data) ? data[0] : void 0;
   return user ? toRecord(user) : null;
 }
-async function clerkGetUser(secretKey, id2, fetchImpl = fetch) {
-  const data = await clerkGet(`/v1/users/${encodeURIComponent(id2)}`, secretKey, fetchImpl).catch(() => null);
+async function clerkGetUser(secretKey, id4, fetchImpl = fetch) {
+  const data = await clerkGet(`/v1/users/${encodeURIComponent(id4)}`, secretKey, fetchImpl).catch(() => null);
   return data ? toRecord(data) : null;
 }
 async function clerkListUsers(secretKey, fetchImpl = fetch) {
@@ -2172,15 +2729,15 @@ async function clerkListUsers(secretKey, fetchImpl = fetch) {
     const data = await clerkGet(`/v1/users?limit=${PAGE}&offset=${offset}`, secretKey, fetchImpl);
     const page = Array.isArray(data) ? data : [];
     for (const u of page) {
-      const record = toRecord(u);
-      if (record) out.push(record);
+      const record2 = toRecord(u);
+      if (record2) out.push(record2);
     }
     if (page.length < PAGE) break;
   }
   return out;
 }
-async function clerkSetRole(secretKey, id2, role, fetchImpl = fetch) {
-  const res = await fetchImpl(`${CLERK_API}/v1/users/${encodeURIComponent(id2)}/metadata`, {
+async function clerkSetRole(secretKey, id4, role, fetchImpl = fetch) {
+  const res = await fetchImpl(`${CLERK_API}/v1/users/${encodeURIComponent(id4)}/metadata`, {
     method: "PATCH",
     headers: { authorization: `Bearer ${secretKey}`, "content-type": "application/json" },
     body: JSON.stringify({ public_metadata: { role } })
@@ -2556,15 +3113,15 @@ function rowToTier(row, groupId) {
 }
 async function loadTiers(db, group) {
   const groupId = String(group.id ?? "");
-  let rows;
+  let rows2;
   try {
-    rows = (await db.query({
+    rows2 = (await db.query({
       tiers: { $: { where: { groupId }, order: { sortOrder: "asc" }, limit: 100 } }
     })).tiers;
   } catch {
-    rows = void 0;
+    rows2 = void 0;
   }
-  const list = Array.isArray(rows) ? rows.map((row) => rowToTier(row, groupId)) : [];
+  const list = Array.isArray(rows2) ? rows2.map((row) => rowToTier(row, groupId)) : [];
   return resolveTiers(group, list);
 }
 async function loadOfferableTiers(db, group, hasSecretKey) {
@@ -2575,32 +3132,6 @@ async function loadOfferableTiers(db, group, hasSecretKey) {
 var SIGNUP_CONTROL_SCHEMA_VERSION = 1;
 var SIGNUP_CONTROL_PATH = "/api/signup-control";
 
-// src/signup-control-canonical.ts
-var encoder = new TextEncoder();
-function canonicalValue(value) {
-  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) return `[${value.map(canonicalValue).join(",")}]`;
-  if (typeof value !== "object") throw new TypeError("signup control contains an unsupported value");
-  const record = value;
-  const entries = Object.keys(record).sort().flatMap((key) => {
-    const item = record[key];
-    return item === void 0 ? [] : [`${JSON.stringify(key)}:${canonicalValue(item)}`];
-  });
-  return `{${entries.join(",")}}`;
-}
-function canonicalSignupControl(value) {
-  return canonicalValue(value);
-}
-async function signupControlDigest(document) {
-  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(canonicalSignupControl(document)));
-  return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
-}
-async function createSignupControlEnvelope(document) {
-  return { document, digest: await signupControlDigest(document) };
-}
-
 // src/membership-page.ts
 var MEMBERSHIP_PAGE_RENDERER = "membership-cards-v1";
 var TIER_ID = /^[a-z][a-z0-9-]{0,79}$/;
@@ -2641,10 +3172,10 @@ function boundedString(value, path, errors, max, required = false) {
     errors.push(`${path} must be a string`);
     return void 0;
   }
-  const text2 = value.trim();
-  if (required && !text2) errors.push(`${path} is required`);
-  if (text2.length > max) errors.push(`${path} must be at most ${max.toLocaleString("en-US")} characters`);
-  return text2;
+  const text3 = value.trim();
+  if (required && !text3) errors.push(`${path} is required`);
+  if (text3.length > max) errors.push(`${path} must be at most ${max.toLocaleString("en-US")} characters`);
+  return text3;
 }
 function validateMembershipPageDocument(input, options = {}) {
   const errors = [];
@@ -2693,8 +3224,8 @@ function validateMembershipPageDocument(input, options = {}) {
       else {
         if (item.benefits.length > MAX_BENEFITS) errors.push(`${path}.benefits supports at most ${MAX_BENEFITS} entries`);
         benefits = item.benefits.slice(0, MAX_BENEFITS).flatMap((benefit, benefitIndex) => {
-          const text2 = boundedString(benefit, `${path}.benefits[${benefitIndex}]`, errors, 2e3, true);
-          return text2 ? [text2] : [];
+          const text3 = boundedString(benefit, `${path}.benefits[${benefitIndex}]`, errors, 2e3, true);
+          return text3 ? [text3] : [];
         });
       }
     }
@@ -2773,7 +3304,7 @@ function membershipPageDocument(input, options = {}) {
 var SLUG4 = /^[a-z0-9][a-z0-9-]{1,62}$/;
 var ENVIRONMENT = /^[a-z][a-z0-9_-]{0,62}$/;
 var TIER = /^[a-z][a-z0-9-]{0,79}$/;
-var PRICE = /^price_[A-Za-z0-9]{12,}$/;
+var PRICE2 = /^price_[A-Za-z0-9]{12,}$/;
 var ROOT_KEYS2 = /* @__PURE__ */ new Set([
   "schemaVersion",
   "revision",
@@ -2785,14 +3316,15 @@ var ROOT_KEYS2 = /* @__PURE__ */ new Set([
   "application",
   "policy",
   "scheduling",
-  "theme"
+  "theme",
+  "giftOffers"
 ]);
 var TIER_KEYS2 = /* @__PURE__ */ new Set(["id", "name", "available", "sortOrder", "priceCents", "stripePriceId", "blurb"]);
 var recordOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 function unknownKeys(value, allowed, path, errors) {
   for (const key of Object.keys(value)) if (!allowed.has(key)) errors.push(`${path}.${key} is not supported`);
 }
-function text(value, path, errors, max = 65536) {
+function text2(value, path, errors, max = 65536) {
   if (typeof value !== "string" || !value.trim()) {
     errors.push(`${path} is required`);
     return "";
@@ -2815,25 +3347,25 @@ function tiersOf(value, errors) {
       return [];
     }
     unknownKeys(item, TIER_KEYS2, path, errors);
-    const id2 = text(item.id, `${path}.id`, errors, 80);
-    if (id2 && !TIER.test(id2)) errors.push(`${path}.id must be a lowercase kebab-case id`);
-    if (seen.has(id2)) errors.push(`${path}.id duplicates "${id2}"`);
-    seen.add(id2);
-    const name = text(item.name, `${path}.name`, errors, 160);
+    const id4 = text2(item.id, `${path}.id`, errors, 80);
+    if (id4 && !TIER.test(id4)) errors.push(`${path}.id must be a lowercase kebab-case id`);
+    if (seen.has(id4)) errors.push(`${path}.id duplicates "${id4}"`);
+    seen.add(id4);
+    const name = text2(item.name, `${path}.name`, errors, 160);
     if (typeof item.available !== "boolean") errors.push(`${path}.available must be boolean`);
     if (!Number.isInteger(item.sortOrder) || Number(item.sortOrder) < 0) errors.push(`${path}.sortOrder must be a non-negative integer`);
     if (!Number.isInteger(item.priceCents) || Number(item.priceCents) < 0 || Number(item.priceCents) > 1e8) {
       errors.push(`${path}.priceCents must be an integer from 0 to 100,000,000`);
     }
-    if (item.stripePriceId !== void 0 && (typeof item.stripePriceId !== "string" || !PRICE.test(item.stripePriceId))) {
+    if (item.stripePriceId !== void 0 && (typeof item.stripePriceId !== "string" || !PRICE2.test(item.stripePriceId))) {
       errors.push(`${path}.stripePriceId must be a real Stripe Price id`);
     }
     if (item.available === true && Number(item.priceCents) > 0 && !item.stripePriceId) {
       errors.push(`${path}.stripePriceId is required for an available paid tier`);
     }
-    const blurb = item.blurb === void 0 ? void 0 : text(item.blurb, `${path}.blurb`, errors, 4e3);
+    const blurb = item.blurb === void 0 ? void 0 : text2(item.blurb, `${path}.blurb`, errors, 4e3);
     return [{
-      id: id2,
+      id: id4,
       name,
       available: item.available === true,
       sortOrder: Number(item.sortOrder) || 0,
@@ -2880,7 +3412,7 @@ function policyOf(value, errors) {
   const result = {};
   for (const key of allowed) {
     if (input[key] === void 0 && key !== "disclaimerText" && key !== "refundPolicyText") continue;
-    result[key] = text(input[key], `document.policy.${key}`, errors);
+    result[key] = text2(input[key], `document.policy.${key}`, errors);
   }
   return result;
 }
@@ -2894,12 +3426,18 @@ function themeOf(value, errors) {
   }
   unknownKeys(input, /* @__PURE__ */ new Set(["tokens"]), "document.theme", errors);
   if (Object.keys(tokens).length > 256) errors.push("document.theme.tokens supports at most 256 entries");
+  let serializedLength = 0;
   for (const [key, token] of Object.entries(tokens)) {
-    if (!/^--[a-z0-9-]{1,100}$/.test(key)) errors.push(`document.theme.tokens.${key} must be a CSS custom-property name`);
-    if (typeof token !== "string" && typeof token !== "number" || String(token).length > 1e3) {
-      errors.push(`document.theme.tokens.${key} must be a bounded string or number`);
+    if (!/^--ui-[a-z0-9][a-z0-9-]{0,94}$/.test(key)) {
+      errors.push(`document.theme.tokens.${key} must be an allowlisted --ui-* custom property`);
+    }
+    const rendered = String(token).trim();
+    serializedLength += key.length + rendered.length + 4;
+    if (typeof token !== "string" && typeof token !== "number" || typeof token === "number" && !Number.isFinite(token) || !rendered || rendered.length > 1e3 || /[\u0000-\u001f\u007f\\<>{};]|\/\*|\*\/|(?:^|[^a-z])(?:url|expression)\s*\(|@import/i.test(rendered)) {
+      errors.push(`document.theme.tokens.${key} must be a bounded breakout-safe CSS value`);
     }
   }
+  if (serializedLength > 65536) errors.push("document.theme.tokens exceeds the serialized size bound");
   return { tokens };
 }
 function validateSignupControlDocument(input) {
@@ -2912,9 +3450,9 @@ function validateSignupControlDocument(input) {
   if (!Number.isSafeInteger(root.generatedAt) || Number(root.generatedAt) < 1) errors.push("document.generatedAt must be epoch milliseconds");
   const source = recordOf(root.source);
   const target = recordOf(root.target);
-  const appId = text(source?.appId, "document.source.appId", errors, 63);
-  const chapterId = text(target?.chapterId, "document.target.chapterId", errors, 63);
-  const environment = text(target?.environment, "document.target.environment", errors, 63);
+  const appId = text2(source?.appId, "document.source.appId", errors, 63);
+  const chapterId = text2(target?.chapterId, "document.target.chapterId", errors, 63);
+  const environment = text2(target?.environment, "document.target.environment", errors, 63);
   if (appId && !SLUG4.test(appId)) errors.push("document.source.appId must be a lowercase app slug");
   if (chapterId && !SLUG4.test(chapterId)) errors.push("document.target.chapterId must be a lowercase app slug");
   if (environment && !ENVIRONMENT.test(environment)) errors.push("document.target.environment is invalid");
@@ -2935,6 +3473,8 @@ function validateSignupControlDocument(input) {
     else scheduling = root.scheduling;
   }
   const theme = themeOf(root.theme, errors);
+  const giftOffers = root.giftOffers === void 0 ? void 0 : validateGiftOfferCatalog(root.giftOffers, new Set(tiers2.map((tier) => tier.id)));
+  if (giftOffers && !giftOffers.ok) errors.push(...giftOffers.errors);
   if (errors.length || !page.ok) return { ok: false, errors };
   return { ok: true, value: {
     schemaVersion: 1,
@@ -2947,10 +3487,121 @@ function validateSignupControlDocument(input) {
     ...application ? { application } : {},
     ...policy ? { policy } : {},
     ...scheduling ? { scheduling } : {},
-    ...theme ? { theme } : {}
+    ...theme ? { theme } : {},
+    ...giftOffers?.ok ? { giftOffers: giftOffers.value } : {}
   } };
 }
 
+// src/signup-control-theme.ts
+var SIGNUP_CONTROL_THEME_MARKER = "<!--odla:signup-control-theme-->";
+var SIGNUP_CONTROL_THEME_STYLE_ID = "odla-signup-control-theme";
+var TOKEN_NAME = /^--ui-[a-z0-9][a-z0-9-]{0,94}$/;
+var DIGEST = /^sha256:[0-9a-f]{64}$/;
+var UNSAFE_VALUE = /[\u0000-\u001f\u007f\\<>{};]|\/\*|\*\/|(?:^|[^a-z])(?:url|expression)\s*\(|@import/i;
+var MAX_TOKENS = 256;
+var MAX_VALUE_LENGTH = 1e3;
+var MAX_SERIALIZED_LENGTH = 65536;
+function validatedTokens(input) {
+  const entries = Object.entries(input ?? {});
+  if (entries.length > MAX_TOKENS) {
+    throw new TypeError(`signup-control theme supports at most ${MAX_TOKENS} tokens`);
+  }
+  const tokens = {};
+  let serializedLength = 0;
+  for (const [name, raw] of entries.sort(([left], [right]) => left.localeCompare(right))) {
+    if (!TOKEN_NAME.test(name)) {
+      throw new TypeError(`signup-control theme token "${name}" must be an allowlisted --ui-* property`);
+    }
+    if (typeof raw !== "string" && typeof raw !== "number" || typeof raw === "number" && !Number.isFinite(raw)) {
+      throw new TypeError(`signup-control theme token "${name}" must be a finite string or number`);
+    }
+    const value = String(raw).trim();
+    if (!value || value.length > MAX_VALUE_LENGTH || UNSAFE_VALUE.test(value)) {
+      throw new TypeError(`signup-control theme token "${name}" has an unsafe or oversized value`);
+    }
+    serializedLength += name.length + value.length + 4;
+    if (serializedLength > MAX_SERIALIZED_LENGTH) {
+      throw new TypeError("signup-control theme exceeds the serialized size bound");
+    }
+    tokens[name] = value;
+  }
+  return tokens;
+}
+function cssFor(tokens) {
+  const declarations = Object.entries(tokens).map(([name, value]) => `  ${name}: ${value};`);
+  return declarations.length ? `:root {
+${declarations.join("\n")}
+}` : "";
+}
+function stateFor(revision, options) {
+  if (!revision) {
+    return {
+      css: cssFor(validatedTokens(options.bootstrapTokens)),
+      metadata: { source: "bootstrap", revision: null, digest: null, cacheKey: "signup-control:bootstrap" }
+    };
+  }
+  if (!Number.isSafeInteger(revision.revision) || revision.revision < 1 || !DIGEST.test(revision.digest)) {
+    throw new TypeError("signup-control theme revision metadata is invalid");
+  }
+  return {
+    css: cssFor(validatedTokens(revision.theme?.tokens)),
+    metadata: {
+      source: "active",
+      revision: revision.revision,
+      digest: revision.digest,
+      cacheKey: `signup-control:${revision.digest}`
+    }
+  };
+}
+function attributes(metadata) {
+  return [
+    `id="${SIGNUP_CONTROL_THEME_STYLE_ID}"`,
+    `data-signup-control-source="${metadata.source}"`,
+    `data-signup-control-cache-key="${metadata.cacheKey}"`,
+    ...metadata.revision === null ? [] : [`data-signup-control-revision="${metadata.revision}"`],
+    ...metadata.digest === null ? [] : [`data-signup-control-digest="${metadata.digest}"`]
+  ].join(" ");
+}
+function renderSignupControlThemeHead(revision, options = {}) {
+  const { css, metadata } = stateFor(revision, options);
+  return { css, metadata, head: `<style ${attributes(metadata)}>${css}</style>` };
+}
+function injectSignupControlThemeHead(html, rendered, marker = SIGNUP_CONTROL_THEME_MARKER) {
+  const existing = /<style\b(?=[^>]*\bid\s*=\s*["']odla-signup-control-theme["'])[^>]*>[\s\S]*?<\/style>/gi;
+  const existingBlocks = html.match(existing) ?? [];
+  if (existingBlocks.length > 1) {
+    throw new TypeError("signup-control theme style block must appear at most once");
+  }
+  if (existingBlocks.length === 1) return html.replace(existing, rendered.head);
+  const markerIndex = html.indexOf(marker);
+  if (markerIndex >= 0) {
+    if (html.indexOf(marker, markerIndex + marker.length) >= 0) {
+      throw new TypeError("signup-control theme marker must appear exactly once");
+    }
+    return `${html.slice(0, markerIndex)}${rendered.head}${html.slice(markerIndex + marker.length)}`;
+  }
+  const closingHead = html.search(/<\/head\s*>/i);
+  if (closingHead < 0) throw new TypeError("signup-control theme requires an HTML head");
+  return `${html.slice(0, closingHead)}${rendered.head}${html.slice(closingHead)}`;
+}
+function hydrateSignupControlTheme(target, revision, options = {}) {
+  const next = stateFor(revision, options);
+  const currentSource = target.getAttribute("data-signup-control-source");
+  const currentRevision = target.getAttribute("data-signup-control-revision");
+  const currentDigest = target.getAttribute("data-signup-control-digest");
+  if (currentSource === next.metadata.source && currentRevision === (next.metadata.revision === null ? null : String(next.metadata.revision)) && currentDigest === next.metadata.digest) {
+    return false;
+  }
+  target.textContent = next.css;
+  target.setAttribute("data-signup-control-source", next.metadata.source);
+  target.setAttribute("data-signup-control-cache-key", next.metadata.cacheKey);
+  if (next.metadata.revision === null) target.removeAttribute("data-signup-control-revision");
+  else target.setAttribute("data-signup-control-revision", String(next.metadata.revision));
+  if (next.metadata.digest === null) target.removeAttribute("data-signup-control-digest");
+  else target.setAttribute("data-signup-control-digest", next.metadata.digest);
+  return true;
+}
+
 // src/membership-markdown.ts
 var MAX_BENEFITS2 = 24;
 var MAX_MARKDOWN2 = 65536;
@@ -2978,9 +3629,9 @@ function markdownBenefits(lines, path, errors) {
       errors.push(`${path} line ${index + 1} must be a Markdown bullet`);
       continue;
     }
-    const text2 = (match[1] ?? "").trim();
-    if (text2.length > 2e3) errors.push(`${path} line ${index + 1} must be at most 2,000 characters`);
-    if (text2) benefits.push(text2);
+    const text3 = (match[1] ?? "").trim();
+    if (text3.length > 2e3) errors.push(`${path} line ${index + 1} must be at most 2,000 characters`);
+    if (text3) benefits.push(text3);
   }
   if (benefits.length > MAX_BENEFITS2) errors.push(`${path} supports at most ${MAX_BENEFITS2} entries`);
   return benefits.slice(0, MAX_BENEFITS2);
@@ -3082,7 +3733,7 @@ var exclusions = (chapterId, paidTierIds) => [
     id: chapterId,
     reason: "provider_identity",
     paths: [
-      ...paidTierIds.map((id2) => `tiers[${id2}].stripePriceId`),
+      ...paidTierIds.map((id4) => `tiers[${id4}].stripePriceId`),
       "groups.stripePublishableKey",
       "applications.stripeCustomerId",
       "applications.stripeSubscriptionId",
@@ -3124,9 +3775,9 @@ async function exportChapterPromotion(input) {
     sourceIds: [`signup-control:${document.revision}`, document.source.appId, document.target.chapterId].sort(),
     receiptDigests: [input.digest]
   };
-  const artifact = (kind, id2, content) => ({
+  const artifact = (kind, id4, content) => ({
     kind,
-    id: id2,
+    id: id4,
     sourceRevision: revision,
     provenance: promotionProvenance,
     content: canonicalPromotionValue(content)
@@ -3164,13 +3815,19 @@ async function exportChapterPromotion(input) {
   };
 }
 export {
+  ADMISSION_GRANTS_PATH,
+  ADMISSION_GRANTS_SCHEMA_VERSION,
   CHAPTER_PROMOTION_ADAPTER,
   DEFAULT_CHAPTER_COPY,
   DEFAULT_SHARE_FIELDS,
+  GIFT_OFFER_CATALOG_VERSION,
+  MAX_GIFT_OFFERS,
   MEMBERSHIP_PAGE_RENDERER,
   SCHEDULING_DEFAULTS,
   SIGNUP_CONTROL_PATH,
   SIGNUP_CONTROL_SCHEMA_VERSION,
+  SIGNUP_CONTROL_THEME_MARKER,
+  SIGNUP_CONTROL_THEME_STYLE_ID,
   applicantProfile,
   applicationBookingUpdate,
   applicationSummary,
@@ -3197,6 +3854,7 @@ export {
   clerkListUsers,
   clerkSetRole,
   clerkUserRequest,
+  createAdmissionGrantEnvelope,
   createChapterIntegration,
   createClerkInvitation,
   createClerkUser,
@@ -3207,13 +3865,18 @@ export {
   emailGroupFrom,
   endForSlot,
   exportChapterPromotion,
+  findAdmissionGrant,
   findApplicationRef,
+  findGiftOffer,
   findTier,
   firstPaymentPatch,
   formatChapterCopy,
   formationFields,
   getVaultSecret,
+  giftOfferActive,
   hasDisclaimerAck,
+  hydrateSignupControlTheme,
+  injectSignupControlThemeHead,
   introIdempotencyKey,
   isAdminRole,
   isAlreadySent,
@@ -3223,8 +3886,10 @@ export {
   joinConfig,
   joinConfigTiers,
   leaderCrmConfig,
+  loadLatestAdmissionRevision,
   loadOfferableTiers,
   loadTiers,
+  materializeAdmissionGrants,
   meetingCreateRow,
   meetingRescheduleUpdate,
   memberApplication,
@@ -3232,6 +3897,7 @@ export {
   membershipPageDocument,
   membershipTierPresentationFromMarkdown,
   networkSourceTag,
+  normalizeAdmissionEmail,
   normalizeSharedRecord,
   normalizeWebhookEvent,
   offerableTiers,
@@ -3240,15 +3906,18 @@ export {
   planDelivery,
   projectApplicant,
   projectSharedRecord,
+  publicGiftOffers,
   reconcileMeetings,
   refundedPatch,
   render,
+  renderSignupControlThemeHead,
   renderSummary,
   renderTemplateBody,
   renewalPatch,
   resolveApplication,
   resolveAuth,
   resolveChapterCopy,
+  resolveJoinContinuation,
   resolveLeaderFormation,
   resolvePipeline,
   resolveScheduling,
@@ -3271,6 +3940,8 @@ export {
   tierPayable,
   updateClerkUserMetadata,
   updateClerkUserMetadataByEmail,
+  validateAdmissionGrantDocument,
+  validateGiftOfferCatalog,
   validateMembershipPageDocument,
   validateScheduling,
   validateSignupControlDocument,