@odla-ai/chapter 0.25.8 → 0.26.0

package/dist/index.cjs

@@ -57,6 +57,7 @@ __export(index_exports, {
   findApplicationRef: () => findApplicationRef,
   firstPaymentPatch: () => firstPaymentPatch,
   formatChapterCopy: () => formatChapterCopy,
+  formationFields: () => formationFields,
   getVaultSecret: () => getVaultSecret,
   hasDisclaimerAck: () => hasDisclaimerAck,
   introIdempotencyKey: () => introIdempotencyKey,
@@ -66,6 +67,7 @@ __export(index_exports, {
   isSlotAvailable: () => isSlotAvailable,
   isValidEmail: () => isValidEmail,
   joinConfig: () => joinConfig,
+  leaderCrmConfig: () => leaderCrmConfig,
   meetingCreateRow: () => meetingCreateRow,
   meetingRescheduleUpdate: () => meetingRescheduleUpdate,
   memberApplication: () => memberApplication,
@@ -87,6 +89,7 @@ __export(index_exports, {
   resolveApplication: () => resolveApplication,
   resolveAuth: () => resolveAuth,
   resolveChapterCopy: () => resolveChapterCopy,
+  resolveLeaderFormation: () => resolveLeaderFormation,
   resolvePipeline: () => resolvePipeline,
   resolveScheduling: () => resolveScheduling,
   roleFromClaim: () => roleFromClaim,
@@ -630,12 +633,17 @@ var DEFAULT_ADMIN_COPY = {
     overview: "Overview",
     billing: "Billing",
     people: "People",
+    portfolio: "Portfolio",
     settings: "Settings",
     calendar: "Calendar",
     email: "Email",
+    chapters: "Chapters",
+    formations: "Formation applications",
+    dealFlow: "Deal flow",
     dashboardViewsLabel: "Dashboard views",
     settingsViewsLabel: "Settings views",
-    collectionsLabel: "CRM collections"
+    collectionsLabel: "CRM collections",
+    portfolioViewsLabel: "Portfolio views"
   },
   dashboard: {
     loading: "Loading dashboard\u2026",
@@ -741,7 +749,19 @@ var DEFAULT_ADMIN_COPY = {
     shareWith: "Share with {target}",
     shared: "Shared with {target}.",
     shareFailed: "Could not share with {target}.",
-    deliveryFailed: "Delivery failed."
+    deliveryFailed: "Delivery failed.",
+    loadingRollup: "Loading network overview\u2026",
+    loadRollupFailed: "Couldn't load the network overview",
+    overview: "Network overview",
+    configuredFollowers: "Configured followers",
+    reachableFollowers: "Reachable followers",
+    recordsAcrossFollowers: "Records across followers",
+    noFollowers: "No follower sites are configured.",
+    followers: "Followers",
+    available: "available",
+    unavailable: "unavailable",
+    recordTotals: "Portfolio records",
+    noRecordTotals: "No aggregate records are available yet."
   },
   records: {
     workflowMissing: "This record is not linked to an application workflow.",
@@ -899,6 +919,81 @@ function formatChapterCopy(template, values) {
   );
 }
 
+// src/formation.ts
+var DEFAULT_REQUIRED2 = ["name", "email", "location", "thesis"];
+var DEFAULT_OPTIONAL2 = ["proposedChapter", "experience", "collaborators"];
+function resolveLeaderFormation(input, crm) {
+  const type = input?.type ?? "chapter_application";
+  if (!input) {
+    return {
+      enabled: false,
+      type,
+      required: [],
+      optional: [],
+      maxLen: {},
+      defaultMaxLen: 4e3,
+      bodyCap: 32768
+    };
+  }
+  const def = crm.config.types[type];
+  if (!def) throw new Error(`defineChapter.formation.type: unknown CRM type "${type}"`);
+  const required = input.required ?? (type === "chapter_application" ? DEFAULT_REQUIRED2 : []);
+  const optional = input.optional ?? (type === "chapter_application" ? DEFAULT_OPTIONAL2 : []);
+  for (const [name, values] of [["required", required], ["optional", optional]]) {
+    if (!Array.isArray(values) || !values.every((field) => typeof field === "string" && field !== "")) {
+      throw new Error(`defineChapter.formation.${name}: must be an array of field-name strings`);
+    }
+  }
+  const duplicates = [...required, ...optional].filter((field, index, fields) => fields.indexOf(field) !== index);
+  if (duplicates.length) throw new Error(`defineChapter.formation: duplicate public field "${duplicates[0]}"`);
+  const unknown = [...required, ...optional].filter((field) => !def.fields[field]);
+  if (unknown.length) throw new Error(`defineChapter.formation: field "${unknown[0]}" is not declared on CRM type "${type}"`);
+  const missingRequired = Object.entries(def.fields).filter(([, field]) => field.required).map(([field]) => field).filter((field) => !required.includes(field));
+  if (missingRequired.length) {
+    throw new Error(`defineChapter.formation.required: must include required CRM field "${missingRequired[0]}"`);
+  }
+  const unsupportedRequired = required.find((field) => !["string", "email", "url", "enum"].includes(def.fields[field].type));
+  if (unsupportedRequired) {
+    throw new Error(`defineChapter.formation.required: field "${unsupportedRequired}" must be string-like`);
+  }
+  if (required.length === 0) throw new Error("defineChapter.formation.required: must not be empty");
+  const defaultMaxLen = input.defaultMaxLen ?? 4e3;
+  const bodyCap = input.bodyCap ?? 32768;
+  if (!Number.isSafeInteger(defaultMaxLen) || defaultMaxLen < 1 || defaultMaxLen > 32768) {
+    throw new Error("defineChapter.formation.defaultMaxLen: must be an integer from 1 to 32768");
+  }
+  if (!Number.isSafeInteger(bodyCap) || bodyCap < 1024 || bodyCap > 131072) {
+    throw new Error("defineChapter.formation.bodyCap: must be an integer from 1024 to 131072");
+  }
+  for (const [field, cap] of Object.entries(input.maxLen ?? {})) {
+    if (![...required, ...optional].includes(field) || !Number.isSafeInteger(cap) || cap < 1 || cap > 32768) {
+      throw new Error(`defineChapter.formation.maxLen.${field}: must name a public field and be an integer from 1 to 32768`);
+    }
+  }
+  return {
+    enabled: true,
+    type,
+    required,
+    optional,
+    maxLen: input.maxLen ?? {},
+    defaultMaxLen,
+    bodyCap
+  };
+}
+function formationFields(crm, formation) {
+  const def = crm.type(formation.type);
+  return [...formation.required, ...formation.optional].map((id2) => {
+    const field = def.fields[id2];
+    return {
+      id: id2,
+      label: field.label ?? id2,
+      type: field.type,
+      required: formation.required.includes(id2),
+      ...field.options ? { options: field.options } : {}
+    };
+  });
+}
+
 // src/config.ts
 var SLUG = /^[a-z0-9][a-z0-9-]{1,62}$/;
 var FIELD = /^[a-z][a-zA-Z0-9_]*$/;
@@ -987,6 +1082,7 @@ function defineChapter(config) {
   const brand = { ...config.brand, wordmark: config.brand?.wordmark ?? name };
   const copy = resolveChapterCopy(config.copy);
   const network = resolveNetwork(config, crm);
+  const formation = resolveLeaderFormation(config.formation, crm);
   const { schema, rules } = chapterDb(mode, auth);
   const services = config.services ?? ["db", "calendar", "o11y"];
   const account = config.account ?? "none";
@@ -1042,6 +1138,7 @@ function defineChapter(config) {
     brand,
     copy,
     network,
+    formation,
     crm,
     auth,
     pipeline,
@@ -1058,13 +1155,154 @@ function defineChapter(config) {
   return chapter;
 }
 
-// src/descriptor.ts
+// src/leader.ts
 var import_crm2 = require("@odla-ai/crm");
+function leaderCrmConfig(options = {}) {
+  const base = options.base ?? defaultCrm("hub");
+  const portfolio = {
+    types: {
+      chapter: {
+        label: "Chapter",
+        labelPlural: "Chapters",
+        workspace: "portfolio",
+        nameField: "name",
+        fields: {
+          name: { type: "string", label: "Name", required: true },
+          slug: { type: "string", label: "Slug", slot: "s1" },
+          region: { type: "string", label: "Region", slot: "s2" },
+          url: { type: "url", label: "Website" },
+          thesis: { type: "string", label: "Investment thesis" },
+          launchedAt: { type: "date", label: "Launch date", slot: "d1" },
+          notes: { type: "string", label: "Notes" }
+        },
+        pipeline: {
+          stages: [
+            { id: "proposed", label: "Proposed" },
+            { id: "forming", label: "Forming" },
+            { id: "active", label: "Active" },
+            { id: "paused", label: "Paused" },
+            { id: "closed", label: "Closed", terminal: true }
+          ],
+          transitions: {
+            proposed: ["forming", "closed"],
+            forming: ["active", "paused", "closed"],
+            active: ["paused", "closed"],
+            paused: ["forming", "active", "closed"]
+          }
+        },
+        facets: { rank: "manual" }
+      },
+      chapter_application: {
+        label: "Chapter application",
+        labelPlural: "Formation applications",
+        workspace: "portfolio",
+        nameField: "name",
+        emailField: "email",
+        fields: {
+          name: { type: "string", label: "Applicant name", required: true },
+          email: { type: "email", label: "Email", required: true },
+          location: { type: "string", label: "Location", required: true, slot: "s1" },
+          proposedChapter: { type: "string", label: "Proposed chapter", slot: "s2" },
+          thesis: { type: "string", label: "Proposed thesis", required: true },
+          experience: { type: "string", label: "Relevant experience" },
+          collaborators: { type: "json", label: "Collaborators" },
+          notes: { type: "string", label: "Internal notes" }
+        },
+        pipeline: {
+          stages: [
+            { id: "submitted", label: "Submitted" },
+            { id: "reviewing", label: "Reviewing" },
+            { id: "interviewing", label: "Interviewing" },
+            { id: "approved", label: "Approved" },
+            { id: "forming", label: "Forming" },
+            { id: "declined", label: "Declined", terminal: true }
+          ],
+          transitions: {
+            submitted: ["reviewing", "declined"],
+            reviewing: ["interviewing", "approved", "declined"],
+            interviewing: ["approved", "declined"],
+            approved: ["forming", "declined"]
+          }
+        },
+        facets: { email: true, rank: "manual" }
+      },
+      deal: {
+        label: "Deal",
+        labelPlural: "Deal flow",
+        workspace: "portfolio",
+        nameField: "name",
+        fields: {
+          name: { type: "string", label: "Company or deal", required: true },
+          chapter: { type: "string", label: "Source chapter", slot: "s1" },
+          sector: { type: "string", label: "Sector", slot: "s2" },
+          source: { type: "string", label: "Source", slot: "s3" },
+          website: { type: "url", label: "Website" },
+          amount: { type: "number", label: "Target amount", slot: "n1" },
+          notes: { type: "string", label: "Notes" }
+        },
+        pipeline: {
+          stages: [
+            { id: "sourced", label: "Sourced" },
+            { id: "screening", label: "Screening" },
+            { id: "diligence", label: "Diligence" },
+            { id: "committee", label: "Committee" },
+            { id: "offered", label: "Offered" },
+            { id: "invested", label: "Invested", terminal: true },
+            { id: "passed", label: "Passed", terminal: true }
+          ],
+          transitions: {
+            sourced: ["screening", "passed"],
+            screening: ["diligence", "committee", "passed"],
+            diligence: ["committee", "offered", "passed"],
+            committee: ["offered", "passed"],
+            offered: ["invested", "passed"],
+            passed: ["sourced"]
+          }
+        },
+        facets: { rank: "manual" }
+      }
+    },
+    relations: {
+      formation_result: {
+        from: "chapter_application",
+        to: "chapter",
+        label: "formed as",
+        reverseLabel: "formation application"
+      },
+      chapter_deal: {
+        from: "deal",
+        to: "chapter",
+        label: "sourced by",
+        reverseLabel: "deal flow"
+      }
+    }
+  };
+  if (base.types.company) {
+    portfolio.relations.deal_company = {
+      from: "deal",
+      to: "company",
+      label: "concerns",
+      reverseLabel: "deals"
+    };
+  }
+  if (base.types.person) {
+    portfolio.relations.application_contact = {
+      from: "person",
+      to: "chapter_application",
+      label: "submitted",
+      reverseLabel: "applicant"
+    };
+  }
+  return (0, import_crm2.composeCrmConfigs)(base, portfolio);
+}
+
+// src/descriptor.ts
+var import_crm3 = require("@odla-ai/crm");
 function createChapterIntegration(chapter, options = {}) {
   const basePath = options.basePath ?? "/api/crm";
   const now = options.now ?? Date.now();
   const emails = chapter.config.emails;
-  const crmDesc = (0, import_crm2.createCrmIntegration)(chapter.crm, {
+  const crmDesc = (0, import_crm3.createCrmIntegration)(chapter.crm, {
     basePath,
     now,
     ...emails?.notificationEmail ? { notificationEmail: emails.notificationEmail } : {},
@@ -1096,7 +1334,15 @@ function createChapterIntegration(chapter, options = {}) {
     },
     rules: { ...crmDesc.rules, ...chapter.rules },
     seeds,
-    probes: [...crmDesc.probes ?? []],
+    probes: [
+      ...crmDesc.probes ?? [],
+      // The snapshot route is deliberately private. A credential-free smoke
+      // request must prove that the route is mounted and closed.
+      { path: "/api/network/snapshot", expectedStatus: 401 },
+      // Formation metadata is public only when the host explicitly enables
+      // the bounded intake contract.
+      ...chapter.formation.enabled ? [{ path: "/api/formation/config", expectedStatus: 200 }] : []
+    ],
     runbooks
   };
 }
@@ -1300,11 +1546,15 @@ function canceledPatch() {
 }
 
 // src/network.ts
-var import_crm3 = require("@odla-ai/crm");
+var import_crm4 = require("@odla-ai/crm");
+
+// src/network-contract.ts
 var DEFAULT_SHARE_FIELDS = {
   person: ["name", "email", "firstName", "lastName", "phone", "linkedin"],
   company: ["name", "domain", "industry", "location", "linkedin", "notes"]
 };
+
+// src/network.ts
 function sharedPersonInput(person) {
   const email = person.email.toLowerCase();
   const fullName = [person.firstName, person.lastName].filter(Boolean).join(" ").trim();
@@ -1326,25 +1576,55 @@ function shortHash(value) {
   }
   return `${(a >>> 0).toString(36)}${(b >>> 0).toString(36)}`;
 }
-function networkSourceTag(type, hubRecordId) {
+function networkSourceTag(type, hubRecordId, sourceId) {
   const typeKey = type.toLowerCase();
   const readable = /^[a-z0-9_-]+$/.test(hubRecordId);
-  const raw = `network:${typeKey}:${hubRecordId}`;
+  const prefix = sourceId ? `network:${sourceId.toLowerCase()}:${typeKey}` : `network:${typeKey}`;
+  const raw = `${prefix}:${hubRecordId}`;
   if (readable && raw.length <= 64) return raw;
-  return `network:${typeKey.slice(0, 20)}:${shortHash(`${type}\0${hubRecordId}`)}`;
-}
-function normalizeSharedRecord(record) {
-  if ("input" in record) return { version: 1, type: record.type, hubRecordId: record.hubRecordId, input: record.input };
+  return `network:${typeKey.slice(0, 16)}:${shortHash(`${sourceId ?? ""}\0${type}\0${hubRecordId}`)}`;
+}
+function normalizeSharedRecord(record, fallbackSourceId = "legacy-source") {
+  if ("input" in record && record.version === 2) {
+    return {
+      version: 2,
+      sourceId: record.source.siteId,
+      sourceRecordId: record.source.recordId,
+      type: record.type,
+      input: record.input
+    };
+  }
+  if ("input" in record) {
+    return {
+      version: 1,
+      sourceId: fallbackSourceId,
+      sourceRecordId: record.hubRecordId,
+      type: record.type,
+      input: record.input
+    };
+  }
   if ("type" in record && record.type === "company") {
     const input = { name: record.name };
     for (const key of ["domain", "industry", "location", "linkedin", "notes"]) {
       if (record[key]) input[key] = record[key];
     }
-    return { version: 1, type: "company", hubRecordId: record.hubRecordId, input };
+    return {
+      version: 1,
+      sourceId: fallbackSourceId,
+      sourceRecordId: record.hubRecordId,
+      type: "company",
+      input
+    };
   }
-  return { version: 1, type: "person", hubRecordId: record.hubRecordId, input: sharedPersonInput(record) };
+  return {
+    version: 1,
+    sourceId: fallbackSourceId,
+    sourceRecordId: record.hubRecordId,
+    type: "person",
+    input: sharedPersonInput(record)
+  };
 }
-function sharedRecordFromCrm(crm, record, target) {
+function sharedRecordFromCrm(crm, record, target, sourceId) {
   if (target.fields && !target.fields[record.type]) {
     throw new Error(`${target.name} does not accept "${record.type}" records`);
   }
@@ -1360,7 +1640,7 @@ function sharedRecordFromCrm(crm, record, target) {
     if (value !== void 0) input[field] = value;
   }
   if (input[nameField] === void 0) input[nameField] = record.name;
-  return { version: 1, type: record.type, hubRecordId: record.id, input };
+  return sourceId ? { version: 2, source: { siteId: sourceId, recordId: record.id }, type: record.type, input } : { version: 1, type: record.type, hubRecordId: record.id, input };
 }
 async function upsertPerson(deps, opts) {
   const email = opts.email.toLowerCase();
@@ -1368,13 +1648,19 @@ async function upsertPerson(deps, opts) {
   const { crm_record } = await deps.db.query({ crm_record: { $: { where: { type: "person", primaryEmail: email }, limit: 1 } } });
   const existing = crm_record?.[0];
   if (existing && typeof existing.id === "string") {
-    await (0, import_crm3.updateRecord)(crmDeps, { id: existing.id, input: opts.input });
+    await (0, import_crm4.updateRecord)(crmDeps, { id: existing.id, input: opts.input });
     return { recordId: existing.id };
   }
-  const created = await (0, import_crm3.createRecord)(crmDeps, { type: "person", input: opts.input, mutationId: opts.mutationId });
+  const created = await (0, import_crm4.createRecord)(crmDeps, { type: "person", input: opts.input, mutationId: opts.mutationId });
   return { recordId: created.id };
 }
 async function findSharedRecord(deps, record, tag) {
+  const structured = await (0, import_crm4.getRecordByOrigin)(
+    { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId },
+    record.sourceId,
+    record.sourceRecordId
+  );
+  if (structured) return structured;
   const mapped = await deps.db.query({ crm_tag: { $: { where: { tag }, limit: 1 } } });
   const mappedId = mapped.crm_tag?.[0]?.recordId;
   if (typeof mappedId === "string") {
@@ -1408,21 +1694,24 @@ async function findSharedRecord(deps, record, tag) {
   }
   return void 0;
 }
-async function projectSharedRecord(deps, shared) {
-  const record = normalizeSharedRecord(shared);
-  if (!record.type.trim() || !record.hubRecordId.trim()) {
-    throw new Error("type and hubRecordId must be non-empty");
+async function projectSharedRecord(deps, shared, options = {}) {
+  const record = normalizeSharedRecord(shared, options.sourceId);
+  if (!record.type.trim() || !record.sourceId.trim() || !record.sourceRecordId.trim()) {
+    throw new Error("type, source site id, and source record id must be non-empty");
+  }
+  if (options.sourceId && options.sourceId !== record.sourceId) {
+    throw new Error("signed sender does not match payload source");
   }
-  const tag = networkSourceTag(record.type, record.hubRecordId);
+  const tag = networkSourceTag(record.type, record.sourceRecordId, record.version === 2 ? record.sourceId : void 0);
   const crmDeps = { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId };
   const existing = await findSharedRecord(deps, record, tag);
   let recordId;
   if (existing && typeof existing.id === "string") {
-    await (0, import_crm3.updateRecord)(crmDeps, { id: existing.id, input: record.input });
+    await (0, import_crm4.updateRecord)(crmDeps, { id: existing.id, input: record.input });
     recordId = existing.id;
   } else {
-    recordId = `network_${shortHash(`${record.type}\0${record.hubRecordId}`)}`;
-    await (0, import_crm3.createRecord)({ ...crmDeps, newId: () => recordId }, {
+    recordId = `network_${shortHash(`${record.sourceId}\0${record.type}\0${record.sourceRecordId}`)}`;
+    await (0, import_crm4.createRecord)({ ...crmDeps, newId: () => recordId }, {
       type: record.type,
       input: record.input,
       mutationId: `share-create:${tag}`
@@ -1432,6 +1721,13 @@ async function projectSharedRecord(deps, shared) {
     [{ t: "update", ns: "crm_tag", id: tag, attrs: { key: `${recordId}:${tag}`, recordId, tag, createdAt: deps.now() } }],
     { mutationId: `share-map:${tag}:${recordId}` }
   );
+  await (0, import_crm4.upsertRecordOrigin)(crmDeps, {
+    recordId,
+    sourceId: record.sourceId,
+    sourceRecordId: record.sourceRecordId,
+    ...options.sourceUrl ? { sourceUrl: options.sourceUrl } : {},
+    payloadVersion: record.version
+  });
   return { recordId };
 }
 async function projectApplicant(deps, applicant) {
@@ -1454,7 +1750,7 @@ async function projectApplicant(deps, applicant) {
 }
 
 // src/crm-sync.ts
-var import_crm4 = require("@odla-ai/crm");
+var import_crm5 = require("@odla-ai/crm");
 var str = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
 function personInputFromApp(chapter, app) {
   const input = sharedPersonInput({
@@ -1494,16 +1790,16 @@ async function syncApplicationToCrm(deps, opts) {
   let recordId;
   if (existing && typeof existing.id === "string") {
     recordId = existing.id;
-    await (0, import_crm4.updateRecord)(recordDeps, { id: recordId, input });
+    await (0, import_crm5.updateRecord)(recordDeps, { id: recordId, input });
   } else {
-    const created = await (0, import_crm4.createRecord)(recordDeps, { type: "person", input, ...stage ? { stage } : {} });
+    const created = await (0, import_crm5.createRecord)(recordDeps, { type: "person", input, ...stage ? { stage } : {} });
     recordId = created.id;
   }
   if (existing && stage && existing.stage !== stage) {
-    await (0, import_crm4.setStage)(recordDeps, { id: recordId, to: stage, authorId: "system", mutationId: `crm:stage:${recordId}:${stage}` }).catch(() => void 0);
+    await (0, import_crm5.setStage)(recordDeps, { id: recordId, to: stage, authorId: "system", mutationId: `crm:stage:${recordId}:${stage}` }).catch(() => void 0);
   }
   await deps.db.transact([{ t: "update", ns: "crm_record", id: recordId, attrs: billingColumns(opts.app) }]);
-  await (0, import_crm4.linkIdentity)(recordDeps, { recordId, email: emailKey, mutationId: `crm:link:${recordId}:${emailKey}` }).catch(() => void 0);
+  await (0, import_crm5.linkIdentity)(recordDeps, { recordId, email: emailKey, mutationId: `crm:link:${recordId}:${emailKey}` }).catch(() => void 0);
   return recordId;
 }
 async function backfillCrm(deps) {