@polycode-projects/the-mechanical-code-talker 2.3.1 → 2.5.2

package/src/domain/licences.mjs

@@ -1,68 +0,0 @@
-// licences.mjs — the allowlist, the SPDX expression rule, and the two pure
-// reads the licence check needs. Pure: objects and strings in, verdicts out, so
-// the rule that gates CI can be tested without an installed node_modules tree.
-//
-// The check itself (scripts/check-licences.mjs) shells out to `npm ls` and
-// reads each package's package.json off disk. That is the disk half. This is
-// the deciding half, and the deciding half is where the edge cases are.
-
-export const ALLOWED = new Set([
-  "MIT",
-  "ISC",
-  "BSD-2-Clause",
-  "BSD-3-Clause",
-  "Apache-2.0",
-  "MPL-2.0",
-  "0BSD",
-  "CC0-1.0",
-  "Unlicense",
-]);
-
-/** The licence `pkg` declares, across the three shapes npm has used: the
- *  current string, the legacy `{ type }` object, and the legacy `licenses[]`
- *  array (read as a choice, so it joins with OR). */
-export function licenseFromPackageJson(pkg) {
-  if (typeof pkg.license === "string") return pkg.license;
-  if (pkg.license && typeof pkg.license.type === "string") return pkg.license.type;
-  if (Array.isArray(pkg.licenses)) return pkg.licenses.map((l) => l.type).join(" OR ");
-  return "(none declared)";
-}
-
-/** True iff `license` is inside the allowlist.
- *
- *  A flat OR expression passes when any part is allowlisted, because OR is a
- *  choice and we can take the allowlisted one. A flat AND expression needs
- *  every part. Everything else — nesting, a WITH exception, an OR and an AND in
- *  the same expression, even a redundantly parenthesised single licence like
- *  "(MIT)" — returns false and gets reviewed by hand. Those are rare enough
- *  that a parser would be more code than the reviews it saves, and false is the
- *  safe direction: it stops CI and asks a human, rather than waving through an
- *  expression it only half understood. */
-export function isAllowed(license) {
-  if (ALLOWED.has(license)) return true;
-  const inner = license.replace(/^\(/, "").replace(/\)$/, "");
-  if (/[()]|\bWITH\b/.test(inner)) return false;
-  if (inner.includes(" OR ") && !inner.includes(" AND ")) {
-    return inner.split(" OR ").some((part) => ALLOWED.has(part.trim()));
-  }
-  if (inner.includes(" AND ") && !inner.includes(" OR ")) {
-    return inner.split(" AND ").every((part) => ALLOWED.has(part.trim()));
-  }
-  return false;
-}
-
-/** Every installed package in an `npm ls --json` dependency tree, deduped by
- *  name@version and sorted by name. A node with no `path` is a peer or optional
- *  dependency that was never installed, so it cannot ship and is skipped. */
-export function installedPackages(deps) {
-  const seen = new Map();
-  (function walk(level) {
-    for (const [name, node] of Object.entries(level ?? {})) {
-      if (node && node.path && node.version) {
-        seen.set(`${name}@${node.version}`, { name, version: node.version, path: node.path });
-      }
-      if (node) walk(node.dependencies);
-    }
-  })(deps);
-  return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
-}

package/src/domain/markdown-links.mjs

@@ -1,55 +0,0 @@
-// markdown-links.mjs — pull the relative link targets out of a markdown string.
-// Pure: a string in, `[{ target, line }]` out, no filesystem and no imports, so
-// the CI jobs that run without `npm ci` can reach it.
-//
-// Code is not prose. A doc that writes `[text](target)` inside backticks is
-// showing you what a link looks like, not making one, and a checker that cannot
-// tell the difference reports the example as a broken link to a file named
-// "target". So the spans are blanked before the link patterns run — blanked
-// rather than cut, because every offset behind them still has to name the right
-// line number.
-
-const blank = (line) => line.replace(/[^\n]/g, " ");
-const FENCE = /^[ \t]{0,3}(`{3,}|~{3,})/;
-
-/** Replace every fenced block and inline code span with spaces, keeping the
- *  string's length and its newlines so later offsets still map to their line.
- *  Fences are walked line by line: a lazy multiline regex stops at the end of
- *  the opening fence's own line and blanks only the markers. */
-export function blankCodeSpans(markdown) {
-  let fence = null;
-  const lines = markdown.split("\n").map((line) => {
-    const marker = line.match(FENCE)?.[1];
-    if (fence) {
-      if (marker && marker[0] === fence[0] && marker.length >= fence.length) fence = null;
-      return blank(line);
-    }
-    if (marker) fence = marker;
-    return marker ? blank(line) : line;
-  });
-  return lines.join("\n").replace(/(`+)[\s\S]*?\1/g, blank);
-}
-
-// Inline links/images: [text](target "title") — target ends at the first
-// whitespace or closing paren. Reference definitions: [label]: target.
-const INLINE_LINK = /!?\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
-const REFERENCE_DEF = /^\s{0,3}\[[^\]]+\]:\s+(\S+)/gm;
-
-/** Every repo-relative link target in `markdown`, with the 1-based line it sits
- *  on. External URLs, bare #anchors and absolute paths are out of scope. */
-export function relativeTargets(markdown) {
-  const prose = blankCodeSpans(markdown);
-  const targets = [];
-  for (const regex of [INLINE_LINK, REFERENCE_DEF]) {
-    for (const match of prose.matchAll(regex)) {
-      let target = match[1];
-      if (/^(https?|mailto|ftp):/i.test(target)) continue;
-      if (target.startsWith("#") || target.startsWith("/") || target.startsWith("<")) continue;
-      target = decodeURIComponent(target.split("#")[0].split("?")[0]);
-      if (!target) continue;
-      const line = prose.slice(0, match.index).split("\n").length;
-      targets.push({ target, line });
-    }
-  }
-  return targets;
-}

package/src/domain/persona/codegen.mjs

@@ -1,123 +0,0 @@
-// codegen.mjs — renders a reviewed persona-tier worksheet as JS source, ready
-// to splice into corpus/tier2/generate.mjs's CORPUSES object, and as the
-// lexicon-core.json noun entries those facts need.
-//
-// Pure: worksheet in, source text out, no imports.
-
-export const CLUMP_ORDER = [
-  "human-core", "human-places", "human-objects", "human-nature",
-  "human-time-events", "human-body-food", "human-mind",
-];
-
-export const CLUMP_LABEL = {
-  "human-core": "people, family, common roles",
-  "human-places": "places",
-  "human-objects": "objects, clothing, tools",
-  "human-nature": "animals, plants, substances",
-  "human-time-events": "time and events",
-  "human-body-food": "body and food",
-  "human-mind": "communication, cognition, feeling",
-};
-
-// The irregular plurals among the words these batches introduce (Latin/Greek-
-// derived cognition/body/nature vocabulary especially). A word absent from this
-// map gets `{}` and relies on the regular -s/-es/-ies suffix fold at LOOKUP
-// time (src/domain/grammar/lexicon.mjs's foldCandidates), same as the vast
-// majority of Small tier's own additions. So this map is not a pluralizer: it
-// is the list of exceptions that folding cannot recover, and declaring a
-// regular plural here would be redundant.
-//
-// This is deliberately NOT src/domain/inflect.mjs's pluralOf, and the two must
-// not be merged. They answer opposite questions. pluralOf GENERATES candidate
-// surface forms for the real-word collision table, where over-generating is the
-// cheap mistake and its own header commits to regular rules only — it wants
-// "foots", because a form it fails to generate is a real word the repair tier
-// may rewrite into a different question. This map DECLARES the one correct
-// plural for a lexicon entry, where "foots" would simply be a lie the grammar
-// then trusts. Teaching pluralOf about "feet" would cost the collision table
-// "foots"; deriving this map from pluralOf would put "foots" in the lexicon.
-export const IRREGULAR_PLURALS = {
-  foot: "feet", tooth: "teeth", goose: "geese", ox: "oxen", die: "dice",
-  louse: "lice", mouse: "mice", crisis: "crises", analysis: "analyses",
-  hypothesis: "hypotheses", thesis: "theses", axis: "axes", basis: "bases",
-  oasis: "oases", criterion: "criteria", phenomenon: "phenomena",
-  alumnus: "alumni", cactus: "cacti", focus: "foci", radius: "radii",
-  fungus: "fungi", nucleus: "nuclei", stimulus: "stimuli", larva: "larvae",
-  alga: "algae", vertebra: "vertebrae", antenna: "antennae",
-  formula: "formulae", datum: "data", medium: "media", index: "indices",
-  matrix: "matrices", appendix: "appendices", curriculum: "curricula",
-  memorandum: "memoranda", millennium: "millennia", bacterium: "bacteria",
-  stratum: "strata", genus: "genera", species: "species", series: "series",
-  sheep: "sheep", deer: "deer", moose: "moose", salmon: "salmon",
-  trout: "trout", swine: "swine", offspring: "offspring", spacecraft: "spacecraft",
-  aircraft: "aircraft", scissors: "scissors", knife: "knives", wife: "wives",
-  life: "lives", leaf: "leaves", loaf: "loaves", thief: "thieves",
-  shelf: "shelves", elf: "elves", calf: "calves", half: "halves",
-  wolf: "wolves", self: "selves", woman: "women", man: "men",
-  child: "children", person: "people", tempo: "tempi",
-};
-
-/** One noun's lexicon-core.json entry: an explicit plural only where folding
- *  could not recover it. */
-export function lexiconNounEntry(word) {
-  const plural = IRREGULAR_PLURALS[word];
-  return plural ? { plural } : {};
-}
-
-/** One clump's facts as indented JS array-literal source lines. */
-export function factsBlock(facts) {
-  return facts.map(([s, r, o]) => `      ["${s}", "${r}", "${o}"],`).join("\n");
-}
-
-/** A noun list wrapped at ~8 words/line, matching Small tier's own
- *  lexicon-list style. */
-export function nounsListBlock(words) {
-  const lines = [];
-  for (let i = 0; i < words.length; i += 8) {
-    lines.push(`        ${words.slice(i, i + 8).map((w) => `"${w}"`).join(", ")},`);
-  }
-  return lines.join("\n");
-}
-
-/** One CORPUSES entry as JS source, for `id` ("human-medium"/"human-large")
- *  from `byClump`, the reviewed worksheet's per-clump {facts, newNouns}. */
-export function buildCorpusEntry(id, tierLabel, byClump) {
-  const nounsSrc = CLUMP_ORDER.map((c) => `        // ${c} (+${byClump[c].newNouns.length} words: ${CLUMP_LABEL[c]})\n${nounsListBlock(byClump[c].newNouns)}`).join("\n");
-  const factsSrc = CLUMP_ORDER.map((c) => `      // ---- ${c} (+${byClump[c].facts.length} facts, ${tierLabel}) ----\n${factsBlock(byClump[c].facts)}`).join("\n\n");
-
-  return `
-  // ${tierLabel} tier — INCREMENTAL facts beyond ${id === "human-medium" ? "Small (corpus/tier2/human.jsonl)" : "Medium (corpus/tier2/human-medium.jsonl)"} only
-  // (PLAN_SEED.md §3's tier-selection design: Small/Medium/Large are SIZES of
-  // one bundle, not separate corpus ids — this file holds only what ${tierLabel}
-  // ADDS beyond the previous tier). Built by scripts/build-persona-tiers.mjs
-  // from the same two locally-cloned WordNet source files as Small
-  // (~/projects/globalwordnet/english-wordnet/src/yaml/), automatically
-  // curated: candidate words ranked by WordNet sense-count (a commonness
-  // proxy, PLAN_SEED.md §12), restricted to each word's own TOP senses (not
-  // some rare/slang meaning that happens to live in this domain), obscure/
-  // archaic/offensive/pharmaceutical content excluded via a definition-text
-  // blocklist plus an explicit word denylist, reviewed by hand before being
-  // spliced in here (scripts/apply-persona-tiers.mjs). ${id === "human-large" ? "Large's own facts walk real multi-hop hypernym chains (up to 4 hops, PLAN_SEED.md §3's own \"surgeon ⊑ doctor ⊑ … ⊑ person\" example) wherever WordNet's real structure supports it, not a flat one-hop-per-word cap." : "Medium stays flat, one hop per word, same style as Small."}
-  "${id}": {
-    kind: "domain",
-    description: "The ${tierLabel} tier of the default human-world persona (PLAN_SEED.md): incremental facts beyond ${id === "human-medium" ? "Small" : "Medium"} only — activated alongside \\"human\\" via --persona-size ${id === "human-medium" ? "medium" : "large"}, never active by default.",
-    lexicon: {
-      nouns: [
-${nounsSrc}
-      ],
-    },
-    facts: [
-${factsSrc}
-    ],
-  },
-`;
-}
-
-/** The CORPUSES source with `entries` spliced in before its closing brace.
- *  Throws when the anchor is absent rather than writing a mangled file. */
-export function spliceCorpusEntries(generateSrc, entries) {
-  const anchor = "\n};\n\nconst conceptUri = ";
-  const idx = generateSrc.indexOf(anchor);
-  if (idx === -1) throw new Error("apply-persona-tiers: could not find CORPUSES closing anchor in generate.mjs");
-  return generateSrc.slice(0, idx) + entries.join("") + generateSrc.slice(idx + 1);
-}

package/src/domain/publish-gate.mjs

@@ -1,41 +0,0 @@
-// publish-gate.mjs — should this commit publish to npm? Pure: two version
-// strings in, a decision and a reason out, no imports, so CI can ask without
-// npm ci.
-//
-// CI asked this with `[ "$PUBLISHED" = "$LOCAL" ]`, which only answers "same".
-// A local version BELOW what npm already has — a revert, a bad merge, a branch
-// landing behind — reads as "different" and goes to `npm publish`, where the
-// registry rejects it and the job fails on a confusing error instead of a clear
-// skip. Equality cannot tell "ahead" from "behind"; comparing can.
-
-const CORE = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/;
-
-/** [major, minor, patch] for a semver string, or null if it isn't one. */
-function core(version) {
-  const found = CORE.exec(String(version ?? "").trim());
-  return found ? [Number(found[1]), Number(found[2]), Number(found[3])] : null;
-}
-
-/** -1 | 0 | 1 comparing the release cores of `a` and `b`. Pre-release and build
- *  metadata are ignored: this gate decides whether a release moved, and 2.2.0
- *  and 2.2.0-rc.1 are the same release for that purpose. */
-export function compareVersions(a, b) {
-  const [x, y] = [core(a), core(b)];
-  if (!x || !y) throw new Error(`not a comparable version: "${!x ? a : b}"`);
-  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] < y[i] ? -1 : 1;
-  return 0;
-}
-
-/** Should `local` publish, given the registry currently serves `published`?
- *  `published` is "none" when the package has never been published.
- *  Returns { publish, reason } — the reason is what CI prints either way. */
-export function shouldPublish(local, published) {
-  if (!core(local)) throw new Error(`not a publishable version: "${local}"`);
-  if (published === "none" || published == null || published === "") {
-    return { publish: true, reason: `publishing ${local} (nothing published yet)` };
-  }
-  const order = compareVersions(local, published);
-  if (order === 0) return { publish: false, reason: `npm already has ${local} — no version bump in this push, skipping publish` };
-  if (order < 0) return { publish: false, reason: `local ${local} is BEHIND npm's ${published} — refusing to publish; the registry would reject it` };
-  return { publish: true, reason: `publishing ${local} (npm currently has ${published})` };
-}

package/src/domain/schemaorg/turtle.mjs

@@ -1,25 +0,0 @@
-// turtle.mjs — a very small Turtle reader for schema.ttl's OWN regular shape:
-// each class is one `:Name a rdfs:Class ;` block terminated by a line ending
-// in ` .`, with `rdfs:label`/`rdfs:comment`/`rdfs:subClassOf` as `;`-separated
-// predicate lines. Not a general Turtle parser — schema.ttl's own generator
-// emits a single, very regular style (confirmed by direct inspection).
-//
-// Pure: text in, Map out, no imports.
-
-/** Every rdfs:Class in `text`, as name -> { name, label, comment, subClassOf }.
- *  A class with no rdfs:label falls back to its own name; no rdfs:comment
- *  yields "". Blocks that are not classes (properties, say) are skipped. */
-export function parseSchemaClasses(text) {
-  const classes = new Map();
-  const blocks = text.split(/\n(?=:[A-Za-z])/); // each class/property starts a new top-level block
-  for (const block of blocks) {
-    const head = /^:([A-Za-z0-9_]+)\s+a\s+rdfs:Class\s*;/.exec(block);
-    if (!head) continue;
-    const name = head[1];
-    const label = /rdfs:label\s+"([^"]*)"/.exec(block)?.[1] || name;
-    const comment = /rdfs:comment\s+"([^"]*)"/.exec(block)?.[1] || "";
-    const subClassOf = [...block.matchAll(/rdfs:subClassOf\s+:([A-Za-z0-9_]+)/g)].map((m) => m[1]);
-    classes.set(name, { name, label, comment, subClassOf });
-  }
-  return classes;
-}

package/src/domain/semcor/parse.mjs

@@ -1,87 +0,0 @@
-// parse.mjs — a targeted reader for SemCor's own regular YAML shape:
-// flow-style lemmas/pos arrays and a folded single-quoted `text` scalar, one
-// record per sentence. Not a general YAML parser (this repo has no YAML
-// dependency), and not the same shape as the WordNet dump's reader in
-// src/domain/wordnet/yaml.mjs — SemCor's flow style is JSON-compatible once
-// isolated, which the WordNet subset never is.
-//
-// Pure: text in, arrays/strings out, no imports, so it runs with no SemCor
-// clone present.
-
-/** Split a SemCor YAML file into per-sentence record blocks (top-level
- *  "<key>:" lines, skipping the leading "_meta:" schema block). */
-export function splitRecords(text) {
-  const lines = text.split("\n");
-  const blocks = [];
-  let i = 0;
-  while (i < lines.length && lines[i] !== "_meta:") i++;
-  i += 1;
-  while (i < lines.length && (lines[i].startsWith(" ") || lines[i].trim() === "")) i++; // skip rest of _meta
-  while (i < lines.length) {
-    if (/^[A-Za-z0-9_]+:$/.test(lines[i])) {
-      let j = i + 1;
-      const block = [];
-      while (j < lines.length && !/^[A-Za-z0-9_]+:$/.test(lines[j])) {
-        block.push(lines[j]);
-        j += 1;
-      }
-      blocks.push(block.join("\n"));
-      i = j;
-    } else {
-      i += 1;
-    }
-  }
-  return blocks;
-}
-
-/** Extract a flow-style JSON-compatible array value for `key` from one
- *  record block (lemmas/pos are double-quoted string arrays — valid JSON
- *  once isolated), balancing brackets across a line wrap if one occurs. */
-export function extractArray(block, key) {
-  const re = new RegExp(`^\\s*${key}:\\s*(\\[.*)$`, "m");
-  const m = re.exec(block);
-  if (!m) return null;
-  let buf = m[1];
-  let depth = (buf.match(/\[/g) || []).length - (buf.match(/\]/g) || []).length;
-  const afterIdx = block.indexOf(m[0]) + m[0].length;
-  const rest = block.slice(afterIdx).split("\n");
-  let ri = 0;
-  while (depth > 0 && ri < rest.length) {
-    buf += `\n${rest[ri]}`;
-    depth += (rest[ri].match(/\[/g) || []).length - (rest[ri].match(/\]/g) || []).length;
-    ri += 1;
-  }
-  try { return JSON.parse(buf); } catch { return null; }
-}
-
-/** Extract the `text:` folded single-quoted scalar (YAML's own `''` ->
- *  literal `'` escape; line breaks folded to spaces). */
-export function extractText(block) {
-  const m = /^\s*text:\s*'/m.exec(block);
-  if (!m) return null;
-  const start = block.indexOf("'", m.index);
-  let i = start + 1;
-  let raw = "";
-  while (i < block.length) {
-    if (block[i] === "'") {
-      if (block[i + 1] === "'") { raw += "'"; i += 2; continue; }
-      break;
-    }
-    raw += block[i];
-    i += 1;
-  }
-  return raw.replace(/\s+/g, " ").trim();
-}
-
-export const NOUN_POS = new Set(["NN", "NNS"]);
-
-/** Simple-grammar filter: short, no semicolons/colons, no embedded quotes
- *  (which signal reported speech), no more than one comma — a rough proxy for
- *  "no complex embedded clauses". */
-export function isSimpleSentence(text, wordCount) {
-  if (wordCount > 18) return false;
-  if (/[;:]/.test(text)) return false;
-  if ((text.match(/,/g) || []).length > 1) return false;
-  if (/"/.test(text)) return false;
-  return true;
-}

package/src/domain/version-stamp.mjs

@@ -1,36 +0,0 @@
-// version-stamp.mjs — the home page's #pkg-version element, written and read
-// from one place. Pure: strings in, strings out, no imports, so the deploy
-// smoke check can reach it without npm ci.
-//
-// This existed three times and the copies had already drifted: the writer
-// matched [^<]*, the smoke check demanded \d+\.\d+\.\d+, and the estate test
-// accepted [^<\s]*. A writer that accepts what its reader rejects is a green
-// build and a failed deploy, so the pattern lives here and all three call it.
-
-/** The element that carries the version, and the value inside it. */
-const STAMP = /(id="pkg-version"[^>]*>)\s*v?([^<]*?)\s*(<)/;
-
-/** A semver core, which is what the deploy smoke check is entitled to expect. */
-const SEMVER = /^\d+\.\d+\.\d+$/;
-
-/** True iff `html` carries an element the stamp can be written into. */
-export function hasVersionStamp(html) {
-  return STAMP.test(html);
-}
-
-/** The version `html` displays, or null when the element is absent or holds
- *  something that is not a semver core (an unstamped placeholder, say). */
-export function parseVersionStamp(html) {
-  const found = STAMP.exec(html);
-  if (!found) return null;
-  const value = found[2].trim();
-  return SEMVER.test(value) ? value : null;
-}
-
-/** `html` with the stamp set to `version`. Throws when there is nothing to
- *  stamp — a page that lost its element would otherwise publish blank. */
-export function stampVersion(html, version) {
-  if (!SEMVER.test(version)) throw new Error(`not a stampable version: "${version}"`);
-  if (!hasVersionStamp(html)) throw new Error("no #pkg-version element to stamp");
-  return html.replace(STAMP, `$1${version}$3`);
-}

package/src/domain/wordnet/yaml.mjs

@@ -1,133 +0,0 @@
-// yaml.mjs — a reader for the small YAML subset the Open English WordNet dump
-// uses: 2-space-indented block mappings/sequences, quoted or bare scalars, and
-// long scalar list-items that simply WRAP onto a further-indented continuation
-// line. No block scalars, no anchors, no flow style — confirmed by direct
-// inspection of the dump. This reads exactly that subset; it is not a general
-// YAML parser.
-//
-// Pure: text in, object out, no imports, so it is testable without the WordNet
-// clone the scripts that call it need.
-
-/** Non-greedy key group so a MULTI-WORD entry key ("M-1 rifle", "ice cream")
- *  still matches — the first ": "/end-of-line colon wins, exactly as real
- *  YAML's block-mapping key/value split works. A plain wrapped scalar
- *  continuation line (a definition/example fragment) only coincidentally
- *  matches this if it ALSO happens to contain a bare "word: " sequence — rare
- *  in this corpus's prose, and this feeds a maintainer worksheet whose output
- *  is hand-reviewed, not a correctness-critical parser. */
-const KEY_RE = /^(.+?):(\s+(.*)|)$/;
-
-const isDash = (t) => t === "-" || t.startsWith("- ");
-
-function parseScalar(s) {
-  const t = s.trim();
-  if ((t.startsWith("'") && t.endsWith("'") && t.length >= 2) || (t.startsWith('"') && t.endsWith('"') && t.length >= 2)) {
-    return t.slice(1, -1);
-  }
-  return t;
-}
-
-export function parseYaml(text) {
-  const rawLines = text.split("\n");
-  const lines = [];
-  for (const line of rawLines) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-    const indent = line.length - line.trimStart().length;
-    lines.push({ indent, text: line.trimStart() });
-  }
-  let pos = 0;
-
-  // A scalar that may continue on subsequent MORE-indented lines with no
-  // "key:"/"- " marker of their own (WordNet's definition-wrapping style). A
-  // QUOTED scalar ('...' or "...") is handled separately: WordNet definitions
-  // routinely contain a literal ": " inside the quoted text itself (e.g. "…
-  // Matthew, Mark, Luke, and John" split across a line boundary right after a
-  // colon) — the bare-scalar heuristic below would misread that continuation
-  // line as a new "key:" line and truncate the string. Once inside an open
-  // quote, EVERY line is a continuation until one ends with the matching
-  // closing quote, full stop — the key/dash heuristic never applies inside it.
-  function parseScalarOrContinue(first, minContinIndent) {
-    const trimmed = first.trim();
-    const quote = trimmed[0] === "'" || trimmed[0] === '"' ? trimmed[0] : null;
-    if (quote) {
-      const closes = (s) => s.length >= 2 && s.endsWith(quote);
-      let buf = trimmed;
-      while (!closes(buf) && pos < lines.length && lines[pos].indent >= minContinIndent) {
-        buf += " " + lines[pos].text.trim();
-        pos += 1;
-      }
-      return closes(buf) ? buf.slice(1, -1) : buf;
-    }
-    let s = parseScalar(first);
-    while (pos < lines.length && lines[pos].indent >= minContinIndent
-      && !isDash(lines[pos].text) && !KEY_RE.test(lines[pos].text)) {
-      s += " " + lines[pos].text.trim();
-      pos += 1;
-    }
-    return s;
-  }
-
-  /** The value that follows a "key:" (bare, no inline scalar) — peeks at the
-   *  next line to decide whether it's a nested sequence (which YAML allows to
-   *  sit at the SAME indent as the key itself, not just deeper) or a nested
-   *  mapping (which must be deeper) or simply absent (null). `parentIndent`
-   *  is the indent of the "key:" line whose value this resolves. */
-  function parseValue(parentIndent) {
-    if (pos >= lines.length || lines[pos].indent < parentIndent) return null;
-    const line = lines[pos];
-    if (isDash(line.text)) return parseSeq(line.indent);
-    if (line.indent > parentIndent && KEY_RE.test(line.text)) return parseMap(line.indent);
-    return null;
-  }
-
-  function parseSeq(indent) {
-    const arr = [];
-    while (pos < lines.length && lines[pos].indent === indent && isDash(lines[pos].text)) {
-      const dashIndent = indent;
-      const rest = lines[pos].text === "-" ? "" : lines[pos].text.slice(2);
-      pos += 1;
-      if (rest === "") {
-        arr.push(parseValue(dashIndent));
-        continue;
-      }
-      // A quoted scalar is classified FIRST, unconditionally — WordNet
-      // definitions routinely contain a literal ": " (or a colon at the very
-      // end of a wrapped line, e.g. "…including:\n  whales, …") inside quoted
-      // prose, which KEY_RE would otherwise misread as an inline "- key:"
-      // mapping. Only an UNQUOTED rest is even considered for that shape.
-      const quoted = rest[0] === "'" || rest[0] === '"';
-      const m = quoted ? null : KEY_RE.exec(rest);
-      if (m) {
-        // "- key: value" or "- key:" — an inline mapping for this list item;
-        // sibling keys of the SAME item are indented +2 from the dash.
-        const obj = {};
-        obj[m[1]] = m[3] !== undefined && m[3] !== "" ? parseScalarOrContinue(m[3], dashIndent + 2) : parseValue(dashIndent + 2);
-        while (pos < lines.length && lines[pos].indent === dashIndent + 2 && KEY_RE.test(lines[pos].text)) {
-          const mm = KEY_RE.exec(lines[pos].text);
-          pos += 1;
-          obj[mm[1]] = mm[3] !== undefined && mm[3] !== "" ? parseScalarOrContinue(mm[3], dashIndent + 4) : parseValue(dashIndent + 2);
-        }
-        arr.push(obj);
-      } else {
-        // a plain (or quoted) scalar list item — may wrap onto continuation lines
-        arr.push(parseScalarOrContinue(rest, dashIndent + 2));
-      }
-    }
-    return arr;
-  }
-
-  function parseMap(indent) {
-    const obj = {};
-    while (pos < lines.length && lines[pos].indent === indent && KEY_RE.test(lines[pos].text)) {
-      const m = KEY_RE.exec(lines[pos].text);
-      const key = parseScalar(m[1]);
-      pos += 1;
-      obj[key] = m[3] !== undefined && m[3] !== "" ? parseScalarOrContinue(m[3], indent + 2) : parseValue(indent);
-      // (parseValue(indent) — not indent+2 — so a same-indent sequence value
-      // is recognized; parseValue itself accepts child indent >= indent.)
-    }
-    return obj;
-  }
-
-  return parseMap(0);
-}