@chrisdudek/yg 5.4.1 → 5.5.0

package/dist/structure.d.ts

@@ -491,6 +491,14 @@ declare class SuppressMarkerError extends Error {
     file: string;
     line: number;
     readonly code = "SUPPRESS_MARKER_MISSING_REASON";
+    /**
+     * Self-describing what/why/next for the malformed marker. A reasonless marker
+     * is a fault in the SOURCE file's marker — NOT in the aspect's check.mjs — so
+     * the deterministic runners re-surface this as its own diagnostic instead of an
+     * `aspect-check-runtime-error`. (The LLM-sizing paths build their own message
+     * from `file`/`line`; only the deterministic consumers read `messageData`.)
+     */
+    readonly messageData: IssueMessage;
     constructor(message: string, file: string, line: number);
 }
 

package/dist/structure.js

@@ -164,6 +164,26 @@ var UndeclaredGraphReadError = class extends Error {
   }
   nodePath;
 };
+function makeGraphFile(repoRelPosixPath, content, bytes, recorder, subjectFiles) {
+  if (!recorder || subjectFiles?.has(repoRelPosixPath)) {
+    return { path: repoRelPosixPath, content };
+  }
+  const rec = recorder;
+  let recorded = false;
+  const file = { path: repoRelPosixPath };
+  Object.defineProperty(file, "content", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      if (!recorded) {
+        rec.recordRead(repoRelPosixPath, bytes);
+        recorded = true;
+      }
+      return content;
+    }
+  });
+  return file;
+}
 function computeAllowedNodePaths(currentPath, graph) {
   const allowed = /* @__PURE__ */ new Set([currentPath]);
   const current = graph.nodes.get(currentPath);
@@ -225,11 +245,8 @@ function createCtxGraph(params) {
         if (stat2.isFile()) {
           const bytes = fs2.readFileSync(abs);
           const content = bytes.toString("utf8");
-          files.push({ path: p, content });
           touchedFiles.push(p);
-          if (recorder && !subjectFiles?.has(p)) {
-            recorder.recordRead(p, bytes);
-          }
+          files.push(makeGraphFile(p, content, bytes, recorder, subjectFiles));
         }
       } catch {
       }
@@ -734,45 +751,96 @@ var SuppressMarkerError = class extends Error {
     this.file = file;
     this.line = line;
     this.name = "SuppressMarkerError";
+    const loc = `${toPosixPath(file)}:${line}`;
+    this.messageData = {
+      what: `Malformed yg-suppress marker at ${loc} \u2014 it is missing the required reason after the aspect id.`,
+      why: `A single-line or disable marker must carry a reason after its closing parenthesis; a reasonless marker cannot be honored. This is a fault in the source file's marker, not in the aspect's check.`,
+      next: `Add a reason to the marker at ${loc}, or remove it.`
+    };
   }
   file;
   line;
   code = "SUPPRESS_MARKER_MISSING_REASON";
+  /**
+   * Self-describing what/why/next for the malformed marker. A reasonless marker
+   * is a fault in the SOURCE file's marker — NOT in the aspect's check.mjs — so
+   * the deterministic runners re-surface this as its own diagnostic instead of an
+   * `aspect-check-runtime-error`. (The LLM-sizing paths build their own message
+   * from `file`/`line`; only the deterministic consumers read `messageData`.)
+   */
+  messageData;
 };
-var RE_SINGLE = /\byg-suppress\(\s*([^)]+?)\s*\)\s*(.+)?$/m;
-var RE_DISABLE = /\byg-suppress-disable\(\s*([^)]+?)\s*\)\s*(.+)?$/m;
-var RE_ENABLE = /\byg-suppress-enable\(\s*([^)]+?)\s*\)/;
-function commentBody(text) {
-  if (text.startsWith("//")) return text.slice(2).trim();
-  if (text.startsWith("/*")) return text.replace(/^\/\*+/, "").replace(/\*+\/$/, "").trim();
-  return text.trim();
+var LEADER_DELIM = String.raw`\/\/[/!]*|\/\*+|\*+|#+|--+|;+|<!--|\{-|\(\*|[!%'"]`;
+var RE_LEADER_OPTIONAL = new RegExp(String.raw`^\s*(${LEADER_DELIM})?\s*`);
+var RE_LEADER_REQUIRED = new RegExp(String.raw`^\s*(${LEADER_DELIM})\s*`);
+var RE_MARKER = /^yg-suppress(-disable|-enable)?\(\s*([^)]*?)\s*\)\s*(.*)$/;
+var RE_ASPECT_ID = /^(?:\*|[A-Za-z0-9_][A-Za-z0-9_./-]*)$/;
+var RE_ANY_CLOSER = /\s*(?:\*+\/|-->|-\}|\*\))\s*$/;
+var RE_CLOSER_CSTYLE = /\s*\*+\/\s*$/;
+var RE_CLOSER_HTML = /\s*-->\s*$/;
+var RE_CLOSER_HASKELL = /\s*-\}\s*$/;
+var RE_CLOSER_OCAML = /\s*\*\)\s*$/;
+function stripCloser(reason, leader) {
+  if (leader === void 0) return reason.replace(RE_ANY_CLOSER, "");
+  if (leader.startsWith("//")) return reason;
+  if (leader.startsWith("/*") || /^\*+$/.test(leader)) return reason.replace(RE_CLOSER_CSTYLE, "");
+  if (leader === "<!--") return reason.replace(RE_CLOSER_HTML, "");
+  if (leader === "{-") return reason.replace(RE_CLOSER_HASKELL, "");
+  if (leader === "(*") return reason.replace(RE_CLOSER_OCAML, "");
+  return reason;
 }
 function splitAspectList(raw) {
   return raw.split(",").map((s) => s.trim()).filter(Boolean);
 }
-function makeMarker(kind, match, line, file) {
-  const aspectIds = splitAspectList(match[1]);
-  const reason = (match[2] ?? "").trim();
-  if (reason === "") {
+function matchMarkerLine(line, requireDelimiter) {
+  if (line.endsWith("\r")) line = line.slice(0, -1);
+  const leader = (requireDelimiter ? RE_LEADER_REQUIRED : RE_LEADER_OPTIONAL).exec(line);
+  if (leader === null) return null;
+  const m = RE_MARKER.exec(line.slice(leader[0].length));
+  if (m === null) return null;
+  const aspectIds = splitAspectList(m[2]);
+  if (aspectIds.length === 0) return null;
+  if (!aspectIds.every((id) => RE_ASPECT_ID.test(id))) return null;
+  const kind = m[1] === "-disable" ? "disable" : m[1] === "-enable" ? "enable" : "single";
+  const reason = kind === "enable" ? "" : stripCloser(m[3], leader[1]).trim();
+  return { kind, aspectIds, reason };
+}
+function parseMarker(lineText, line, file, requireDelimiter) {
+  const m = matchMarkerLine(lineText, requireDelimiter);
+  if (m === null) return null;
+  if (m.kind !== "enable" && m.reason === "") {
     throw new SuppressMarkerError(
-      `yg-suppress${kind === "disable" ? "-disable" : ""}(${match[1]}) missing reason at ${file}:${line}`,
+      `yg-suppress${m.kind === "disable" ? "-disable" : ""}(${m.aspectIds.join(", ")}) missing reason at ${file}:${line}`,
       file,
       line
     );
   }
-  return { kind, aspectIds, reason, line };
+  return { kind: m.kind, aspectIds: m.aspectIds, reason: m.reason, line };
 }
-function parseMarker(commentText, line, file) {
-  const body = commentBody(commentText);
-  let m = body.match(RE_DISABLE);
-  if (m) return makeMarker("disable", m, line, file);
-  m = body.match(RE_ENABLE);
-  if (m) {
-    return { kind: "enable", aspectIds: splitAspectList(m[1]), reason: "", line };
-  }
-  m = body.match(RE_SINGLE);
-  if (m) return makeMarker("single", m, line, file);
-  return null;
+var RE_FENCE = /^ {0,3}((?:`{3,})|(?:~{3,}))[ \t]*(.*)$/;
+var MARKDOWN_EXTS = /* @__PURE__ */ new Set([".md", ".markdown"]);
+function isMarkdownExt(file) {
+  return MARKDOWN_EXTS.has(extname3(file).toLowerCase());
+}
+function markdownFencedLines(text) {
+  const fenced = /* @__PURE__ */ new Set();
+  const lines = text.split("\n");
+  let open = null;
+  for (let i = 0; i < lines.length; i++) {
+    const m = RE_FENCE.exec(lines[i]);
+    if (open === null) {
+      if (m) {
+        open = { char: m[1][0], len: m[1].length };
+        fenced.add(i + 1);
+      }
+      continue;
+    }
+    fenced.add(i + 1);
+    if (m && m[1][0] === open.char && m[1].length >= open.len && m[2].trim() === "") {
+      open = null;
+    }
+  }
+  return fenced;
 }
 function collectSuppressions(tree, file, totalLines, content) {
   const hasGrammar = getLanguageForExtension(extname3(file)) !== null;
@@ -780,13 +848,18 @@ function collectSuppressions(tree, file, totalLines, content) {
   if (hasGrammar && tree) {
     const comments = findComments({ path: file, ast: tree });
     for (const c of comments) {
-      const m = parseMarker(c.text, c.startPosition.row + 1, file);
-      if (m) markers.push(m);
+      const commentLines = c.text.split("\n");
+      for (let i = 0; i < commentLines.length; i++) {
+        const m = parseMarker(commentLines[i], c.startPosition.row + i + 1, file, false);
+        if (m) markers.push(m);
+      }
     }
   } else if (content !== void 0) {
     const lines = content.split("\n");
+    const fenced = isMarkdownExt(file) ? markdownFencedLines(content) : null;
     for (let i = 0; i < lines.length; i++) {
-      const m = parseMarker(lines[i], i + 1, file);
+      if (fenced && fenced.has(i + 1)) continue;
+      const m = parseMarker(lines[i], i + 1, file, true);
       if (m) markers.push(m);
     }
   } else {
@@ -812,22 +885,26 @@ function collectSuppressions(tree, file, totalLines, content) {
       for (const id of m.aspectIds) {
         if (id === "*") {
           if (openWildcard !== null) {
-            ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: m.line - 1, isWildcard: true });
+            if (m.line - 1 >= openWildcard) {
+              ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: m.line - 1, isWildcard: true });
+            }
             openWildcard = null;
           }
         } else {
           const start = openSpecific.get(id);
           if (start !== void 0) {
-            ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: m.line - 1, isWildcard: false });
+            if (m.line - 1 >= start) {
+              ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: m.line - 1, isWildcard: false });
+            }
             openSpecific.delete(id);
           }
         }
       }
     }
   }
-  if (openWildcard !== null) ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: totalLines, isWildcard: true });
+  if (openWildcard !== null && openWildcard <= totalLines) ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: totalLines, isWildcard: true });
   for (const [id, start] of openSpecific) {
-    ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: totalLines, isWildcard: false });
+    if (start <= totalLines) ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: totalLines, isWildcard: false });
   }
   return ranges;
 }
@@ -838,7 +915,7 @@ function isLineSuppressed(ranges, aspectId, line) {
   });
 }
 function formatSuppressedRangesForAspect(ranges, aspectId) {
-  return ranges.filter((r) => r.isWildcard || r.aspectIds.has(aspectId)).map((r) => ({ startLine: r.startLine, endLine: r.endLine })).sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+  return ranges.filter((r) => r.isWildcard || r.aspectIds.has(aspectId)).filter((r) => r.startLine <= r.endLine).map((r) => ({ startLine: r.startLine, endLine: r.endLine })).sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
 }
 
 // src/utils/validate-check-module.ts
@@ -1458,6 +1535,7 @@ async function buildUnitCtx(params) {
 }
 
 // src/structure/runner.ts
+var SUPPRESS_MARKER_MALFORMED_CODE = "STRUCTURE_SUPPRESS_MARKER_MALFORMED";
 async function runStructureAspect(params) {
   const { aspectDir, aspectId, nodePath, graph, projectRoot, subjectScope } = params;
   const ownCache = !params.parseCache;
@@ -1469,11 +1547,18 @@ async function runStructureAspect(params) {
       if (existing !== void 0) return existing;
       const cached = astCache.get(filePath);
       let ranges;
-      if (cached) {
-        ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
-      } else {
-        const content = contentByPath.get(filePath);
-        ranges = content !== void 0 ? collectSuppressions(void 0, filePath, content.split("\n").length, content) : null;
+      try {
+        if (cached) {
+          ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
+        } else {
+          const content = contentByPath.get(filePath);
+          ranges = content !== void 0 ? collectSuppressions(void 0, filePath, content.split("\n").length, content) : null;
+        }
+      } catch (err) {
+        if (err instanceof SuppressMarkerError) {
+          throw new StructureRunnerError(SUPPRESS_MARKER_MALFORMED_CODE, err.messageData);
+        }
+        throw err;
       }
       rangesByFile.set(filePath, ranges);
       return ranges;

package/dist/templates/portal/app.css

@@ -0,0 +1,278 @@
+/*
+ * Component styles — the count header, the tree, the node panel, the glossary tooltip,
+ * and the command-palette overlay.
+ *
+ * The reusable surface pieces the views compose. Tokens come from tokens.css; the shell
+ * frame from shell.css. Calm, dense, document-like; the only saturated color is a state
+ * (resolved through the state classes in tokens.css). This file stays focused on the
+ * in-stage components and the ⌘K overlay.
+ */
+
+/* ── Count header + chips ───────────────────────────────────────────────── */
+.stage-header {
+  border-bottom: 1px solid var(--border);
+  padding-bottom: 16px;
+  margin-bottom: 18px;
+}
+.stage-title {
+  font-size: 24px;
+  line-height: 32px;
+  font-weight: 600;
+  margin: 0 0 4px;
+  letter-spacing: -0.01em;
+}
+.stage-sub {
+  color: var(--text-secondary);
+  font-size: 12.5px;
+  margin: 0 0 16px;
+}
+.count-bar {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.count-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 10px;
+  border-radius: 7px;
+  border: 1px solid var(--border-subtle);
+  background: var(--surface-1);
+  font-size: 13px;
+}
+.chip-count {
+  font-weight: 600;
+}
+.chip-label {
+  color: var(--text-secondary);
+}
+
+.stage-intro {
+  margin-bottom: 14px;
+}
+.stage-notfound {
+  margin: 10px 0 0;
+  padding: 8px 12px;
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--unverified);
+  border-radius: 8px;
+  background: var(--surface-1);
+  color: var(--text-secondary);
+  font-size: 13px;
+}
+.stage-vtitle {
+  font-size: 16px;
+  margin: 0 0 2px;
+}
+.stage-vblurb {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 13px;
+}
+.stage-note {
+  color: var(--text-muted);
+  font-size: 12.5px;
+  border: 1px dashed var(--border);
+  border-radius: 9px;
+  padding: 10px 12px;
+  margin: 4px 0 18px;
+}
+
+/* ── Tree (virtualized) ─────────────────────────────────────────────────── */
+.tree-filter {
+  margin: 4px 0 8px;
+}
+.tree-filter-input {
+  width: 100%;
+  padding: 7px 11px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--bg);
+  color: var(--text-primary);
+  font: inherit;
+  font-size: 13px;
+}
+/* "You are here" marker for a row revealed by a palette pick / deep-link. */
+.tree-row-revealed {
+  background: var(--surface-3);
+  box-shadow: inset 3px 0 0 var(--accent);
+}
+.tree-mount {
+  margin: 4px 0 18px;
+}
+.tree-scroller {
+  position: relative;
+  height: 60vh;
+  min-height: 280px;
+  overflow: auto;
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  background: var(--surface-1);
+}
+.tree-spacer {
+  position: relative;
+  width: 100%;
+}
+.tree-window {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  will-change: transform;
+}
+.tree-row {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  height: 28px;
+  padding-right: 12px;
+  border-bottom: 1px solid var(--surface-2);
+  font-size: 13px;
+  cursor: pointer;
+}
+.tree-row:hover {
+  background: var(--surface-3);
+}
+.tree-name {
+  font-weight: 500;
+}
+.tree-type {
+  margin-left: auto;
+  color: var(--text-muted);
+  font-size: 11px;
+}
+
+/* ── Node panel ─────────────────────────────────────────────────────────── */
+.panel-title {
+  font-size: 13px;
+  margin: 0 0 10px;
+  font-family: 'JetBrains Mono', ui-monospace, monospace;
+  word-break: break-all;
+}
+.panel-head {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  font-size: 13px;
+  margin-bottom: 8px;
+}
+.panel-sub {
+  color: var(--text-secondary);
+  font-size: 12.5px;
+  margin: 0;
+}
+
+/* ── Glossary term tooltip ──────────────────────────────────────────────── */
+.term {
+  border-bottom: 1px dotted var(--border-strong);
+  cursor: help;
+}
+
+/* ── Command palette overlay ────────────────────────────────────────────── */
+.palette-backdrop {
+  position: fixed;
+  inset: 0;
+  display: flex;
+  align-items: flex-start;
+  justify-content: center;
+  padding-top: 60px;
+  background: rgba(0, 0, 0, 0.32);
+  z-index: 50;
+}
+.palette-box {
+  width: 640px;
+  max-width: 92vw;
+  background: var(--surface-1);
+  border: 1px solid var(--border);
+  border-radius: 14px;
+  box-shadow: 0 1px 1px rgba(0, 0, 0, 0.04), 0 16px 40px -10px rgba(0, 0, 0, 0.45);
+  overflow: hidden;
+}
+.palette-input {
+  display: flex;
+  align-items: center;
+  gap: 11px;
+  padding: 13px 16px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+.palette-search-ic {
+  color: var(--text-muted);
+}
+.palette-field {
+  flex: 1;
+  border: 0;
+  background: none;
+  color: var(--text-primary);
+  font: inherit;
+  font-size: 16px;
+}
+.palette-field:focus {
+  outline: none;
+}
+.palette-results {
+  max-height: 380px;
+  overflow: auto;
+  padding: 6px;
+}
+.palette-empty {
+  padding: 16px;
+  color: var(--text-muted);
+  font-size: 13px;
+}
+.palette-row {
+  display: flex;
+  align-items: center;
+  gap: 11px;
+  padding: 8px 12px;
+  border-radius: 8px;
+  font-size: 13.5px;
+  cursor: pointer;
+}
+.palette-row.on {
+  background: var(--surface-3);
+}
+.palette-ic {
+  width: 18px;
+  text-align: center;
+  color: var(--text-muted);
+}
+.palette-nm {
+  font-weight: 500;
+}
+.palette-sub {
+  color: var(--text-muted);
+  font-size: 11.5px;
+}
+.palette-kind {
+  margin-left: auto;
+  font-size: 10px;
+  color: var(--text-muted);
+  border: 1px solid var(--border-subtle);
+  border-radius: 5px;
+  padding: 0 6px;
+}
+.palette-foot {
+  display: flex;
+  gap: 16px;
+  padding: 9px 14px;
+  border-top: 1px solid var(--border-subtle);
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+.portal-error {
+  color: var(--refused);
+  padding: 24px;
+  font-size: 14px;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    transition: none !important;
+    animation: none !important;
+    scroll-behavior: auto !important;
+  }
+}

package/dist/templates/portal/js/export.js

@@ -62,7 +62,7 @@
     var rows = [['metric', 'value']];
     var keys = [
       'nodes', 'aspects', 'flows', 'pairsTotal', 'pairsLLM', 'pairsDet',
-      'verified', 'refused', 'advisoryRefused', 'unverified', 'noRule', 'draft', 'notApplicable',
+      'verified', 'verifiedDet', 'verifiedLlm', 'refused', 'advisoryRefused', 'unverified', 'noRule', 'draft', 'notApplicable',
       'suppressed', 'coveredFiles', 'uncoveredFiles', 'totalFiles', 'errors', 'warnings',
     ];
     for (var i = 0; i < keys.length; i += 1) rows.push([keys[i], c[keys[i]]]);

package/dist/templates/portal/js/views/coverage-view.js

@@ -75,8 +75,11 @@
 
     // The bar is sized by the real pair STATES (verified / refused / unverified), never by the
     // expected-pair kind totals — a verified segment must be exactly as wide as the verified
-    // count, so an unverified pair can never paint green. The verified label states the LLM-vs-
-    // deterministic makeup of the expected universe honestly without faking a verified split.
+    // count, so an unverified pair can never paint green. The verified label states BOTH the
+    // LLM-vs-deterministic makeup of the expected universe AND the real split of the verified
+    // count itself (verifiedDet / verifiedLlm — tallied off the identical pairs loop `yg check`
+    // uses for its own header), so a green bar can never hide how many pairs were machine-checked
+    // for free vs actually reviewed by an LLM.
     // Advisory refusals are a real expected-pair state, but per the honesty model they render
     // as a NON-BLOCKING warning, never a blocking `refused`. They get their own warning-coloured
     // segment + key so the bar still accounts for every expected pair without ever showing an
@@ -96,7 +99,12 @@
     ledger.appendChild(bar);
 
     var labels = dom.el('div', 'cov-barlabels');
-    labels.appendChild(key('verified', c.verified, 'of ' + c.pairsLLM + ' LLM + ' + c.pairsDet + ' deterministic expected'));
+    labels.appendChild(key(
+      'verified',
+      c.verified,
+      'of ' + c.pairsLLM + ' LLM + ' + c.pairsDet + ' deterministic expected'
+        + ' (' + (c.verifiedDet || 0) + ' deterministic, ' + (c.verifiedLlm || 0) + ' LLM verified)',
+    ));
     labels.appendChild(key('refused', c.refused, 'enforced — blocks (== yg check)'));
     if (advisoryRefused > 0) labels.appendChild(key('warning', advisoryRefused, 'advisory refusal — does not block'));
     labels.appendChild(key('unverified', c.unverified));