@claritylabs/cl-sdk 3.0.22 → 3.0.24

package/dist/index.mjs

@@ -2045,14 +2045,38 @@ var SourceBackedValueSchema = z20.object({
   sourceNodeIds: z20.array(z20.string().min(1)).default([]),
   sourceSpanIds: z20.array(z20.string().min(1)).default([])
 });
+var OperationalCoverageTermSchema = z20.object({
+  kind: z20.enum([
+    "each_claim_limit",
+    "each_occurrence_limit",
+    "each_loss_limit",
+    "aggregate_limit",
+    "sublimit",
+    "retention",
+    "deductible",
+    "retroactive_date",
+    "premium",
+    "other"
+  ]).default("other"),
+  label: z20.string(),
+  value: z20.string(),
+  amount: z20.number().optional(),
+  appliesTo: z20.string().optional(),
+  sourceNodeIds: z20.array(z20.string().min(1)).default([]),
+  sourceSpanIds: z20.array(z20.string().min(1)).default([])
+});
 var OperationalCoverageLineSchema = z20.object({
   name: z20.string(),
   coverageCode: z20.string().optional(),
   limit: z20.string().optional(),
   deductible: z20.string().optional(),
   premium: z20.string().optional(),
+  retroactiveDate: z20.string().optional(),
   formNumber: z20.string().optional(),
   sectionRef: z20.string().optional(),
+  coverageOrigin: z20.enum(["core", "endorsement"]).optional(),
+  endorsementNumber: z20.string().optional(),
+  limits: z20.array(OperationalCoverageTermSchema).default([]),
   sourceNodeIds: z20.array(z20.string().min(1)).default([]),
   sourceSpanIds: z20.array(z20.string().min(1)).default([])
 });
@@ -2920,6 +2944,9 @@ function cleanValue(value) {
   if (!value) return void 0;
   return normalizeWhitespace3(value.replace(/^[\s:;#-]+|[\s;,.]+$/g, ""));
 }
+function cleanCoverageLabel(value) {
+  return cleanValue(value)?.replace(/^column\s+\d+\s*:\s*/i, "");
+}
 function moneyValue(value) {
   const clean = cleanValue(value);
   if (!clean) return void 0;
@@ -2977,12 +3004,12 @@ function inferDocumentType(nodes) {
 }
 function coverageNameFromRow(text) {
   const labelled = text.match(/\b(?:coverage|coverage part|line)\s*:?\s*([^|;$]{3,80})/i)?.[1];
-  if (labelled) return cleanValue(labelled);
-  const parts = text.split(/\s+\|\s+| {2,}|\t/).map(cleanValue).filter(Boolean);
+  if (labelled) return cleanCoverageLabel(labelled);
+  const parts = text.split(/\s+\|\s+| {2,}|\t/).map(cleanCoverageLabel).filter(Boolean);
   const first = parts.find(
     (part) => !/^(limit|limits?|deductible|premium|amount|basis|rate|retroactive|aggregate|each occurrence)$/i.test(part) && !/^\$?[\d,]+/.test(part)
   );
-  return cleanValue(first);
+  return cleanCoverageLabel(first);
 }
 function limitFromText(text) {
   return moneyValue(
@@ -2995,14 +3022,292 @@ function deductibleFromText(text) {
 function premiumFromText(text) {
   return moneyValue(text.match(/\b(?:premium|total premium|total cost|amount due)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?)/i)?.[1]);
 }
+function moneyAmount(value) {
+  const match = value?.match(/\$?\s*([0-9][0-9,]*(?:\.\d+)?)/);
+  if (!match) return void 0;
+  const amount = Number(match[1].replace(/,/g, ""));
+  return Number.isFinite(amount) ? amount : void 0;
+}
+function normalizeLabel(value) {
+  return normalizeWhitespace3(value ?? "").toLowerCase();
+}
+var OPERATIONAL_COVERAGE_TERM_KINDS = /* @__PURE__ */ new Set([
+  "each_claim_limit",
+  "each_occurrence_limit",
+  "each_loss_limit",
+  "aggregate_limit",
+  "sublimit",
+  "retention",
+  "deductible",
+  "retroactive_date",
+  "premium",
+  "other"
+]);
+function termKind(label, value) {
+  const text = normalizeLabel(`${label} ${value}`);
+  if (/\bretroactive\b/.test(text)) return "retroactive_date";
+  if (/\b(self[-\s]?insured retention|retention|sir)\b/.test(text)) return "retention";
+  if (/\bdeductible\b/.test(text)) return "deductible";
+  if (/\bpremium\b/.test(text)) return "premium";
+  if (/\bsub[-\s]?limit\b/.test(text)) return "sublimit";
+  if (/\baggregate\b/.test(text)) return "aggregate_limit";
+  if (/\beach\s+claim|per\s+claim\b/.test(text)) return "each_claim_limit";
+  if (/\beach\s+occurrence|per\s+occurrence\b/.test(text)) return "each_occurrence_limit";
+  if (/\beach\s+loss|per\s+loss\b/.test(text)) return "each_loss_limit";
+  if (/\blimit\b/.test(text)) return "other";
+  return "other";
+}
+function normalizeTermKind(value, label, termValue) {
+  return typeof value === "string" && OPERATIONAL_COVERAGE_TERM_KINDS.has(value) ? value : termKind(label, termValue);
+}
+function isValueCell(label, value) {
+  const normalizedLabel = normalizeLabel(label);
+  const normalizedValue = normalizeLabel(value);
+  if (!value || normalizedValue === "\u2014") return false;
+  if (/\b(policy\s*(number|no|#)|named insured|insured|carrier|company|broker|producer|agent|coverage|coverage part|description|item|name|form|source)\b/.test(normalizedLabel)) {
+    return false;
+  }
+  return /\b(limit|aggregate|retention|deductible|sir|retroactive|premium|amount)\b/.test(normalizedLabel) || moneyAmount(value) !== void 0 || /\b(full prior acts|none|included|not included|as stated)\b/.test(normalizedValue);
+}
+function isNameCell(label, value) {
+  const normalizedLabel = normalizeLabel(label);
+  const normalizedValue = normalizeLabel(value);
+  if (!value || moneyAmount(value) !== void 0) return false;
+  if (/\b(coverage|coverage part|insuring agreement|description|item|name)\b/.test(normalizedLabel)) {
+    return true;
+  }
+  if (/^column\s+\d+$/.test(normalizedLabel) && /\b(coverage|sub[-\s]?limit|liability|expense|part\s+[a-z])\b/.test(normalizedValue)) {
+    return true;
+  }
+  return false;
+}
+function childMap(nodes) {
+  const children = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const group = children.get(node.parentId) ?? [];
+    group.push(node);
+    children.set(node.parentId, group);
+  }
+  for (const group of children.values()) group.sort((left, right) => left.order - right.order);
+  return children;
+}
+function cellRows(row, children) {
+  return (children.get(row.id) ?? []).filter((child) => child.kind === "table_cell").map((cell) => ({
+    label: cleanValue(cell.title) ?? "Value",
+    value: cleanValue(cell.textExcerpt ?? cell.description ?? cell.title) ?? "",
+    node: cell
+  })).filter((cell) => cell.value);
+}
+function directChildren(parent, children) {
+  return children.get(parent.id) ?? [];
+}
+function descendants(parent, children) {
+  const stack = [...directChildren(parent, children)];
+  const result = [];
+  while (stack.length > 0) {
+    const node = stack.shift();
+    result.push(node);
+    stack.unshift(...directChildren(node, children));
+  }
+  return result;
+}
+function ancestry(node, byId) {
+  const result = [];
+  let current = node.parentId ? byId.get(node.parentId) : void 0;
+  while (current) {
+    result.push(current);
+    current = current.parentId ? byId.get(current.parentId) : void 0;
+  }
+  return result;
+}
+function endorsementAncestor(node, byId) {
+  return ancestry(node, byId).find((ancestor) => ancestor.kind === "endorsement");
+}
+function endorsementNumberFrom(value) {
+  return cleanValue(value?.match(/\bendorsement\s+no\.?\s*([0-9A-Z-]+)/i)?.[1]);
+}
+function endorsementNameFrom(node) {
+  const candidates = [node.title, node.textExcerpt, node.description, nodeText(node)].filter(Boolean);
+  for (const candidate of candidates) {
+    const match = candidate.match(/\bendorsement\s+no\.?\s*([0-9A-Z-]+)\s*[—-]\s*(.{3,140}?)(?=\s+This\s+endorsement\b|\.|$)/i);
+    if (match) return cleanValue(`Endorsement No. ${match[1]} - ${match[2]}`) ?? node.title;
+  }
+  return node.title;
+}
+function sourceIds(nodes) {
+  return {
+    sourceNodeIds: [...new Set(nodes.map((node) => node.id))],
+    sourceSpanIds: [...new Set(nodes.flatMap((node) => node.sourceSpanIds))]
+  };
+}
+function relabelGenericTerm(term, label) {
+  const cleanLabel = cleanValue(label);
+  if (!cleanLabel || !/^column\s+\d+$/i.test(term.label)) return term;
+  return {
+    ...term,
+    kind: termKind(cleanLabel, term.value),
+    label: cleanLabel
+  };
+}
+function termFromCell(params) {
+  const value = cleanValue(params.value);
+  if (!value) return void 0;
+  const nodes = [params.row, params.cell].filter((node) => Boolean(node));
+  const kind = termKind(params.label, value);
+  const amount = moneyAmount(value);
+  return {
+    kind,
+    label: params.label,
+    value,
+    ...amount !== void 0 && kind !== "retroactive_date" ? { amount } : {},
+    ...params.appliesTo ? { appliesTo: params.appliesTo } : {},
+    ...sourceIds(nodes)
+  };
+}
+function termsFromRow(row, children) {
+  const cells = cellRows(row, children);
+  if (cells.length > 0) {
+    return cells.filter((cell) => isValueCell(cell.label, cell.value)).map((cell) => termFromCell({ row, cell: cell.node, label: cell.label, value: cell.value })).filter((term) => Boolean(term));
+  }
+  const text = normalizeWhitespace3(row.textExcerpt ?? row.description ?? nodeText(row));
+  const terms = [];
+  for (const part of text.split(/\s+\|\s+/)) {
+    const match = part.match(/^([^:]{2,80}):\s*(.+)$/);
+    if (!match) continue;
+    if (!isValueCell(match[1], match[2])) continue;
+    const term = termFromCell({ row, label: cleanValue(match[1]) ?? "Value", value: match[2] });
+    if (term) terms.push(term);
+  }
+  if (terms.length === 0) {
+    const limit = limitFromText(text);
+    if (limit) {
+      const term = termFromCell({ row, label: "Limit", value: limit });
+      if (term) terms.push(term);
+    }
+    const deductible = deductibleFromText(text);
+    if (deductible) {
+      const term = termFromCell({ row, label: "Deductible", value: deductible });
+      if (term) terms.push(term);
+    }
+  }
+  return terms;
+}
+function nameFromRow(row, children) {
+  const cells = cellRows(row, children);
+  const named = cells.find((cell) => isNameCell(cell.label, cell.value));
+  if (named) return cleanValue(named.value);
+  return coverageNameFromRow(row.textExcerpt ?? row.description ?? nodeText(row));
+}
+function legacyLimit(terms) {
+  return terms.find(
+    (term) => ["each_claim_limit", "each_occurrence_limit", "each_loss_limit", "aggregate_limit", "sublimit", "other"].includes(term.kind)
+  )?.value;
+}
+function legacyDeductible(terms) {
+  return terms.find((term) => term.kind === "deductible" || term.kind === "retention")?.value;
+}
+function legacyPremium(terms) {
+  return terms.find((term) => term.kind === "premium")?.value;
+}
+function retroDate(terms) {
+  return terms.find((term) => term.kind === "retroactive_date")?.value;
+}
+function uniqueTerms(terms) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const term of terms) {
+    const key = [term.kind, term.label.toLowerCase(), term.value.toLowerCase(), term.appliesTo ?? ""].join("|");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(term);
+  }
+  return result;
+}
+function coverageFromTableRow(row, children, byId) {
+  if (row.metadata?.isHeader === true || row.metadata?.isHeader === "true") return void 0;
+  const name = nameFromRow(row, children);
+  const terms = uniqueTerms(termsFromRow(row, children));
+  if (!name || terms.length === 0) return void 0;
+  const ids = sourceIds([row, ...directChildren(row, children)]);
+  const endorsement = endorsementAncestor(row, byId);
+  return {
+    name,
+    limit: legacyLimit(terms),
+    deductible: legacyDeductible(terms),
+    premium: legacyPremium(terms),
+    retroactiveDate: retroDate(terms),
+    formNumber: typeof row.metadata?.formNumber === "string" ? row.metadata.formNumber : void 0,
+    sectionRef: endorsement?.title,
+    coverageOrigin: endorsement ? "endorsement" : "core",
+    endorsementNumber: endorsementNumberFrom(endorsement?.title),
+    limits: terms,
+    ...ids
+  };
+}
+function coverageFromEndorsement(endorsement, children) {
+  const rows = descendants(endorsement, children).filter((node) => node.kind === "table_row");
+  const terms = uniqueTerms(rows.flatMap(
+    (row) => termsFromRow(row, children).map((term) => {
+      const appliesTo = nameFromRow(row, children);
+      const labelled = relabelGenericTerm(term, appliesTo);
+      return appliesTo && labelled.label !== appliesTo ? { ...labelled, appliesTo } : labelled;
+    })
+  ));
+  if (terms.length === 0) return void 0;
+  const ids = sourceIds([endorsement, ...rows, ...rows.flatMap((row) => directChildren(row, children))]);
+  const name = endorsementNameFrom(endorsement);
+  return {
+    name,
+    limit: legacyLimit(terms),
+    deductible: legacyDeductible(terms),
+    premium: legacyPremium(terms),
+    retroactiveDate: retroDate(terms),
+    formNumber: typeof endorsement.metadata?.formNumber === "string" ? endorsement.metadata.formNumber : void 0,
+    sectionRef: name,
+    coverageOrigin: "endorsement",
+    endorsementNumber: endorsementNumberFrom(name),
+    limits: terms,
+    ...ids
+  };
+}
+function hasDescendantEndorsementWithTableRows(endorsement, children) {
+  return descendants(endorsement, children).some(
+    (node) => node.kind === "endorsement" && descendants(node, children).some((descendant) => descendant.kind === "table_row")
+  );
+}
 function buildCoverages(nodes) {
+  const children = childMap(nodes);
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const coverages = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const endorsement of nodes.filter((node) => node.kind === "endorsement")) {
+    if (hasDescendantEndorsementWithTableRows(endorsement, children)) continue;
+    const coverage = coverageFromEndorsement(endorsement, children);
+    if (!coverage) continue;
+    const key = [coverage.name.toLowerCase(), coverage.sourceNodeIds.join(",")].join("|");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    coverages.push(coverage);
+  }
   const rows = nodes.filter((node) => {
     const text = nodeText(node);
-    return (node.kind === "table_row" || node.kind === "schedule" || node.kind === "text") && /\b(coverage|limit|deductible|aggregate|occurrence|liability|premium)\b/i.test(text);
+    return (node.kind === "table_row" || node.kind === "schedule" || node.kind === "text") && /\b(coverage|limit|deductible|aggregate|occurrence|liability|premium|retroactive|retention)\b/i.test(text);
   });
-  const coverages = [];
-  const seen = /* @__PURE__ */ new Set();
   for (const row of rows) {
+    if (endorsementAncestor(row, byId)) continue;
+    const structured = row.kind === "table_row" ? coverageFromTableRow(row, children, byId) : void 0;
+    if (structured) {
+      const key2 = [
+        structured.name.toLowerCase(),
+        structured.limits.map((term) => `${term.kind}:${term.value}`).join(","),
+        structured.sourceNodeIds.join(",")
+      ].join("|");
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      coverages.push(structured);
+      if (coverages.length >= 60) break;
+      continue;
+    }
     const text = nodeText(row);
     const name = coverageNameFromRow(text);
     const limit = limitFromText(text);
@@ -3018,6 +3323,8 @@ function buildCoverages(nodes) {
       deductible,
       premium,
       formNumber: typeof row.metadata?.formNumber === "string" ? row.metadata.formNumber : void 0,
+      coverageOrigin: "core",
+      limits: [],
       sourceNodeIds: [row.id],
       sourceSpanIds: row.sourceSpanIds
     });
@@ -3159,11 +3466,33 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
       sourceSpanIds
     };
   };
-  const coverages = Array.isArray(candidate.coverages) ? candidate.coverages.map((coverage) => ({
-    ...coverage,
-    sourceNodeIds: keepIds(coverage.sourceNodeIds, validNodeIds),
-    sourceSpanIds: keepIds(coverage.sourceSpanIds, validSpanIds)
-  })).filter((coverage) => coverage.name && (coverage.sourceNodeIds.length > 0 || coverage.sourceSpanIds.length > 0)) : base.coverages;
+  const coverages = base.coverages.length > 0 ? base.coverages : Array.isArray(candidate.coverages) ? candidate.coverages.map((coverage) => {
+    const record = coverage;
+    const limits = Array.isArray(record.limits) ? record.limits.filter(
+      (term) => Boolean(term) && typeof term === "object" && !Array.isArray(term)
+    ).flatMap((term) => {
+      const label = typeof term.label === "string" ? cleanValue(term.label) : void 0;
+      const value = typeof term.value === "string" ? cleanValue(term.value) : void 0;
+      const sourceNodeIds = keepIds(term.sourceNodeIds, validNodeIds);
+      const sourceSpanIds = keepIds(term.sourceSpanIds, validSpanIds);
+      if (!label || !value || sourceNodeIds.length === 0 && sourceSpanIds.length === 0) return [];
+      return [{
+        kind: normalizeTermKind(term.kind, label, value),
+        label,
+        value,
+        amount: typeof term.amount === "number" && Number.isFinite(term.amount) ? term.amount : void 0,
+        appliesTo: typeof term.appliesTo === "string" ? term.appliesTo : void 0,
+        sourceNodeIds,
+        sourceSpanIds
+      }];
+    }) : [];
+    return {
+      ...coverage,
+      limits,
+      sourceNodeIds: keepIds(record.sourceNodeIds, validNodeIds),
+      sourceSpanIds: keepIds(record.sourceSpanIds, validSpanIds)
+    };
+  }).filter((coverage) => coverage.name && (coverage.sourceNodeIds.length > 0 || coverage.sourceSpanIds.length > 0)) : base.coverages;
   return PolicyOperationalProfileSchema.parse({
     ...base,
     documentType: candidate.documentType === "quote" ? "quote" : candidate.documentType === "policy" ? "policy" : base.documentType,
@@ -9173,8 +9502,31 @@ var OperationalProfilePromptSchema = z41.object({
     limit: z41.string().optional(),
     deductible: z41.string().optional(),
     premium: z41.string().optional(),
+    retroactiveDate: z41.string().optional(),
     formNumber: z41.string().optional(),
     sectionRef: z41.string().optional(),
+    coverageOrigin: z41.enum(["core", "endorsement"]).optional(),
+    endorsementNumber: z41.string().optional(),
+    limits: z41.array(z41.object({
+      kind: z41.enum([
+        "each_claim_limit",
+        "each_occurrence_limit",
+        "each_loss_limit",
+        "aggregate_limit",
+        "sublimit",
+        "retention",
+        "deductible",
+        "retroactive_date",
+        "premium",
+        "other"
+      ]).optional(),
+      label: z41.string(),
+      value: z41.string(),
+      amount: z41.number().optional(),
+      appliesTo: z41.string().optional(),
+      sourceNodeIds: z41.array(z41.string()),
+      sourceSpanIds: z41.array(z41.string())
+    })).optional(),
     sourceNodeIds: z41.array(z41.string()),
     sourceSpanIds: z41.array(z41.string())
   })).optional(),
@@ -9988,8 +10340,8 @@ function applyTitleSectionHierarchy(sourceTree) {
       const current = updates.get(child.id) ?? child;
       const heading = sectionHeadingTitle(current, container);
       if (heading) {
-        const descendants = byParent.get(child.id) ?? [];
-        const hasOwnContent = descendants.some((descendant) => descendant.kind !== "table_row" && descendant.kind !== "table_cell");
+        const descendants2 = byParent.get(child.id) ?? [];
+        const hasOwnContent = descendants2.some((descendant) => descendant.kind !== "table_row" && descendant.kind !== "table_cell");
         let hasFollowingContent = false;
         for (const nextChild of directPageChildren.slice(index + 1)) {
           const next = updates.get(nextChild.id) ?? nextChild;
@@ -10007,7 +10359,7 @@ function applyTitleSectionHierarchy(sourceTree) {
           parentId: container.id,
           kind: sectionKindForTitle(heading),
           title: heading,
-          description: descriptionWithPages(cleanText([heading, "section"].join(" "), heading), [current, ...descendants]),
+          description: descriptionWithPages(cleanText([heading, "section"].join(" "), heading), [current, ...descendants2]),
           metadata: {
             ...current.metadata,
             organizer: "title_section",
@@ -10337,13 +10689,16 @@ function buildOperationalProfilePrompt(sourceTree, fallback) {
 
 Return only high-value operational facts needed for policy lists, Q&A, compliance, and certificate generation:
 - policy number, named insured, insurer/carrier/security, broker/producer, policy period, retroactive date, premium
-- coverage lines with limits, deductibles, premiums, and form references
+- coverage units with their own nested limit terms, deductibles/retentions, retroactive dates, premiums, and form references
 - coverage type labels
 
 Rules:
 - Every returned value must include sourceNodeIds or sourceSpanIds from the provided nodes.
 - If a value is not directly supported, omit it.
 - Prefer declarations, schedules, premium tables, and endorsement schedules over generic policy wording.
+- Treat an endorsement as one coverage unit when it contains a schedule. Do not split an endorsement schedule into generic rows like "Aggregate Limit".
+- For coverage schedules, put each claim, aggregate, sublimit, retention, deductible, and retroactive date values in coverages[].limits with labels and source IDs. Keep the legacy coverages[].limit as the primary display value only.
+- Use coverageOrigin: "endorsement" for endorsement units and "core" for declarations/core policy coverage units.
 - Do not copy entire policy wording into fields.
 
 Deterministic baseline:
@@ -10459,11 +10814,18 @@ function materializeDocument(params) {
     limit: coverage.limit,
     deductible: coverage.deductible,
     premium: coverage.premium,
+    retroactiveDate: coverage.retroactiveDate,
     formNumber: coverage.formNumber,
     sectionRef: coverage.sectionRef,
+    coverageOrigin: coverage.coverageOrigin,
+    endorsementNumber: coverage.endorsementNumber,
+    limits: coverage.limits,
     sourceSpanIds: coverage.sourceSpanIds,
     documentNodeId: coverage.sourceNodeIds[0],
-    originalContent: [coverage.name, coverage.limit, coverage.deductible, coverage.premium].filter(Boolean).join(" | ")
+    originalContent: [
+      coverage.name,
+      ...coverage.limits?.length ? coverage.limits.map((term) => `${term.label}: ${term.value}`) : [coverage.limit, coverage.deductible, coverage.premium]
+    ].filter(Boolean).join(" | ")
   }));
   const documentOutline = sourceTreeToOutline(params.sourceTree);
   const documentMetadata = {
@@ -15589,6 +15951,7 @@ export {
   MissingInfoQuestionSchema,
   NamedInsuredSchema,
   OperationalCoverageLineSchema,
+  OperationalCoverageTermSchema,
   OperationalEndorsementSupportSchema,
   OperationalPartySchema,
   PERSONAL_AUTO_USAGES,