@odla-ai/chapter 0.15.0 → 0.16.0

package/dist/worker/index.js

@@ -10,6 +10,23 @@ function roleFromClaim(payload, auth) {
 function isAdminRole(role, auth) {
   return role === auth.adminRole;
 }
+function canChangeRole(ctx) {
+  const { auth } = ctx;
+  if (!auth.ladder.includes(ctx.newRole)) {
+    return { ok: false, status: 400, error: `role must be one of: ${auth.ladder.join(", ")}` };
+  }
+  if (ctx.actorId === ctx.targetId) {
+    return { ok: false, status: 400, error: "you cannot change your own role" };
+  }
+  if (ctx.targetIsSuper && !ctx.actorIsSuper) {
+    return { ok: false, status: 403, error: "this person is a super-admin; their access is managed in odla Studio" };
+  }
+  const touchesAdmin = ctx.newRole === auth.adminRole || ctx.targetCurrentRole === auth.adminRole;
+  if (auth.superAdmins && touchesAdmin && !ctx.actorIsSuper) {
+    return { ok: false, status: 403, error: `only super-admins can create or change an ${auth.adminRole}` };
+  }
+  return { ok: true };
+}
 async function getVaultSecret(db, name) {
   try {
     const value = await db.secrets.get(name);
@@ -243,14 +260,14 @@ function sharedPersonInput(person) {
 }
 async function upsertPerson(deps, opts) {
   const email = opts.email.toLowerCase();
-  const crmDeps = { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId };
+  const crmDeps3 = { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId };
   const { crm_record } = await deps.db.query({ crm_record: { $: { where: { type: "person", primaryEmail: email }, limit: 1 } } });
   const existing = crm_record?.[0];
   if (existing && typeof existing.id === "string") {
-    await updateRecord(crmDeps, { id: existing.id, input: opts.input });
+    await updateRecord(crmDeps3, { id: existing.id, input: opts.input });
     return { recordId: existing.id };
   }
-  const created = await createRecord(crmDeps, { type: "person", input: opts.input, mutationId: opts.mutationId });
+  const created = await createRecord(crmDeps3, { type: "person", input: opts.input, mutationId: opts.mutationId });
   return { recordId: created.id };
 }
 async function projectSharedRecord(deps, person) {
@@ -426,6 +443,11 @@ function groupVars(group, vars) {
     normsText: group.normsText ?? ""
   };
 }
+function renderTemplateBody(group, template, vars) {
+  const tpl = group.emailTemplates?.[template];
+  if (!tpl) return null;
+  return render(tpl.text, groupVars(group, vars));
+}
 function isAlreadySent(priorRows) {
   return priorRows.some((row) => !row.error);
 }
@@ -446,6 +468,7 @@ function planDelivery(input) {
 }
 
 // src/notify.ts
+var EMAIL_TEMPLATE_NAMES = ["adminNotification", "paymentConfirmation", "prepEmail", "onboardingInvite"];
 async function sendTemplated(deps, input) {
   const { emailLog } = await deps.db.query({ emailLog: { $: { where: { dedupeKey: input.dedupeKey } } } });
   const prior = Array.isArray(emailLog) ? emailLog : [];
@@ -497,16 +520,16 @@ async function sendTemplated(deps, input) {
   return error ? { sent: false, reason: error } : { sent: true };
 }
 function emailGroupFrom(row) {
-  const str = (v) => typeof v === "string" ? v : void 0;
+  const str3 = (v) => typeof v === "string" ? v : void 0;
   const templates = row.emailTemplates && typeof row.emailTemplates === "object" ? row.emailTemplates : {};
   return {
     id: String(row.id),
     name: String(row.name ?? ""),
-    replyTo: str(row.replyTo) ?? "",
-    debugEmail: str(row.debugEmail),
-    refundPolicyText: str(row.refundPolicyText),
-    commitmentText: str(row.commitmentText),
-    normsText: str(row.normsText),
+    replyTo: str3(row.replyTo) ?? "",
+    debugEmail: str3(row.debugEmail),
+    refundPolicyText: str3(row.refundPolicyText),
+    commitmentText: str3(row.commitmentText),
+    normsText: str3(row.normsText),
     emailTemplates: templates
   };
 }
@@ -694,9 +717,17 @@ var handleMember = async (req, url, env, ctx) => {
 import { computeBookableSlots, initCalendar } from "@odla-ai/calendar";
 
 // src/pipeline.ts
+function canTransition(from, to, p) {
+  const fi = p.stages.indexOf(from);
+  const ti = p.stages.indexOf(to);
+  return fi >= 0 && ti >= 0 && ti >= fi;
+}
 function canBook(status, p) {
   return p.bookableFrom.includes(status);
 }
+function canApprove(status, p) {
+  return p.approvableFrom.includes(status);
+}
 
 // src/worker-routes-schedule.ts
 function errCode(err) {
@@ -711,8 +742,8 @@ function makeCalendar(env) {
 }
 async function firstRow(db, ns, q) {
   const res = await db.query({ [ns]: { $: q } });
-  const rows = res[ns];
-  return Array.isArray(rows) ? rows[0] : void 0;
+  const rows2 = res[ns];
+  return Array.isArray(rows2) ? rows2[0] : void 0;
 }
 async function computeSlots(cal, cfg) {
   const { from, to } = slotWindow(Date.now(), cfg.windowDays);
@@ -1005,8 +1036,8 @@ function createStripeProvider(config) {
       const sk = requireSecret(secretKey);
       const charges = await stripeCall(sk, "GET", "/v1/charges", { customer: input.customerId, limit: 100 });
       if (!charges.ok) fail("charges list", charges);
-      const rows = charges.body.data ?? [];
-      const paid = rows.filter((c) => c.status === "succeeded" && c.refunded !== true);
+      const rows2 = charges.body.data ?? [];
+      const paid = rows2.filter((c) => c.status === "succeeded" && c.refunded !== true);
       const charge = paid[paid.length - 1];
       if (!charge) {
         const err = new Error("no paid charge to refund");
@@ -1026,8 +1057,8 @@ function createStripeProvider(config) {
 var codeOf = (err) => err && typeof err === "object" && typeof err.code === "string" ? err.code : "unknown";
 async function firstRow2(db, ns, q) {
   const res = await db.query({ [ns]: { $: q } });
-  const rows = res[ns];
-  return Array.isArray(rows) ? rows[0] : void 0;
+  const rows2 = res[ns];
+  return Array.isArray(rows2) ? rows2[0] : void 0;
 }
 function lineItems(group) {
   const standard = Number(group.standardPriceCents ?? 0);
@@ -1262,8 +1293,8 @@ async function upcomingEvents(env) {
   const res = await cal.availability.upcoming();
   return res.events.map((e) => ({ eventId: e.eventId, status: e.status, startAt: e.startAt, endAt: e.endAt }));
 }
-function toReconcile(rows) {
-  return rows.map((m) => ({
+function toReconcile(rows2) {
+  return rows2.map((m) => ({
     id: String(m.id),
     applicationId: String(m.applicationId),
     googleEventId: typeof m.googleEventId === "string" ? m.googleEventId : null,
@@ -1284,12 +1315,12 @@ var handleAdminMeetings = async (req, url, env, ctx) => {
   const query = await db.query({
     meetings: { $: { where: all ? {} : { status: "scheduled" }, order: { startAt: "asc" }, limit: 500 } }
   });
-  let rows = Array.isArray(query.meetings) ? query.meetings : [];
-  if (Number.isFinite(from)) rows = rows.filter((m) => Number(m.startAt ?? 0) >= from);
-  if (Number.isFinite(to)) rows = rows.filter((m) => Number(m.startAt ?? 0) <= to);
+  let rows2 = Array.isArray(query.meetings) ? query.meetings : [];
+  if (Number.isFinite(from)) rows2 = rows2.filter((m) => Number(m.startAt ?? 0) >= from);
+  if (Number.isFinite(to)) rows2 = rows2.filter((m) => Number(m.startAt ?? 0) <= to);
   let decisions = [];
   try {
-    decisions = reconcileMeetings(toReconcile(rows), await upcomingEvents(env), Date.now());
+    decisions = reconcileMeetings(toReconcile(rows2), await upcomingEvents(env), Date.now());
   } catch {
   }
   const patched = /* @__PURE__ */ new Map();
@@ -1316,10 +1347,757 @@ var handleAdminMeetings = async (req, url, env, ctx) => {
   };
   const group = (await db.query({ groups: { $: { where: { id: ctx.chapter.id }, limit: 1 } } })).groups?.[0];
   const timezone = resolveScheduling(group?.schedulingJson).timezone;
-  const meetings = rows.map((m) => ({ ...m, ...patched.get(String(m.id)) ?? {}, applicant: applicantOf(m) })).filter((m) => all || m.status === "scheduled");
+  const meetings = rows2.map((m) => ({ ...m, ...patched.get(String(m.id)) ?? {}, applicant: applicantOf(m) })).filter((m) => all || m.status === "scheduled");
   return json({ meetings, adopted: decisions.length, timezone });
 };
 
+// src/clerk-roles.ts
+var CLERK_API = "https://api.clerk.com";
+var DEFAULT_ROLE = "provisional";
+var PAGE = 100;
+function toRecord(u) {
+  if (typeof u.id !== "string") return null;
+  const pm = u.public_metadata ?? {};
+  const role = typeof pm.role === "string" && pm.role ? pm.role : DEFAULT_ROLE;
+  const email = u.email_addresses?.[0]?.email_address;
+  return { id: u.id, email: typeof email === "string" ? email : void 0, role, publicMetadata: pm };
+}
+async function clerkGet(path, secretKey, fetchImpl) {
+  const res = await fetchImpl(`${CLERK_API}${path}`, { headers: { authorization: `Bearer ${secretKey}` } });
+  if (!res.ok) throw new Error(`clerk GET ${path} \u2192 ${res.status}`);
+  return res.json();
+}
+async function clerkGetUserByEmail(secretKey, email, fetchImpl = fetch) {
+  const data = await clerkGet(`/v1/users?email_address=${encodeURIComponent(email)}&limit=1`, secretKey, fetchImpl).catch(() => null);
+  const user = Array.isArray(data) ? data[0] : void 0;
+  return user ? toRecord(user) : null;
+}
+async function clerkGetUser(secretKey, id, fetchImpl = fetch) {
+  const data = await clerkGet(`/v1/users/${encodeURIComponent(id)}`, secretKey, fetchImpl).catch(() => null);
+  return data ? toRecord(data) : null;
+}
+async function clerkListUsers(secretKey, fetchImpl = fetch) {
+  const out = [];
+  for (let offset = 0; ; offset += PAGE) {
+    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);
+    }
+    if (page.length < PAGE) break;
+  }
+  return out;
+}
+async function clerkSetRole(secretKey, id, role, fetchImpl = fetch) {
+  const res = await fetchImpl(`${CLERK_API}/v1/users/${encodeURIComponent(id)}/metadata`, {
+    method: "PATCH",
+    headers: { authorization: `Bearer ${secretKey}`, "content-type": "application/json" },
+    body: JSON.stringify({ public_metadata: { role } })
+  });
+  return res.ok;
+}
+
+// src/crm-sync.ts
+import { createRecord as createRecord2, updateRecord as updateRecord2, setStage, linkIdentity } from "@odla-ai/crm";
+var str = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
+function personInputFromApp(chapter, app) {
+  const input = sharedPersonInput({
+    email: str(app.email),
+    firstName: str(app.firstName) || void 0,
+    lastName: str(app.lastName) || void 0,
+    phone: str(app.phone) || void 0,
+    linkedin: str(app.linkedin) || void 0,
+    hubRecordId: str(app.id)
+  });
+  for (const f of chapter.application.crmFields) {
+    if (app[f] !== void 0) input[f] = app[f];
+  }
+  if (app.id !== void 0) input.applicationId = str(app.id);
+  return input;
+}
+function billingColumns(app) {
+  const status = str(app.status);
+  const paid = Boolean(app.stripeSubscriptionId) && status !== "refunded";
+  const billingStatus = status === "refunded" ? "refunded" : app.canceled === true ? "canceled" : paid ? "active" : "none";
+  const cols = { billingStatus };
+  if (app.stripeCustomerId) cols.stripeCustomerId = str(app.stripeCustomerId);
+  if (app.stripeSubscriptionId) cols.subscriptionId = str(app.stripeSubscriptionId);
+  if (typeof app.renewalAt === "number") cols.renewalAt = app.renewalAt;
+  return cols;
+}
+async function syncApplicationToCrm(deps, opts) {
+  const emailKey = str(opts.app.email).toLowerCase();
+  if (!emailKey) return null;
+  const crmDeps3 = { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId };
+  const input = personInputFromApp(deps.chapter, opts.app);
+  const { crm_record } = await deps.db.query({
+    crm_record: { $: { where: { type: "person", primaryEmail: emailKey }, limit: 1 } }
+  });
+  const existing = crm_record?.[0] ?? null;
+  const stage = opts.stage || void 0;
+  let recordId;
+  if (existing && typeof existing.id === "string") {
+    recordId = existing.id;
+    await updateRecord2(crmDeps3, { id: recordId, input });
+  } else {
+    const created = await createRecord2(crmDeps3, { type: "person", input, ...stage ? { stage } : {} });
+    recordId = created.id;
+  }
+  if (existing && stage && existing.stage !== stage) {
+    await setStage(crmDeps3, { id: recordId, to: stage, authorId: "system", mutationId: `crm:stage:${recordId}:${stage}` }).catch(() => void 0);
+  }
+  await deps.db.transact([{ t: "update", ns: "crm_record", id: recordId, attrs: billingColumns(opts.app) }]);
+  await linkIdentity(crmDeps3, { recordId, email: emailKey, mutationId: `crm:link:${recordId}:${emailKey}` }).catch(() => void 0);
+  return recordId;
+}
+async function backfillCrm(deps) {
+  const [appsRes, usersRes] = await Promise.all([
+    deps.db.query({ applications: { $: { order: { createdAt: "desc" }, limit: 1e3 } } }),
+    deps.db.query({ $users: { $: { limit: 1e3 } } })
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  let synced = 0;
+  const errors = [];
+  const run = async (app, stage) => {
+    const key = str(app.email).toLowerCase();
+    if (!key || seen.has(key)) return;
+    seen.add(key);
+    try {
+      await syncApplicationToCrm(deps, { app, stage });
+      synced += 1;
+    } catch (err) {
+      errors.push({ email: key, error: err instanceof Error ? err.message : String(err) });
+    }
+  };
+  for (const a of appsRes.applications ?? []) await run(a, str(a.status));
+  for (const u of usersRes.$users ?? []) {
+    if (u.deleted === true) continue;
+    await run({ email: u.email, firstName: str(u.name) });
+  }
+  return { synced, errors };
+}
+
+// src/worker-routes-admin-people.ts
+async function adminGate(req, env, ctx) {
+  const rawDb = ctx.makeDb(env);
+  const u = await ctx.verifyUser(req, env);
+  if (!u) return json({ error: "unauthorized" }, 401);
+  if (!await ctx.isAdmin(rawDb, u)) return json({ error: "forbidden" }, 403);
+  return { db: rawDb, actor: { userId: u.userId, email: u.email ?? void 0 } };
+}
+var crmDeps = (db, ctx) => ({
+  crm: ctx.chapter.crm,
+  db,
+  now: () => Date.now(),
+  newId: () => crypto.randomUUID(),
+  chapter: ctx.chapter
+});
+var handleAdminCrmSync = async (req, url, env, ctx) => {
+  if (req.method !== "POST" || url.pathname !== "/api/admin/crm/sync") return null;
+  const gate4 = await adminGate(req, env, ctx);
+  if (gate4 instanceof Response) return gate4;
+  const result = await backfillCrm(crmDeps(gate4.db, ctx));
+  return json({ ok: true, ...result });
+};
+var handleAdminPeople = async (req, url, env, ctx) => {
+  if (req.method !== "GET" || url.pathname !== "/api/admin/people") return null;
+  const gate4 = await adminGate(req, env, ctx);
+  if (gate4 instanceof Response) return gate4;
+  const { db } = gate4;
+  const sk = await getVaultSecret(db, "clerk_secret_key");
+  const [appsRes, usersRes, roleList] = await Promise.all([
+    db.query({ applications: { $: { order: { createdAt: "desc" }, limit: 200 } } }),
+    db.query({ $users: { $: { limit: 200 } } }),
+    sk ? clerkListUsers(sk).catch(() => []) : Promise.resolve([])
+  ]);
+  const roleByUserId = new Map(roleList.map((u) => [u.id, u.role]));
+  const people = /* @__PURE__ */ new Map();
+  for (const u of usersRes.$users ?? []) {
+    if (u.deleted === true) continue;
+    const email = typeof u.email === "string" ? u.email : "";
+    if (!email) continue;
+    people.set(email.toLowerCase(), {
+      email,
+      name: typeof u.name === "string" ? u.name : "",
+      userId: typeof u.id === "string" ? u.id : null,
+      role: roleByUserId.get(String(u.id)) ?? "provisional",
+      application: null
+    });
+  }
+  for (const a of appsRes.applications ?? []) {
+    const key = String(a.email ?? "").toLowerCase();
+    if (!key) continue;
+    const name = `${a.firstName ?? ""} ${a.lastName ?? ""}`.trim();
+    const row = people.get(key);
+    if (row) {
+      if (!row.application) row.application = applicationSummary(a);
+      if (!row.name) row.name = name;
+    } else {
+      people.set(key, { email: String(a.email), name, userId: null, role: null, application: applicationSummary(a) });
+    }
+  }
+  const rows2 = [...people.values()].sort(
+    (x, y) => (y.application?.createdAt ?? -1) - (x.application?.createdAt ?? -1)
+  );
+  return json({ people: rows2 });
+};
+var handleAdminPeopleAccess = async (req, url, env, ctx) => {
+  if (req.method !== "GET" || url.pathname !== "/api/admin/people/access") return null;
+  const gate4 = await adminGate(req, env, ctx);
+  if (gate4 instanceof Response) return gate4;
+  const { db } = gate4;
+  const targetId = url.searchParams.get("userId") ?? "";
+  if (!targetId.startsWith("user_")) return json({ error: "invalid userId" }, 400);
+  const sk = await getVaultSecret(db, "clerk_secret_key");
+  if (!sk) return json({ error: "role management unavailable: clerk_secret_key missing from vault" }, 503);
+  const info = await clerkGetUser(sk, targetId);
+  if (!info) return json({ error: "user lookup unavailable" }, 502);
+  return json({ userId: targetId, role: info.role, email: info.email ?? null, superAdmin: await ctx.isSuperAdminEmail(db, info.email) });
+};
+var handleAdminPeopleRole = async (req, url, env, ctx) => {
+  if (req.method !== "POST" || url.pathname !== "/api/admin/people/role") return null;
+  const gate4 = await adminGate(req, env, ctx);
+  if (gate4 instanceof Response) return gate4;
+  const { db, actor } = gate4;
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return json({ error: "invalid JSON body" }, 400);
+  }
+  const targetId = typeof body.userId === "string" ? body.userId : "";
+  const newRole = typeof body.role === "string" ? body.role : "";
+  if (!targetId.startsWith("user_")) return json({ error: "invalid userId" }, 400);
+  const sk = await getVaultSecret(db, "clerk_secret_key");
+  if (!sk) return json({ error: "role management unavailable: clerk_secret_key missing from vault" }, 503);
+  const target = await clerkGetUser(sk, targetId);
+  const guard = canChangeRole({
+    actorId: actor.userId,
+    actorIsSuper: await ctx.isSuperAdminEmail(db, actor.email),
+    targetId,
+    targetCurrentRole: target?.role ?? "provisional",
+    targetIsSuper: await ctx.isSuperAdminEmail(db, target?.email),
+    newRole,
+    auth: ctx.chapter.auth
+  });
+  if (!guard.ok) return json({ error: guard.error }, guard.status);
+  if (!await clerkSetRole(sk, targetId, newRole)) return json({ error: "role update failed upstream" }, 502);
+  return json({ ok: true });
+};
+
+// src/series.ts
+function bucketSeries(points, now, weeks = 12) {
+  const WEEK = 7 * 864e5;
+  const end = now;
+  const start = end - weeks * WEEK;
+  const buckets = Array.from({ length: weeks }, (_, i) => ({ weekStart: start + i * WEEK, value: 0 }));
+  for (const p of points) {
+    if (!Number.isFinite(p.t) || p.t < start || p.t > end) continue;
+    const idx = Math.min(weeks - 1, Math.floor((p.t - start) / WEEK));
+    const bucket = buckets[idx];
+    if (bucket) bucket.value += Number.isFinite(p.v) ? p.v : 0;
+  }
+  return buckets;
+}
+function subAnnualCents(sub) {
+  const items = sub.items?.data ?? [];
+  let cents = 0;
+  for (const it of items) {
+    const price = it.price ?? {};
+    const per = (price.unit_amount ?? 0) * (it.quantity ?? 1);
+    cents += price.recurring?.interval === "month" ? per * 12 : per;
+  }
+  return cents;
+}
+
+// src/worker-routes-admin-dashboard.ts
+async function gate(req, env, ctx) {
+  const rawDb = ctx.makeDb(env);
+  const u = await ctx.verifyUser(req, env);
+  if (!u) return json({ error: "unauthorized" }, 401);
+  if (!await ctx.isAdmin(rawDb, u)) return json({ error: "forbidden" }, 403);
+  return rawDb;
+}
+var rows = (v) => Array.isArray(v) ? v : [];
+var handleAdminDashboard = async (req, url, env, ctx) => {
+  if (req.method !== "GET" || url.pathname !== "/api/admin/dashboard") return null;
+  const got = await gate(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const now = Date.now();
+  const d7 = now - 7 * 864e5;
+  const d30 = now - 30 * 864e5;
+  const [appsRes, meetingsRes, recsRes, groupRes] = await Promise.all([
+    db.query({ applications: { $: { order: { createdAt: "desc" }, limit: 1e3 } } }),
+    db.query({ meetings: { $: { where: { status: "scheduled" }, order: { startAt: "asc" }, limit: 500 } } }),
+    db.query({ crm_record: { $: { where: { type: "person" }, limit: 1e3 } } }),
+    db.query({ groups: { $: { where: { id: ctx.chapter.id }, limit: 1 } } })
+  ]);
+  const apps = rows(appsRes.applications);
+  const applications = {
+    total: apps.length,
+    last7: apps.filter((a) => a.createdAt >= d7).length,
+    last30: apps.filter((a) => a.createdAt >= d30).length
+  };
+  const pipeline = {};
+  const pipelineDelta = {};
+  for (const s of ctx.chapter.pipeline.stages) {
+    pipeline[s] = 0;
+    pipelineDelta[s] = 0;
+  }
+  for (const r of rows(recsRes.crm_record)) {
+    const s = r.stage;
+    if (s in pipeline) {
+      pipeline[s] = (pipeline[s] ?? 0) + 1;
+      const sc = typeof r.stageChangedAt === "number" ? r.stageChangedAt : Date.parse(String(r.stageChangedAt));
+      if (Number.isFinite(sc) && sc >= d7) pipelineDelta[s] = (pipelineDelta[s] ?? 0) + 1;
+    }
+  }
+  const meetings = rows(meetingsRes.meetings);
+  const appById = new Map(apps.map((a) => [a.id, a]));
+  const upcoming = meetings.filter((m) => m.startAt >= now - 36e5);
+  const calls = { upcoming: upcoming.length, needsAttention: meetings.filter((m) => m.drift && m.drift !== "none").length };
+  const agenda = upcoming.slice(0, 8).map((m) => {
+    const a = appById.get(m.applicationId);
+    return {
+      id: m.id,
+      startAt: m.startAt,
+      meetUrl: m.meetUrl ?? null,
+      htmlLink: m.htmlLink ?? null,
+      drift: m.drift ?? "none",
+      name: a ? `${a.firstName} ${a.lastName}` : "(unknown)",
+      email: a?.email ?? null
+    };
+  });
+  const group = groupRes.groups?.[0];
+  const timezone = resolveScheduling(group?.schedulingJson).timezone;
+  let revenue = { billingReady: false };
+  let revenueSeries = null;
+  let membersSeries = null;
+  const sk = await getVaultSecret(db, "stripe_secret_key");
+  if (sk) {
+    const subsRes = await stripeCall(sk, "GET", "/v1/subscriptions", { limit: 100, status: "all" });
+    if (subsRes.ok) {
+      const subs = rows(subsRes.body.data);
+      const subMs = (s) => (s.created ?? 0) * 1e3;
+      membersSeries = bucketSeries(subs.map((s) => ({ t: subMs(s), v: 1 })), now);
+      revenueSeries = bucketSeries(subs.map((s) => ({ t: subMs(s), v: subAnnualCents(s) })), now);
+      const active = subs.filter((s) => s.status === "active");
+      revenue = {
+        billingReady: true,
+        testMode: String(group?.stripePublishableKey ?? "").startsWith("pk_test"),
+        activeCount: active.length,
+        annualRunRateCents: active.reduce((sum, s) => sum + subAnnualCents(s), 0),
+        newPaid7: subs.filter((s) => subMs(s) >= d7).length,
+        newPaid30: subs.filter((s) => subMs(s) >= d30).length
+      };
+    }
+  }
+  const applicationsSeries = bucketSeries(apps.map((a) => ({ t: a.createdAt || 0, v: 1 })), now);
+  return json({ applications, applicationsSeries, pipeline, pipelineDelta, calls, agenda, timezone, revenue, revenueSeries, membersSeries });
+};
+var handleAdminBilling = async (req, url, env, ctx) => {
+  if (req.method !== "GET" || url.pathname !== "/api/admin/billing") return null;
+  const got = await gate(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const sk = await getVaultSecret(db, "stripe_secret_key");
+  if (!sk) return json({ billingReady: false, rows: [], summary: null });
+  const [appsRes, subsRes, groupRes] = await Promise.all([
+    db.query({ applications: { $: { order: { createdAt: "desc" }, limit: 200 } } }),
+    stripeCall(sk, "GET", "/v1/subscriptions", { limit: 100, status: "all" }),
+    db.query({ groups: { $: { where: { id: ctx.chapter.id }, limit: 1 } } })
+  ]);
+  const testMode = String(groupRes.groups?.[0]?.stripePublishableKey ?? "").startsWith("pk_test");
+  if (!subsRes.ok) return json({ error: "billing lookup failed upstream" }, 502);
+  const subById = new Map(rows(subsRes.body.data).map((s) => [s.id, s]));
+  const billingRows = [];
+  for (const a of rows(appsRes.applications)) {
+    if (!a.stripeCustomerId && !a.stripeSubscriptionId) continue;
+    const sub = a.stripeSubscriptionId ? subById.get(a.stripeSubscriptionId) : void 0;
+    const items = sub?.items?.data ?? [];
+    let amountCents = 0;
+    let interval = "year";
+    for (const it of items) {
+      amountCents += (it.price?.unit_amount ?? 0) * (it.quantity ?? 1);
+      interval = it.price?.recurring?.interval ?? interval;
+    }
+    const periodEnd = sub?.current_period_end ?? items[0]?.current_period_end;
+    billingRows.push({
+      id: a.id,
+      name: `${a.firstName} ${a.lastName}`,
+      email: a.email,
+      applicationStatus: a.status,
+      subscriptionStatus: sub?.status ?? null,
+      cancelAtPeriodEnd: sub?.cancel_at_period_end === true,
+      amountCents,
+      interval,
+      renewalAt: periodEnd ? periodEnd * 1e3 : a.renewalAt ?? null
+    });
+  }
+  const renewing = billingRows.filter((r) => r.subscriptionStatus === "active" && !r.cancelAtPeriodEnd);
+  const soonCutoff = Date.now() + 60 * 864e5;
+  const summary = {
+    activeCount: billingRows.filter((r) => r.subscriptionStatus === "active").length,
+    annualizedCents: renewing.reduce((s, r) => s + r.amountCents * (r.interval === "month" ? 12 : 1), 0),
+    renewingSoonCount: renewing.filter((r) => r.renewalAt && r.renewalAt < soonCutoff).length,
+    pastDueCount: billingRows.filter((r) => r.subscriptionStatus === "past_due").length,
+    canceledCount: billingRows.filter((r) => r.subscriptionStatus === "canceled" || r.cancelAtPeriodEnd).length,
+    refundedCount: billingRows.filter((r) => r.applicationStatus === "refunded").length
+  };
+  return json({
+    billingReady: true,
+    testMode,
+    truncated: subsRes.body.has_more === true,
+    rows: billingRows,
+    summary
+  });
+};
+
+// src/worker-routes-admin-lifecycle.ts
+import { computeBookableSlots as computeBookableSlots2, initCalendar as initCalendar3 } from "@odla-ai/calendar";
+async function gate2(req, env, ctx) {
+  const rawDb = ctx.makeDb(env);
+  const u = await ctx.verifyUser(req, env);
+  if (!u) return json({ error: "unauthorized" }, 401);
+  if (!await ctx.isAdmin(rawDb, u)) return json({ error: "forbidden" }, 403);
+  return rawDb;
+}
+var calFor = (env) => initCalendar3({ appId: env.ODLA_APP_ID, env: env.ODLA_ENV, adminToken: env.ODLA_API_KEY, endpoint: env.ODLA_PLATFORM });
+var crmDeps2 = (db, ctx) => ({ crm: ctx.chapter.crm, db, now: () => Date.now(), newId: () => crypto.randomUUID(), chapter: ctx.chapter });
+var readJson = async (req) => {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+};
+async function loadApp(db, id) {
+  const { applications } = await db.query({ applications: { $: { where: { id }, limit: 1 } } });
+  return applications?.[0] ?? null;
+}
+async function loadGroup(db, id) {
+  const { groups } = await db.query({ groups: { $: { where: { id }, limit: 1 } } });
+  return groups?.[0] ?? null;
+}
+var handleAdminMeetingReschedule = async (req, url, env, ctx) => {
+  const m = url.pathname.match(/^\/api\/admin\/meetings\/([0-9a-f-]+)\/reschedule$/);
+  if (req.method !== "POST" || !m) return null;
+  const got = await gate2(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const body = await readJson(req);
+  const startAt = Number(body?.startAt);
+  if (!Number.isFinite(startAt)) return json({ error: "startAt required" }, 400);
+  const { meetings } = await db.query({ meetings: { $: { where: { id: m[1] }, limit: 1 } } });
+  const meeting = meetings?.[0];
+  if (!meeting) return json({ error: "not found" }, 404);
+  if (meeting.status !== "scheduled") return json({ error: "meeting is cancelled" }, 409);
+  if (!meeting.googleEventId) return json({ error: "no calendar event on file" }, 409);
+  const cfg = resolveScheduling((await loadGroup(db, String(meeting.groupId ?? ctx.chapter.id)))?.schedulingJson);
+  const endAt = endForSlot(startAt, cfg.slotMinutes);
+  const cal = calFor(env);
+  try {
+    const { from, to } = slotWindow(Date.now(), cfg.windowDays);
+    const fb = await cal.availability.freeBusy({ timeMin: from, timeMax: to });
+    const slots = computeBookableSlots2(fb.busy, {
+      from: fb.timeMin,
+      to: fb.timeMax,
+      timezone: cfg.timezone,
+      slotMinutes: cfg.slotMinutes,
+      businessHours: { days: [...cfg.days], startHour: cfg.startHour, endHour: cfg.endHour },
+      minNoticeMs: cfg.minNoticeHours * 36e5
+    });
+    if (!isSlotAvailable(slots, startAt)) return json({ error: "slot no longer available", code: "calendar_slot_unavailable" }, 409);
+    await cal.actions.reschedule(String(meeting.googleEventId), { startAt, endAt });
+  } catch {
+    return json({ error: "reschedule failed upstream" }, 502);
+  }
+  await db.transact([{ t: "update", ns: "meetings", id: String(meeting.id), attrs: meetingRescheduleUpdate(startAt, endAt) }]);
+  await db.transact([{ t: "update", ns: "applications", id: String(meeting.applicationId), attrs: { meetingAt: startAt } }]);
+  return json({ ok: true, startAt, endAt });
+};
+var handleAdminMeetingCancel = async (req, url, env, ctx) => {
+  const m = url.pathname.match(/^\/api\/admin\/meetings\/([0-9a-f-]+)\/cancel$/);
+  if (req.method !== "POST" || !m) return null;
+  const got = await gate2(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const { meetings } = await db.query({ meetings: { $: { where: { id: m[1] }, limit: 1 } } });
+  const meeting = meetings?.[0];
+  if (!meeting) return json({ error: "not found" }, 404);
+  if (meeting.status !== "scheduled") return json({ error: "already cancelled" }, 409);
+  if (meeting.googleEventId) {
+    try {
+      await calFor(env).actions.cancel(String(meeting.googleEventId));
+    } catch {
+      return json({ error: "cancel failed upstream" }, 502);
+    }
+  }
+  await db.transact([{ t: "update", ns: "meetings", id: String(meeting.id), attrs: { status: "cancelled", drift: "none" } }]);
+  await db.transact([{ t: "update", ns: "applications", id: String(meeting.applicationId), attrs: { meetingAt: 0, meetingLink: "" } }]);
+  return json({ ok: true });
+};
+var handleAdminApprove = async (req, url, env, ctx) => {
+  const m = url.pathname.match(/^\/api\/admin\/applications\/([0-9a-f-]+)\/approve$/);
+  if (req.method !== "POST" || !m) return null;
+  const got = await gate2(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const id = m[1];
+  const app = await loadApp(db, id);
+  if (!app) return json({ error: "not found" }, 404);
+  if (!canApprove(String(app.status), ctx.chapter.pipeline)) return json({ error: `cannot approve from status "${String(app.status)}"` }, 409);
+  const target = "approved";
+  await db.transact([{ t: "update", ns: "applications", id, attrs: { status: target } }]);
+  await syncApplicationToCrm(crmDeps2(db, ctx), { app: { ...app, status: target }, stage: target }).catch(() => void 0);
+  const { promoteTo, send } = ctx.chapter.operations.onApprove;
+  let rolePromoted = false;
+  const sk = await getVaultSecret(db, "clerk_secret_key");
+  if (promoteTo !== false && sk) {
+    let userId = app.clerkUserId || null;
+    if (!userId) {
+      const found = await clerkGetUserByEmail(sk, String(app.email));
+      userId = found?.id ?? null;
+      if (userId) await db.transact([{ t: "update", ns: "applications", id, attrs: { clerkUserId: userId } }]);
+    }
+    if (userId) rolePromoted = await clerkSetRole(sk, userId, promoteTo);
+  }
+  let emailLogged = false;
+  const group = await loadGroup(db, String(app.groupId ?? ctx.chapter.id));
+  if (send !== false && group) {
+    const res = await sendTemplated(
+      { db, envName: env.ODLA_ENV, sender: env.SEND_EMAIL, from: env.EMAIL_FROM, now: () => Date.now(), newId: () => crypto.randomUUID() },
+      { group: emailGroupFrom(group), template: send, to: String(app.email), vars: { firstName: String(app.firstName ?? ""), membersUrl: `${url.origin}/members/` }, applicationId: id, dedupeKey: `approve:${id}` }
+    );
+    emailLogged = res.sent;
+  }
+  return json({ ok: true, status: target, rolePromoted, emailLogged });
+};
+var handleAdminRefund = async (req, url, env, ctx) => {
+  const m = url.pathname.match(/^\/api\/admin\/applications\/([0-9a-f-]+)\/refund$/);
+  if (req.method !== "POST" || !m) return null;
+  const got = await gate2(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const app = await loadApp(db, m[1]);
+  if (!app) return json({ error: "not found" }, 404);
+  if (app.status === "refunded") return json({ error: "already refunded" }, 409);
+  const allowedFrom = ctx.chapter.operations.refund.allowedFrom;
+  if (allowedFrom && !allowedFrom.includes(String(app.status))) {
+    return json({ error: `cannot refund from status "${String(app.status)}"` }, 409);
+  }
+  const subscriptionId = app.stripeSubscriptionId;
+  const customerId = app.stripeCustomerId;
+  if (!customerId) return json({ error: "no customer on file" }, 409);
+  const sk = await getVaultSecret(db, "stripe_secret_key");
+  if (!sk) return json({ error: "payments not configured" }, 503);
+  const charges = await stripeCall(sk, "GET", "/v1/charges", { customer: customerId, limit: 100 });
+  if (!charges.ok) return json({ error: "refund failed upstream" }, 502);
+  const succeeded = (charges.body.data ?? []).filter((c) => c.status === "succeeded" && c.refunded !== true);
+  const firstCharge = succeeded[succeeded.length - 1];
+  if (!firstCharge) return json({ error: "no paid charge to refund" }, 409);
+  const refund = await stripeCall(sk, "POST", "/v1/refunds", { charge: String(firstCharge.id) });
+  if (!refund.ok) return json({ error: "refund failed upstream" }, 502);
+  let subscriptionCanceled = false;
+  if (ctx.chapter.operations.refund.cancelSubscription && subscriptionId) {
+    const cancel = await stripeCall(sk, "DELETE", `/v1/subscriptions/${subscriptionId}`);
+    subscriptionCanceled = cancel.ok;
+  }
+  return json({ ok: true, refundedCents: refund.body.amount ?? null, subscriptionCanceled });
+};
+var handleAdminApplicationPatch = async (req, url, env, ctx) => {
+  const m = url.pathname.match(/^\/api\/admin\/applications\/([0-9a-f-]+)$/);
+  if (req.method !== "PATCH" || !m) return null;
+  const got = await gate2(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const id = m[1];
+  const body = await readJson(req);
+  if (!body) return json({ error: "invalid JSON body" }, 400);
+  const app = await loadApp(db, id);
+  if (!app) return json({ error: "not found" }, 404);
+  const attrs = {};
+  if (body.status !== void 0) {
+    const to = String(body.status);
+    if (!ctx.chapter.pipeline.stages.includes(to)) return json({ error: `status must be one of: ${ctx.chapter.pipeline.stages.join(", ")}` }, 400);
+    if (!canTransition(String(app.status), to, ctx.chapter.pipeline)) return json({ error: `cannot move from "${String(app.status)}" to "${to}"` }, 409);
+    attrs.status = to;
+  }
+  if (body.meetingAt !== void 0) {
+    if (typeof body.meetingAt !== "number" || !Number.isFinite(body.meetingAt)) return json({ error: "meetingAt must be epoch milliseconds" }, 400);
+    attrs.meetingAt = body.meetingAt;
+  }
+  if (Object.keys(attrs).length === 0) return json({ error: "nothing to update" }, 400);
+  await db.transact([{ t: "update", ns: "applications", id, attrs }]);
+  if (attrs.status !== void 0) {
+    await syncApplicationToCrm(crmDeps2(db, ctx), { app: { ...app, ...attrs }, stage: String(attrs.status) }).catch(() => void 0);
+  }
+  return json({ ok: true });
+};
+
+// src/worker-routes-admin-comms.ts
+async function gate3(req, env, ctx) {
+  const rawDb = ctx.makeDb(env);
+  const u = await ctx.verifyUser(req, env);
+  if (!u) return json({ error: "unauthorized" }, 401);
+  if (!await ctx.isAdmin(rawDb, u)) return json({ error: "forbidden" }, 403);
+  return rawDb;
+}
+async function loadGroup2(db, id) {
+  const { groups } = await db.query({ groups: { $: { where: { id }, limit: 1 } } });
+  return groups?.[0] ?? null;
+}
+var str2 = (v, d = "") => typeof v === "string" ? v : d;
+var notifyDeps = (db, env) => ({
+  db,
+  envName: env.ODLA_ENV,
+  sender: env.SEND_EMAIL,
+  from: env.EMAIL_FROM,
+  now: () => Date.now(),
+  newId: () => crypto.randomUUID()
+});
+var handleAdminGroupEmail = async (req, url, env, ctx) => {
+  if (url.pathname !== "/api/admin/group/email" || req.method !== "GET" && req.method !== "PUT") return null;
+  const got = await gate3(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const group = await loadGroup2(db, ctx.chapter.id);
+  if (!group) return json({ error: "not found" }, 404);
+  if (req.method === "GET") {
+    const stored = group.emailTemplates ?? {};
+    const emailTemplates = {};
+    for (const key of EMAIL_TEMPLATE_NAMES) {
+      const t = stored[key];
+      if (t) emailTemplates[key] = { subject: str2(t.subject), text: str2(t.text), enabled: t.enabled !== false };
+    }
+    return json({
+      groupId: group.id,
+      name: group.name,
+      replyTo: str2(group.replyTo),
+      notificationEmail: str2(group.notificationEmail),
+      debugEmail: str2(group.debugEmail),
+      emailTemplates,
+      commitmentText: str2(group.commitmentText),
+      normsText: str2(group.normsText),
+      refundPolicyText: str2(group.refundPolicyText),
+      // Read-only delivery wiring — surfaced so "why did this not send?" is
+      // answerable without logs.
+      envName: env.ODLA_ENV,
+      transport: env.SEND_EMAIL && env.EMAIL_FROM ? "cloudflare" : "log-only",
+      fromEmail: env.EMAIL_FROM ?? null
+    });
+  }
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return json({ error: "invalid JSON body" }, 400);
+  }
+  const templates = body.emailTemplates;
+  if (!templates || typeof templates !== "object") return json({ error: "emailTemplates object required" }, 400);
+  const clean = {};
+  for (const key of EMAIL_TEMPLATE_NAMES) {
+    const t = templates[key];
+    const subject = typeof t?.subject === "string" ? t.subject.trim() : "";
+    const text = typeof t?.text === "string" ? t.text : "";
+    if (!subject || !text.trim()) return json({ error: `template "${key}" needs a subject and a body` }, 400);
+    if (/[\r\n]/.test(subject) || subject.length > 200) return json({ error: `template "${key}" subject must be a single line under 200 characters` }, 400);
+    if (text.length > 1e4) return json({ error: `template "${key}" body is too long` }, 400);
+    clean[key] = { subject, text, enabled: t?.enabled !== false };
+  }
+  const emailish = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  const notificationEmail = str2(body.notificationEmail).trim();
+  const replyTo = str2(body.replyTo).trim();
+  const debugEmail = str2(body.debugEmail).trim();
+  if (!emailish.test(notificationEmail)) return json({ error: "notification address must be a valid email" }, 400);
+  if (!emailish.test(replyTo)) return json({ error: "reply-to address must be a valid email" }, 400);
+  if (debugEmail && !emailish.test(debugEmail)) return json({ error: "debug address must be a valid email" }, 400);
+  const commitmentText = str2(body.commitmentText);
+  const normsText = str2(body.normsText);
+  if (commitmentText.length > 5e3 || normsText.length > 5e3) return json({ error: "commitment/norms text is too long" }, 400);
+  await db.transact([{ t: "update", ns: "groups", id: ctx.chapter.id, attrs: { emailTemplates: clean, commitmentText, normsText, notificationEmail, replyTo, debugEmail } }]);
+  return json({ ok: true });
+};
+var handleAdminEmailLog = async (req, url, env, ctx) => {
+  if (req.method !== "GET" || url.pathname !== "/api/admin/email/log") return null;
+  const got = await gate3(req, env, ctx);
+  if (got instanceof Response) return got;
+  const { emailLog } = await got.query({ emailLog: { $: { order: { sentAt: "desc" }, limit: 50 } } });
+  const sends = (emailLog ?? []).map((r) => ({
+    id: r.id,
+    template: r.template,
+    to: r.to,
+    subject: r.subject,
+    transport: r.transport,
+    redirected: r.redirected === true,
+    error: r.error ?? null,
+    sentAt: r.sentAt
+  }));
+  return json({ sends });
+};
+var handleAdminEmailTest = async (req, url, env, ctx) => {
+  if (req.method !== "POST" || url.pathname !== "/api/admin/email/test") return null;
+  const got = await gate3(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return json({ error: "invalid JSON body" }, 400);
+  }
+  const template = str2(body.template);
+  if (!EMAIL_TEMPLATE_NAMES.includes(template)) {
+    return json({ error: `template must be one of: ${EMAIL_TEMPLATE_NAMES.join(", ")}` }, 400);
+  }
+  const group = await loadGroup2(db, ctx.chapter.id);
+  if (!group) return json({ error: "not found" }, 404);
+  const res = await sendTemplated(notifyDeps(db, env), {
+    group: emailGroupFrom(group),
+    template,
+    to: str2(group.notificationEmail),
+    vars: { firstName: "Sample", lastName: "Person", email: "sample@example.com", phone: "(555) 010-0100", state: "CA", adminUrl: `${url.origin}/admin/`, membersUrl: `${url.origin}/members/` },
+    dedupeKey: `test:${template}:${Date.now()}`,
+    force: true
+  });
+  return json({ ok: res.sent, reason: res.reason ?? null, to: str2(group.notificationEmail), redirected: env.ODLA_ENV !== "prod" && !!group.debugEmail });
+};
+var handleAdminComms = async (req, url, env, ctx) => {
+  const m = url.pathname.match(/^\/api\/admin\/people\/([0-9a-fA-F-]+)\/comms$/);
+  if (req.method !== "GET" || !m) return null;
+  const got = await gate3(req, env, ctx);
+  if (got instanceof Response) return got;
+  const db = got;
+  const appId = m[1];
+  const [emailRes, meetingRes, appRes] = await Promise.all([
+    db.query({ emailLog: { $: { where: { applicationId: appId }, order: { sentAt: "desc" }, limit: 100 } } }),
+    db.query({ meetings: { $: { where: { applicationId: appId } } } }),
+    db.query({ applications: { $: { where: { id: appId }, limit: 1 } } })
+  ]);
+  const app = appRes.applications?.[0] ?? null;
+  const group = await loadGroup2(db, str2(app?.groupId, ctx.chapter.id));
+  const vars = app ? { firstName: str2(app.firstName), lastName: str2(app.lastName), email: str2(app.email), phone: str2(app.phone), state: str2(app.state), adminUrl: `${url.origin}/admin/`, membersUrl: `${url.origin}/members/` } : null;
+  const emails = (emailRes.emailLog ?? []).filter((r) => r.template !== "adminNotification").map((r) => {
+    let mailBody = typeof r.body === "string" ? r.body : null;
+    if (!mailBody && group && vars) mailBody = renderTemplateBody(emailGroupFrom(group), String(r.template), vars);
+    const channel = r.error ? "email (failed)" : r.redirected ? "email (dev-redirected)" : r.transport === "log-only" ? "email (not delivered)" : "email";
+    return { kind: "email", channel, label: String(r.template), subject: str2(r.subject), to: r.to ?? null, body: mailBody, at: r.sentAt, error: r.error ?? null };
+  });
+  const calendar = (meetingRes.meetings ?? []).map((m2) => ({
+    kind: "calendar",
+    channel: "Google Calendar",
+    label: m2.status === "cancelled" ? "Invitation (call later cancelled)" : "Meeting invitation",
+    subject: "Introduction call invitation",
+    to: null,
+    at: m2.createdAt ?? m2.startAt,
+    error: null
+  }));
+  const items = [...emails, ...calendar].sort((a, b) => (b.at ?? 0) - (a.at ?? 0));
+  return json({ items });
+};
+
 // src/worker.ts
 var BUILTIN_ROUTES = [
   handleHealth,
@@ -1331,7 +2109,26 @@ var BUILTIN_ROUTES = [
   handleSchedule,
   handlePayments,
   handleAdminMeetings,
-  handleAdminScheduling
+  handleAdminScheduling,
+  // Roster + identity
+  handleAdminPeople,
+  handleAdminPeopleAccess,
+  handleAdminPeopleRole,
+  handleAdminCrmSync,
+  // Aggregation
+  handleAdminDashboard,
+  handleAdminBilling,
+  // Lifecycle actions
+  handleAdminMeetingReschedule,
+  handleAdminMeetingCancel,
+  handleAdminApprove,
+  handleAdminRefund,
+  handleAdminApplicationPatch,
+  // Email + comms
+  handleAdminGroupEmail,
+  handleAdminEmailLog,
+  handleAdminEmailTest,
+  handleAdminComms
 ];
 function chapterWorker(options) {
   const ctx = createWorkerContext(options);