@supersuit/hyperspec 0.5.0 → 0.7.0

package/src/stations/links.mjs

@@ -0,0 +1,275 @@
+// Station "links" (hyperspec 0.6). Checks every Markdown link and
+// every bare http(s):// URL in the draft: an absolute http/https URL must be well-formed (a real
+// host), a mailto: link must carry an address, any other scheme fails outright, a link rooted at
+// "/" is site-root-relative and warns rather than resolving locally (there is
+// no site root here to resolve it against), and any other relative link must resolve to a file
+// that actually exists, relative to the DRAFT's own directory (never the spec's). No network
+// access, ever: well-formed means "the URL parses and names a host", not "the host answers".
+//
+// Three Markdown link forms are checked, all through the same checkUrl:
+//   - inline: [text](url)
+//   - reference, full or collapsed: [text][ref] / [ref][], resolved against a [ref]: url
+//     definition elsewhere in the draft (label matching is case-insensitive and whitespace-
+//     collapsed); a full or collapsed reference with no matching definition is its own
+//     finding, station-links-undefined-reference, naming the label, since the second bracket
+//     pair says a link was meant.
+//   - shortcut reference: [ref] alone (no second bracket pair), checked only when a definition
+//     for that label exists, once every inline link, reference definition and full/collapsed
+//     reference has already been matched and masked out of the text. With no definition it is
+//     ordinary text, as CommonMark renders it: [sic], a task-list [x], a footnote-style [1].
+//
+// Anchors: the "#fragment" part of any link is stripped before checking anything else, so
+// "notes.md#section-two" is checked as "notes.md" (its target heading is never verified), and a
+// link that is nothing but "#fragment" (empty path once the anchor is stripped) always resolves,
+// since it points at the draft itself.
+//
+// Fenced code blocks and inline code spans are masked out (src/stations/util.mjs's maskCode)
+// before ANY of the above runs, so a Markdown link or URL shown as illustrative syntax inside a
+// fence or a `` `span` `` is never checked as a real, followable link.
+
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { lineAt, maskCode, maskRanges, truncate } from "./util.mjs";
+
+export const name = "links";
+
+// Every "[text](url)" span in `text`, in document order: { start, end, url }. The url is the raw
+// content between the parens, up to the first run of whitespace (a Markdown link may carry a
+// `"title"` after the url, separated by whitespace; that title is not itself a link and is
+// ignored here). `end` is the index just past the closing ")", used both to report a line number
+// and to mask the span out before later scans, so the same URL is never counted twice.
+const MD_LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
+
+function markdownLinks(text) {
+  const out = [];
+  let m;
+  MD_LINK_RE.lastIndex = 0;
+  while ((m = MD_LINK_RE.exec(text))) {
+    const inner = m[2].trim();
+    const url = inner.split(/\s+/)[0];
+    if (url) out.push({ start: m.index, end: m.index + m[0].length, url });
+  }
+  return out;
+}
+
+// A reference definition line: up to 3 spaces of indent, "[label]:", the URL, and an optional
+// title in "quotes", 'quotes' or (parens). One definition per line, the common case; a multi-line
+// definition (title on the following line) is not attempted.
+const DEF_RE = /^[ \t]{0,3}\[([^\]]+)\]:[ \t]*(\S+)[ \t]*(?:"[^"]*"|'[^']*'|\([^)]*\))?[ \t]*$/gm;
+
+const normalizeLabel = (label) => label.trim().toLowerCase().replace(/\s+/g, " ");
+
+// Every reference definition in `text`: a Map from normalized label to { url }, plus the [start,
+// end) span of each whole definition line, ready to mask out (so a definition's own "[label]:" is
+// never later mistaken for a reference USE, and its URL is never also picked up by the bare-URL
+// scan below). The FIRST definition for a given label wins on a duplicate, matching CommonMark.
+function definitions(text) {
+  const defs = new Map();
+  const spans = [];
+  let m;
+  DEF_RE.lastIndex = 0;
+  while ((m = DEF_RE.exec(text))) {
+    const label = normalizeLabel(m[1]);
+    if (!defs.has(label)) defs.set(label, { url: m[2] });
+    spans.push({ start: m.index, end: m.index + m[0].length });
+  }
+  return { defs, spans };
+}
+
+// Every "[text][ref]" (full) or "[text][]" (collapsed, label = text) span, in document order:
+// { start, end, label }. Run AFTER inline links and definitions are already masked out of `text`,
+// so this can only match genuine two-bracket-pair reference syntax.
+const FULL_REF_RE = /\[([^\]]*)\]\[([^\]]*)\]/g;
+
+function fullReferences(text) {
+  const out = [];
+  let m;
+  FULL_REF_RE.lastIndex = 0;
+  while ((m = FULL_REF_RE.exec(text))) {
+    const label = (m[2].trim() || m[1].trim());
+    if (label) out.push({ start: m.index, end: m.index + m[0].length, label });
+  }
+  return out;
+}
+
+// Every remaining "[label]" span, in document order: { start, end, label }. Run AFTER inline
+// links, definitions and full/collapsed references are already masked out, so whatever "[...]"
+// is left is either a shortcut reference or ordinary bracketed prose. The caller keeps only the
+// ones whose label has a definition: CommonMark renders an undefined "[label]" as plain text, so
+// an editorial [sic], a task-list [x] or a footnote-style [1] is never a link.
+const SHORTCUT_REF_RE = /\[([^\]]+)\]/g;
+
+function shortcutReferences(text) {
+  const out = [];
+  let m;
+  SHORTCUT_REF_RE.lastIndex = 0;
+  while ((m = SHORTCUT_REF_RE.exec(text))) {
+    const label = m[1].trim();
+    if (label) out.push({ start: m.index, end: m.index + m[0].length, label });
+  }
+  return out;
+}
+
+// Every bare "http://" or "https://" URL left in `text` (after every other link form has been
+// masked out of it), stopping at whitespace or a closing bracket/paren/angle-bracket that is more
+// likely to be surrounding punctuation than part of the URL itself. The host part may be empty,
+// so a bare "https://" is matched and fails as malformed rather than passing unseen.
+const BARE_URL_RE = /https?:\/\/[^\s)>\]]*/g;
+
+function bareUrls(text) {
+  const out = [];
+  let m;
+  BARE_URL_RE.lastIndex = 0;
+  while ((m = BARE_URL_RE.exec(text))) out.push({ start: m.index, end: m.index + m[0].length, url: m[0] });
+  return out;
+}
+
+const SCHEME_RE = /^([a-zA-Z][a-zA-Z0-9+.-]*):/;
+
+// Classifies one URL, with its "#..." anchor already known to the caller as stripped: "http" (the
+// scheme itself, lowercased, is on `scheme`), "mailto", "other-scheme" (anything else with a
+// scheme prefix), or "relative" (no scheme prefix at all: a bare path, root-relative or relative).
+function classify(withoutAnchor) {
+  const m = SCHEME_RE.exec(withoutAnchor);
+  if (!m) return { kind: "relative", path: withoutAnchor };
+  const scheme = m[1].toLowerCase();
+  if (scheme === "http" || scheme === "https") return { kind: "http", scheme };
+  if (scheme === "mailto") return { kind: "mailto" };
+  return { kind: "other-scheme", scheme };
+}
+
+// Why `url` is broken (or merely unresolvable locally), as one of "malformed-http",
+// "malformed-mailto", "bad-scheme", "root-relative" or "broken-relative", or null when it is
+// fine. draftDirAbs is the draft's own directory (resolved once by the caller), which every
+// relative link resolves against, never the spec's directory.
+function checkUrl(url, draftDirAbs) {
+  const hashIdx = url.indexOf("#");
+  const withoutAnchor = hashIdx === -1 ? url : url.slice(0, hashIdx);
+  const c = classify(withoutAnchor);
+
+  if (c.kind === "http") {
+    try {
+      const u = new URL(url);
+      if (!u.hostname) return "malformed-http";
+    } catch {
+      return "malformed-http";
+    }
+    return null;
+  }
+  if (c.kind === "mailto") {
+    const address = withoutAnchor.slice("mailto:".length).split("?")[0].trim();
+    return address ? null : "malformed-mailto";
+  }
+  if (c.kind === "other-scheme") return "bad-scheme";
+
+  // relative: an empty path (the link was nothing but "#fragment", or literally empty) always
+  // resolves, since it points at the draft's own file, which exists by construction (check.mjs
+  // only ever builds a draft object after successfully reading it).
+  if (!c.path) return null;
+  // A link rooted at "/" names a path from some site's root, which this station has no way to
+  // resolve (there is no "site" here, only the draft's own folder), so it is neither a pass nor a
+  // fail -- a warning, naming the fact that it cannot be checked locally.
+  if (c.path.startsWith("/")) return "root-relative";
+  const target = resolve(draftDirAbs, c.path);
+  return existsSync(target) ? null : "broken-relative";
+}
+
+const REASON = {
+  "malformed-http": {
+    id: "station-links-malformed",
+    severity: "fail",
+    text: (url) => `link "${url}" is not a well-formed http/https URL (no host)`,
+    fix: "Fix the URL to include a scheme (http:// or https://) and a real host.",
+  },
+  "malformed-mailto": {
+    id: "station-links-malformed",
+    severity: "fail",
+    text: (url) => `link "${url}" is a mailto: link with no address`,
+    fix: "Add a real address after mailto:, or remove the link.",
+  },
+  "bad-scheme": {
+    id: "station-links-bad-scheme",
+    severity: "fail",
+    text: (url) => `link "${url}" uses a scheme that is not http, https or mailto`,
+    fix: "Use an http(s):// URL, a mailto: link, or a path relative to the draft.",
+  },
+  "root-relative": {
+    id: "station-links-root-relative",
+    severity: "warn",
+    text: (url) => `link "${url}" is site-root-relative and cannot be resolved against a file on disk`,
+    fix: "Point the link at a path relative to the draft, or use a full URL, if it must be checked.",
+  },
+  "broken-relative": {
+    id: "station-links-broken-relative",
+    severity: "fail",
+    text: (url) => `relative link "${url}" does not resolve to a file next to the draft`,
+    fix: "Fix the path, or add the file the link points at.",
+  },
+};
+
+function reasonFinding(reason, url, line) {
+  const r = REASON[reason];
+  return { station: name, id: r.id, severity: r.severity, line, message: r.text(truncate(url, 80)), fix: r.fix };
+}
+
+function undefinedReferenceFinding(label, line) {
+  const shown = truncate(label, 80);
+  return {
+    station: name,
+    id: "station-links-undefined-reference",
+    severity: "fail",
+    line,
+    message: `reference "${shown}" has no matching "[${shown}]: url" definition`,
+    fix: `Add a "[${shown}]: <url>" definition, or fix the reference to match a label that already has one.`,
+  };
+}
+
+export function run(spec, draft) {
+  const draftDirAbs = dirname(resolve(draft.path));
+
+  // Masking pipeline: code first, then each link form in turn, each pass working on the text the
+  // previous pass left behind, so nothing is ever matched twice by a later, looser pattern (a
+  // reference definition's own brackets are not a shortcut reference; the leftover "[text]" half
+  // of a masked-out "[text][ref]" pair is not itself a shortcut reference; a URL already read as
+  // part of a Markdown link is not also a bare URL). Every span carries its ORIGINAL start offset
+  // throughout, since maskRanges never shifts anything, only blanks it, so draft.text and lineAt
+  // stay valid for every one of them regardless of how many passes it survived.
+  let working = maskCode(draft.text);
+
+  const mdLinks = markdownLinks(working);
+  working = maskRanges(working, mdLinks);
+
+  const { defs, spans: defSpans } = definitions(working);
+  working = maskRanges(working, defSpans);
+
+  const fullRefs = fullReferences(working);
+  working = maskRanges(working, fullRefs);
+
+  const shortcutRefs = shortcutReferences(working).filter((r) => defs.has(normalizeLabel(r.label)));
+  working = maskRanges(working, shortcutRefs);
+
+  const bare = bareUrls(working);
+
+  const entries = [];
+
+  for (const { start, url } of [...mdLinks, ...bare]) {
+    const reason = checkUrl(url, draftDirAbs);
+    if (reason) entries.push({ start, finding: reasonFinding(reason, url, lineAt(draft.text, start)) });
+  }
+
+  for (const { start, label } of [...fullRefs, ...shortcutRefs]) {
+    const line = lineAt(draft.text, start);
+    const def = defs.get(normalizeLabel(label));
+    if (!def) {
+      entries.push({ start, finding: undefinedReferenceFinding(label, line) });
+      continue;
+    }
+    const reason = checkUrl(def.url, draftDirAbs);
+    if (reason) entries.push({ start, finding: reasonFinding(reason, def.url, line) });
+  }
+
+  entries.sort((a, b) => a.start - b.start);
+  const findings = entries.map((e) => e.finding);
+  const status = findings.some((f) => f.severity === "fail") ? "fail" : "pass";
+  return { station: name, status, findings };
+}

package/src/stations/private.mjs

@@ -0,0 +1,117 @@
+// Station "private" (hyperspec 0.6). No run of 8 or more consecutive words from
+// any `private` segment of a marked material may appear in the draft. Pure and deterministic: a
+// word-level match over normalized text, no model call and no judgment about what would count as
+// a paraphrase (a paraphrase is not caught, by design; a verbatim run is).
+//
+// Normalization, applied the same way to the draft and to every private segment: split into words
+// with dna.mjs's wordsOf (already lowercased, the one word definition every station shares), then
+// drop apostrophes from each word, so case, punctuation and whitespace never decide a match and
+// "don't", "don’t" and "dont" are one word. Fenced code and inline code are masked out of the
+// draft first (util.mjs's maskCode), like every other station that reads prose.
+//
+// A private segment of 8 or more words fails when any 8-word window of it appears in the draft. One
+// of 4 to 7 words is checked as a whole: all of its words, in order, anywhere in the draft. One
+// under 4 words is not checked at all: two or three words ("Yes, Tuesday.") match
+// ordinary prose, so checking them would fail drafts that leak nothing. Skipping silently would
+// hide that a private passage went unchecked, so the station reports how many it skipped as ONE
+// warning, station-private-short-skipped, carrying the count and never the text (the text is
+// the private part). Each leak is reported once, as the longest run the segment and the draft share from where
+// the match starts, so a whole pasted paragraph is one finding rather than one per window; a
+// segment that leaks in two separate places is two findings. Every finding names the material, the
+// segment and the leaked run (normalized words, at most 80 characters), with the draft line where
+// the run starts.
+
+import { wordsOf } from "../dna.mjs";
+import { lineAt, maskCode, markedSegments, truncate } from "./util.mjs";
+
+export const name = "private";
+
+const WINDOW = 8;
+const MIN_CHECKED = 4;
+// dna.mjs's WORD_RE, repeated here only because wordsOf returns words without their offsets and a
+// finding needs the line a leak starts on; the segment side goes through wordsOf itself.
+const WORD_RE = /[\p{L}\p{N}'’]+/gu;
+const stripApostrophes = (w) => w.replace(/['’]/g, "");
+
+// The draft's words, normalized, each with the offset it starts at (for the finding's line).
+function draftWords(text) {
+  const out = [];
+  WORD_RE.lastIndex = 0;
+  let m;
+  while ((m = WORD_RE.exec(text))) {
+    const w = stripApostrophes(m[0].toLowerCase());
+    if (w) out.push({ w, at: m.index });
+  }
+  return out;
+}
+
+const segmentWords = (text) => wordsOf(text).map(stripApostrophes).filter(Boolean);
+
+// The first index in `words` (draft word objects) where `seq` (strings) appears contiguously, or -1.
+function findSequence(words, seq) {
+  outer: for (let i = 0; i + seq.length <= words.length; i++) {
+    for (let k = 0; k < seq.length; k++) if (words[i + k].w !== seq[k]) continue outer;
+    return i;
+  }
+  return -1;
+}
+
+export function run(spec, draft, ctx) {
+  const words = draftWords(maskCode(draft.text));
+  // First draft position of every 8-word window, so each private window is one map lookup.
+  const windows = new Map();
+  for (let i = 0; i + WINDOW <= words.length; i++) {
+    const key = words.slice(i, i + WINDOW).map((x) => x.w).join(" ");
+    if (!windows.has(key)) windows.set(key, i);
+  }
+
+  const findings = [];
+  let skippedShort = 0;
+  const leak = (material, segId, run, at) => findings.push({
+    station: name,
+    id: "station-private-leak",
+    severity: "fail",
+    line: lineAt(draft.text, at),
+    message: `material ${material}, segment ${segId} is private, and the draft repeats it: "${truncate(run.join(" "), 80)}"`,
+    fix: "Rewrite the passage in words that do not repeat the private material, or relabel the segment if it is not private.",
+  });
+
+  for (const { material, segments } of markedSegments(spec, ctx)) {
+    for (const seg of segments) {
+      if (seg.label !== "private" || typeof seg.text !== "string") continue;
+      const segId = typeof seg.id === "string" && seg.id.trim() ? seg.id.trim() : "(no id)";
+      const tokens = segmentWords(seg.text);
+      if (!tokens.length) continue;
+      if (tokens.length < MIN_CHECKED) { skippedShort++; continue; }
+
+      if (tokens.length < WINDOW) {
+        const at = findSequence(words, tokens);
+        if (at !== -1) leak(material, segId, tokens, words[at].at);
+        continue;
+      }
+
+      let i = 0;
+      while (i + WINDOW <= tokens.length) {
+        const start = windows.get(tokens.slice(i, i + WINDOW).join(" "));
+        if (start === undefined) { i++; continue; }
+        // Extend the shared run as far as the segment and the draft keep agreeing.
+        let len = WINDOW;
+        while (i + len < tokens.length && start + len < words.length && tokens[i + len] === words[start + len].w) len++;
+        leak(material, segId, tokens.slice(i, i + len), words[start].at);
+        i += len;
+      }
+    }
+  }
+
+  if (skippedShort) {
+    findings.push({
+      station: name,
+      id: "station-private-short-skipped",
+      severity: "warn",
+      message: `${skippedShort} private segment${skippedShort === 1 ? " is" : "s are"} under ${MIN_CHECKED} words and ${skippedShort === 1 ? "was" : "were"} not checked`,
+      fix: `Check the draft against ${skippedShort === 1 ? "it" : "them"} by hand, or widen the private segment to ${MIN_CHECKED} or more words.`,
+    });
+  }
+
+  return { station: name, status: findings.some((x) => x.severity === "fail") ? "fail" : "pass", findings };
+}

package/src/stations/quotes.mjs

@@ -0,0 +1,170 @@
+// Station "quotes" (hyperspec 0.6). Every double-quoted span in the draft of 4 or
+// more words must appear in a `quote` or `story` segment of a marked material; a quote the draft
+// attributes to someone by name must appear in a `quote` segment whose speaker is that someone.
+// Pure and deterministic: no model call, no judgment about what counts as quoting, just the closed
+// rules below.
+//
+// What counts as a quoted span: text between a pair of straight double quotes ("...") or a pair of
+// curly ones (U+201C ... U+201D), paired left to right WITHIN one paragraph, so a stray quote mark
+// can never pair with one in a later paragraph and swallow everything between. Fenced code and
+// inline code are masked first (util.mjs's maskCode): a quote inside example syntax is not the
+// writer quoting anyone. A span is checked only when it holds 4 or more words (dna.mjs's wordsOf,
+// the one word definition every station shares); shorter spans are scare quotes and titles as
+// often as they are quotations.
+//
+// Matching: both sides are normalized the same way (curly quotes and apostrophes to straight,
+// whitespace runs to one space, ends trimmed; case is kept, so a changed capital is a changed
+// quote). The span also drops trailing commas and periods before matching, because typographic
+// convention puts a sentence's own comma or period inside the closing quote ("...at a time," he
+// said) whether or not the speaker's sentence ended there. The normalized span must then appear as
+// a substring of some quote or story segment's text, in any marked material of the spec.
+//
+// Attribution: a speaker is any `speaker` value on a quote segment. It is named in the draft
+// when the sentence that holds the quote contains, case-insensitively and as whole
+// words, EITHER the full value (split on anything that is not a letter, digit or apostrophe, so the
+// slug "maria-lopez" reads as "maria lopez", its words joined in the draft by whitespace, hyphens or
+// underscores) OR the value's first word alone ("Maria said" names maria-lopez; "Mariana" does not).
+// The first word alone counts only when it has 2 or more letters and is not one of dna.mjs's
+// STOPWORDS: a speaker recorded as "the manager interviewed" would otherwise be named by every
+// sentence holding "the". Such a speaker is still named by its full value. The sentence is read
+// with the quote itself blanked out (a name inside the quoted words is what was said, not who said it). A named speaker
+// means the span must be in a quote segment with that speaker; matching only some other speaker's
+// quote, or only a story, is `station-quotes-misattributed`. With no speaker named, any quote or
+// story segment is enough. Sentences come from splitSegments(text, { by: "sentence" }), and every
+// sentence the span overlaps is read, so a curly quote the splitter cuts in two still keeps its
+// attribution.
+
+import { splitSegments } from "../segments.mjs";
+import { STOPWORDS, wordsOf } from "../dna.mjs";
+import { str } from "../placeholder.mjs";
+import { lineAt, maskCode, markedSegments, truncate } from "./util.mjs";
+
+export const name = "quotes";
+
+const QUOTE_RE = /"([^"]*)"|“([^“”]*)”/g;
+const WORD_CLASS = "\\p{L}\\p{N}'’";
+
+function normalize(text) {
+  return String(text)
+    .replace(/[‘’‚‛]/g, "'")
+    .replace(/[“”„‟]/g, '"')
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+// What a quoted span is matched on: normalized, then trailing commas and periods dropped.
+// Typographic convention puts the writer's own comma or period inside the closing quote
+// ("...at a time," he said) whether or not the speaker's sentence ended there, so keeping them
+// would fail nearly every quotation used mid-sentence. "?" and "!" are kept: adding either changes
+// what was said.
+const matchKey = (inner) => normalize(inner).replace(/[.,]+$/, "").trim();
+
+// Every quoted span in `text`, as { start, end, inner, para }: start/end bound the whole span
+// including its quote marks, inner is the text between them, para is { start, end } of the
+// paragraph holding it. Paired per paragraph (see the header). Also how the attribution judge
+// (src/judges/attribution.mjs) finds a draft's dialogue lines.
+export function quotedSpans(text) {
+  const spans = [];
+  for (const para of splitSegments(text, { by: "paragraph" })) {
+    QUOTE_RE.lastIndex = 0;
+    let m;
+    while ((m = QUOTE_RE.exec(para.text))) {
+      spans.push({ start: para.start + m.index, end: para.start + m.index + m[0].length, inner: m[1] ?? m[2] ?? "", para: { start: para.start, end: para.end } });
+    }
+  }
+  return spans;
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+const STOPWORD_SET = new Set(STOPWORDS);
+
+// Whether a speaker's first word may name the speaker on its own: 2 or more letters, and not a
+// stopword (compared lowercased, apostrophes as written).
+function firstWordNames(word) {
+  const letters = word.match(/\p{L}/gu)?.length ?? 0;
+  return letters >= 2 && !STOPWORD_SET.has(word.toLowerCase());
+}
+
+// A speaker value as a whole-word, case-insensitive pattern matching its full words, or its first
+// word alone when firstWordNames allows it; null when it has no words at all.
+export function speakerPattern(value) {
+  const words = value.split(new RegExp(`[^${WORD_CLASS}]+`, "u")).filter(Boolean);
+  if (!words.length) return null;
+  const full = words.map(escapeRe).join("[\\s_-]+");
+  const alts = firstWordNames(words[0]) && words.length > 1 ? `${full}|${escapeRe(words[0])}` : full;
+  return new RegExp(`(?<![${WORD_CLASS}])(?:${alts})(?![${WORD_CLASS}])`, "iu");
+}
+
+// The text of every sentence the span overlaps, with the span itself blanked out.
+function attributionContext(text, sentences, span) {
+  const over = sentences.filter((s) => s.start < span.end && s.end > span.start);
+  const from = over.length ? Math.min(span.start, over[0].start) : span.start;
+  const to = over.length ? Math.max(span.end, over[over.length - 1].end) : span.end;
+  return `${text.slice(from, span.start)} ${text.slice(span.end, to)}`;
+}
+
+export function run(spec, draft, ctx) {
+  // Fiction: a character's line is invented, not quoted from a material, so holding dialogue to
+  // the marked quotes would fail every story that uses quotation marks. The character stations of a
+  // later release check dialogue against each character's golden and rejected lines instead.
+  if (str(spec?.data?.fiction) === "true") {
+    return { station: name, status: "skip", findings: [], reason: "fiction dialogue is checked by the character stations in a later release" };
+  }
+  const text = maskCode(draft.text);
+  const spans = quotedSpans(text).filter((s) => wordsOf(s.inner).length >= 4);
+  if (!spans.length) return { station: name, status: "pass", findings: [] };
+
+  // Every quote and story segment across every marked material, normalized once. A speaker's key
+  // is its value lowercased; shownSpeaker keeps the first spelling the material wrote, for findings.
+  const sources = [];
+  const shownSpeaker = new Map();
+  for (const { segments } of markedSegments(spec, ctx)) {
+    for (const seg of segments) {
+      if ((seg.label !== "quote" && seg.label !== "story") || typeof seg.text !== "string") continue;
+      const speaker = seg.label === "quote" && typeof seg.speaker === "string" ? seg.speaker.trim() : "";
+      const key = speaker.toLowerCase();
+      if (key && !shownSpeaker.has(key)) shownSpeaker.set(key, speaker);
+      sources.push({ label: seg.label, speaker: key, norm: normalize(seg.text) });
+    }
+  }
+  const speakers = [...shownSpeaker.keys()]
+    .map((key) => ({ key, re: speakerPattern(key) }))
+    .filter((sp) => sp.re);
+
+  const sentences = splitSegments(text, { by: "sentence" });
+  const findings = [];
+  for (const span of spans) {
+    const key = matchKey(span.inner);
+    if (!key) continue;
+    const shown = truncate(span.inner.replace(/\s+/g, " "), 80);
+    const line = lineAt(draft.text, span.start);
+    const hits = sources.filter((s) => s.norm.includes(key));
+    if (!hits.length) {
+      findings.push({
+        station: name,
+        id: "station-quotes-unmatched",
+        severity: "fail",
+        line,
+        message: `quoted span "${shown}" does not appear in any quote or story segment of a marked material`,
+        fix: "Quote the material verbatim, or drop the quotation marks and paraphrase.",
+      });
+      continue;
+    }
+    const around = attributionContext(text, sentences, span);
+    const named = speakers.filter((sp) => sp.re.test(around)).map((sp) => sp.key);
+    if (named.length && !hits.some((h) => h.label === "quote" && named.includes(h.speaker))) {
+      const who = named.map((k) => shownSpeaker.get(k) ?? k).join(", ");
+      findings.push({
+        station: name,
+        id: "station-quotes-misattributed",
+        severity: "fail",
+        line,
+        message: `quoted span "${shown}" is attributed to ${who} in its sentence, but no quote segment by ${who} contains it`,
+        fix: `Attribute the quote to whoever the material records saying it, or quote what ${who} actually said.`,
+      });
+    }
+  }
+
+  return { station: name, status: findings.length ? "fail" : "pass", findings };
+}