@bendyline/squisq 2.13.13 → 2.13.15

package/dist/{chunk-SGNWO7OF.js → chunk-OFE5RZWW.js}

@@ -209,6 +209,109 @@ function extractMediaFromContents(contents, makeId, blockId) {
   return { media, documentMedia, remaining };
 }
 
+// src/doc/templates/conceptItems.ts
+var LABEL_WORDS = 7;
+function splitConceptItem(text) {
+  const clean = text.replace(/\s+/gu, " ").trim();
+  const match = clean.match(/^(.{1,64}?)(:\s|\s[—–-]\s)(.+)$/u);
+  const range = !!match && !match[2].startsWith(":") && /\d$/u.test(match[1]);
+  if (match && !range && !/[.!?]\s/u.test(match[1]) && match[1].split(" ").length <= LABEL_WORDS)
+    return { label: match[1].trim(), detail: match[3].trim() };
+  return { label: "", detail: clean };
+}
+var FIGURE = /^[~≈<>±+−-]?\s?[$€£¥]?\s?\d[\d.,]*(?:\s?(?:%|‰|°[CF]?|[x×](?![a-z])|[KMB](?![a-z])|(?:thousand|million|billion|trillion|percent)\b)|\s(?:in|of|out of)\s\d[\d.,]*)?/iu;
+function isDottedIdentifier(figure) {
+  const digits = figure.match(/\d[\d.,]*/u)?.[0] ?? "";
+  return /\d\.\d+\.\d/u.test(digits) && !/^\d{1,3}(?:\.\d{3})+(?:,\d+)?$/u.test(digits);
+}
+function isFigureText(text) {
+  const clean = text.trim();
+  if (!clean || clean.length > 18) return false;
+  const match = clean.match(FIGURE);
+  if (!match || !match[0].trim() || isDottedIdentifier(match[0])) return false;
+  const rest = clean.slice(match[0].length).trim();
+  return rest === "" || /^[\p{L}°/%²³.]{1,10}(?:\s[\p{L}/²³.]{1,8})?$/u.test(rest);
+}
+function splitStatItem(text) {
+  const { label, detail } = splitConceptItem(text);
+  if (label && isFigureText(label)) return { figure: label, caption: detail };
+  if (label && isFigureText(detail)) return { figure: detail, caption: label };
+  const clean = label ? `${label}: ${detail}` : detail;
+  const lead = clean.match(FIGURE)?.[0] ?? "";
+  const after = clean.slice(lead.length);
+  const figure = /^(?:\s|,\s|$)/u.test(after) && !isDottedIdentifier(lead) ? lead.trim() : "";
+  const rest = figure ? after.replace(/^[\s,;:—–-]+/u, "") : "";
+  if (figure && rest) return { figure: figure.replace(/[.,]+$/u, ""), caption: rest };
+  return { figure: "", caption: clean };
+}
+var OVERLAP_LABEL = /^(?:both|shared?|overlap|in common|common|common ground|together|all|all three|each|either)$/iu;
+function vennOverlapIndex(items) {
+  return items.findIndex((item) => OVERLAP_LABEL.test(item.label.trim()));
+}
+var MONTH = "(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\\.?\\s+";
+var LEADING_DATE = new RegExp(
+  `^((?:${MONTH}(?:\\d{1,2},?\\s+)?)?(?:\\d{4}s?|\\d{1,4}\\s?(?:BCE?|AD|CE))(?![.,]?\\d))[\\s,:;\u2014\u2013-]*(.*)$`,
+  "u"
+);
+function timelineItems(items) {
+  if (items.length < 2) return void 0;
+  let last = -Infinity;
+  const dated = [];
+  for (const item of items) {
+    const match = (item.label || item.detail).match(LEADING_DATE);
+    if (!match) return void 0;
+    const when = match[1];
+    const year = Number(when.match(/\d{1,4}(?=s?\s?(?:BCE?|AD|CE)?$)/u)?.[0] ?? NaN);
+    const signed = /BCE?$/u.test(when) ? -year : year;
+    if (!Number.isFinite(signed) || signed < last) return void 0;
+    last = signed;
+    const rest = match[2].trim();
+    dated.push(
+      item.label ? { when, label: rest, detail: item.detail } : { when, label: "", detail: rest }
+    );
+  }
+  return dated;
+}
+var LEVEL = /\b(low|little|small|less|minimal|few|high|a lot of|lots of|much|more|big|large|great|major|significant)\s+([\p{L}][\p{L}-]*)/giu;
+var LOW_LEVELS = /* @__PURE__ */ new Set([
+  "low",
+  "little",
+  "small",
+  "less",
+  "minimal",
+  "few"
+]);
+function readMatrixItems(items) {
+  if (items.length !== 4) return void 0;
+  const read = items.map((item) => {
+    const levels = /* @__PURE__ */ new Map();
+    for (const match of item.matchAll(LEVEL))
+      levels.set(match[2].toLowerCase(), !LOW_LEVELS.has(match[1].toLowerCase()));
+    return levels;
+  });
+  const measures = [...read[0].keys()].filter(
+    (measure) => read.every((levels) => levels.has(measure))
+  );
+  if (measures.length !== 2) return void 0;
+  const name = (measure) => `${measure[0].toUpperCase()}${measure.slice(1)}`;
+  const corner = (levels, x, y) => (levels.get(y) ? 0 : 2) + (levels.get(x) ? 1 : 0);
+  const [first, second] = measures;
+  for (const [x, y] of [
+    [first, second],
+    [second, first]
+  ]) {
+    const corners = read.map((levels) => corner(levels, x, y));
+    if (new Set(corners).size !== 4) return void 0;
+    if (corners.every((at, index) => at === index))
+      return { xAxis: name(x), yAxis: name(y), items: [...items], reordered: false };
+  }
+  const placed = [];
+  read.forEach((levels, index) => {
+    placed[corner(levels, first, second)] = items[index];
+  });
+  return { xAxis: name(first), yAxis: name(second), items: placed, reordered: true };
+}
+
 // src/doc/asciiDiagram/chars.ts
 function toCells(s) {
   return Array.from(s);
@@ -1561,7 +1664,7 @@ function layeredPlacement(children, unpositionedIdx, opts) {
   }
   if (edges.length === 0) return null;
   const across = opts.direction === "right";
-  const result = layoutGraph(
+  const result2 = layoutGraph(
     {
       nodes: unpositionedIdx.map((i) => ({
         id: children[i].id,
@@ -1582,7 +1685,7 @@ function layeredPlacement(children, unpositionedIdx, opts) {
   );
   const out = /* @__PURE__ */ new Map();
   unpositionedIdx.forEach((entryIdx, k) => {
-    const n = result.nodes[k];
+    const n = result2.nodes[k];
     out.set(entryIdx, { x: Math.round(n.x), y: Math.round(n.y) });
   });
   return out;
@@ -3175,6 +3278,37 @@ function extractBodyPlainText(contents) {
 function extractListItems(contents) {
   return extractRichListItems(contents).map((item) => item.text);
 }
+function extractConceptItems(contents) {
+  const flat = (node) => extractPlainText(node).replace(/\s+/g, " ").trim();
+  const items = [];
+  for (const node of contents ?? []) {
+    if (node.type !== "list") continue;
+    for (const item of node.children) {
+      const own = item.children.filter((child) => child.type !== "list").map(flat).filter(Boolean).join(" ");
+      const nested = item.children.filter((child) => child.type === "list").flatMap((list) => list.children.map(flat)).filter(Boolean);
+      if (!own && !nested.length) continue;
+      if (!nested.length) items.push(own);
+      else if (!own) items.push(nested.join("; "));
+      else
+        items.push(
+          `${own.replace(/[:;,.]$/, "")}${/:\s/.test(own) ? ";" : ":"} ${nested.join("; ")}`
+        );
+    }
+  }
+  return items;
+}
+var COLUMN_LABEL_CHARACTERS = 40;
+function twoColumnsFromList(contents) {
+  const items = extractConceptItems(contents);
+  if (items.length !== 2) return null;
+  const sides = items.map((item) => {
+    const { label, detail } = splitConceptItem(item);
+    if (label) return { label, sublabel: detail };
+    return detail.length <= COLUMN_LABEL_CHARACTERS ? { label: detail } : null;
+  });
+  const [left, right] = sides;
+  return left && right ? { left, right } : null;
+}
 function escapeInlineHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
@@ -3466,12 +3600,26 @@ function extractTableFromContents(contents) {
   }
   return null;
 }
+function blockquoteLines(contents) {
+  const quote = (contents ?? []).find((node) => node.type === "blockquote");
+  if (!quote) return [];
+  const children = quote.children ?? [];
+  return children.flatMap((child) => extractPlainText(child).split(/\r?\n/)).map((line) => line.replace(/\s+/g, " ").trim()).filter(Boolean);
+}
 function extractBlockquoteText(contents) {
-  if (!contents) return "";
-  for (const node of contents) {
-    if (node.type === "blockquote") return extractPlainText(node).trim();
+  return blockquoteLines(contents).join(" ");
+}
+var ATTRIBUTION_LINE = /^(?:[—–―]|-{2,})\s*(\S.*)$/u;
+var ATTRIBUTION_TAIL = /^(.*[.!?…]["”’')\]]?)\s+(?:[—–―]|-{2,})\s*([^.!?…]{2,90})$/su;
+function extractBlockquote(contents) {
+  const lines = blockquoteLines(contents);
+  if (lines.length > 1) {
+    const last = lines[lines.length - 1].match(ATTRIBUTION_LINE);
+    if (last) return { text: lines.slice(0, -1).join(" "), attribution: last[1].trim() };
   }
-  return "";
+  const text = lines.join(" ");
+  const tail = text.match(ATTRIBUTION_TAIL);
+  return tail ? { text: tail[1].trim(), attribution: tail[2].trim() } : { text };
 }
 function firstParagraph(contents) {
   if (!contents) return null;
@@ -3552,6 +3700,61 @@ function deriveStatHighlightInputs(headingText, contents, bodyText) {
 function normalizeCoverageText(value) {
   return value.replace(/\s+/g, " ").trim();
 }
+var RICH_INLINE_TYPES = /* @__PURE__ */ new Set([
+  "link",
+  "linkReference",
+  "image",
+  "imageReference",
+  "inlineCode",
+  "inlineMath",
+  "htmlInline",
+  "icon",
+  "footnoteReference",
+  "mention"
+]);
+function conceptListIsPlain(list) {
+  const items = list.children;
+  if (items.length < 2 || items.length > 6) return false;
+  let plain = true;
+  const visit = (node, depth) => {
+    if (!plain) return;
+    if (RICH_INLINE_TYPES.has(node.type) || node.type === "code" || node.type === "table") {
+      plain = false;
+      return;
+    }
+    const task = node.type === "listItem" && typeof node.checked === "boolean";
+    if (task || node.type === "list" && depth >= 2) {
+      plain = false;
+      return;
+    }
+    const children = node.children ?? [];
+    for (const child of children) visit(child, node.type === "list" ? depth + 1 : depth);
+  };
+  visit(list, 0);
+  return plain;
+}
+var CONCEPT_PLACEHOLDERS = {
+  stats: ["3\xD7: faster to make", "92%: finish a first draft", "14 days: saved each quarter"],
+  pyramid: [
+    "Vision: where it is going",
+    "Strategy: how it gets there",
+    "Daily work: what makes it happen"
+  ],
+  funnel: ["Everyone: who hears of it", "Interested: who looks closer", "Committed: who stays"],
+  hub: [
+    "People: who does the work",
+    "Process: how it gets done",
+    "Tools: what they use",
+    "Goals: what it is for"
+  ],
+  venn: ["This: what only it has", "That: what only it has", "Both: what they share"],
+  matrix: [
+    "Do first: urgent and important",
+    "Plan: important, not urgent",
+    "Delegate: urgent, not important",
+    "Drop: neither"
+  ]
+};
 function autoTemplatePreservesContent(templateName, contents) {
   const nodes = contents ?? [];
   switch (templateName) {
@@ -3561,6 +3764,17 @@ function autoTemplatePreservesContent(templateName, contents) {
       return nodes.length === 1 && nodes[0]?.type === "table";
     case "list":
       return nodes.length === 1 && nodes[0]?.type === "list";
+    case "cards":
+    case "process":
+    case "cycle":
+    case "layers":
+    case "stats":
+    case "pyramid":
+    case "funnel":
+    case "hub":
+    case "venn":
+    case "matrix":
+      return nodes.length === 1 && nodes[0]?.type === "list" && conceptListIsPlain(nodes[0]);
     case "diagram":
     case "timeline":
       return nodes.length === 1 && nodes[0]?.type === "code";
@@ -3615,8 +3829,14 @@ function deriveTemplateInputs(templateName, headingText, contents, options = {})
       };
     }
     case "quote": {
-      const quote = extractBlockquoteText(contents) || bodyText;
-      if (quote) return { quote, ...headingText ? { title: headingText } : {} };
+      const quoted = extractBlockquote(contents);
+      const quote = quoted.text || bodyText;
+      if (quote)
+        return {
+          quote,
+          ...quoted.attribution ? { attribution: quoted.attribution } : {},
+          ...headingText ? { title: headingText } : {}
+        };
       return { quote: headingText };
     }
     case "fullBleedQuote": {
@@ -3624,18 +3844,22 @@ function deriveTemplateInputs(templateName, headingText, contents, options = {})
       return { text };
     }
     case "pullQuote": {
-      const text = extractBlockquoteText(contents) || bodyText || headingText;
+      const quoted = extractBlockquote(contents);
+      const text = quoted.text || bodyText || headingText;
       const img = extractFirstImage(contents);
       return {
         text,
+        ...quoted.attribution ? { attribution: quoted.attribution } : {},
         ...img ? { backgroundImage: { src: img.src, alt: img.alt || headingText } } : {}
       };
     }
     case "videoPullQuote": {
-      const text = extractBlockquoteText(contents) || bodyText || headingText;
+      const quoted = extractBlockquote(contents);
+      const text = quoted.text || bodyText || headingText;
       const video = extractFirstEmbeddedVideo(contents);
       return {
         text,
+        ...quoted.attribution ? { attribution: quoted.attribution } : {},
         ...video ? {
           backgroundVideo: {
             src: video.src,
@@ -3649,10 +3873,13 @@ function deriveTemplateInputs(templateName, headingText, contents, options = {})
     }
     case "factCard":
       return { fact: headingText, explanation: bodyText };
-    case "twoColumn":
-      return headingText ? { header: headingText } : placeholders ? {} : null;
+    case "twoColumn": {
+      const columns = twoColumnsFromList(contents);
+      if (!headingText && !columns) return placeholders ? {} : null;
+      return { ...headingText ? { header: headingText } : {}, ...columns };
+    }
     case "comparisonBar":
-      return placeholders ? { leftLabel: "A", leftValue: 60, rightLabel: "B", rightValue: 40 } : null;
+      return placeholders && !contents?.length ? { leftLabel: "A", leftValue: 60, rightLabel: "B", rightValue: 40 } : null;
     case "list": {
       const items = extractListItems(contents);
       const firstList = (contents ?? []).find((n) => n.type === "list");
@@ -3664,17 +3891,30 @@ function deriveTemplateInputs(templateName, headingText, contents, options = {})
           ...headingText ? { title: headingText } : {}
         };
       }
-      return placeholders ? { items: ["Item 1", "Item 2", "Item 3"] } : null;
+      return placeholders && !contents?.length ? { items: ["Item 1", "Item 2", "Item 3"] } : null;
     }
     case "cards":
     case "process":
     case "cycle":
-    case "layers": {
-      const listed = extractListItems(contents);
+    case "layers":
+    case "stats":
+    case "pyramid":
+    case "funnel":
+    case "hub":
+    case "venn":
+    case "matrix": {
+      const listed = extractConceptItems(contents);
       const items = listed.length ? listed : (contents ?? []).filter((node) => node.type === "paragraph" && !isPictureParagraph(node)).map((node) => extractPlainText(node).trim()).filter(Boolean);
-      if (items.length > 0) return { items, ...headingText ? { title: headingText } : {} };
-      return placeholders ? {
-        items: templateName === "cards" ? [
+      if (items.length > 0) {
+        const matrix = templateName === "matrix" ? readMatrixItems(items) : void 0;
+        return {
+          items,
+          ...matrix && !matrix.reordered ? { xAxis: matrix.xAxis, yAxis: matrix.yAxis } : {},
+          ...headingText ? { title: headingText } : {}
+        };
+      }
+      return placeholders && !contents?.length ? {
+        items: CONCEPT_PLACEHOLDERS[templateName] ?? (templateName === "cards" ? [
           "First idea: what makes it matter",
           "Second idea: how it differs",
           "Third idea: why it helps"
@@ -3682,7 +3922,11 @@ function deriveTemplateInputs(templateName, headingText, contents, options = {})
           "Core: the innermost part",
           "Middle: what surrounds it",
           "Outer: the outermost layer"
-        ] : ["Begin: the first stage", "Grow: what happens next", "Finish: where it leads"]
+        ] : [
+          "Begin: the first stage",
+          "Grow: what happens next",
+          "Finish: where it leads"
+        ])
       } : null;
     }
     case "definitionCard":
@@ -3811,6 +4055,203 @@ function deriveTemplateInputs(templateName, headingText, contents, options = {})
   }
 }
 
+// src/recommend/listShape.ts
+var MAX_IDEAS = 6;
+var MAX_IDEA_CHARACTERS = 170;
+var CYCLE_CUE = /\b(?:cycles?(?!\s+(?:tracks?|lanes?|paths?|routes?|hire|shops?|parking|helmets?))|cyclical|loops?|recurring|rinse and repeat|virtuous circle|vicious circle)\b/iu;
+var CYCLE_INTRO = /\b(?:repeats? itself|(?:cycle|process|sequence|pattern|it|this|which) (?:then |all )?repeats?|over and over|again and again|feedback loop|comes? full circle|round and round)\b/iu;
+var CYCLE_CLOSE = /\b(?:repeats?|again|back to|returns? to|starts? over|begins? again|the cycle|full circle)\b/iu;
+var NESTED_CUE = /\b(?:layers?|anatomy|cross[- ]section|strata|shells?|nested|concentric|zones?|inside (?:the|an?)\b)/iu;
+var INNERMOST = /\b(?:inner(?:most)?|core|cent(?:er|re)|nucleus|heart|kernel)\b/iu;
+var OUTERMOST = /\b(?:outer(?:most)?|crust|surface|skin|shell|exosphere|atmosphere|bark|rind|periphery|edge)\b/iu;
+var HIERARCHY_CUE = /\b(?:hierarch(?:y|ies)|pyramids?|tiers?|levels? of|ranks?|chain of command|food chain|pecking order|priorit(?:y|ies)|maslow)\b/iu;
+var TOP_FIRST_CUE = /\b(?:chain of command|pecking order|priorit(?:y|ies)|ranks?|food chain)\b/iu;
+var APEX = /\b(?:top|highest|peak|apex|summit|chief|executive|president|king|queen|ceo)\b/iu;
+var BASE = /\b(?:base|bottom|foundation(?:al)?|basic|lowest|ground|bedrock|physiological)\b/iu;
+var FUNNEL_CUE = /\b(?:funnels?|conversion|drop[- ]?off|narrow(?:s|ing|ed)? down|winnow(?:s|ing|ed)?|whittl(?:e|es|ing|ed) down|filter(?:s|ing|ed)?(?: down)?|sieve)\b/iu;
+var SEQUENCE_CUE = /\b(?:steps?|how to|process(?:es)?|stages?|phases?|procedure|workflow|instructions?|journey|roadmap|pathway|sequence|walkthrough)\b/iu;
+var ORDINAL_OPENER = /^(?:(?:first|second|third|fourth|fifth)(?:ly)?|then|next|after(?:wards| that)?|finally|lastly|step \d+)\b/iu;
+var CONTRAST_CUE = /\b(?:vs\.?|versus|compared (?:to|with)|comparison|differences? between|contrast)\b|\bor\b[^?]*\?/iu;
+var OPPOSITES = [
+  [/^before$/iu, /^after$/iu],
+  [/^then$/iu, /^now$/iu],
+  [/^pros?$/iu, /^cons?$/iu],
+  [/^advantages?$/iu, /^disadvantages?$/iu],
+  [/^strengths?$/iu, /^weakness(?:es)?$/iu],
+  [/^benefits?$/iu, /^(?:risks?|costs?|drawbacks?)$/iu],
+  [/^(?:risks?|costs?)$/iu, /^(?:benefits?|rewards?)$/iu],
+  [/^old$/iu, /^new$/iu],
+  [/^myth$/iu, /^(?:fact|reality|truth)$/iu],
+  [/^expectations?$/iu, /^reality$/iu],
+  [/^problem$/iu, /^solution$/iu],
+  [/^causes?$/iu, /^effects?$/iu],
+  [/^do$/iu, /^don[’']?t$/iu],
+  [/^with$/iu, /^without$/iu],
+  [/^for$/iu, /^against$/iu]
+];
+var OVERLAP_CUE = /\b(?:overlap(?:s|ping)?|in common|venn|intersection|common ground)\b/iu;
+var MATRIX_CUE = /\b(?:matrix|quadrants?|2\s?[x×]\s?2|two[- ]by[- ]two|four[- ]box|eisenhower|swot)\b/iu;
+var HUB_CUE = /\b(?:factors?|causes?|drivers?|pillars?|elements?|components?|ingredients?|principles?|dimensions?|aspects?|forces?|contributors?|building blocks|parts of|sources of|reasons?)\b/iu;
+var YEAR_LIKE = /^(?:1\d{3}|20\d{2})s?$/u;
+function figureValue(figure) {
+  const match = figure.replace(/,/gu, "").match(/\d+(?:\.\d+)?/u);
+  if (!match) return NaN;
+  const scale = /\b(?:trillion)\b/iu.test(figure) ? 1e12 : /\b(?:billion)\b|\dB\b/u.test(figure) ? 1e9 : /\b(?:million)\b|\dM\b/u.test(figure) ? 1e6 : /\b(?:thousand)\b|\d[Kk]\b/u.test(figure) ? 1e3 : 1;
+  return Number(match[0]) * scale;
+}
+function result(shape, template, confidence, reason, inputs) {
+  return { shape, template, confidence, reason, ...inputs ? { inputs } : {} };
+}
+var PLAIN = (reason) => result("plain", "list", "strong", reason);
+function opposites(a, b) {
+  const [x, y] = [a.trim(), b.trim()];
+  return OPPOSITES.some(
+    ([left, right]) => left.test(x) && right.test(y) || left.test(y) && right.test(x)
+  );
+}
+function classifyListShape(input) {
+  const texts = input.items.map((item) => item.replace(/\s+/gu, " ").trim()).filter(Boolean);
+  if (texts.length < 2) return PLAIN("fewer than two items");
+  if (texts.length > MAX_IDEAS) return PLAIN(`more than ${MAX_IDEAS} items`);
+  if (texts.some((text) => text.length > MAX_IDEA_CHARACTERS)) return PLAIN("items run long");
+  const items = texts.map(splitConceptItem);
+  const n = items.length;
+  const heading = (input.heading ?? "").replace(/\s+/gu, " ").trim();
+  const context = `${heading} ${input.intro ?? ""}`;
+  const labelled = items.filter((item) => item.label).length;
+  const first = `${items[0].label} ${items[0].detail}`;
+  const last = `${items[n - 1].label} ${items[n - 1].detail}`;
+  if (timelineItems(items))
+    return result("timeline", "process", "strong", "items open with dates in order");
+  const stats = texts.map(splitStatItem);
+  const figures = stats.map((stat) => stat.figure);
+  const allFigures = figures.every(Boolean) && !figures.every((figure) => YEAR_LIKE.test(figure));
+  if (allFigures) {
+    const values = figures.map(figureValue);
+    const narrowing = n >= 3 && values.every((value, index) => index === 0 || value < values[index - 1]);
+    if (narrowing && (FUNNEL_CUE.test(context) || SEQUENCE_CUE.test(context) || input.ordered))
+      return result("funnel", "funnel", "strong", "figures that shrink stage by stage");
+    const explicit = texts.every((text) => {
+      const { label, detail } = splitConceptItem(text);
+      return !!label && (isFigureText(label) || isFigureText(detail));
+    });
+    const scaled = figures.every(
+      (figure) => /[%‰$€£¥×,]|\d\s?(?:[xKMB]|million|billion|trillion|thousand|percent)\b|\s(?:in|of)\s\d/iu.test(
+        figure
+      )
+    );
+    if (n <= 6 && (explicit || scaled))
+      return result("figures", "stats", "strong", "every item is a figure and what it measures");
+  }
+  if (vennOverlapIndex(items) >= 0 && n === 3)
+    return result("overlap", "venn", "strong", "two sets and an item naming what they share");
+  if (n === 2 && items.every((item) => item.label) && opposites(items[0].label, items[1].label))
+    return result("contrast", "cards", "strong", "two items labelled as opposites", {
+      versus: true
+    });
+  if (n >= 3 && (CYCLE_CUE.test(heading) || CYCLE_INTRO.test(input.intro ?? "") || CYCLE_CLOSE.test(last) && (input.ordered || SEQUENCE_CUE.test(context))))
+    return result(
+      "cycle",
+      "cycle",
+      "strong",
+      "the heading or the last item says it comes round again"
+    );
+  if (n === 4 && MATRIX_CUE.test(context))
+    return result("matrix", "matrix", "strong", "four items under a heading that names a matrix");
+  if (n >= 3 && FUNNEL_CUE.test(context))
+    return result("funnel", "funnel", "strong", "the heading says the stages narrow");
+  if (n >= 3 && NESTED_CUE.test(context)) {
+    if (INNERMOST.test(first) && !INNERMOST.test(last))
+      return result("nested", "layers", "strong", "nested parts, listed from the inside out");
+    if (INNERMOST.test(last) && (OUTERMOST.test(first) || !INNERMOST.test(first)))
+      return result("nested", "layers", "strong", "nested parts, listed from the outside in", {
+        items: [...texts].reverse()
+      });
+    return result("nested", "layers", "weak", "the heading suggests nested parts");
+  }
+  if (n >= 3 && HIERARCHY_CUE.test(context)) {
+    if (BASE.test(first) && !BASE.test(last))
+      return result("hierarchy", "pyramid", "strong", "a hierarchy, listed from the base up", {
+        items: [...texts].reverse()
+      });
+    if (APEX.test(first) || BASE.test(last) || TOP_FIRST_CUE.test(context))
+      return result("hierarchy", "pyramid", "strong", "a hierarchy, listed from the top down");
+    return result("hierarchy", "pyramid", "weak", "the heading suggests a hierarchy");
+  }
+  if (n === 2 && CONTRAST_CUE.test(heading))
+    return result("contrast", "cards", "strong", "two items under a heading that compares them", {
+      versus: true
+    });
+  if (n === 2 && OVERLAP_CUE.test(context))
+    return result("overlap", "venn", "weak", "the heading suggests two sets that overlap");
+  const openers = texts.filter((text) => ORDINAL_OPENER.test(text)).length;
+  if (input.ordered || openers >= 2 || SEQUENCE_CUE.test(heading))
+    return result(
+      "sequence",
+      "process",
+      "strong",
+      input.ordered ? "a numbered list" : openers >= 2 ? "items open with ordering words" : "the heading names steps"
+    );
+  const brief = texts.every((text) => text.length <= 110);
+  if (n >= 3 && brief && HUB_CUE.test(heading) && labelled * 2 >= n)
+    return result(
+      "hub",
+      "hub",
+      "strong",
+      "labelled items under a heading that names what they share"
+    );
+  if (labelled * 3 >= n * 2)
+    return result("parallel", "cards", "strong", "items written as a label and its detail");
+  if (n >= 3 && brief && HUB_CUE.test(heading))
+    return result("hub", "hub", "weak", "the heading names what the items share");
+  if (n <= 4 && texts.every((text) => text.length <= 90))
+    return result("parallel", "cards", "weak", "a few short items");
+  return PLAIN("no relationship the items make clear");
+}
+var SHARED_CUE = /\b(?:both|shared?|shares|sharing|alike|similar(?:ly|ity|ities)?|in common)\b/iu;
+function shapeIsStated(template, evidence) {
+  const heading = (evidence.heading ?? "").replace(/\s+/gu, " ").trim();
+  const passage = (evidence.passage ?? "").replace(/\s+/gu, " ").trim();
+  const texts = evidence.items.map((item) => item.replace(/\s+/gu, " ").trim()).filter(Boolean);
+  const context = `${heading} ${passage}`;
+  const everything = `${context} ${texts.join(" ")}`;
+  switch (template) {
+    case "cycle":
+      return CYCLE_CUE.test(context) || CYCLE_INTRO.test(passage) || texts.length > 0 && CYCLE_CLOSE.test(texts[texts.length - 1]);
+    case "layers":
+      return NESTED_CUE.test(context) || INNERMOST.test(everything) && OUTERMOST.test(everything);
+    case "pyramid":
+      return HIERARCHY_CUE.test(context) || APEX.test(everything) && BASE.test(everything);
+    case "funnel": {
+      if (FUNNEL_CUE.test(context)) return true;
+      const values = texts.map((text) => figureValue(splitStatItem(text).figure));
+      return values.length >= 3 && values.every(
+        (value, index) => Number.isFinite(value) && (!index || value < values[index - 1])
+      );
+    }
+    case "venn":
+      return OVERLAP_CUE.test(context) || SHARED_CUE.test(passage);
+    case "matrix":
+      return MATRIX_CUE.test(context) || !!evidence.axes?.[0]?.trim() && !!evidence.axes[1]?.trim();
+    default:
+      return true;
+  }
+}
+function unstatedShapeFallback(template) {
+  switch (template) {
+    case "cycle":
+    case "funnel":
+      return "process";
+    case "layers":
+    case "pyramid":
+    case "venn":
+    case "matrix":
+      return "cards";
+    default:
+      return void 0;
+  }
+}
+
 // src/recommend/templates.ts
 var EMPTY_PROFILE = Object.freeze({
   hasImage: false,
@@ -3850,7 +4291,7 @@ function htmlElementsByTag(root, tagNames) {
   }
   return out;
 }
-function profileBlockContents(nodes) {
+function profileBlockContents(nodes, options = {}) {
   if (!nodes || nodes.length === 0) return { ...EMPTY_PROFILE };
   let imageCount = 0;
   let hasBlockquote = false;
@@ -3904,6 +4345,7 @@ function profileBlockContents(nodes) {
   let hasNumberHighlight = false;
   walkMarkdownTree(root, (n) => {
     if (hasNumberHighlight) return true;
+    if (n.type === "list") return true;
     if (n.type !== "paragraph") return;
     const text = extractPlainText(n).trim();
     if (!text) return true;
@@ -3939,6 +4381,12 @@ function profileBlockContents(nodes) {
       hasTree = true;
     }
   }
+  const onlyList = nodes.length === 1 && nodes[0].type === "list" ? nodes[0] : void 0;
+  const listShape = onlyList ? classifyListShape({
+    heading: options.heading,
+    items: extractConceptItems([onlyList]),
+    ordered: onlyList.ordered === true
+  }) : void 0;
   return {
     hasImage: imageCount > 0,
     imageCount,
@@ -3952,7 +4400,8 @@ function profileBlockContents(nodes) {
     hasCompoundBody: nodes.length > 1 && nodes.some((node) => node.type !== "paragraph"),
     hasAsciiDiagram,
     hasTimeline,
-    hasTree
+    hasTree,
+    ...listShape ? { listShape } : {}
   };
 }
 var UNIVERSAL_DEFAULTS = ["title", "sectionHeader", "content", "factCard", "twoColumn"];
@@ -4001,6 +4450,11 @@ function recommendedNamesForProfile(profile) {
   if (profile.hasList) {
     anyContentSignal = true;
     names.add("list");
+    if (profile.listShape && profile.listShape.shape !== "plain") {
+      names.add(profile.listShape.template);
+      names.add("cards");
+      names.add("process");
+    }
   }
   if (profile.hasTable) {
     anyContentSignal = true;
@@ -4028,7 +4482,7 @@ function recommendedNamesForProfile(profile) {
   }
   return Array.from(names);
 }
-function pickAutoTemplate(profile, blockIndex = 0) {
+function pickAutoTemplate(profile, blockIndex = 0, options = {}) {
   if (profile.hasCompoundBody) return void 0;
   if (profile.hasAsciiDiagram) return "diagram";
   if (profile.hasTimeline) return "timeline";
@@ -4039,7 +4493,8 @@ function pickAutoTemplate(profile, blockIndex = 0) {
   if (profile.hasImage) return blockIndex % 2 === 0 ? "leftFeature" : "rightFeature";
   if (profile.hasBlockquote) return "quote";
   if (profile.hasNumberHighlight) return "statHighlight";
-  if (profile.hasList) return "list";
+  if (profile.hasList)
+    return options.concepts !== false && profile.listShape?.confidence === "strong" ? profile.listShape.template : "list";
   return void 0;
 }
 function recommendTemplatesForBlock(profile, allNames) {
@@ -4060,6 +4515,12 @@ export {
   isMediaAnnotationName,
   isStandaloneHtmlVideo,
   extractMediaFromContents,
+  splitConceptItem,
+  isFigureText,
+  splitStatItem,
+  vennOverlapIndex,
+  timelineItems,
+  readMatrixItems,
   toCells,
   cellWidth,
   isHoriz,
@@ -4114,6 +4575,7 @@ export {
   isPictureParagraph,
   extractBodyPlainText,
   extractListItems,
+  extractConceptItems,
   renderMarkdownBlocksHtml,
   markdownBlockSeparatorLines,
   extractRichListItems,
@@ -4123,8 +4585,12 @@ export {
   extractFirstEmbeddedVideo,
   extractTableFromContents,
   extractBlockquoteText,
+  extractBlockquote,
   autoTemplatePreservesContent,
   deriveTemplateInputs,
+  classifyListShape,
+  shapeIsStated,
+  unstatedShapeFallback,
   profileBlockContents,
   pickAutoTemplate,
   recommendTemplatesForBlock