@odla-ai/chapter 0.32.2 → 0.33.0

package/dist/index.js

@@ -188,6 +188,19 @@ var networkNotes = {
     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(),
@@ -335,7 +348,7 @@ var emailLog = {
     sentAt: attr("number", { indexed: true })
   }
 };
-function chapterDb(mode, auth, includeNetworkNotes = false, application = resolveApplication(void 0)) {
+function chapterDb(mode, auth, includeNetworkNotes = false, application = resolveApplication(void 0), includeSignupControl = false) {
   const entities = {};
   if (mode === "chapter") {
     entities.applications = applicationsFor(application);
@@ -343,6 +356,7 @@ function chapterDb(mode, auth, includeNetworkNotes = false, application = resolv
     entities.tiers = tiers;
     entities.meetings = meetings;
     entities.emailLog = emailLog;
+    if (includeSignupControl) entities.signupControls = signupControls;
   }
   if (auth.source === "table") entities.admins = admins;
   if (auth.superAdmins) entities.superAdmins = superAdmins;
@@ -1116,15 +1130,33 @@ function resolveNetwork(config, crm) {
   return { targets, readers };
 }
 
-// src/config.ts
+// src/config-signup-control.ts
 var SLUG2 = /^[a-z0-9][a-z0-9-]{1,62}$/;
+var SECRET_NAME = /^[a-z][a-z0-9_]{1,127}$/;
+function resolveSignupControl(input) {
+  if (!input) return null;
+  if (!SLUG2.test(input.sourceId)) {
+    throw new Error("defineChapter.signupControl.sourceId: must be a lowercase app slug");
+  }
+  if (input.stripeMode !== "test" && input.stripeMode !== "live") {
+    throw new Error('defineChapter.signupControl.stripeMode: must be "test" or "live"');
+  }
+  const secretName = input.secretName?.trim() || "signup_control_secret";
+  if (!SECRET_NAME.test(secretName)) {
+    throw new Error("defineChapter.signupControl.secretName: must be a vault-key identifier");
+  }
+  return { sourceId: input.sourceId, secretName, stripeMode: input.stripeMode };
+}
+
+// src/config.ts
+var SLUG3 = /^[a-z0-9][a-z0-9-]{1,62}$/;
 function isResolvedCrm(x) {
   return !!x && typeof x === "object" && "prepare" in x && typeof x.prepare === "function";
 }
 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" || !SLUG2.test(id2)) {
+  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)}`);
   }
   if (typeof name !== "string" || name.trim() === "") throw new Error("defineChapter.name: a non-empty name is required");
@@ -1148,8 +1180,18 @@ function defineChapter(config) {
   const brand = { ...config.brand, wordmark: config.brand?.wordmark ?? name };
   const copy = resolveChapterCopy(config.copy);
   const network = resolveNetwork(config, crm);
+  const signupControl = resolveSignupControl(config.signupControl);
   const formation = resolveLeaderFormation(config.formation, crm);
-  const { schema, rules } = chapterDb(mode, auth, network.targets.length > 0, application);
+  if (signupControl && mode !== "chapter") {
+    throw new Error("defineChapter.signupControl: only chapter-mode followers can receive signup control");
+  }
+  const { schema, rules } = chapterDb(
+    mode,
+    auth,
+    network.targets.length > 0,
+    application,
+    Boolean(signupControl)
+  );
   const services = config.services ?? ["db", "calendar", "o11y"];
   const account = config.account ?? "none";
   if (account !== "invite" && account !== "create" && account !== "none") {
@@ -1204,6 +1246,7 @@ function defineChapter(config) {
     brand,
     copy,
     network,
+    signupControl,
     formation,
     crm,
     auth,
@@ -1534,10 +1577,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 text = redirect ? `(dev redirect; original recipient: ${input.to})
+  const text2 = redirect ? `(dev redirect; original recipient: ${input.to})
 
 ` + render(tpl.text, vars) : render(tpl.text, vars);
-  return { deliver: true, transport, to, subject, text, redirected: redirect };
+  return { deliver: true, transport, to, subject, text: text2, redirected: redirect };
 }
 
 // src/notify.ts
@@ -2528,6 +2571,36 @@ async function loadOfferableTiers(db, group, hasSecretKey) {
   return offerableTiers(await loadTiers(db, group), group, hasSecretKey);
 }
 
+// src/signup-control-contract.ts
+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}$/;
@@ -2568,10 +2641,10 @@ function boundedString(value, path, errors, max, required = false) {
     errors.push(`${path} must be a string`);
     return void 0;
   }
-  const text = value.trim();
-  if (required && !text) errors.push(`${path} is required`);
-  if (text.length > max) errors.push(`${path} must be at most ${max.toLocaleString("en-US")} characters`);
-  return text;
+  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;
 }
 function validateMembershipPageDocument(input, options = {}) {
   const errors = [];
@@ -2620,8 +2693,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 text = boundedString(benefit, `${path}.benefits[${benefitIndex}]`, errors, 2e3, true);
-          return text ? [text] : [];
+          const text2 = boundedString(benefit, `${path}.benefits[${benefitIndex}]`, errors, 2e3, true);
+          return text2 ? [text2] : [];
         });
       }
     }
@@ -2696,6 +2769,188 @@ function membershipPageDocument(input, options = {}) {
   return result.value;
 }
 
+// src/signup-control-validate.ts
+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 ROOT_KEYS2 = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "revision",
+  "generatedAt",
+  "source",
+  "target",
+  "tiers",
+  "membershipPage",
+  "application",
+  "policy",
+  "scheduling",
+  "theme"
+]);
+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) {
+  if (typeof value !== "string" || !value.trim()) {
+    errors.push(`${path} is required`);
+    return "";
+  }
+  if (value.length > max) errors.push(`${path} must be at most ${max} characters`);
+  return value.trim();
+}
+function tiersOf(value, errors) {
+  if (!Array.isArray(value) || !value.length) {
+    errors.push("document.tiers must be a non-empty array");
+    return [];
+  }
+  if (value.length > 20) errors.push("document.tiers supports at most 20 entries");
+  const seen = /* @__PURE__ */ new Set();
+  return value.slice(0, 20).flatMap((raw, index) => {
+    const path = `document.tiers[${index}]`;
+    const item = recordOf(raw);
+    if (!item) {
+      errors.push(`${path} must be an object`);
+      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);
+    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))) {
+      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);
+    return [{
+      id: id2,
+      name,
+      available: item.available === true,
+      sortOrder: Number(item.sortOrder) || 0,
+      priceCents: Number(item.priceCents) || 0,
+      ...typeof item.stripePriceId === "string" ? { stripePriceId: item.stripePriceId } : {},
+      ...blurb ? { blurb } : {}
+    }];
+  });
+}
+function applicationOf(value, errors) {
+  if (value === void 0) return void 0;
+  const input = recordOf(value);
+  if (!input) {
+    errors.push("document.application must be an object");
+    return void 0;
+  }
+  unknownKeys(input, /* @__PURE__ */ new Set(["required", "optional", "conditions", "copy"]), "document.application", errors);
+  try {
+    const resolved = resolveApplication(input);
+    const copy = recordOf(input.copy);
+    if (input.copy !== void 0 && (!copy || Object.values(copy).some((item) => typeof item !== "string"))) {
+      errors.push("document.application.copy must contain only string values");
+    }
+    return {
+      required: resolved.required,
+      optional: resolved.optional,
+      ...Object.keys(resolved.conditions).length ? { conditions: resolved.conditions } : {},
+      ...copy ? { copy } : {}
+    };
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : "document.application is invalid");
+    return void 0;
+  }
+}
+function policyOf(value, errors) {
+  if (value === void 0) return void 0;
+  const input = recordOf(value);
+  if (!input) {
+    errors.push("document.policy must be an object");
+    return void 0;
+  }
+  const allowed = /* @__PURE__ */ new Set(["disclaimerText", "refundPolicyText", "trustCopy", "commitmentText", "normsText"]);
+  unknownKeys(input, allowed, "document.policy", 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);
+  }
+  return result;
+}
+function themeOf(value, errors) {
+  if (value === void 0) return void 0;
+  const input = recordOf(value);
+  const tokens = recordOf(input?.tokens);
+  if (!input || !tokens) {
+    errors.push("document.theme.tokens must be an object");
+    return void 0;
+  }
+  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");
+  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`);
+    }
+  }
+  return { tokens };
+}
+function validateSignupControlDocument(input) {
+  const errors = [];
+  const root = recordOf(input);
+  if (!root) return { ok: false, errors: ["document must be an object"] };
+  unknownKeys(root, ROOT_KEYS2, "document", errors);
+  if (root.schemaVersion !== 1) errors.push("document.schemaVersion must be 1");
+  if (!Number.isSafeInteger(root.revision) || Number(root.revision) < 1) errors.push("document.revision must be a positive integer");
+  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);
+  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");
+  if (target?.stripeMode !== "test" && target?.stripeMode !== "live") errors.push("document.target.stripeMode must be test or live");
+  const tiers2 = tiersOf(root.tiers, errors);
+  const available = tiers2.filter((tier) => tier.available).sort((a, b) => a.sortOrder - b.sortOrder);
+  const page = validateMembershipPageDocument(root.membershipPage, { tiers: available });
+  if (!page.ok) errors.push(...page.errors);
+  else if (page.value.tiers.some((tier, index) => tier.tierId !== available[index]?.id)) {
+    errors.push("document.membershipPage.tiers must follow the available tier display order");
+  }
+  const application = applicationOf(root.application, errors);
+  const policy = policyOf(root.policy, errors);
+  let scheduling;
+  if (root.scheduling !== void 0) {
+    const checked = validateScheduling(root.scheduling);
+    if (!checked.ok) errors.push(...Object.entries(checked.errors).map(([key, value]) => `document.scheduling.${key}: ${value}`));
+    else scheduling = root.scheduling;
+  }
+  const theme = themeOf(root.theme, errors);
+  if (errors.length || !page.ok) return { ok: false, errors };
+  return { ok: true, value: {
+    schemaVersion: 1,
+    revision: Number(root.revision),
+    generatedAt: Number(root.generatedAt),
+    source: { appId },
+    target: { chapterId, environment, stripeMode: target?.stripeMode },
+    tiers: tiers2,
+    membershipPage: page.value,
+    ...application ? { application } : {},
+    ...policy ? { policy } : {},
+    ...scheduling ? { scheduling } : {},
+    ...theme ? { theme } : {}
+  } };
+}
+
 // src/membership-markdown.ts
 var MAX_BENEFITS2 = 24;
 var MAX_MARKDOWN2 = 65536;
@@ -2723,9 +2978,9 @@ function markdownBenefits(lines, path, errors) {
       errors.push(`${path} line ${index + 1} must be a Markdown bullet`);
       continue;
     }
-    const text = (match[1] ?? "").trim();
-    if (text.length > 2e3) errors.push(`${path} line ${index + 1} must be at most 2,000 characters`);
-    if (text) benefits.push(text);
+    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);
   }
   if (benefits.length > MAX_BENEFITS2) errors.push(`${path} supports at most ${MAX_BENEFITS2} entries`);
   return benefits.slice(0, MAX_BENEFITS2);
@@ -2820,6 +3075,8 @@ export {
   DEFAULT_SHARE_FIELDS,
   MEMBERSHIP_PAGE_RENDERER,
   SCHEDULING_DEFAULTS,
+  SIGNUP_CONTROL_PATH,
+  SIGNUP_CONTROL_SCHEMA_VERSION,
   applicantProfile,
   applicationBookingUpdate,
   applicationSummary,
@@ -2835,6 +3092,7 @@ export {
   canChangeRole,
   canTransition,
   canceledPatch,
+  canonicalSignupControl,
   chapterBrandFromTokens,
   chapterDb,
   clampArray,
@@ -2848,6 +3106,7 @@ export {
   createChapterIntegration,
   createClerkInvitation,
   createClerkUser,
+  createSignupControlEnvelope,
   dashboardMetricData,
   defaultCrm,
   defineChapter,
@@ -2898,11 +3157,13 @@ export {
   resolveLeaderFormation,
   resolvePipeline,
   resolveScheduling,
+  resolveSignupControl,
   resolveTiers,
   roleFromClaim,
   sendTemplated,
   sharedPersonInput,
   sharedRecordFromCrm,
+  signupControlDigest,
   slotWindow,
   stageIndex,
   stripeCall,
@@ -2917,6 +3178,7 @@ export {
   updateClerkUserMetadataByEmail,
   validateMembershipPageDocument,
   validateScheduling,
+  validateSignupControlDocument,
   verifyStripeSignature,
   webhookMutationId
 };