@odla-ai/chapter 0.43.1 → 0.44.0

package/dist/worker/index.cjs

@@ -371,8 +371,8 @@ function tierPayable(tier, group, hasSecretKey) {
 function byOrder(a, b) {
   return a.sortOrder - b.sortOrder || a.id.localeCompare(b.id);
 }
-function resolveTiers(group, rows4 = []) {
-  const stored = rows4.filter((tier) => tier.active);
+function resolveTiers(group, rows5 = []) {
+  const stored = rows5.filter((tier) => tier.active);
   if (stored.length) return [...stored].sort(byOrder);
   return [{
     id: "standard",
@@ -418,15 +418,15 @@ function rowToTier(row, groupId) {
 }
 async function loadTiers(db, group) {
   const groupId = String(group.id ?? "");
-  let rows4;
+  let rows5;
   try {
-    rows4 = (await db.query({
+    rows5 = (await db.query({
       tiers: { $: { where: { groupId }, order: { sortOrder: "asc" }, limit: 100 } }
     })).tiers;
   } catch {
-    rows4 = void 0;
+    rows5 = void 0;
   }
-  const list = Array.isArray(rows4) ? rows4.map((row) => rowToTier(row, groupId)) : [];
+  const list = Array.isArray(rows5) ? rows5.map((row) => rowToTier(row, groupId)) : [];
   return resolveTiers(group, list);
 }
 async function loadOfferableTiers(db, group, hasSecretKey) {
@@ -1480,27 +1480,27 @@ async function hasSignupControl(db, targetId, environment, active) {
   if (db.aggregate) {
     return Number((await db.aggregate("signupControls", { count: true }, { where })).count ?? 0) > 0;
   }
-  const rows4 = (await db.query({ signupControls: {} })).signupControls;
-  return Array.isArray(rows4) && rows4.some((row) => row.targetId === targetId && row.environment === environment && (!active || row.active === true));
+  const rows5 = (await db.query({ signupControls: {} })).signupControls;
+  return Array.isArray(rows5) && rows5.some((row) => row.targetId === targetId && row.environment === environment && (!active || row.active === true));
 }
 async function loadLatestSignupControl(db, targetId, environment) {
   if (!await hasSignupControl(db, targetId, environment)) return null;
-  const rows4 = (await db.query({ signupControls: { $: {
+  const rows5 = (await db.query({ signupControls: { $: {
     where: { targetId, environment },
     order: { revision: "desc" },
     limit: 1
   } } })).signupControls;
-  const latest = Array.isArray(rows4) ? [...rows4].sort((a, b) => Number(b.revision ?? 0) - Number(a.revision ?? 0))[0] : void 0;
+  const latest = Array.isArray(rows5) ? [...rows5].sort((a, b) => Number(b.revision ?? 0) - Number(a.revision ?? 0))[0] : void 0;
   return asStored(latest);
 }
 async function loadActiveSignupControl(db, targetId, environment) {
   if (!await hasSignupControl(db, targetId, environment, true)) return null;
-  const rows4 = (await db.query({ signupControls: { $: {
+  const rows5 = (await db.query({ signupControls: { $: {
     where: { targetId, environment, active: true },
     order: { revision: "desc" },
     limit: 1
   } } })).signupControls;
-  const active = Array.isArray(rows4) ? [...rows4].sort((a, b) => Number(b.revision ?? 0) - Number(a.revision ?? 0))[0] : void 0;
+  const active = Array.isArray(rows5) ? [...rows5].sort((a, b) => Number(b.revision ?? 0) - Number(a.revision ?? 0))[0] : void 0;
   return asStored(active);
 }
 function controlledApplication(base, document) {
@@ -2876,33 +2876,33 @@ var control = (row) => row && row.document && typeof row.document === "object" ?
 var local = (row) => row && row.document && typeof row.document === "object" ? row : null;
 async function exists(db, ns, where) {
   if (db.aggregate) return Number((await db.aggregate(ns, { count: true }, { where })).count ?? 0) > 0;
-  const rows4 = (await db.query({ [ns]: {} }))[ns] ?? [];
-  return rows4.some((row) => Object.entries(where).every(([key, value]) => row[key] === value));
+  const rows5 = (await db.query({ [ns]: {} }))[ns] ?? [];
+  return rows5.some((row) => Object.entries(where).every(([key, value]) => row[key] === value));
 }
 async function loadActiveMemberContentControl(db, targetId, environment) {
   const where = { targetId, environment, active: true };
   if (!await exists(db, "memberContentControls", where)) return null;
-  const rows4 = (await db.query({ memberContentControls: { $: {
+  const rows5 = (await db.query({ memberContentControls: { $: {
     where,
     order: { revision: "desc" },
     limit: 1
   } } })).memberContentControls;
-  return control(Array.isArray(rows4) ? [...rows4].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
+  return control(Array.isArray(rows5) ? [...rows5].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
 }
 async function loadLatestMemberContentControl(db, targetId, environment) {
   const where = { targetId, environment };
   if (!await exists(db, "memberContentControls", where)) return null;
-  const rows4 = (await db.query({ memberContentControls: { $: {
+  const rows5 = (await db.query({ memberContentControls: { $: {
     where,
     order: { revision: "desc" },
     limit: 1
   } } })).memberContentControls;
-  return control(Array.isArray(rows4) ? [...rows4].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
+  return control(Array.isArray(rows5) ? [...rows5].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
 }
 async function loadLocalMemberContent(db, chapterId, environment) {
   const id = `member-content-local:${environment}`;
-  const rows4 = (await db.query({ memberContentLocal: { $: { where: { id }, limit: 1 } } })).memberContentLocal;
-  return local(Array.isArray(rows4) ? rows4[0] : void 0);
+  const rows5 = (await db.query({ memberContentLocal: { $: { where: { id }, limit: 1 } } })).memberContentLocal;
+  return local(Array.isArray(rows5) ? rows5[0] : void 0);
 }
 async function materializeMemberContentControl(db, envelope, previous, receivedAt) {
   const { document, digest } = envelope;
@@ -2957,12 +2957,12 @@ async function groupAndTiers(db, chapterId) {
 }
 async function memberTierId(db, chapterId, email) {
   if (!email) return null;
-  let rows4 = (await db.query({ applications: { $: {
+  let rows5 = (await db.query({ applications: { $: {
     where: { emailNormalized: normalizeAdmissionEmail(email) },
     limit: 20
   } } })).applications;
-  if (!rows4?.length) rows4 = (await db.query({ applications: { $: { where: { email }, limit: 20 } } })).applications;
-  const latest = Array.isArray(rows4) ? [...rows4].filter((row) => String(row.groupId ?? chapterId) === chapterId).sort((a, b) => Number(b.createdAt ?? 0) - Number(a.createdAt ?? 0))[0] : void 0;
+  if (!rows5?.length) rows5 = (await db.query({ applications: { $: { where: { email }, limit: 20 } } })).applications;
+  const latest = Array.isArray(rows5) ? [...rows5].filter((row) => String(row.groupId ?? chapterId) === chapterId).sort((a, b) => Number(b.createdAt ?? 0) - Number(a.createdAt ?? 0))[0] : void 0;
   return typeof latest?.tierId === "string" && latest.tierId ? latest.tierId : null;
 }
 async function activeDocuments(db, chapterId, environment) {
@@ -3688,8 +3688,8 @@ function makeCalendar(env) {
 }
 async function firstRow(db, ns, q) {
   const res = await db.query({ [ns]: { $: q } });
-  const rows4 = res[ns];
-  return Array.isArray(rows4) ? rows4[0] : void 0;
+  const rows5 = res[ns];
+  return Array.isArray(rows5) ? rows5[0] : void 0;
 }
 async function computeSlots(cal, cfg) {
   const { from, to } = slotWindow(Date.now(), cfg.windowDays);
@@ -4089,8 +4089,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 rows4 = charges.body.data ?? [];
-      const paid = rows4.filter((c) => c.status === "succeeded" && c.refunded !== true);
+      const rows5 = charges.body.data ?? [];
+      const paid = rows5.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");
@@ -4198,8 +4198,8 @@ async function issueGiftClaim(db, intent, provider, now) {
     throw new Error("gift issuance conflict");
   }
 }
-function buyerGiftClaims(rows4, now) {
-  return rows4.map((row) => {
+function buyerGiftClaims(rows5, now) {
+  return rows5.map((row) => {
     const stored = String(row.status ?? "pending");
     const status = stored === "pending" && Number(row.codeExpiresAt) <= now ? "expired" : stored;
     return {
@@ -4491,8 +4491,8 @@ function classifyMemberStripeEvent(identity, target, hasProvenLegacyLocalLink) {
 
 // src/stripe-webhook-partition.ts
 var firstRow2 = async (db, ns, q) => {
-  const rows4 = (await db.query({ [ns]: { $: q } }))[ns];
-  return Array.isArray(rows4) ? rows4[0] : void 0;
+  const rows5 = (await db.query({ [ns]: { $: q } }))[ns];
+  return Array.isArray(rows5) ? rows5[0] : void 0;
 };
 var stripeEventDigest = async (rawBody) => {
   const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(rawBody));
@@ -4562,8 +4562,8 @@ async function replayedStripeReceipt(db, eventId, digest, event) {
 // src/worker-routes-payments.ts
 async function firstRow3(db, ns, q) {
   const res = await db.query({ [ns]: { $: q } });
-  const rows4 = res[ns];
-  return Array.isArray(rows4) ? rows4[0] : void 0;
+  const rows5 = res[ns];
+  return Array.isArray(rows5) ? rows5[0] : void 0;
 }
 async function findApplication(db, event) {
   if ("applicationId" in event && event.applicationId) {
@@ -5029,8 +5029,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(rows4) {
-  return rows4.map((m) => ({
+function toReconcile(rows5) {
+  return rows5.map((m) => ({
     id: String(m.id),
     applicationId: String(m.applicationId),
     googleEventId: typeof m.googleEventId === "string" ? m.googleEventId : null,
@@ -5052,12 +5052,12 @@ var handleAdminMeetings = async (req, url, env, ctx) => {
   const query = await db.query({
     meetings: { $: { where: all ? {} : { status: "scheduled" }, order: { startAt: "asc" }, limit: 500 } }
   });
-  let rows4 = Array.isArray(query.meetings) ? query.meetings : [];
-  if (Number.isFinite(from)) rows4 = rows4.filter((m) => Number(m.startAt ?? 0) >= from);
-  if (Number.isFinite(to)) rows4 = rows4.filter((m) => Number(m.startAt ?? 0) <= to);
+  let rows5 = Array.isArray(query.meetings) ? query.meetings : [];
+  if (Number.isFinite(from)) rows5 = rows5.filter((m) => Number(m.startAt ?? 0) >= from);
+  if (Number.isFinite(to)) rows5 = rows5.filter((m) => Number(m.startAt ?? 0) <= to);
   let decisions = [];
   try {
-    decisions = reconcileMeetings(toReconcile(rows4), await upcomingEvents(env), Date.now());
+    decisions = reconcileMeetings(toReconcile(rows5), await upcomingEvents(env), Date.now());
   } catch {
   }
   const patched = /* @__PURE__ */ new Map();
@@ -5084,7 +5084,7 @@ 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 = rows4.map((m) => ({ ...m, ...patched.get(String(m.id)) ?? {}, applicant: applicantOf(m) })).filter((m) => all || m.status === "scheduled");
+  const meetings = rows5.map((m) => ({ ...m, ...patched.get(String(m.id)) ?? {}, applicant: applicantOf(m) })).filter((m) => all || m.status === "scheduled");
   return json({ meetings, adopted: decisions.length, timezone });
 };
 
@@ -5105,16 +5105,16 @@ var crmDeps2 = (db, ctx) => ({
 });
 var handleAdminCrmSync = async (req, url, env, ctx) => {
   if (req.method !== "POST" || url.pathname !== "/api/admin/crm/sync") return null;
-  const gate10 = await adminGate(req, env, ctx);
-  if (gate10 instanceof Response) return gate10;
-  const result = await backfillCrm(crmDeps2(gate10.db, ctx));
+  const gate11 = await adminGate(req, env, ctx);
+  if (gate11 instanceof Response) return gate11;
+  const result = await backfillCrm(crmDeps2(gate11.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 gate10 = await adminGate(req, env, ctx);
-  if (gate10 instanceof Response) return gate10;
-  const { db } = gate10;
+  const gate11 = await adminGate(req, env, ctx);
+  if (gate11 instanceof Response) return gate11;
+  const { db } = gate11;
   const sk = await getVaultSecret(db, "clerk_secret_key");
   const [data, roleList] = await Promise.all([
     db.query({
@@ -5160,16 +5160,16 @@ var handleAdminPeople = async (req, url, env, ctx) => {
       });
     }
   }
-  const rows4 = [...people.values()].sort(
+  const rows5 = [...people.values()].sort(
     (x, y) => (y.application?.createdAt ?? -1) - (x.application?.createdAt ?? -1)
   );
-  return json({ people: rows4 });
+  return json({ people: rows5 });
 };
 var handleAdminPeopleAccess = async (req, url, env, ctx) => {
   if (req.method !== "GET" || url.pathname !== "/api/admin/people/access") return null;
-  const gate10 = await adminGate(req, env, ctx);
-  if (gate10 instanceof Response) return gate10;
-  const { db } = gate10;
+  const gate11 = await adminGate(req, env, ctx);
+  if (gate11 instanceof Response) return gate11;
+  const { db } = gate11;
   const targetId = url.searchParams.get("userId") ?? "";
   if (!targetId.startsWith("user_")) return json({ error: "invalid userId" }, 400);
   const sk = await getVaultSecret(db, "clerk_secret_key");
@@ -5180,9 +5180,9 @@ var handleAdminPeopleAccess = async (req, url, env, ctx) => {
 };
 var handleAdminPeopleRole = async (req, url, env, ctx) => {
   if (req.method !== "POST" || url.pathname !== "/api/admin/people/role") return null;
-  const gate10 = await adminGate(req, env, ctx);
-  if (gate10 instanceof Response) return gate10;
-  const { db, actor } = gate10;
+  const gate11 = await adminGate(req, env, ctx);
+  if (gate11 instanceof Response) return gate11;
+  const { db, actor } = gate11;
   let body;
   try {
     body = await req.json();
@@ -6751,6 +6751,596 @@ var handleAdminNetworkSharedNotes = async (req, url, env, ctx) => {
   }
 };
 
+// src/network-person-registry.ts
+var TOKEN = /^[a-z0-9][a-z0-9._:-]{0,127}$/;
+var CHAPTER_ID = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+function normalizeNetworkIdentity(kind, value) {
+  const trimmed = value.trim();
+  if (kind === "email") return trimmed.toLowerCase();
+  if (kind === "phone") return trimmed.replace(/[\s().-]/g, "");
+  return trimmed;
+}
+function emailLooksReal(value) {
+  const at = value.lastIndexOf("@");
+  if (at <= 0 || at === value.length - 1) return false;
+  const domain = value.slice(at + 1).toLowerCase();
+  return !domain.endsWith(".invalid") && domain !== "example.com" && domain !== "example.test";
+}
+function validateNetworkPersonImport(input, allowedChapterIds) {
+  const errors = [];
+  if (!input || typeof input !== "object" || Array.isArray(input)) return { ok: false, errors: ["import must be an object"] };
+  const raw = input;
+  if (raw.sourceKind !== "external_reimport") errors.push("sourceKind must be external_reimport");
+  if (raw.approved !== true || raw.isRealPerson !== true) errors.push("import must be approved and identify a real person");
+  const sourceSystem = typeof raw.sourceSystem === "string" ? raw.sourceSystem.trim().toLowerCase() : "";
+  const sourceRecordId = typeof raw.sourceRecordId === "string" ? raw.sourceRecordId.trim() : "";
+  const provenance = typeof raw.provenance === "string" ? raw.provenance.trim() : "";
+  const displayName = typeof raw.displayName === "string" ? raw.displayName.trim() : "";
+  if (!TOKEN.test(sourceSystem) || /(?:^|[._:-])(fixture|test|development|dev)(?:$|[._:-])/.test(sourceSystem)) errors.push("sourceSystem must name an approved non-development external system");
+  if (!sourceRecordId || sourceRecordId.length > 200) errors.push("sourceRecordId is required and bounded");
+  if (!provenance || provenance.length > 500) errors.push("provenance is required and bounded");
+  if (!displayName || displayName.length > 200) errors.push("displayName is required and bounded");
+  const rawConsent = raw.consent && typeof raw.consent === "object" && !Array.isArray(raw.consent) ? raw.consent : {};
+  const consentStates = ["unknown", "granted", "denied"];
+  const marketing = typeof rawConsent.marketing === "string" ? rawConsent.marketing : "";
+  const discretionary = typeof rawConsent.discretionary === "string" ? rawConsent.discretionary : "";
+  const recordedAt = Number(rawConsent.recordedAt);
+  const basis = typeof rawConsent.basis === "string" ? rawConsent.basis.trim() : "";
+  if (!consentStates.includes(marketing) || !consentStates.includes(discretionary) || !Number.isSafeInteger(recordedAt) || recordedAt <= 0 || !basis || basis.length > 500) {
+    errors.push("consent must include marketing and discretionary states, recordedAt, and a bounded basis");
+  }
+  const identities = [];
+  if (!Array.isArray(raw.identities) || raw.identities.length < 1 || raw.identities.length > 8) {
+    errors.push("one to eight verified identities are required");
+  } else {
+    for (const item of raw.identities) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) {
+        errors.push("identity must be an object");
+        continue;
+      }
+      const candidate = item;
+      const kind = candidate.kind;
+      const value = typeof candidate.value === "string" ? candidate.value : "";
+      const verifiedAt = Number(candidate.verifiedAt);
+      if (kind !== "email" && kind !== "phone" && kind !== "external") {
+        errors.push("identity kind is invalid");
+        continue;
+      }
+      const normalized = normalizeNetworkIdentity(kind, value);
+      if (!normalized || normalized.length > 320 || !Number.isSafeInteger(verifiedAt) || verifiedAt <= 0) {
+        errors.push("identity value and verifiedAt are required and bounded");
+        continue;
+      }
+      if (kind === "email" && !emailLooksReal(normalized)) {
+        errors.push("development or invalid email identities cannot become Persons");
+        continue;
+      }
+      identities.push({ kind, value: normalized, verifiedAt });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const identity of identities) {
+    const key = `${identity.kind}:${identity.value}`;
+    if (seen.has(key)) errors.push("duplicate identity in import");
+    seen.add(key);
+  }
+  const chapterLinks = [];
+  if (raw.chapterLinks !== void 0) {
+    if (!Array.isArray(raw.chapterLinks) || raw.chapterLinks.length > allowedChapterIds.length) errors.push("chapterLinks are invalid or too numerous");
+    else for (const item of raw.chapterLinks) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) {
+        errors.push("chapter link must be an object");
+        continue;
+      }
+      const chapterId = typeof item.chapterId === "string" ? String(item.chapterId) : "";
+      const chapterPersonId = typeof item.chapterPersonId === "string" ? String(item.chapterPersonId).trim() : "";
+      if (!CHAPTER_ID.test(chapterId) || !allowedChapterIds.includes(chapterId) || !chapterPersonId || chapterPersonId.length > 200) errors.push("chapter link is outside the configured network");
+      else chapterLinks.push({ chapterId, chapterPersonId });
+    }
+  }
+  if (errors.length) return { ok: false, errors };
+  return { ok: true, errors: [], value: {
+    sourceKind: "external_reimport",
+    sourceSystem,
+    sourceRecordId,
+    provenance,
+    approved: true,
+    isRealPerson: true,
+    displayName,
+    consent: {
+      marketing,
+      discretionary,
+      recordedAt,
+      basis
+    },
+    identities,
+    ...chapterLinks.length ? { chapterLinks } : {}
+  } };
+}
+async function sha256(value) {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return [...new Uint8Array(bytes)].map((part) => part.toString(16).padStart(2, "0")).join("");
+}
+async function networkIdentityClaim(input) {
+  const normalized = normalizeNetworkIdentity(input.kind, input.value);
+  const digest = await sha256(`${input.kind}\0${normalized}`);
+  const hint = input.kind === "email" ? `${normalized.slice(0, 1)}***@${normalized.split("@")[1]}` : input.kind === "phone" ? `***${normalized.slice(-4)}` : void 0;
+  return { id: `identity_${digest}`, kind: input.kind, value: normalized, ...hint ? { hint } : {}, verifiedAt: input.verifiedAt };
+}
+async function networkSourceKey(sourceSystem, sourceRecordId) {
+  return `alias_${await sha256(`${sourceSystem}\0${sourceRecordId}`)}`;
+}
+async function networkChapterLinkId(personId, chapterId, chapterPersonId) {
+  return `chapter_person_${await sha256(`${personId}\0${chapterId}\0${chapterPersonId}`)}`;
+}
+function projectNetworkContactPolicy(policy, links) {
+  return links.map((link) => ({ ...link, contactPolicy: { ...policy } }));
+}
+function canonicalNetworkPersonId(personId, persons) {
+  const byId = new Map(persons.map((person) => [person.id, person]));
+  const seen = /* @__PURE__ */ new Set();
+  let current = personId;
+  while (true) {
+    if (seen.has(current)) return null;
+    seen.add(current);
+    const person = byId.get(current);
+    if (!person) return null;
+    if (!person.mergedIntoId) return person.id;
+    current = person.mergedIntoId;
+  }
+}
+
+// src/network-person-store.ts
+var NetworkPersonRegistryError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var rows4 = (value) => Array.isArray(value) ? value : [];
+async function loadNetworkPersonRegistry(db) {
+  const result = await db.query({
+    networkPersons: { $: { order: { updatedAt: "desc" }, limit: 1e3 } },
+    networkIdentityClaims: { $: { limit: 1e3 } },
+    networkPersonAliases: { $: { order: { updatedAt: "desc" }, limit: 1e3 } },
+    networkChapterPersonLinks: { $: { limit: 1e3 } },
+    networkPersonEvents: { $: { order: { createdAt: "desc" }, limit: 1e3 } }
+  });
+  return {
+    persons: rows4(result.networkPersons),
+    claims: rows4(result.networkIdentityClaims),
+    aliases: rows4(result.networkPersonAliases),
+    links: rows4(result.networkChapterPersonLinks),
+    events: rows4(result.networkPersonEvents)
+  };
+}
+var eventOp = (kind, mutationId, actor, now, detail, ids = {}) => ({
+  t: "update",
+  ns: "networkPersonEvents",
+  id: `network_person_event:${mutationId}`,
+  attrs: { id: `network_person_event:${mutationId}`, kind, actorId: actor.id, ...ids, mutationId, detail, createdAt: now }
+});
+var defaultPolicy = (now, consent) => ({
+  marketingSuppressed: consent.marketing !== "granted",
+  discretionarySuppressed: consent.discretionary !== "granted",
+  updatedAt: now
+});
+var isGuardConflict = (error) => error instanceof Error && error.code === "transact_guard_failed";
+async function linkOps(personId, links, now) {
+  return Promise.all(links.map(async (link) => {
+    const id = await networkChapterLinkId(personId, link.chapterId, link.chapterPersonId);
+    return { t: "update", ns: "networkChapterPersonLinks", id, attrs: { id, personId, chapterId: link.chapterId, chapterPersonId: link.chapterPersonId, state: "shadow", createdAt: now } };
+  }));
+}
+async function ambiguousAlias(db, input, aliasId, claims, candidates, mutationId, actor, now) {
+  const alias = {
+    id: aliasId,
+    sourceSystem: input.sourceSystem,
+    sourceRecordId: input.sourceRecordId,
+    sourceKey: aliasId,
+    displayName: input.displayName,
+    provenance: input.provenance,
+    consent: input.consent,
+    status: "ambiguous",
+    candidatePersonIds: candidates,
+    identityClaims: claims,
+    chapterLinks: [...input.chapterLinks ?? []],
+    revision: 1,
+    createdAt: now,
+    updatedAt: now
+  };
+  await db.transact([
+    { t: "update", ns: "networkPersonAliases", id: alias.id, attrs: { ...alias } },
+    eventOp("import_queued_ambiguous", mutationId, actor, now, { candidateCount: candidates.length, sourceSystem: input.sourceSystem }, { aliasId })
+  ], { mutationId, guards: [{ ns: "networkPersonAliases", id: alias.id, exists: false }] });
+  return { status: "ambiguous", alias };
+}
+async function importNetworkPerson(db, input, mutationId, actor, now = Date.now()) {
+  const aliasId = await networkSourceKey(input.sourceSystem, input.sourceRecordId);
+  let state = await loadNetworkPersonRegistry(db);
+  const replay = state.aliases.find((alias2) => alias2.id === aliasId);
+  if (replay) return { status: replay.status, alias: replay, replayed: true };
+  const claims = await Promise.all(input.identities.map(networkIdentityClaim));
+  const candidates = [...new Set(claims.flatMap((claim) => state.claims.filter((row) => row.id === claim.id).map((row) => row.personId)))];
+  if (candidates.length) return ambiguousAlias(db, input, aliasId, claims, candidates, mutationId, actor, now);
+  const personId = `person_${aliasId.slice("alias_".length)}`;
+  const person = { id: personId, displayName: input.displayName, state: "active", contactPolicy: defaultPolicy(now, input.consent), revision: 1, createdAt: now, updatedAt: now };
+  const alias = {
+    id: aliasId,
+    sourceSystem: input.sourceSystem,
+    sourceRecordId: input.sourceRecordId,
+    sourceKey: aliasId,
+    displayName: input.displayName,
+    provenance: input.provenance,
+    consent: input.consent,
+    status: "linked",
+    personId,
+    identityClaims: claims,
+    chapterLinks: [...input.chapterLinks ?? []],
+    revision: 1,
+    createdAt: now,
+    updatedAt: now
+  };
+  const claimOps = claims.map((claim) => ({ t: "update", ns: "networkIdentityClaims", id: claim.id, attrs: { ...claim, personId, createdAt: now } }));
+  const ops = [
+    { t: "update", ns: "networkPersons", id: personId, attrs: { ...person } },
+    { t: "update", ns: "networkPersonAliases", id: aliasId, attrs: { ...alias } },
+    ...claimOps,
+    ...await linkOps(personId, input.chapterLinks ?? [], now),
+    eventOp("person_imported", mutationId, actor, now, { sourceSystem: input.sourceSystem, identityCount: claims.length }, { personId, aliasId })
+  ];
+  try {
+    await db.transact(ops, { mutationId, guards: [
+      { ns: "networkPersonAliases", id: aliasId, exists: false },
+      ...claims.map((claim) => ({ ns: "networkIdentityClaims", id: claim.id, exists: false }))
+    ] });
+    return { status: "linked", alias, person };
+  } catch (error) {
+    if (!isGuardConflict(error)) throw error;
+    state = await loadNetworkPersonRegistry(db);
+    const existing = state.aliases.find((item) => item.id === aliasId);
+    if (existing) return { status: existing.status, alias: existing, replayed: true };
+    const raced = [...new Set(claims.flatMap((claim) => state.claims.filter((row) => row.id === claim.id).map((row) => row.personId)))];
+    if (!raced.length) throw error;
+    return ambiguousAlias(db, input, aliasId, claims, raced, `${mutationId}:review`, actor, now);
+  }
+}
+async function reviewNetworkPersonAlias(db, input, mutationId, actor, now = Date.now()) {
+  const state = await loadNetworkPersonRegistry(db);
+  const alias = state.aliases.find((row) => row.id === input.aliasId);
+  if (!alias) throw new NetworkPersonRegistryError("alias_not_found", "source alias not found");
+  if (alias.revision !== input.expectedRevision || alias.status !== "ambiguous") throw new NetworkPersonRegistryError("stale_review", "source alias changed; reload before reviewing");
+  if (input.decision === "exclude") {
+    const next2 = { ...alias, status: "excluded", revision: alias.revision + 1, updatedAt: now };
+    await db.transact([
+      { t: "update", ns: "networkPersonAliases", id: alias.id, attrs: { ...next2 } },
+      eventOp("alias_excluded", mutationId, actor, now, { sourceSystem: alias.sourceSystem }, { aliasId: alias.id })
+    ], { mutationId, guards: [{ ns: "networkPersonAliases", id: alias.id, exists: true, equals: { revision: alias.revision, status: "ambiguous" } }] });
+    return next2;
+  }
+  const canonicalId = input.personId ? canonicalNetworkPersonId(input.personId, state.persons) : null;
+  if (!canonicalId || canonicalId !== input.personId) throw new NetworkPersonRegistryError("person_not_active", "link target must be an active canonical Person");
+  const conflicting = alias.identityClaims.find((claim) => state.claims.some((row) => row.id === claim.id && row.personId !== canonicalId));
+  if (conflicting) throw new NetworkPersonRegistryError("identity_conflict", "verified identity belongs to another Person; merge or choose that Person explicitly");
+  const missing = alias.identityClaims.filter((claim) => !state.claims.some((row) => row.id === claim.id));
+  const { candidatePersonIds: _candidatePersonIds, ...aliasWithoutCandidates } = alias;
+  const next = { ...aliasWithoutCandidates, status: "linked", personId: canonicalId, revision: alias.revision + 1, updatedAt: now };
+  await db.transact([
+    { t: "update", ns: "networkPersonAliases", id: alias.id, attrs: { ...next } },
+    { t: "retract", ns: "networkPersonAliases", id: alias.id, attrs: ["candidatePersonIds"] },
+    ...missing.map((claim) => ({ t: "update", ns: "networkIdentityClaims", id: claim.id, attrs: { ...claim, personId: canonicalId, createdAt: now } })),
+    ...await linkOps(canonicalId, alias.chapterLinks, now),
+    eventOp("alias_linked", mutationId, actor, now, { identityCount: alias.identityClaims.length }, { personId: canonicalId, aliasId: alias.id })
+  ], { mutationId, guards: [
+    { ns: "networkPersonAliases", id: alias.id, exists: true, equals: { revision: alias.revision, status: "ambiguous" } },
+    ...missing.map((claim) => ({ ns: "networkIdentityClaims", id: claim.id, exists: false }))
+  ] });
+  return next;
+}
+async function mergeNetworkPersons(db, input, mutationId, actor, now = Date.now()) {
+  const state = await loadNetworkPersonRegistry(db);
+  const source = state.persons.find((person) => person.id === input.sourcePersonId);
+  const target = state.persons.find((person) => person.id === input.targetPersonId);
+  if (!source || !target || source.id === target.id || source.state !== "active" || target.state !== "active") throw new NetworkPersonRegistryError("invalid_merge", "merge requires two distinct active Persons");
+  if (source.revision !== input.expectedRevision || target.revision !== input.expectedTargetRevision || canonicalNetworkPersonId(target.id, state.persons) !== target.id) {
+    throw new NetworkPersonRegistryError("stale_merge", "Person changed; reload before merging");
+  }
+  const sourceNext = { ...source, state: "merged", mergedIntoId: target.id, revision: source.revision + 1, updatedAt: now };
+  const targetNext = {
+    ...target,
+    contactPolicy: {
+      marketingSuppressed: source.contactPolicy.marketingSuppressed || target.contactPolicy.marketingSuppressed,
+      discretionarySuppressed: source.contactPolicy.discretionarySuppressed || target.contactPolicy.discretionarySuppressed,
+      ...target.contactPolicy.reason || source.contactPolicy.reason ? { reason: target.contactPolicy.reason ?? source.contactPolicy.reason } : {},
+      updatedAt: now
+    },
+    revision: target.revision + 1,
+    updatedAt: now
+  };
+  await db.transact([
+    { t: "update", ns: "networkPersons", id: source.id, attrs: { ...sourceNext } },
+    { t: "update", ns: "networkPersons", id: target.id, attrs: { ...targetNext } },
+    eventOp("persons_merged", mutationId, actor, now, { targetPersonId: target.id }, { personId: source.id })
+  ], { mutationId, guards: [
+    { ns: "networkPersons", id: source.id, exists: true, equals: { revision: source.revision, state: "active" } },
+    { ns: "networkPersons", id: target.id, exists: true, equals: { revision: target.revision, state: "active" } }
+  ] });
+  return { source: sourceNext, target: targetNext };
+}
+async function unmergeNetworkPerson(db, input, mutationId, actor, now = Date.now()) {
+  const state = await loadNetworkPersonRegistry(db);
+  const person = state.persons.find((row) => row.id === input.personId);
+  if (!person || person.state !== "merged" || person.revision !== input.expectedRevision) throw new NetworkPersonRegistryError("stale_unmerge", "merged Person changed; reload before unmerging");
+  const next = { ...person, state: "active", revision: person.revision + 1, updatedAt: now };
+  delete next.mergedIntoId;
+  await db.transact([
+    { t: "update", ns: "networkPersons", id: person.id, attrs: { state: "active", revision: next.revision, updatedAt: now } },
+    { t: "retract", ns: "networkPersons", id: person.id, attrs: ["mergedIntoId"] },
+    eventOp("person_unmerged", mutationId, actor, now, {}, { personId: person.id })
+  ], { mutationId, guards: [{ ns: "networkPersons", id: person.id, exists: true, equals: { revision: person.revision, state: "merged", mergedIntoId: person.mergedIntoId } }] });
+  return next;
+}
+async function suppressNetworkPerson(db, input, mutationId, actor, now = Date.now()) {
+  const state = await loadNetworkPersonRegistry(db);
+  const person = state.persons.find((row) => row.id === input.personId);
+  if (!person || person.state !== "active" || canonicalNetworkPersonId(person.id, state.persons) !== person.id || person.revision !== input.expectedRevision) {
+    throw new NetworkPersonRegistryError("stale_suppression", "active canonical Person changed; reload before updating suppression");
+  }
+  const policy = { marketingSuppressed: input.marketingSuppressed, discretionarySuppressed: input.discretionarySuppressed, ...input.reason ? { reason: input.reason } : {}, updatedAt: now };
+  const next = { ...person, contactPolicy: policy, revision: person.revision + 1, updatedAt: now };
+  await db.transact([
+    { t: "update", ns: "networkPersons", id: person.id, attrs: { ...next } },
+    eventOp("contact_suppression_changed", mutationId, actor, now, { marketingSuppressed: policy.marketingSuppressed, discretionarySuppressed: policy.discretionarySuppressed }, { personId: person.id })
+  ], { mutationId, guards: [{ ns: "networkPersons", id: person.id, exists: true, equals: { revision: person.revision } }] });
+  return next;
+}
+
+// src/network-person-reveal.ts
+async function revealNetworkPersonRegistryRecord(db, input, mutationId, actor, now = Date.now()) {
+  const reason = input.reason.trim();
+  if (!reason || reason.length > 500) {
+    throw new NetworkPersonRegistryError("invalid_reveal", "a bounded reveal reason is required");
+  }
+  const state = await loadNetworkPersonRegistry(db);
+  const target = input.kind === "person" ? state.persons.find((row) => row.id === input.id) : state.aliases.find((row) => row.id === input.id);
+  if (!target) throw new NetworkPersonRegistryError("reveal_not_found", "registry record not found");
+  const ids = input.kind === "person" ? { personId: input.id } : { aliasId: input.id };
+  const event = {
+    t: "update",
+    ns: "networkPersonEvents",
+    id: `network_person_event:${mutationId}`,
+    attrs: {
+      id: `network_person_event:${mutationId}`,
+      kind: "pii_revealed",
+      actorId: actor.id,
+      ...ids,
+      mutationId,
+      detail: { targetKind: input.kind, reason },
+      createdAt: now
+    }
+  };
+  await db.transact([event], {
+    mutationId,
+    guards: [{ ns: "networkPersonEvents", id: `network_person_event:${mutationId}`, exists: false }]
+  });
+  return input.kind === "person" ? { kind: "person", person: target, identities: state.claims.filter((claim) => claim.personId === input.id) } : { kind: "alias", alias: target };
+}
+
+// src/worker-routes-network-person-registry.ts
+var PATH2 = "/api/admin/network-person-registry";
+var MAX_BODY2 = 32e3;
+var MUTATION_ID4 = /^[A-Za-z0-9_-]{16,128}$/;
+function redactedName(displayName) {
+  return displayName.split(/\s+/).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}\u2026`).join(" ");
+}
+var redactedLink = (link) => ({
+  id: link.id,
+  personId: link.personId,
+  chapterId: link.chapterId,
+  state: link.state,
+  createdAt: link.createdAt
+});
+var safePolicy = (policy) => ({
+  marketingSuppressed: policy.marketingSuppressed,
+  discretionarySuppressed: policy.discretionarySuppressed,
+  hasReason: Boolean(policy.reason),
+  updatedAt: policy.updatedAt
+});
+var safeAlias = (alias) => ({
+  id: alias.id,
+  sourceSystem: alias.sourceSystem,
+  displayNameHint: redactedName(alias.displayName),
+  status: alias.status,
+  personId: alias.personId ?? null,
+  candidatePersonIds: alias.candidatePersonIds ?? [],
+  consent: {
+    marketing: alias.consent.marketing,
+    discretionary: alias.consent.discretionary,
+    recordedAt: alias.consent.recordedAt,
+    hasBasis: Boolean(alias.consent.basis)
+  },
+  identityClaims: alias.identityClaims.map(({ id, kind, hint, verifiedAt }) => ({ id, kind, hint: hint ?? null, verifiedAt })),
+  chapterIds: [...new Set(alias.chapterLinks.map((link) => link.chapterId))],
+  revision: alias.revision,
+  updatedAt: alias.updatedAt
+});
+var safePerson = (person) => ({
+  id: person.id,
+  displayNameHint: redactedName(person.displayName),
+  state: person.state,
+  mergedIntoId: person.mergedIntoId ?? null,
+  revision: person.revision,
+  contactPolicy: safePolicy(person.contactPolicy)
+});
+var positiveRevision = (value) => {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+};
+async function gate10(req, env, ctx) {
+  const db = ctx.makeDb(env);
+  const user = await ctx.verifyUser(req, env);
+  if (!user) return { response: json({ error: "unauthorized" }, 401) };
+  if (!await ctx.isSuperAdminEmail(db, user.email)) return { response: json({ error: "forbidden" }, 403) };
+  return { db, user };
+}
+function registryError(error) {
+  if (error instanceof NetworkPersonRegistryError) {
+    const status = error.code.includes("stale") || error.code === "identity_conflict" ? 409 : error.code.endsWith("not_found") ? 404 : 400;
+    return json({ error: error.message, code: error.code }, status);
+  }
+  if (error instanceof Error && error.code === "transact_guard_failed") {
+    return json({ error: "registry changed; reload and retry", code: "stale_write" }, 409);
+  }
+  return null;
+}
+var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
+  if (url.pathname !== PATH2) return null;
+  if (!ctx.chapter.networkPersonRegistry) return json({ error: "not found" }, 404);
+  if (req.method !== "GET" && req.method !== "POST") return json({ error: "method not allowed" }, 405);
+  if (req.method === "POST" && Number(req.headers.get("content-length") ?? 0) > MAX_BODY2) {
+    return json({ error: "request is too large" }, 413);
+  }
+  const got = await gate10(req, env, ctx);
+  if ("response" in got) return got.response;
+  const db = got.db;
+  if (req.method === "POST") {
+    let body;
+    try {
+      const text4 = await req.text();
+      if (new TextEncoder().encode(text4).byteLength > MAX_BODY2) return json({ error: "request is too large" }, 413);
+      const parsed = JSON.parse(text4);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("invalid");
+      body = parsed;
+    } catch {
+      return json({ error: "invalid JSON body" }, 400);
+    }
+    const command = typeof body.command === "string" ? body.command : "";
+    const mutationId = typeof body.mutationId === "string" ? body.mutationId : "";
+    const input = body.input && typeof body.input === "object" && !Array.isArray(body.input) ? body.input : {};
+    if (!MUTATION_ID4.test(mutationId)) return json({ error: "a valid mutationId is required" }, 400);
+    const actionActor = { id: got.user.userId };
+    try {
+      if (command === "import") {
+        const validated = validateNetworkPersonImport(input, ctx.chapter.networkPersonRegistry.chapterIds);
+        if (!validated.ok || !validated.value) return json({ error: "invalid import", details: validated.errors }, 400);
+        const result = await importNetworkPerson(db, validated.value, mutationId, actionActor);
+        return json({
+          result: {
+            status: result.status,
+            alias: safeAlias(result.alias),
+            ..."person" in result && result.person ? { person: safePerson(result.person) } : {},
+            ..."replayed" in result ? { replayed: result.replayed } : {}
+          }
+        }, 201);
+      }
+      if (command === "review") {
+        if (input.decision !== "link" && input.decision !== "exclude") return json({ error: "review decision must be link or exclude" }, 400);
+        const expectedRevision = positiveRevision(input.expectedRevision);
+        if (!expectedRevision) return json({ error: "expectedRevision is required" }, 400);
+        if (input.decision === "link" && typeof input.personId !== "string") return json({ error: "personId is required when linking" }, 400);
+        const result = await reviewNetworkPersonAlias(db, {
+          aliasId: typeof input.aliasId === "string" ? input.aliasId : "",
+          expectedRevision,
+          decision: input.decision,
+          ...typeof input.personId === "string" ? { personId: input.personId } : {}
+        }, mutationId, actionActor);
+        return json({ result: safeAlias(result) });
+      }
+      if (command === "merge") {
+        const expectedRevision = positiveRevision(input.expectedRevision);
+        const expectedTargetRevision = positiveRevision(input.expectedTargetRevision);
+        if (!expectedRevision || !expectedTargetRevision) return json({ error: "source and target revisions are required" }, 400);
+        const result = await mergeNetworkPersons(db, {
+          sourcePersonId: typeof input.sourcePersonId === "string" ? input.sourcePersonId : "",
+          targetPersonId: typeof input.targetPersonId === "string" ? input.targetPersonId : "",
+          expectedRevision,
+          expectedTargetRevision
+        }, mutationId, actionActor);
+        return json({ result: { source: safePerson(result.source), target: safePerson(result.target) } });
+      }
+      if (command === "unmerge") {
+        const expectedRevision = positiveRevision(input.expectedRevision);
+        if (!expectedRevision) return json({ error: "expectedRevision is required" }, 400);
+        const result = await unmergeNetworkPerson(db, {
+          personId: typeof input.personId === "string" ? input.personId : "",
+          expectedRevision
+        }, mutationId, actionActor);
+        return json({ result: safePerson(result) });
+      }
+      if (command === "suppression") {
+        const expectedRevision = positiveRevision(input.expectedRevision);
+        if (!expectedRevision || typeof input.marketingSuppressed !== "boolean" || typeof input.discretionarySuppressed !== "boolean") {
+          return json({ error: "expectedRevision and both suppression flags are required" }, 400);
+        }
+        const reason = typeof input.reason === "string" ? input.reason.trim() : "";
+        if (reason.length > 500) return json({ error: "suppression reason is too long" }, 400);
+        const result = await suppressNetworkPerson(db, {
+          personId: typeof input.personId === "string" ? input.personId : "",
+          expectedRevision,
+          marketingSuppressed: input.marketingSuppressed,
+          discretionarySuppressed: input.discretionarySuppressed,
+          ...reason ? { reason } : {}
+        }, mutationId, actionActor);
+        return json({ result: safePerson(result) });
+      }
+      if (command === "reveal") {
+        if (input.kind !== "person" && input.kind !== "alias") return json({ error: "reveal kind must be person or alias" }, 400);
+        const result = await revealNetworkPersonRegistryRecord(db, {
+          kind: input.kind,
+          id: typeof input.id === "string" ? input.id : "",
+          reason: typeof input.reason === "string" ? input.reason : ""
+        }, mutationId, actionActor);
+        return json({ sensitive: true, result });
+      }
+      return json({ error: "unknown registry command" }, 400);
+    } catch (error) {
+      const response = registryError(error);
+      if (response) return response;
+      throw error;
+    }
+  }
+  const state = await loadNetworkPersonRegistry(db);
+  const persons = state.persons.map((person) => {
+    const links = state.links.filter((link) => link.personId === person.id);
+    const canonicalId = canonicalNetworkPersonId(person.id, state.persons);
+    const canonical2 = state.persons.find((candidate) => candidate.id === canonicalId) ?? person;
+    return {
+      id: person.id,
+      displayNameHint: redactedName(person.displayName),
+      state: person.state,
+      canonicalPersonId: canonicalId,
+      mergedIntoId: person.mergedIntoId ?? null,
+      revision: person.revision,
+      contactPolicy: safePolicy(person.contactPolicy),
+      identityClaims: state.claims.filter((claim) => claim.personId === person.id).map(({ id, kind, hint, verifiedAt }) => ({ id, kind, hint: hint ?? null, verifiedAt })),
+      chapterLinks: links.map(redactedLink),
+      chapterProjections: projectNetworkContactPolicy(canonical2.contactPolicy, links.map(redactedLink)).map(({ contactPolicy, ...projection }) => ({ ...projection, contactPolicy: safePolicy(contactPolicy) }))
+    };
+  });
+  const aliases = state.aliases.map(safeAlias);
+  return json({
+    version: 1,
+    mode: "shadow",
+    writable: true,
+    authoritativeForChapterOperation: false,
+    configuredChapterIds: ctx.chapter.networkPersonRegistry.chapterIds,
+    persons,
+    aliases,
+    reviewQueue: aliases.filter((alias) => alias.status === "ambiguous"),
+    excluded: aliases.filter((alias) => alias.status === "excluded"),
+    recentEvents: state.events.slice(0, 100).map((event) => ({
+      id: event.id,
+      kind: event.kind,
+      personId: event.personId ?? null,
+      aliasId: event.aliasId ?? null,
+      actorId: event.actorId,
+      mutationId: event.mutationId,
+      createdAt: event.createdAt
+    }))
+  });
+};
+
 // src/worker-routes-formation.ts
 var import_crm11 = require("@odla-ai/crm");
 var SUBMISSION = /^[A-Za-z0-9_-]{8,128}$/;
@@ -7065,17 +7655,17 @@ async function builderLibraryDigest(document) {
 var control2 = (row) => row?.document && typeof row.document === "object" ? row : null;
 var local2 = (row) => row?.document && typeof row.document === "object" ? row : null;
 async function loadActiveBuilderLibraryControls(db, targetId, environment) {
-  const rows4 = (await db.query({ builderLibraryControls: { $: { where: { targetId, environment, active: true }, limit: 500 } } })).builderLibraryControls;
-  return Array.isArray(rows4) ? rows4.map(control2).filter(Boolean) : [];
+  const rows5 = (await db.query({ builderLibraryControls: { $: { where: { targetId, environment, active: true }, limit: 500 } } })).builderLibraryControls;
+  return Array.isArray(rows5) ? rows5.map(control2).filter(Boolean) : [];
 }
 async function loadLatestBuilderLibraryControl(db, sourceId, targetId, environment) {
-  const rows4 = (await db.query({ builderLibraryControls: { $: { where: { sourceId, targetId, environment }, order: { revision: "desc" }, limit: 20 } } })).builderLibraryControls;
-  return control2(Array.isArray(rows4) ? [...rows4].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
+  const rows5 = (await db.query({ builderLibraryControls: { $: { where: { sourceId, targetId, environment }, order: { revision: "desc" }, limit: 20 } } })).builderLibraryControls;
+  return control2(Array.isArray(rows5) ? [...rows5].sort((a, b) => Number(b.revision) - Number(a.revision))[0] : void 0);
 }
 async function loadLocalBuilderLibrary(db, appId, environment) {
   const id = `builder-library-local:${environment}`;
-  const rows4 = (await db.query({ builderLibraryLocal: { $: { where: { id }, limit: 1 } } })).builderLibraryLocal;
-  return local2(Array.isArray(rows4) ? rows4[0] : void 0);
+  const rows5 = (await db.query({ builderLibraryLocal: { $: { where: { id }, limit: 1 } } })).builderLibraryLocal;
+  return local2(Array.isArray(rows5) ? rows5[0] : void 0);
 }
 async function materializeBuilderLibraryControl(db, envelope, previous, receivedAt) {
   const { document, digest } = envelope;
@@ -7134,9 +7724,10 @@ async function verifySource(req, db, ctx) {
   return null;
 }
 var handleBuilderLibraryControl = async (req, url, env, ctx) => {
-  if (req.method !== "POST" || url.pathname !== BUILDER_LIBRARY_CONTROL_PATH) return null;
+  if (url.pathname !== BUILDER_LIBRARY_CONTROL_PATH) return null;
   const settings = ctx.chapter.builderLibrary;
   if (!settings) return json({ error: "not found" }, 404);
+  if (req.method !== "POST") return json({ error: "unauthorized" }, 401);
   const db = ctx.makeDb(env);
   const verified = await verifySource(req, db, ctx);
   if (!verified) return json({ error: "unauthorized" }, 401);
@@ -7565,6 +8156,7 @@ var BUILTIN_ROUTES = [
   handleAdminNetworkRecords,
   handleAdminNetworkNotes,
   handleAdminNetworkSharedNotes,
+  handleAdminNetworkPersonRegistry,
   // API requests must never fall through to an SPA asset response. Hosts still
   // get first refusal through options.routes, then this terminates unknown API
   // paths with an explicit machine-readable 404.