@bendyline/squisq 2.11.0 → 2.11.2

package/dist/{chunk-EH4S7HXE.js → chunk-56MJWI5M.js}

@@ -30,7 +30,7 @@ import {
   templateRegistry,
   writeCustomTemplatesToFrontmatter,
   writeCustomThemesToFrontmatter
-} from "./chunk-ZYCSRDSX.js";
+} from "./chunk-RO7WVERN.js";
 import {
   iconMarker
 } from "./chunk-7ZAAICW4.js";
@@ -45,11 +45,12 @@ import {
   detectAsciiDiagram,
   isHoriz,
   isJunction,
+  isLineChar,
   isVert,
   toCells,
   toGrid,
   traceBoxes
-} from "./chunk-CUYHFOFL.js";
+} from "./chunk-6ATZOUCQ.js";
 import {
   defaultPageStyle,
   resolveMediaSchedule
@@ -5115,6 +5116,19 @@ function pickSides(s, t) {
   gaps.sort((a, b) => a.gap - b.gap);
   return { exit: gaps[0].side, enter: gaps[0].side };
 }
+function blockedAttachmentColumns(p) {
+  const blocked = /* @__PURE__ */ new Set();
+  const innerW = p.rect.c1 - p.rect.c0 - 1;
+  const lines = p.isContainer ? p.labelLines.slice(1) : p.labelLines;
+  for (const line of lines) {
+    const cells = toCells(line);
+    const pad = Math.max(0, Math.floor((innerW - cells.length) / 2));
+    cells.forEach((ch, j) => {
+      if (isLineChar(ch)) blocked.add(p.rect.c0 + 1 + pad + j);
+    });
+  }
+  return blocked;
+}
 function assignAttachments(plans, placed) {
   const bySide = /* @__PURE__ */ new Map();
   plans.forEach((plan, i) => {
@@ -5143,13 +5157,31 @@ function assignAttachments(plans, placed) {
     const to = horizontal ? node.rect.c1 - 1 : node.rect.r1 - 1;
     const inner = Math.max(1, to - from + 1);
     const k = list2.length;
+    const blocked = horizontal ? blockedAttachmentColumns(node) : /* @__PURE__ */ new Set();
+    const taken = [];
+    const place = (want) => {
+      const free = (pos) => pos >= from && pos <= to && !blocked.has(pos) && taken.every((t) => Math.abs(t - pos) >= 2);
+      for (let d = 0; d <= inner; d++) {
+        for (const pos of d === 0 ? [want] : [want - d, want + d]) {
+          if (!free(pos)) continue;
+          taken.push(pos);
+          return pos;
+        }
+      }
+      taken.push(want);
+      return want;
+    };
     if (k === 1) {
-      result.set(list2[0].key, { pos: from + Math.floor((inner - 1) / 2), index: 0, count: 1 });
+      result.set(list2[0].key, {
+        pos: place(from + Math.floor((inner - 1) / 2)),
+        index: 0,
+        count: 1
+      });
     } else {
       const span = 2 * k - 1;
       const start = from + Math.max(0, Math.floor((inner - span) / 2));
       list2.forEach((req, i) => {
-        result.set(req.key, { pos: Math.min(to, start + 2 * i), index: i, count: k });
+        result.set(req.key, { pos: place(Math.min(to, start + 2 * i)), index: i, count: k });
       });
     }
   }

package/dist/{chunk-CUYHFOFL.js → chunk-6ATZOUCQ.js}

@@ -176,6 +176,11 @@ function parseAsciiDiagramWithStats(text) {
   const style = detectStyle(grid);
   const rects = traceBoxes(grid);
   const boxes = buildBoxes(grid, rects, warnings);
+  const boxNodes = boxes.length;
+  const railBoxes = findRailLabels(grid, boxes);
+  for (const rail of railBoxes) boxes.push(rail);
+  const railNodes = railBoxes.length;
+  if (railNodes > 0) warnings.push(`rail-labels(${railNodes})`);
   const mask = new Uint8Array(W * H);
   const perimeterOwners = /* @__PURE__ */ new Map();
   for (let b = 0; b < boxes.length; b++) {
@@ -248,18 +253,21 @@ function parseAsciiDiagramWithStats(text) {
   if (looseRuns.length > MAX_LOOSE_WARNINGS) {
     warnings.push(`loose-text (+${looseRuns.length - MAX_LOOSE_WARNINGS} more)`);
   }
-  const nodes = boxes.map((box) => ({
-    id: box.id,
-    label: box.labelLines.join("\n"),
-    col: box.c0,
-    row: box.r0,
-    wCols: box.c1 - box.c0 + 1,
-    hRows: box.r1 - box.r0 + 1,
-    ...box.parentIdx >= 0 ? { containerId: boxes[box.parentIdx].id } : {}
-  }));
+  const nodes = boxes.map((box) => {
+    const rect = box.emit ?? box;
+    return {
+      id: box.id,
+      label: box.labelLines.join("\n"),
+      col: rect.c0,
+      row: rect.r0,
+      wCols: rect.c1 - rect.c0 + 1,
+      hRows: rect.r1 - rect.r0 + 1,
+      ...box.parentIdx >= 0 ? { containerId: boxes[box.parentIdx].id } : {}
+    };
+  }).sort((a, b) => a.row - b.row || a.col - b.col);
   return {
     diagram: { nodes, edges, style, warnings },
-    stats: { totalNonSpaceCells, looseNonSpaceCells, hasWideChars }
+    stats: { totalNonSpaceCells, looseNonSpaceCells, hasWideChars, boxNodes, railNodes }
   };
 }
 function buildGrid(text, warnings) {
@@ -497,6 +505,176 @@ function slugify(s) {
   const slug2 = s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return slug2 || "node";
 }
+var BUS_LABEL_LOOKASIDE = 3;
+var RAIL_LABEL_PAD = 1;
+var BOX_SPILL_GAP = 2;
+var RAIL_ROW_SCALE = 3;
+var RAIL_COL_SCALE = 2;
+function railRect(text, lines, boxScale) {
+  if (boxScale) {
+    const r0 = text.r0 * RAIL_ROW_SCALE;
+    const c0 = text.c0 * RAIL_COL_SCALE;
+    return {
+      r0,
+      c0,
+      r1: r0 + Math.max(3, lines + 2) - 1,
+      c1: c0 + Math.max(3, text.c1 - text.c0 + 1 + 4) - 1
+    };
+  }
+  const top = Math.max(0, text.r0 - RAIL_LABEL_PAD);
+  const left = Math.max(0, text.c0 - RAIL_LABEL_PAD);
+  return {
+    r0: top,
+    c0: left,
+    r1: top + (text.r1 - text.r0) + 2 * RAIL_LABEL_PAD,
+    c1: left + (text.c1 - text.c0) + 2 * RAIL_LABEL_PAD
+  };
+}
+function findRailLabels(grid, boxes) {
+  const H = grid.length;
+  const W = H > 0 ? grid[0].length : 0;
+  if (H === 0 || W === 0) return [];
+  const inBox = new Uint8Array(W * H);
+  for (const box of boxes) {
+    for (let r = Math.max(0, box.r0); r <= Math.min(H - 1, box.r1); r++) {
+      for (let c = Math.max(0, box.c0); c <= Math.min(W - 1, box.c1); c++) inBox[r * W + c] = 1;
+    }
+  }
+  const at = (r, c) => r >= 0 && r < H && c >= 0 && c < W ? grid[r][c] : " ";
+  const joins = (ch) => isLineChar(ch) || isJunction(ch) || isPlus(ch) || isAnyCorner(ch);
+  const vertJoins = (ch) => {
+    const arrow = arrowDirection(ch);
+    return joins(ch) || arrow === "up" || arrow === "down";
+  };
+  const horizJoins = (ch) => {
+    const arrow = arrowDirection(ch);
+    return joins(ch) || arrow === "left" || arrow === "right";
+  };
+  const routingRow = [];
+  for (let r = 0; r < H; r++) {
+    let any = false;
+    let all = true;
+    for (let c = 0; c < W && all; c++) {
+      const ch = grid[r][c];
+      if (ch === " ") continue;
+      any = true;
+      if (!isLineChar(ch) && arrowDirection(ch) === null) all = false;
+    }
+    routingRow.push(any && all);
+  }
+  const structural = (r, c) => {
+    const ch = at(r, c);
+    if (ch === " ") return false;
+    if (arrowDirection(ch) !== null) return true;
+    const ascii = asciiArrowDirection(ch);
+    if (ascii !== null && asciiArrowGate(grid, r, c, ascii)) return true;
+    if (!isLineChar(ch)) return false;
+    if (routingRow[r]) return true;
+    const vert = vertJoins(at(r - 1, c)) || vertJoins(at(r + 1, c));
+    if (isVert(ch)) return vert;
+    const horiz = horizJoins(at(r, c - 1)) || horizJoins(at(r, c + 1));
+    if (isHoriz(ch)) return horiz;
+    return vert || horiz;
+  };
+  const isTextCell = (r, c) => c >= 0 && c < W && grid[r][c] !== " " && !inBox[r * W + c] && !structural(r, c);
+  const runs = [];
+  for (let r = 0; r < H; r++) {
+    let start = -1;
+    let end = -1;
+    const flush = () => {
+      if (start >= 0) {
+        const text = grid[r].slice(start, end + 1).join("").trim();
+        if (text.length > 0) runs.push({ row: r, c0: start, c1: end, text });
+      }
+      start = -1;
+    };
+    for (let c = 0; c < W; c++) {
+      if (isTextCell(r, c)) {
+        if (start < 0) start = c;
+        end = c;
+      } else if (start >= 0 && grid[r][c] === " " && isTextCell(r, c + 1)) {
+        continue;
+      } else {
+        flush();
+      }
+    }
+    flush();
+  }
+  const abutsRail = (run) => [-1, 1].some((dir) => {
+    for (let step = 1; step <= BUS_LABEL_LOOKASIDE; step++) {
+      const c = dir < 0 ? run.c0 - step : run.c1 + step;
+      if (at(run.row, c) === " ") continue;
+      return structural(run.row, c);
+    }
+    return false;
+  });
+  const spillsFromBox = (run) => boxes.some(
+    (box) => run.row >= box.r0 && run.row <= box.r1 && run.c0 <= box.c1 + BOX_SPILL_GAP && run.c1 >= box.c0 - BOX_SPILL_GAP
+  );
+  const candidates = runs.filter(
+    (run) => /[a-z0-9]/i.test(run.text) && !abutsRail(run) && !spillsFromBox(run)
+  );
+  const groups = [];
+  let previousRow = [];
+  for (let r = 0; r < H; r++) {
+    const rowRuns = candidates.filter((run) => run.row === r);
+    const currentRow = [];
+    for (const run of rowRuns) {
+      const host = previousRow.find((group) => {
+        const last = group[group.length - 1];
+        return last.row === r - 1 && last.c0 <= run.c1 && run.c0 <= last.c1;
+      });
+      if (host) {
+        host.push(run);
+        currentRow.push(host);
+      } else {
+        const group = [run];
+        groups.push(group);
+        currentRow.push(group);
+      }
+    }
+    previousRow = currentRow;
+  }
+  const railHead = (r, c) => {
+    if (r < 0 || r >= H || inBox[r * W + c] === 1 || !structural(r, c)) return false;
+    const ch = grid[r][c];
+    const arrow = arrowDirection(ch) ?? asciiArrowDirection(ch);
+    return isVert(ch) || isJunction(ch) || isPlus(ch) || arrow === "up" || arrow === "down";
+  };
+  const railAdjacent = (group) => group.some(
+    (run) => [run.row - 1, run.row + 1].some((r) => {
+      for (let c = Math.max(0, run.c0 - 1); c <= Math.min(W - 1, run.c1 + 1); c++) {
+        if (railHead(r, c)) return true;
+      }
+      return false;
+    })
+  );
+  const usedIds = /* @__PURE__ */ new Map();
+  for (const box of boxes) usedIds.set(box.id, (usedIds.get(box.id) ?? 0) + 1);
+  const out = [];
+  for (const group of groups) {
+    if (!railAdjacent(group)) continue;
+    const labelLines = group.map((run) => run.text);
+    const r0 = group[0].row;
+    const r1 = group[group.length - 1].row;
+    const c0 = Math.min(...group.map((run) => run.c0));
+    const c1 = Math.max(...group.map((run) => run.c1));
+    const base = slugify(labelLines[0]);
+    const count = usedIds.get(base) ?? 0;
+    usedIds.set(base, count + 1);
+    out.push({
+      r0,
+      c0,
+      r1,
+      c1,
+      parentIdx: -1,
+      labelLines,
+      id: count === 0 ? base : `${base}-${count + 1}`,
+      emit: railRect({ r0, c0, r1, c1 }, labelLines.length, boxes.length === 0)
+    });
+  }
+  return out;
+}
 function extractEdges(grid, mask, perimeterOwners, boxes, warnings) {
   const H = grid.length;
   const W = H > 0 ? grid[0].length : 0;
@@ -687,6 +865,26 @@ function extractEdges(grid, mask, perimeterOwners, boxes, warnings) {
         attachmentsByBox.set(boxIdx, { boxIdx, isArrowEnd: false });
       }
     }
+    if (attachmentsByBox.size < 2) {
+      for (const idx of component) {
+        const r = Math.floor(idx / W);
+        const c = idx % W;
+        const ch = grid[r][c];
+        const axis = isVert(ch) ? [
+          [-1, 0],
+          [1, 0]
+        ] : isHoriz(ch) ? [
+          [0, -1],
+          [0, 1]
+        ] : [];
+        for (const [dr, dc] of axis) {
+          const boxIdx = nearestOwner(r + dr, c + dc);
+          if (boxIdx !== null && !attachmentsByBox.has(boxIdx)) {
+            attachmentsByBox.set(boxIdx, { boxIdx, isArrowEnd: false });
+          }
+        }
+      }
+    }
     const attachments = [...attachmentsByBox.values()].sort(
       (a, b) => boxes[a.boxIdx].r0 - boxes[b.boxIdx].r0 || boxes[a.boxIdx].c0 - boxes[b.boxIdx].c0
     );
@@ -908,6 +1106,7 @@ var MAX_LINES = 400;
 var MAX_COLS = 400;
 var MIN_LINES = 3;
 var MAX_LOOSE_RATIO = 0.25;
+var ROUTING_ROW = /^[\s\u2500-\u257F+\-|^v<>\u25B2\u25BC\u25C0\u25B6\u25C4\u25BA\u2190\u2192\u2191\u2193]+$/;
 var STRUCTURAL_IN_LABEL = /[│┃║┌┐└┘├┤┬┴┼╭╮╰╯┏┓┗┛╔╗╚╝┣┫┳┻╋╠╣╦╩╬╞╡╥╨╫╪]/;
 function isEligibleAsciiFenceLang(lang) {
   if (lang === null || lang === void 0) return true;
@@ -940,8 +1139,14 @@ function detectAsciiDiagram(text, opts = {}) {
       const plusMatches = line.match(/\+[-+]/g);
       tlCandidates += plusMatches ? plusMatches.length : 0;
     }
-    if (tlCandidates < 2) {
-      return { isDiagram: false, reasons: [`too-few-corner-candidates(${tlCandidates})`] };
+    const routingRows = lines.filter(
+      (line) => line.trim().length > 0 && ROUTING_ROW.test(line)
+    ).length;
+    if (tlCandidates < 2 && routingRows < 2) {
+      return {
+        isDiagram: false,
+        reasons: [`too-few-corner-candidates(${tlCandidates}) routing-rows(${routingRows})`]
+      };
     }
   }
   const nonBlank = lines.filter((l) => l.trim().length > 0);
@@ -960,6 +1165,9 @@ function detectAsciiDiagram(text, opts = {}) {
     return { isDiagram: false, reasons: [`garbled-labels(${garbled}/${diagram.nodes.length})`] };
   }
   if (!explicit) {
+    if (stats.boxNodes === 0 && diagram.edges.length === 0) {
+      return { isDiagram: false, reasons: [`rail-labels-unconnected(${stats.railNodes})`] };
+    }
     if (diagram.edges.length === 0 && diagram.nodes.length >= 4 && isLattice(diagram)) {
       return { isDiagram: false, reasons: ["table-lattice"] };
     }
@@ -1961,7 +2169,7 @@ function detectAsciiTimeline(text, options = {}) {
   if (!explicit && lines.some((line) => BOX_TOP_EDGE_RE.test(line))) {
     return { isTimeline: false, reasons: ["has-box-corners"] };
   }
-  const boxes = parseAsciiDiagramWithStats(text).diagram.nodes.length;
+  const boxes = parseAsciiDiagramWithStats(text).stats.boxNodes;
   if (boxes >= (explicit ? 2 : 1)) {
     return { isTimeline: false, reasons: [`has-boxes(${boxes})`] };
   }
@@ -2205,7 +2413,7 @@ function detectTree(text, opts = {}) {
   if (!explicit && detectAsciiTimeline(text).isTimeline) {
     return { isTree: false, reasons: ["is-timeline"] };
   }
-  const boxes = parseAsciiDiagramWithStats(text).diagram.nodes.length;
+  const boxes = parseAsciiDiagramWithStats(text).stats.boxNodes;
   if (boxes >= 2) {
     return { isTree: false, reasons: [`has-boxes(${boxes})`] };
   }
@@ -2488,6 +2696,7 @@ export {
   isVert,
   isJunction,
   arrowDirection,
+  isLineChar,
   UNICODE_VOCAB,
   ASCII_VOCAB,
   MAX_BRIDGE_GAP,

package/dist/{chunk-T3B4WJBR.js → chunk-B3AK7SLZ.js}

@@ -40,14 +40,96 @@ function categorizeLintKind(kind) {
 
 // src/proof/masking.ts
 var ANNOTATION_RE = /\{\[[^\n]*?\]\}/g;
-function blankProtectedSpans(text) {
+function blankProtectedSpans(text, options = {}) {
+  const ranges = [];
+  ANNOTATION_RE.lastIndex = 0;
+  let match;
+  while ((match = ANNOTATION_RE.exec(text)) !== null) {
+    ranges.push({ start: match.index, end: match.index + match[0].length });
+  }
+  if (options.markdownCode) ranges.push(...markdownCodeRanges(text));
+  if (ranges.length === 0) return { text, blanked: [] };
+  ranges.sort((a, b) => a.start - b.start || a.end - b.end);
   const blanked = [];
-  const out = text.replace(ANNOTATION_RE, (match, offset) => {
-    blanked.push({ start: offset, end: offset + match.length });
-    return " ".repeat(match.length);
-  });
+  for (const range of ranges) {
+    const last = blanked[blanked.length - 1];
+    if (last && range.start <= last.end) last.end = Math.max(last.end, range.end);
+    else blanked.push({ ...range });
+  }
+  let out = "";
+  let cursor = 0;
+  for (const range of blanked) {
+    out += text.slice(cursor, range.start);
+    out += text.slice(range.start, range.end).replace(/[^\n]/g, " ");
+    cursor = range.end;
+  }
+  out += text.slice(cursor);
   return { text: out, blanked };
 }
+function markdownCodeRanges(text) {
+  const fences = fencedCodeRanges(text);
+  const ranges = [...fences];
+  let cursor = 0;
+  for (const fence of fences) {
+    collectInlineCodeRanges(text, cursor, fence.start, ranges);
+    cursor = fence.end;
+  }
+  collectInlineCodeRanges(text, cursor, text.length, ranges);
+  return ranges;
+}
+var FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+function fencedCodeRanges(text) {
+  const ranges = [];
+  let lineStart = 0;
+  let open = null;
+  for (; ; ) {
+    const newline = text.indexOf("\n", lineStart);
+    const lineEnd = newline === -1 ? text.length : newline;
+    const match = FENCE_RE.exec(text.slice(lineStart, lineEnd));
+    if (!open) {
+      if (match) open = { start: lineStart, marker: match[2] };
+    } else if (match && // A closing fence is the same character, at least as long, and bare.
+    match[2][0] === open.marker[0] && match[2].length >= open.marker.length && match[3].trim() === "") {
+      ranges.push({ start: open.start, end: lineEnd });
+      open = null;
+    }
+    if (newline === -1) break;
+    lineStart = newline + 1;
+  }
+  if (open) ranges.push({ start: open.start, end: text.length });
+  return ranges;
+}
+function collectInlineCodeRanges(text, from, to, out) {
+  let i = from;
+  let openStart = -1;
+  let openLength = 0;
+  while (i < to) {
+    if (text[i] === "`") {
+      let run = 1;
+      while (i + run < to && text[i + run] === "`") run++;
+      if (openStart < 0) {
+        openStart = i;
+        openLength = run;
+      } else if (run === openLength) {
+        out.push({ start: openStart, end: i + run });
+        openStart = -1;
+        openLength = 0;
+      }
+      i += run;
+      continue;
+    }
+    if (openStart >= 0 && text[i] === "\n" && startsBlankLine(text, i + 1, to)) {
+      openStart = -1;
+      openLength = 0;
+    }
+    i++;
+  }
+}
+function startsBlankLine(text, index, to) {
+  let i = index;
+  while (i < to && (text[i] === " " || text[i] === "	")) i++;
+  return i >= to || text[i] === "\n";
+}
 function dropMaskedFindings(findings, blanked) {
   if (blanked.length === 0) return [...findings];
   return findings.filter(

package/dist/{chunk-ZWID3HM5.js → chunk-QWN5CLCP.js}

@@ -3,7 +3,7 @@ import {
   expectedSyllablesAt,
   flattenRenderableBlocks,
   wordPosAtExpectedSyllables
-} from "./chunk-ZYCSRDSX.js";
+} from "./chunk-RO7WVERN.js";
 
 // src/narration/types.ts
 var DEFAULT_FEATURE_CONFIG = Object.freeze({

package/dist/{chunk-ZYCSRDSX.js → chunk-RO7WVERN.js}

@@ -21,7 +21,7 @@ import {
   parseAsciiTimeline,
   pickAutoTemplate,
   profileBlockContents
-} from "./chunk-CUYHFOFL.js";
+} from "./chunk-6ATZOUCQ.js";
 import {
   DEFAULT_THEME,
   FRONTMATTER_CUSTOM_TEMPLATES_KEY,
@@ -1513,9 +1513,11 @@ function renderMarkdownBlocksHtml(nodes) {
         return "<hr>";
       case "table": {
         const [head, ...body] = node.children;
-        const row = (cells, header) => `<tr>${cells.map((cell) => {
+        const row = (cells, header) => `<tr>${cells.map((cell, columnIndex) => {
           const tag = header ? "th" : "td";
-          return `<${tag}>${renderInlineHtml(cell.children)}</${tag}>`;
+          const alignment = node.align?.[columnIndex];
+          const alignAttribute = alignment ? ` align="${alignment}"` : "";
+          return `<${tag}${alignAttribute}>${renderInlineHtml(cell.children)}</${tag}>`;
         }).join("")}</tr>`;
         const thead = head ? `<thead>${row(head.children, true)}</thead>` : "";
         const tbody = body.length ? `<tbody>${body.map((item) => row(item.children, false)).join("")}</tbody>` : "";

package/dist/doc/index.js

@@ -70,7 +70,7 @@ import {
   validateMarkdownDoc,
   validateMarkdownSource,
   writeDashboardLayoutsToFrontmatter
-} from "../chunk-EH4S7HXE.js";
+} from "../chunk-56MJWI5M.js";
 import {
   ASCII_CHAR_H,
   ASCII_CHAR_W,
@@ -192,7 +192,7 @@ import {
   wrapWithPersistentLayers,
   writeCustomTemplatesToFrontmatter,
   writeCustomThemesToFrontmatter
-} from "../chunk-ZYCSRDSX.js";
+} from "../chunk-RO7WVERN.js";
 import {
   PATH_SHAPE_KINDS,
   anchorPoint,
@@ -229,7 +229,7 @@ import {
   parseAsciiTimelineWithStats,
   parseTree,
   parseWrappedFlowTimeline
-} from "../chunk-CUYHFOFL.js";
+} from "../chunk-6ATZOUCQ.js";
 import "../chunk-GAZKTT4R.js";
 import {
   DEFAULT_THEME,

package/dist/index.d.ts

@@ -26,5 +26,5 @@ export { IconSuggestion, canonicalIconToken, iconGlyph, looksLikeIconToken, reso
 export { BlockContentProfile, RecommendationResult, profileBlockContents, recommendTemplatesForBlock } from './recommend/index.js';
 export { AdvanceCoverage, AlignConfig, AlignInput, BandpassState, BuildAdvanceTimingOptions, BuildNarrationTimingOptions, BuildScriptOptions, DEFAULT_ALIGN_CONFIG, DEFAULT_FEATURE_CONFIG, DEFAULT_NUCLEI_CONFIG, DEFAULT_PACING_CONFIG, DEFAULT_VAD_CONFIG, EMPTY_ADVANCE_LOG, FeatureConfig, FeatureState, FrameFeatures, NarrationAlignment, NarrationBlockRange, NarrationScript, NarrationSessionConfig, NarrationSessionState, NarrationTimingBlock, NarrationTimingJsonV3, NarrationTimingMethod, NarrationTrace, NucleiConfig, NucleiState, PacingConfig, PacingState, PacingTick, ScriptBlockRange, ScriptToken, SlideAdvance, SlideAdvanceLog, TraceSample, VadConfig, VadState, WordTiming, advanceCoverage, alignNarration, bandpassRun, buildAdvanceTimingJson, buildNarrationScript, buildNarrationTimingJson, createBandpass, createFeatureState, createNarrationSession, createNucleiState, createPacingState, createVadState, detectSyllableOnsets, downsampleTrace, estimateSyllables, expectedSyllablesAt, extractFrameFeatures, featureStep, narrationSessionStep, nucleiStep, pacingStep, parseNarrationTimingJson, reanchorPacing, reanchorSession, recordSlideShown, traceWordPosAt, vadStep, wordIndexAtChar, wordIndexAtTime, wordPosAtExpectedSyllables } from './narration/index.js';
 export { FenceRenderContext, FenceRenderer, FenceRendererMap, fenceRendererLangs } from './fence/index.js';
-export { BlankedText, DEFAULT_PROOF_SETTINGS, JoinedSegments, LINT_KIND_CATEGORIES, PROOF_DIALECTS, PROOF_FRONTMATTER_KEYS, PROOF_JOIN_SEPARATOR, ProofCategory, ProofDialect, ProofFinding, ProofRange, ProofSuggestion, ProofSuggestionKind, ProofingSettings, SegmentSpan, blankProtectedSpans, buildJoinedText, categorizeLintKind, dropMaskedFindings, formatProofDictionary, mapJoinedSpanToSegment, parseProofDictionary, readProofingSettings, resolveProofDialect } from './proof/index.js';
+export { BlankProtectedSpansOptions, BlankedText, DEFAULT_PROOF_SETTINGS, JoinedSegments, LINT_KIND_CATEGORIES, PROOF_DIALECTS, PROOF_FRONTMATTER_KEYS, PROOF_JOIN_SEPARATOR, ProofCategory, ProofDialect, ProofFinding, ProofRange, ProofSuggestion, ProofSuggestionKind, ProofingSettings, SegmentSpan, blankProtectedSpans, buildJoinedText, categorizeLintKind, dropMaskedFindings, formatProofDictionary, mapJoinedSpanToSegment, parseProofDictionary, readProofingSettings, resolveProofDialect } from './proof/index.js';
 import './viewState-lTZS-hP_.js';

package/dist/index.js

@@ -27,7 +27,7 @@ import {
   recordSlideShown,
   traceWordPosAt,
   vadStep
-} from "./chunk-ZWID3HM5.js";
+} from "./chunk-QWN5CLCP.js";
 import {
   fenceRendererLangs
 } from "./chunk-PGI7HSWE.js";
@@ -46,7 +46,7 @@ import {
   parseProofDictionary,
   readProofingSettings,
   resolveProofDialect
-} from "./chunk-T3B4WJBR.js";
+} from "./chunk-B3AK7SLZ.js";
 import {
   DEFAULT_TRANSFORM_STYLE_ID,
   analyzeBlocks,
@@ -227,7 +227,7 @@ import {
   validateMarkdownDoc,
   validateMarkdownSource,
   writeDashboardLayoutsToFrontmatter
-} from "./chunk-EH4S7HXE.js";
+} from "./chunk-56MJWI5M.js";
 import {
   ASCII_CHAR_H,
   ASCII_CHAR_W,
@@ -357,7 +357,7 @@ import {
   wrapWithPersistentLayers,
   writeCustomTemplatesToFrontmatter,
   writeCustomThemesToFrontmatter
-} from "./chunk-ZYCSRDSX.js";
+} from "./chunk-RO7WVERN.js";
 import {
   PATH_SHAPE_KINDS,
   anchorPoint,
@@ -402,7 +402,7 @@ import {
   parseWrappedFlowTimeline,
   profileBlockContents,
   recommendTemplatesForBlock
-} from "./chunk-CUYHFOFL.js";
+} from "./chunk-6ATZOUCQ.js";
 import {
   defaultPageStyle,
   getDocPlaybackDuration,

package/dist/narration/index.js

@@ -27,7 +27,7 @@ import {
   recordSlideShown,
   traceWordPosAt,
   vadStep
-} from "../chunk-ZWID3HM5.js";
+} from "../chunk-QWN5CLCP.js";
 import {
   buildNarrationScript,
   buildNarrationTimingJson,
@@ -37,9 +37,9 @@ import {
   wordIndexAtChar,
   wordIndexAtTime,
   wordPosAtExpectedSyllables
-} from "../chunk-ZYCSRDSX.js";
+} from "../chunk-RO7WVERN.js";
 import "../chunk-PUS54YU6.js";
-import "../chunk-CUYHFOFL.js";
+import "../chunk-6ATZOUCQ.js";
 import "../chunk-SBAX4ZPO.js";
 import "../chunk-BAOV476U.js";
 import "../chunk-TMOHAFYE.js";

package/dist/proof/index.d.ts

@@ -73,6 +73,15 @@ declare function categorizeLintKind(kind: string): ProofCategory;
  * spaces — every surrounding offset stays byte-identical — and afterwards
  * drop any finding that intersects a blanked range (which also swallows
  * the whitespace-formatting lints the blank runs themselves can induce).
+ *
+ * MARKDOWN SOURCE carries a second family of machine vocabulary: code.
+ * A fence is a program, and an inline span is an identifier or a signature
+ * (``raycast(origin, dir, maxDist)`` draws a spelling lint on every one of
+ * those words), so `markdownCode` blanks both. It is off by default because
+ * it is only meaningful for source text: the Write view lints the editor's
+ * PLAIN TEXT, where code is a ProseMirror mark with no backticks to find
+ * (`writeViewText.ts` blanks it during collection instead). Newlines are
+ * never blanked, so a line/column mapping over the result stays exact.
  */
 
 interface BlankedText {
@@ -81,8 +90,18 @@ interface BlankedText {
     /** The replaced ranges, in ascending order. */
     blanked: ProofRange[];
 }
-/** Blank `{[…]}` annotation spans to equal-length spaces. */
-declare function blankProtectedSpans(text: string): BlankedText;
+interface BlankProtectedSpansOptions {
+    /**
+     * Also blank markdown code: fenced blocks (delimiters and info string
+     * included) and inline code spans. Only correct for markdown SOURCE text.
+     */
+    markdownCode?: boolean;
+}
+/**
+ * Blank protected spans to equal-length runs of spaces: `{[…]}` annotations
+ * always, and markdown code when `markdownCode` is set.
+ */
+declare function blankProtectedSpans(text: string, options?: BlankProtectedSpansOptions): BlankedText;
 /** Keep only findings whose span does not intersect any blanked range. */
 declare function dropMaskedFindings<T extends ProofRange>(findings: readonly T[], blanked: readonly ProofRange[]): T[];
 
@@ -176,4 +195,4 @@ declare function formatProofDictionary(words: readonly string[]): string | null;
 /** Read all proofing settings from a parsed frontmatter record. */
 declare function readProofingSettings(frontmatter: Record<string, unknown> | undefined): ProofingSettings;
 
-export { type BlankedText, DEFAULT_PROOF_SETTINGS, type JoinedSegments, LINT_KIND_CATEGORIES, PROOF_DIALECTS, PROOF_FRONTMATTER_KEYS, PROOF_JOIN_SEPARATOR, type ProofCategory, type ProofDialect, type ProofFinding, type ProofRange, type ProofSuggestion, type ProofSuggestionKind, type ProofingSettings, type SegmentSpan, blankProtectedSpans, buildJoinedText, categorizeLintKind, dropMaskedFindings, formatProofDictionary, mapJoinedSpanToSegment, parseProofDictionary, readProofingSettings, resolveProofDialect };
+export { type BlankProtectedSpansOptions, type BlankedText, DEFAULT_PROOF_SETTINGS, type JoinedSegments, LINT_KIND_CATEGORIES, PROOF_DIALECTS, PROOF_FRONTMATTER_KEYS, PROOF_JOIN_SEPARATOR, type ProofCategory, type ProofDialect, type ProofFinding, type ProofRange, type ProofSuggestion, type ProofSuggestionKind, type ProofingSettings, type SegmentSpan, blankProtectedSpans, buildJoinedText, categorizeLintKind, dropMaskedFindings, formatProofDictionary, mapJoinedSpanToSegment, parseProofDictionary, readProofingSettings, resolveProofDialect };

package/dist/proof/index.js

@@ -13,7 +13,7 @@ import {
   parseProofDictionary,
   readProofingSettings,
   resolveProofDialect
-} from "../chunk-T3B4WJBR.js";
+} from "../chunk-B3AK7SLZ.js";
 export {
   DEFAULT_PROOF_SETTINGS,
   LINT_KIND_CATEGORIES,

package/dist/recommend/index.js

@@ -1,7 +1,7 @@
 import {
   profileBlockContents,
   recommendTemplatesForBlock
-} from "../chunk-CUYHFOFL.js";
+} from "../chunk-6ATZOUCQ.js";
 import "../chunk-O7JILDEF.js";
 export {
   profileBlockContents,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq",
-  "version": "2.11.0",
+  "version": "2.11.2",
   "description": "Headless utilities for doc/block rendering, spatial math, Markdown, and storage",
   "license": "MIT",
   "author": "Bendyline",