@odla-ai/chapter 0.47.3 → 0.47.5

package/dist/worker/index.js

@@ -340,8 +340,8 @@ function tierPayable(tier, group, hasSecretKey) {
 function byOrder(a, b) {
   return a.sortOrder - b.sortOrder || a.id.localeCompare(b.id);
 }
-function resolveTiers(group, rows6 = []) {
-  const stored = rows6.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",
@@ -387,15 +387,15 @@ function rowToTier(row, groupId) {
 }
 async function loadTiers(db, group) {
   const groupId = String(group.id ?? "");
-  let rows6;
+  let rows5;
   try {
-    rows6 = (await db.query({
+    rows5 = (await db.query({
       tiers: { $: { where: { groupId }, order: { sortOrder: "asc" }, limit: 100 } }
     })).tiers;
   } catch {
-    rows6 = void 0;
+    rows5 = void 0;
   }
-  const list = Array.isArray(rows6) ? rows6.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) {
@@ -1454,27 +1454,27 @@ async function hasSignupControl(db, targetId, environment, active) {
   if (db.aggregate) {
     return Number((await db.aggregate("signupControls", { count: true }, { where })).count ?? 0) > 0;
   }
-  const rows6 = (await db.query({ signupControls: {} })).signupControls;
-  return Array.isArray(rows6) && rows6.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 rows6 = (await db.query({ signupControls: { $: {
+  const rows5 = (await db.query({ signupControls: { $: {
     where: { targetId, environment },
     order: { revision: "desc" },
     limit: 1
   } } })).signupControls;
-  const latest = Array.isArray(rows6) ? [...rows6].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 rows6 = (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(rows6) ? [...rows6].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) {
@@ -2850,33 +2850,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 rows6 = (await db.query({ [ns]: {} }))[ns] ?? [];
-  return rows6.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 rows6 = (await db.query({ memberContentControls: { $: {
+  const rows5 = (await db.query({ memberContentControls: { $: {
     where,
     order: { revision: "desc" },
     limit: 1
   } } })).memberContentControls;
-  return control(Array.isArray(rows6) ? [...rows6].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 rows6 = (await db.query({ memberContentControls: { $: {
+  const rows5 = (await db.query({ memberContentControls: { $: {
     where,
     order: { revision: "desc" },
     limit: 1
   } } })).memberContentControls;
-  return control(Array.isArray(rows6) ? [...rows6].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 rows6 = (await db.query({ memberContentLocal: { $: { where: { id }, limit: 1 } } })).memberContentLocal;
-  return local(Array.isArray(rows6) ? rows6[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: digest2 } = envelope;
@@ -2931,12 +2931,12 @@ async function groupAndTiers(db, chapterId) {
 }
 async function memberTierId(db, chapterId, email) {
   if (!email) return null;
-  let rows6 = (await db.query({ applications: { $: {
+  let rows5 = (await db.query({ applications: { $: {
     where: { emailNormalized: normalizeAdmissionEmail(email) },
     limit: 20
   } } })).applications;
-  if (!rows6?.length) rows6 = (await db.query({ applications: { $: { where: { email }, limit: 20 } } })).applications;
-  const latest = Array.isArray(rows6) ? [...rows6].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) {
@@ -3662,8 +3662,8 @@ function makeCalendar(env) {
 }
 async function firstRow(db, ns, q) {
   const res = await db.query({ [ns]: { $: q } });
-  const rows6 = res[ns];
-  return Array.isArray(rows6) ? rows6[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);
@@ -4063,8 +4063,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 rows6 = charges.body.data ?? [];
-      const paid = rows6.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");
@@ -4172,8 +4172,8 @@ async function issueGiftClaim(db, intent, provider, now) {
     throw new Error("gift issuance conflict");
   }
 }
-function buyerGiftClaims(rows6, now) {
-  return rows6.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 {
@@ -4465,8 +4465,8 @@ function classifyMemberStripeEvent(identity, target, hasProvenLegacyLocalLink) {
 
 // src/stripe-webhook-partition.ts
 var firstRow2 = async (db, ns, q) => {
-  const rows6 = (await db.query({ [ns]: { $: q } }))[ns];
-  return Array.isArray(rows6) ? rows6[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));
@@ -4536,8 +4536,8 @@ async function replayedStripeReceipt(db, eventId, digest2, event) {
 // src/worker-routes-payments.ts
 async function firstRow3(db, ns, q) {
   const res = await db.query({ [ns]: { $: q } });
-  const rows6 = res[ns];
-  return Array.isArray(rows6) ? rows6[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) {
@@ -5003,8 +5003,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(rows6) {
-  return rows6.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,
@@ -5026,12 +5026,12 @@ var handleAdminMeetings = async (req, url, env, ctx) => {
   const query = await db.query({
     meetings: { $: { where: all ? {} : { status: "scheduled" }, order: { startAt: "asc" }, limit: 500 } }
   });
-  let rows6 = Array.isArray(query.meetings) ? query.meetings : [];
-  if (Number.isFinite(from)) rows6 = rows6.filter((m) => Number(m.startAt ?? 0) >= from);
-  if (Number.isFinite(to)) rows6 = rows6.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(rows6), await upcomingEvents(env), Date.now());
+    decisions = reconcileMeetings(toReconcile(rows5), await upcomingEvents(env), Date.now());
   } catch {
   }
   const patched = /* @__PURE__ */ new Map();
@@ -5058,7 +5058,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 = rows6.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 });
 };
 
@@ -5134,10 +5134,10 @@ var handleAdminPeople = async (req, url, env, ctx) => {
       });
     }
   }
-  const rows6 = [...people.values()].sort(
+  const rows5 = [...people.values()].sort(
     (x, y) => (y.application?.createdAt ?? -1) - (x.application?.createdAt ?? -1)
   );
-  return json({ people: rows6 });
+  return json({ people: rows5 });
 };
 var handleAdminPeopleAccess = async (req, url, env, ctx) => {
   if (req.method !== "GET" || url.pathname !== "/api/admin/people/access") return null;
@@ -6993,6 +6993,9 @@ async function networkSourceKey(sourceSystem, sourceRecordId) {
 async function networkChapterLinkId(personId, chapterId, chapterPersonId) {
   return `chapter_person_${await sha256(`${personId}\0${chapterId}\0${chapterPersonId}`)}`;
 }
+async function networkChapterPersonSourceKey(chapterId, chapterPersonId) {
+  return `chapter_source_${await sha256(`${chapterId}\0${chapterPersonId}`)}`;
+}
 function projectNetworkContactPolicy(policy, links) {
   return links.map((link) => ({ ...link, contactPolicy: { ...policy } }));
 }
@@ -7010,7 +7013,7 @@ function canonicalNetworkPersonId(personId, persons) {
   }
 }
 
-// src/network-person-store.ts
+// src/network-person-store-state.ts
 var NetworkPersonRegistryError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -7018,29 +7021,112 @@ var NetworkPersonRegistryError = class extends Error {
   }
   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 = {}) => ({
+var networkPersonEventOp = (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 asRows = (value) => Array.isArray(value) ? value : [];
+var MAX_ROWS = 1e4;
+async function boundedRows(db, ns, order2) {
+  const collected = [];
+  const pageSize = 500;
+  for (let offset = 0; offset <= MAX_ROWS; offset += pageSize) {
+    const result = await db.query({ [ns]: { $: { limit: pageSize, offset, ...order2 ? { order: order2 } : {} } } });
+    const page = asRows(result[ns]);
+    collected.push(...page);
+    if (collected.length > MAX_ROWS) {
+      throw new NetworkPersonRegistryError(
+        "registry_too_large",
+        `network Person registry ${ns} exceeds the ${MAX_ROWS.toLocaleString()}-row operational bound`
+      );
+    }
+    if (page.length < pageSize) return collected;
+  }
+  return collected;
+}
+async function loadNetworkPersonRegistry(db) {
+  const [persons, claims, aliases, links, events] = await Promise.all([
+    boundedRows(db, "networkPersons", { updatedAt: "desc" }),
+    boundedRows(db, "networkIdentityClaims"),
+    boundedRows(db, "networkPersonAliases", { updatedAt: "desc" }),
+    boundedRows(db, "networkChapterPersonLinks"),
+    boundedRows(db, "networkPersonEvents", { createdAt: "desc" })
+  ]);
+  return { persons, claims, aliases, links, events };
+}
+
+// src/network-person-link-store.ts
+async function linkNetworkChapterPerson(db, input, mutationId, actor, now = Date.now()) {
+  const state = await loadNetworkPersonRegistry(db);
+  const canonicalId = canonicalNetworkPersonId(input.personId, state.persons);
+  const person = state.persons.find((row) => row.id === input.personId);
+  if (!person || person.state !== "active" || canonicalId !== person.id) {
+    throw new NetworkPersonRegistryError("person_not_active", "link target must be an active canonical Person");
+  }
+  const sourceKey = await networkChapterPersonSourceKey(input.chapterId, input.chapterPersonId);
+  const existingSource = state.links.find((link2) => link2.state === "shadow" && (link2.sourceKey === sourceKey || link2.chapterId === input.chapterId && link2.chapterPersonId === input.chapterPersonId));
+  if (existingSource) {
+    if (existingSource.personId !== person.id) {
+      throw new NetworkPersonRegistryError("source_already_linked", "chapter source row is linked to another Person");
+    }
+    return { person, link: existingSource, replayed: true };
+  }
+  if (person.revision !== input.expectedPersonRevision) {
+    throw new NetworkPersonRegistryError("stale_source_link", "Person changed; reload before linking this source row");
+  }
+  const expectedClaim = await networkIdentityClaim({ kind: "email", value: input.verifiedEmail, verifiedAt: 1 });
+  if (!state.claims.some((claim) => claim.id === expectedClaim.id && claim.personId === person.id && claim.kind === "email")) {
+    throw new NetworkPersonRegistryError("identity_mismatch", "source email is not an exact verified identity on this Person");
+  }
+  const id = await networkChapterLinkId(person.id, input.chapterId, input.chapterPersonId);
+  const previous = state.links.find((link2) => link2.id === id);
+  const link = {
+    id,
+    personId: person.id,
+    chapterId: input.chapterId,
+    chapterPersonId: input.chapterPersonId,
+    sourceKey,
+    state: "shadow",
+    createdAt: previous?.createdAt ?? now
+  };
+  const nextPerson = { ...person, revision: person.revision + 1, updatedAt: now };
+  await db.transact([
+    { t: "update", ns: "networkPersons", id: person.id, attrs: { ...nextPerson } },
+    { t: "update", ns: "networkChapterPersonLinks", id, attrs: { ...link } },
+    networkPersonEventOp("chapter_source_linked", mutationId, actor, now, { chapterId: input.chapterId }, { personId: person.id })
+  ], { mutationId, guards: [
+    { ns: "networkPersons", id: person.id, exists: true, equals: { revision: person.revision, state: "active" } },
+    { ns: "networkChapterPersonLinks", id, exists: Boolean(previous), ...previous ? { equals: { state: "revoked" } } : {} }
+  ] });
+  return { person: nextPerson, link };
+}
+async function unlinkNetworkChapterPerson(db, input, mutationId, actor, now = Date.now()) {
+  const reason = input.reason.trim();
+  if (!reason || reason.length > 500) throw new NetworkPersonRegistryError("invalid_unlink", "a bounded unlink reason is required");
+  const state = await loadNetworkPersonRegistry(db);
+  const person = state.persons.find((row) => row.id === input.personId);
+  const link = state.links.find((row) => row.id === input.linkId && row.personId === input.personId);
+  if (!person || person.state !== "active" || person.revision !== input.expectedPersonRevision || !link || link.state !== "shadow") {
+    throw new NetworkPersonRegistryError("stale_source_unlink", "Person or source link changed; reload before undoing the link");
+  }
+  const nextPerson = { ...person, revision: person.revision + 1, updatedAt: now };
+  const nextLink = { ...link, state: "revoked" };
+  delete nextLink.sourceKey;
+  await db.transact([
+    { t: "update", ns: "networkPersons", id: person.id, attrs: { ...nextPerson } },
+    { t: "update", ns: "networkChapterPersonLinks", id: link.id, attrs: { state: "revoked" } },
+    { t: "retract", ns: "networkChapterPersonLinks", id: link.id, attrs: ["sourceKey"] },
+    networkPersonEventOp("chapter_source_unlinked", mutationId, actor, now, { chapterId: link.chapterId, reason }, { personId: person.id })
+  ], { mutationId, guards: [
+    { ns: "networkPersons", id: person.id, exists: true, equals: { revision: person.revision, state: "active" } },
+    { ns: "networkChapterPersonLinks", id: link.id, exists: true, equals: { state: "shadow", personId: person.id } }
+  ] });
+  return { person: nextPerson, link: nextLink };
+}
+
+// src/network-person-store.ts
 var defaultPolicy = (now, consent) => ({
   marketingSuppressed: consent.marketing !== "granted",
   discretionarySuppressed: consent.discretionary !== "granted",
@@ -7050,7 +7136,8 @@ var isGuardConflict = (error) => error instanceof Error && error.code === "trans
 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 } };
+    const sourceKey = await networkChapterPersonSourceKey(link.chapterId, link.chapterPersonId);
+    return { t: "update", ns: "networkChapterPersonLinks", id, attrs: { id, personId, chapterId: link.chapterId, chapterPersonId: link.chapterPersonId, sourceKey, state: "shadow", createdAt: now } };
   }));
 }
 async function ambiguousAlias(db, input, aliasId, claims, candidates, mutationId, actor, now) {
@@ -7072,7 +7159,7 @@ async function ambiguousAlias(db, input, aliasId, claims, candidates, mutationId
   };
   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 })
+    networkPersonEventOp("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 };
 }
@@ -7108,7 +7195,7 @@ async function importNetworkPerson(db, input, mutationId, actor, now = Date.now(
     { 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 })
+    networkPersonEventOp("person_imported", mutationId, actor, now, { sourceSystem: input.sourceSystem, identityCount: claims.length }, { personId, aliasId })
   ];
   try {
     await db.transact(ops, { mutationId, guards: [
@@ -7130,12 +7217,21 @@ async function reviewNetworkPersonAlias(db, input, mutationId, actor, now = Date
   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");
+  const expectedStatus = input.decision === "reopen" ? "excluded" : "ambiguous";
+  if (alias.revision !== input.expectedRevision || alias.status !== expectedStatus) throw new NetworkPersonRegistryError("stale_review", "source alias changed; reload before reviewing");
+  if (input.decision === "reopen") {
+    const next2 = { ...alias, status: "ambiguous", revision: alias.revision + 1, updatedAt: now };
+    await db.transact([
+      { t: "update", ns: "networkPersonAliases", id: alias.id, attrs: { ...next2 } },
+      networkPersonEventOp("alias_reopened", mutationId, actor, now, { sourceSystem: alias.sourceSystem }, { aliasId: alias.id })
+    ], { mutationId, guards: [{ ns: "networkPersonAliases", id: alias.id, exists: true, equals: { revision: alias.revision, status: "excluded" } }] });
+    return next2;
+  }
   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 })
+      networkPersonEventOp("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;
   }
@@ -7151,7 +7247,7 @@ async function reviewNetworkPersonAlias(db, input, mutationId, actor, now = Date
     { 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 })
+    networkPersonEventOp("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 }))
@@ -7181,7 +7277,7 @@ async function mergeNetworkPersons(db, input, mutationId, actor, now = Date.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 })
+    networkPersonEventOp("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" } }
@@ -7197,7 +7293,7 @@ async function unmergeNetworkPerson(db, input, mutationId, actor, now = Date.now
   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 })
+    networkPersonEventOp("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;
 }
@@ -7211,63 +7307,30 @@ async function suppressNetworkPerson(db, input, mutationId, actor, now = Date.no
   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 })
+    networkPersonEventOp("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}$/;
+// src/network-person-route-projection.ts
 function redactedName(displayName) {
   return displayName.split(/\s+/).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}\u2026`).join(" ");
 }
-var redactedLink = (link) => ({
+var redactedNetworkPersonLink = async (link) => ({
   id: link.id,
   personId: link.personId,
   chapterId: link.chapterId,
+  sourceKey: await networkChapterPersonSourceKey(link.chapterId, link.chapterPersonId),
   state: link.state,
   createdAt: link.createdAt
 });
-var safePolicy = (policy) => ({
+var safeNetworkContactPolicy = (policy) => ({
   marketingSuppressed: policy.marketingSuppressed,
   discretionarySuppressed: policy.discretionarySuppressed,
   hasReason: Boolean(policy.reason),
   updatedAt: policy.updatedAt
 });
-var safeAlias = (alias) => ({
+var safeNetworkPersonAlias = async (alias) => ({
   id: alias.id,
   sourceSystem: alias.sourceSystem,
   displayNameHint: redactedName(alias.displayName),
@@ -7282,17 +7345,91 @@ var safeAlias = (alias) => ({
   },
   identityClaims: alias.identityClaims.map(({ id, kind, hint, verifiedAt }) => ({ id, kind, hint: hint ?? null, verifiedAt })),
   chapterIds: [...new Set(alias.chapterLinks.map((link) => link.chapterId))],
+  chapterSources: await Promise.all(alias.chapterLinks.map(async (link) => ({
+    chapterId: link.chapterId,
+    sourceKey: await networkChapterPersonSourceKey(link.chapterId, link.chapterPersonId)
+  }))),
   revision: alias.revision,
   updatedAt: alias.updatedAt
 });
-var safePerson = (person) => ({
+var safeNetworkPerson = (person, claims = []) => ({
   id: person.id,
+  displayName: person.displayName,
   displayNameHint: redactedName(person.displayName),
+  verifiedEmails: claims.filter((claim) => claim.kind === "email").map((claim) => ({ value: claim.value, verifiedAt: claim.verifiedAt })).sort((left, right) => right.verifiedAt - left.verifiedAt || left.value.localeCompare(right.value)),
   state: person.state,
   mergedIntoId: person.mergedIntoId ?? null,
   revision: person.revision,
-  contactPolicy: safePolicy(person.contactPolicy)
+  contactPolicy: safeNetworkContactPolicy(person.contactPolicy)
 });
+async function projectNetworkPersonRegistryState(state) {
+  const persons = await Promise.all(state.persons.map(async (person) => {
+    const claims = state.claims.filter((claim) => claim.personId === person.id);
+    const links = state.links.filter((link) => link.personId === person.id && link.state === "shadow");
+    const safeLinks = await Promise.all(links.map(redactedNetworkPersonLink));
+    const canonicalId = canonicalNetworkPersonId(person.id, state.persons);
+    const canonical2 = state.persons.find((candidate) => candidate.id === canonicalId) ?? person;
+    return {
+      ...safeNetworkPerson(person, claims),
+      canonicalPersonId: canonicalId,
+      identityClaims: claims.map(({ id, kind, hint, verifiedAt }) => ({ id, kind, hint: hint ?? null, verifiedAt })),
+      chapterLinks: safeLinks,
+      chapterProjections: projectNetworkContactPolicy(canonical2.contactPolicy, safeLinks).map(({ contactPolicy, ...projection }) => ({ ...projection, contactPolicy: safeNetworkContactPolicy(contactPolicy) }))
+    };
+  }));
+  const aliases = await Promise.all(state.aliases.map(safeNetworkPersonAlias));
+  return {
+    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/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}$/;
 var positiveRevision = (value) => {
   const parsed = Number(value);
   return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
@@ -7348,14 +7485,14 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
         return json({
           result: {
             status: result.status,
-            alias: safeAlias(result.alias),
-            ..."person" in result && result.person ? { person: safePerson(result.person) } : {},
+            alias: await safeNetworkPersonAlias(result.alias),
+            ..."person" in result && result.person ? { person: safeNetworkPerson(result.person, result.alias.identityClaims) } : {},
             ..."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);
+        if (input.decision !== "link" && input.decision !== "exclude" && input.decision !== "reopen") return json({ error: "review decision must be link, exclude, or reopen" }, 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);
@@ -7365,7 +7502,42 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
           decision: input.decision,
           ...typeof input.personId === "string" ? { personId: input.personId } : {}
         }, mutationId, actionActor);
-        return json({ result: safeAlias(result) });
+        return json({ result: await safeNetworkPersonAlias(result) });
+      }
+      if (command === "link-source") {
+        const expectedPersonRevision = positiveRevision(input.expectedPersonRevision);
+        const chapterId = typeof input.chapterId === "string" ? input.chapterId : "";
+        const chapterPersonId = typeof input.chapterPersonId === "string" ? input.chapterPersonId.trim() : "";
+        const verifiedEmail = typeof input.verifiedEmail === "string" ? input.verifiedEmail.trim() : "";
+        if (!expectedPersonRevision || !ctx.chapter.networkPersonRegistry.chapterIds.includes(chapterId) || !chapterPersonId || chapterPersonId.length > 200 || !verifiedEmail || verifiedEmail.length > 320) return json({ error: "a configured source row, exact email, and Person revision are required" }, 400);
+        const result = await linkNetworkChapterPerson(db, {
+          personId: typeof input.personId === "string" ? input.personId : "",
+          expectedPersonRevision,
+          chapterId,
+          chapterPersonId,
+          verifiedEmail
+        }, mutationId, actionActor);
+        return json({
+          result: {
+            person: safeNetworkPerson(result.person),
+            link: await redactedNetworkPersonLink(result.link),
+            ...result.replayed ? { replayed: true } : {}
+          }
+        });
+      }
+      if (command === "unlink-source") {
+        const expectedPersonRevision = positiveRevision(input.expectedPersonRevision);
+        const reason = typeof input.reason === "string" ? input.reason.trim() : "";
+        if (!expectedPersonRevision || !reason || reason.length > 500) {
+          return json({ error: "a Person revision and bounded unlink reason are required" }, 400);
+        }
+        const result = await unlinkNetworkChapterPerson(db, {
+          personId: typeof input.personId === "string" ? input.personId : "",
+          linkId: typeof input.linkId === "string" ? input.linkId : "",
+          expectedPersonRevision,
+          reason
+        }, mutationId, actionActor);
+        return json({ result: { person: safeNetworkPerson(result.person), linkState: result.link.state } });
       }
       if (command === "merge") {
         const expectedRevision = positiveRevision(input.expectedRevision);
@@ -7377,7 +7549,7 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
           expectedRevision,
           expectedTargetRevision
         }, mutationId, actionActor);
-        return json({ result: { source: safePerson(result.source), target: safePerson(result.target) } });
+        return json({ result: { source: safeNetworkPerson(result.source), target: safeNetworkPerson(result.target) } });
       }
       if (command === "unmerge") {
         const expectedRevision = positiveRevision(input.expectedRevision);
@@ -7386,7 +7558,7 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
           personId: typeof input.personId === "string" ? input.personId : "",
           expectedRevision
         }, mutationId, actionActor);
-        return json({ result: safePerson(result) });
+        return json({ result: safeNetworkPerson(result) });
       }
       if (command === "suppression") {
         const expectedRevision = positiveRevision(input.expectedRevision);
@@ -7402,7 +7574,7 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
           discretionarySuppressed: input.discretionarySuppressed,
           ...reason ? { reason } : {}
         }, mutationId, actionActor);
-        return json({ result: safePerson(result) });
+        return json({ result: safeNetworkPerson(result) });
       }
       if (command === "reveal") {
         if (input.kind !== "person" && input.kind !== "alias") return json({ error: "reveal kind must be person or alias" }, 400);
@@ -7421,43 +7593,19 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
     }
   }
   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);
+  const projection = await projectNetworkPersonRegistryState(state);
   return json({
     version: 1,
     mode: "shadow",
     writable: true,
     authoritativeForChapterOperation: false,
+    // The store pages every collection to its explicit 10,000-row operational
+    // bound and rejects larger state instead of returning a partial projection.
+    chapterLinkProjectionComplete: true,
+    personProjectionComplete: true,
+    aliasProjectionComplete: true,
     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
-    }))
+    ...projection
   });
 };
 
@@ -7650,12 +7798,12 @@ function projectNetworkCommercialEvents(input, sources) {
     const prior = latest.get(key);
     if (!prior || order(prior, fact) <= 0) latest.set(key, row);
   }
-  const rows6 = [...latest.values()];
-  const customers = rows6.filter((row) => row.objectKind === "customer");
-  const subscriptions = rows6.filter((row) => row.objectKind === "subscription");
-  const invoices = rows6.filter((row) => row.objectKind === "invoice");
-  const refunds = rows6.filter((row) => row.objectKind === "refund" && row.eventType.startsWith("refund."));
-  for (const charge of rows6.filter((row) => row.eventType === "charge.refunded")) {
+  const rows5 = [...latest.values()];
+  const customers = rows5.filter((row) => row.objectKind === "customer");
+  const subscriptions = rows5.filter((row) => row.objectKind === "subscription");
+  const invoices = rows5.filter((row) => row.objectKind === "invoice");
+  const refunds = rows5.filter((row) => row.objectKind === "refund" && row.eventType.startsWith("refund."));
+  for (const charge of rows5.filter((row) => row.eventType === "charge.refunded")) {
     if (!refunds.some((refund) => refund.chargeId === charge.objectId)) {
       exceptions.push({ eventId: charge.eventId, kind: "charge_refund_without_refund_object", sourceKey: charge.sourceKey, detail: { eventType: charge.eventType, objectId: charge.objectId } });
     }
@@ -7684,7 +7832,7 @@ var materializedNamespaces = [
   "networkCommercialInvoices",
   "networkCommercialRefunds"
 ];
-async function rows5(db, ns) {
+async function rows4(db, ns) {
   const all = [];
   const pageSize = 500;
   for (let offset = 0; ; offset += pageSize) {
@@ -7695,9 +7843,9 @@ async function rows5(db, ns) {
   }
 }
 async function loadNetworkCommercialProjection(db, sources) {
-  const stored = await rows5(db, "networkCommercialEvents");
+  const stored = await rows4(db, "networkCommercialEvents");
   const projection = projectNetworkCommercialEvents(stored.map((row) => row.fact), sources);
-  const persisted = await rows5(db, "networkCommercialExceptions");
+  const persisted = await rows4(db, "networkCommercialExceptions");
   for (const row of persisted) {
     if (row.status !== "active" || row.kind !== "collision") continue;
     if (projection.exceptions.some((item) => item.eventId === row.eventId && item.kind === "collision")) continue;
@@ -7735,8 +7883,8 @@ function projectionOps(projection, now) {
 async function rebuildNetworkCommercialProjection(db, sources, mutationId, now = Date.now()) {
   const projection = await loadNetworkCommercialProjection(db, sources);
   const [existing, ...materialized] = await Promise.all([
-    rows5(db, "networkCommercialExceptions"),
-    ...materializedNamespaces.map((ns) => rows5(db, ns))
+    rows4(db, "networkCommercialExceptions"),
+    ...materializedNamespaces.map((ns) => rows4(db, ns))
   ]);
   const activeIds = new Set(projection.exceptions.map((item) => exceptionId(item.eventId, item.kind)));
   const projectedIds = new Set(projectionOps(projection, now).map((op) => String(op.id)));
@@ -7845,11 +7993,11 @@ async function listStripeObjects(client, path, params = {}, maxPages = 20) {
     if (!Array.isArray(page.data) || typeof page.has_more !== "boolean") {
       throw new Error("Stripe returned an invalid commercial list response");
     }
-    const rows6 = page.data.map(asRaw).filter((row) => row !== null);
-    if (rows6.length !== page.data.length) throw new Error("Stripe returned a malformed commercial object");
-    objects.push(...rows6);
+    const rows5 = page.data.map(asRaw).filter((row) => row !== null);
+    if (rows5.length !== page.data.length) throw new Error("Stripe returned a malformed commercial object");
+    objects.push(...rows5);
     if (!page.has_more) return { objects, complete: true };
-    const cursor = rows6.at(-1)?.id;
+    const cursor = rows5.at(-1)?.id;
     if (typeof cursor !== "string" || !cursor) throw new Error("Stripe pagination did not provide a cursor");
     startingAfter = cursor;
   }
@@ -8101,14 +8249,14 @@ var PAGE2 = 500;
 var MAX_SCAN = 5e3;
 var MAX_RECORDS2 = 500;
 async function localCommercialRows(db) {
-  const rows6 = [];
+  const rows5 = [];
   for (let offset = 0; offset < MAX_SCAN; offset += PAGE2) {
     const result = await db.query({ applications: { $: { limit: PAGE2, offset, order: { createdAt: "asc" } } } });
     const page = Array.isArray(result.applications) ? result.applications : [];
-    rows6.push(...page.slice(0, MAX_SCAN - rows6.length));
-    if (page.length < PAGE2) return { rows: rows6, truncated: false };
+    rows5.push(...page.slice(0, MAX_SCAN - rows5.length));
+    if (page.length < PAGE2) return { rows: rows5, truncated: false };
   }
-  return { rows: rows6, truncated: true };
+  return { rows: rows5, truncated: true };
 }
 var handleNetworkCommercialParity = async (req, url, env, ctx) => {
   if (req.method !== "GET" || url.pathname !== PARITY_PATH) return null;
@@ -8667,17 +8815,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 rows6 = (await db.query({ builderLibraryControls: { $: { where: { targetId, environment, active: true }, limit: 500 } } })).builderLibraryControls;
-  return Array.isArray(rows6) ? rows6.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 rows6 = (await db.query({ builderLibraryControls: { $: { where: { sourceId, targetId, environment }, order: { revision: "desc" }, limit: 20 } } })).builderLibraryControls;
-  return control2(Array.isArray(rows6) ? [...rows6].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 rows6 = (await db.query({ builderLibraryLocal: { $: { where: { id }, limit: 1 } } })).builderLibraryLocal;
-  return local2(Array.isArray(rows6) ? rows6[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: digest2 } = envelope;