oh-my-opencode 5.1.47 → 5.1.51

package/dist/skills/ulw-research/scripts/html-text-map.mjs

@@ -0,0 +1,140 @@
+// html-text-map.mjs - the reader-visible text of a page, with a source map back into the markup.
+//
+// extractHtml(html) returns { root, text, blocks, starts, ends }: `text` is one line per block
+// (prose blocks and table cells; whitespace collapsed, entities decoded) and text unit k came from
+// html.slice(starts[k], ends[k]). Only text nodes are read: attribute values, CSS, scripts, and
+// anything a reader never sees (head, script, style, svg, noscript, template, code-like elements,
+// aria-hidden="true" and their descendants, and what the page's CSS hides: css-hiding.mjs)
+// contribute nothing, so a locator over `text` can never land in markup. A synthetic separator
+// (collapsed break, line feed) maps to an empty range at the previous character's end.
+// Plain Node ESM, sibling imports only.
+
+import { cssVisibility } from "./css-hiding.mjs"
+import { decodeOne } from "./entities.mjs"
+import { parseHtml, PROSE_BREAKS, PROSE_TAGS } from "./html-lite.mjs"
+
+const SKIP = new Set(["head", "script", "style", "svg", "code", "pre", "kbd", "samp", "template", "noscript"])
+const INLINE = new Set([
+	"a", "abbr", "b", "bdi", "bdo", "cite", "data", "del", "dfn", "em", "font", "i", "ins", "label", "mark", "q", "s",
+	"small", "span", "strong", "sub", "sup", "time", "u", "var",
+])
+const SPACE = /\s/
+
+/** null when a reader never sees the element or anything inside it, else whether its own text shows (css: cssVisibility). */
+function shownState(node, css, parentShown) {
+	if (SKIP.has(node.tag) || String(node.attrs?.["aria-hidden"] ?? "").trim().toLowerCase() === "true") return null
+	return css(node, parentShown)
+}
+
+function newLine() {
+	return { node: null, text: "", starts: [], ends: [], space: null }
+}
+
+function put(line, unit, start, end) {
+	if (SPACE.test(unit)) {
+		if (line.text !== "" && line.space === null) line.space = [start, end]
+		return
+	}
+	if (line.space !== null) {
+		line.text += " "
+		line.starts.push(line.space[0])
+		line.ends.push(line.space[1])
+		line.space = null
+	}
+	line.text += unit
+	line.starts.push(start)
+	line.ends.push(end)
+}
+
+/** A collapsible break with no source character of its own. */
+function softBreak(line) {
+	if (line.text !== "" && line.space === null) {
+		const at = line.ends[line.ends.length - 1]
+		line.space = [at, at]
+	}
+}
+
+/** Append a text node's source range, decoding entities exactly as decodeEntities does. */
+function putText(line, src, from, to) {
+	for (let at = from; at < to; ) {
+		if (src[at] === "&") {
+			const semi = src.indexOf(";", at + 1)
+			const decoded = semi !== -1 && semi < to && semi - at <= 12 ? decodeOne(src.slice(at + 1, semi)) : null
+			if (decoded !== null) {
+				for (let k = 0; k < decoded.length; k++) put(line, decoded[k], at, semi + 1)
+				at = semi + 1
+				continue
+			}
+		}
+		put(line, src[at], at, at + 1)
+		at++
+	}
+}
+
+function putProse(line, src, node, css, shown) {
+	for (const child of node.children) {
+		if (child.tag === "#text") {
+			if (shown) putText(line, src, child.source_start, child.source_end)
+			continue
+		}
+		const state = shownState(child, css, shown)
+		if (state === null) continue
+		const breaks = PROSE_BREAKS.has(child.tag)
+		if (breaks) softBreak(line)
+		putProse(line, src, child, css, state)
+		if (breaks) softBreak(line)
+	}
+}
+
+/** See the file comment. blocks: [{ node, start, end }] with text.slice(start, end) one block line. */
+export function extractHtml(html) {
+	const src = String(html)
+	const root = parseHtml(src)
+	const css = cssVisibility(root)
+	const lines = []
+	let line = newLine()
+	const flush = (node) => {
+		if (line.text !== "") lines.push({ ...line, node })
+		line = newLine()
+	}
+	const walk = (node, shown) => {
+		for (const child of node.children) {
+			if (child.tag === "#text") {
+				if (shown) putText(line, src, child.source_start, child.source_end)
+				continue
+			}
+			const state = shownState(child, css, shown)
+			if (state === null) continue
+			if (child.tag === "br") flush(node)
+			else if (INLINE.has(child.tag)) walk(child, state)
+			else if (PROSE_TAGS.has(child.tag)) {
+				flush(node)
+				putProse(line, src, child, css, state)
+				flush(child)
+			} else {
+				flush(node)
+				walk(child, state)
+				flush(child)
+			}
+		}
+	}
+	walk(root, true)
+	flush(root)
+	const blocks = []
+	const starts = []
+	const ends = []
+	let text = ""
+	for (const entry of lines) {
+		if (text !== "") {
+			const at = ends[ends.length - 1]
+			text += "\n"
+			starts.push(at)
+			ends.push(at)
+		}
+		blocks.push({ node: entry.node, start: text.length, end: text.length + entry.text.length })
+		text += entry.text
+		starts.push(...entry.starts)
+		ends.push(...entry.ends)
+	}
+	return { root, text, blocks, starts, ends }
+}

package/dist/skills/ulw-research/scripts/html-text-map.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test"
+
+import { extractHtml } from "./html-text-map.mjs"
+
+/** {T} is the target sentence: every row runs once with English text and once with Korean text. */
+const TARGET = { en: "Target length is 999 m.", ko: "\ubaa9\ud45c \uae38\uc774\ub294 999 m\uc774\ub2e4." }
+const CONTROL = "Control length is 410 m."
+
+type Row = { form: string; html: string; expected: "hidden" | "visible" }
+
+const css = (sheet: string, element = '<p class="x">{T}</p>') => `<style>${sheet}</style>${element}`
+
+const ROWS: Row[] = [
+	// conditional and grouping at-rules: only an unconditional rule hides; a conditional one never does
+	{ form: "@media (max-width:600px)", html: css("@media (max-width:600px){.x{display:none}}"), expected: "visible" },
+	{ form: "@media print", html: css("@media print{.x{display:none}}"), expected: "visible" },
+	{ form: "@media screen and (min-width:0)", html: css("@media screen and (min-width: 0){.x{display:none}}"), expected: "visible" },
+	{ form: "@media not print", html: css("@media not print{.x{display:none}}"), expected: "visible" },
+	{ form: "@media all", html: css("@media all{.x{display:none}}"), expected: "hidden" },
+	{ form: "@media all and (min-width:1px)", html: css("@media all and (min-width:1px){.x{display:none}}"), expected: "visible" },
+	{ form: "@supports (display:grid)", html: css("@supports (display:grid){.x{display:none}}"), expected: "visible" },
+	{ form: "@container (min-width:400px)", html: css("@container (min-width: 400px){.x{display:none}}"), expected: "visible" },
+	{ form: "@scope (.card)", html: css("@scope (.card){.x{display:none}}", '<div class="card"><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "@starting-style", html: css("@starting-style{.x{display:none}}"), expected: "visible" },
+	{ form: "@document url-prefix()", html: css("@-moz-document url-prefix(){.x{display:none}}"), expected: "visible" },
+	{ form: "@layer base (block)", html: css("@layer base{.x{display:none}}"), expected: "hidden" },
+	{ form: "@layer statement then block", html: css("@layer a, b; @layer b{.x{display:none}}"), expected: "hidden" },
+	{ form: "@layer inside @media", html: css("@media print{@layer a{.x{display:none}}}"), expected: "visible" },
+	{ form: "@media inside @layer", html: css("@layer a{@media print{.x{display:none}}}"), expected: "visible" },
+	{ form: "@media inside @supports", html: css("@supports (display:grid){@media (min-width:1px){.x{display:none}}}"), expected: "visible" },
+	{ form: "@media nested in a style rule", html: css(".x{color:red;@media print{display:none}}"), expected: "visible" },
+	{ form: "@import before a rule", html: css('@import url("print.css") print; .x{display:none}'), expected: "hidden" },
+	{ form: "@font-face before a rule", html: css("@font-face{font-family:F;src:url(f.woff2)} .x{display:none}"), expected: "hidden" },
+	{ form: "@keyframes hiding steps", html: css("@keyframes k{from{visibility:hidden}to{display:none}} .x{animation:k 1s}"), expected: "visible" },
+	{ form: "@page", html: css("@page{display:none} .y{display:none}"), expected: "visible" },
+	{ form: "CSS nesting (combinator, not evaluated)", html: css(".card{.x{display:none}}", '<div class="card"><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "conditional rule after an unconditional one", html: css(".x{display:none} @media print{.x{color:red}}"), expected: "hidden" },
+	// comments
+	{ form: "rule inside a comment", html: css("/* .x{display:none} */"), expected: "visible" },
+	{ form: "comment before the declaration", html: css(".x{/* display:block */display:none}"), expected: "hidden" },
+	{ form: "comment inside the value", html: css(".x{display:/**/none}"), expected: "hidden" },
+	{ form: "HTML comment markers in <style>", html: css("<!-- .x{display:none} -->"), expected: "hidden" },
+	{ form: "comment in an inline style", html: '<p style="display:/* hide */none">{T}</p>', expected: "hidden" },
+	// selector lists and the cascade
+	{ form: "selector list", html: css(".a, .x {display:none}"), expected: "hidden" },
+	{ form: "selector list with a compound part", html: css("div p, .x{display:none}"), expected: "hidden" },
+	{ form: "compound selector alone (not evaluated)", html: css("p.x{display:none}"), expected: "visible" },
+	{ form: "descendant selector alone (not evaluated)", html: css("div .x{display:none}", '<div><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "attribute selector (not evaluated)", html: css("[data-off]{display:none}", "<p data-off>{T}</p>"), expected: "visible" },
+	{ form: "later rule shows again", html: css(".x{display:none} .x{display:block}"), expected: "visible" },
+	{ form: "later rule hides", html: css(".x{display:block} .x{display:none}"), expected: "hidden" },
+	{ form: "id outranks class", html: css("#y{display:block} .x{display:none}", '<p id="y" class="x">{T}</p>'), expected: "visible" },
+	{ form: "class outranks tag", html: css(".x{display:none} p{display:block}"), expected: "hidden" },
+	{ form: "responsive show (d-none d-md-block)", html: css(".x{display:none} @media (min-width:768px){.y{display:block}}", '<p class="x y">{T}</p>'), expected: "visible" },
+	{ form: "important hide beats a conditional show", html: css(".x{display:none!important} @media (min-width:768px){.y{display:block}}", '<p class="x y">{T}</p>'), expected: "hidden" },
+	{ form: "important hide and important conditional show", html: css(".x{display:none!important} @media (min-width:768px){.y{display:block!important}}", '<p class="x y">{T}</p>'), expected: "visible" },
+	{ form: "compound show may apply", html: css(".x{display:none} div .x{display:block}", '<div><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "compound show that cannot match", html: css(".x{display:none} div .z{display:block}", '<div><p class="x">{T}</p></div>'), expected: "hidden" },
+	{ form: "layered show loses to unlayered hide", html: css("@layer base{.x{display:block}} .x{display:none}"), expected: "hidden" },
+	{ form: "unlayered show beats layered hide", html: css("@layer base{.x{display:none}} p{display:block}"), expected: "visible" },
+	{ form: "later layer beats earlier layer", html: css("@layer a, b; @layer b{.x{display:none}} @layer a{#y{display:block}}", '<p id="y" class="x">{T}</p>'), expected: "hidden" },
+	// !important against inline styles
+	{ form: "important rule beats inline show", html: css(".x{display:none !important}", '<p class="x" style="display:block">{T}</p>'), expected: "hidden" },
+	{ form: "inline show beats a normal rule", html: css(".x{display:none}", '<p class="x" style="display:block">{T}</p>'), expected: "visible" },
+	{ form: "important show beats inline hide", html: css(".x{display:block !important}", '<p class="x" style="display:none">{T}</p>'), expected: "visible" },
+	{ form: "important without a space", html: css(".x{display:none!important}"), expected: "hidden" },
+	{ form: "inline important beats important rule", html: css(".x{display:block!important}", '<p class="x" style="display:none!important">{T}</p>'), expected: "hidden" },
+	// which properties hide
+	{ form: "display:none (rule)", html: css(".x{display:none}"), expected: "hidden" },
+	{ form: "visibility:hidden (rule)", html: css(".x{visibility:hidden}"), expected: "hidden" },
+	{ form: "visibility:collapse", html: '<p style="visibility:collapse">{T}</p>', expected: "hidden" },
+	{ form: "visibility:hidden parent, visible child", html: '<div style="visibility:hidden"><p style="visibility:visible">{T}</p></div>', expected: "visible" },
+	{ form: "visibility:hidden parent, plain child", html: '<div style="visibility:hidden"><p>{T}</p></div>', expected: "hidden" },
+	{ form: "visibility:hidden parent, child by rule", html: css(".x{visibility:visible}", '<div style="visibility:hidden"><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "display:none parent, visible child", html: '<div style="display:none"><p style="visibility:visible;display:block">{T}</p></div>', expected: "hidden" },
+	{ form: "content-visibility:hidden", html: '<div style="content-visibility:hidden"><p>{T}</p></div>', expected: "hidden" },
+	{ form: "display:contents", html: '<p style="display:contents">{T}</p>', expected: "visible" },
+	{ form: "opacity:0", html: '<p style="opacity:0">{T}</p>', expected: "visible" },
+	{ form: "clip rect (sr-only)", html: '<p style="position:absolute;clip:rect(0 0 0 0);width:1px;height:1px;overflow:hidden">{T}</p>', expected: "visible" },
+	{ form: "clip-path inset", html: '<p style="clip-path:inset(50%)">{T}</p>', expected: "visible" },
+	{ form: "height:0 with overflow hidden", html: '<p style="height:0;overflow:hidden">{T}</p>', expected: "visible" },
+	{ form: "font-size:0", html: '<p style="font-size:0">{T}</p>', expected: "visible" },
+	{ form: "off-screen position", html: '<p style="position:absolute;left:-9999px">{T}</p>', expected: "visible" },
+	{ form: "transparent color", html: '<p style="color:transparent">{T}</p>', expected: "visible" },
+	// the hidden attribute
+	{ form: "hidden attribute", html: "<p hidden>{T}</p>", expected: "hidden" },
+	{ form: 'hidden="hidden"', html: '<p hidden="hidden">{T}</p>', expected: "hidden" },
+	{ form: "HIDDEN in upper case", html: "<p HIDDEN>{T}</p>", expected: "hidden" },
+	{ form: 'hidden="until-found"', html: '<p hidden="until-found">{T}</p>', expected: "visible" },
+	{ form: "hidden attribute under an author display rule", html: css(".x{display:block}", '<p class="x" hidden>{T}</p>'), expected: "visible" },
+	{ form: "hidden attribute under an inline display", html: '<p hidden style="display:block">{T}</p>', expected: "visible" },
+	{ form: "descendant of a hidden element", html: "<div hidden><p>{T}</p></div>", expected: "hidden" },
+	// aria-hidden
+	{ form: 'aria-hidden="true"', html: '<p aria-hidden="true">{T}</p>', expected: "hidden" },
+	{ form: 'aria-hidden=" TRUE "', html: '<p aria-hidden=" TRUE ">{T}</p>', expected: "hidden" },
+	{ form: 'aria-hidden="false"', html: '<p aria-hidden="false">{T}</p>', expected: "visible" },
+	{ form: "descendant of aria-hidden", html: '<div aria-hidden="true"><p>{T}</p></div>', expected: "hidden" },
+	// inline style spellings
+	{ form: "inline display:none", html: '<p style="display:none">{T}</p>', expected: "hidden" },
+	{ form: "inline with spaces and a trailing semicolon", html: '<p style=" display : none ; ">{T}</p>', expected: "hidden" },
+	{ form: "inline in upper case", html: '<p style="DISPLAY:NONE">{T}</p>', expected: "hidden" },
+	{ form: "inline after another declaration", html: '<p style="color:red;display:none">{T}</p>', expected: "hidden" },
+	{ form: "inline: last declaration wins", html: '<p style="display:none;display:block">{T}</p>', expected: "visible" },
+	{ form: "inline custom property", html: '<p style="--display:none">{T}</p>', expected: "visible" },
+	{ form: "inline var() value", html: '<p style="display:var(--d)">{T}</p>', expected: "visible" },
+	{ form: "inline display:none in a string value", html: '<p style="font-family:\'display:none\'">{T}</p>', expected: "visible" },
+	// case: tag names are case-insensitive, class and id names are case-sensitive
+	{ form: ".Foo vs class=foo", html: css(".Foo{display:none}", '<p class="foo">{T}</p>'), expected: "visible" },
+	{ form: ".foo vs class=Foo", html: css(".foo{display:none}", '<p class="Foo">{T}</p>'), expected: "visible" },
+	{ form: ".Foo vs class=Foo", html: css(".Foo{display:none}", '<p class="Foo">{T}</p>'), expected: "hidden" },
+	{ form: "#Gone vs id=gone", html: css("#Gone{display:none}", '<p id="gone">{T}</p>'), expected: "visible" },
+	{ form: "#gone vs id=gone", html: css("#gone{display:none}", '<p id="gone">{T}</p>'), expected: "hidden" },
+	{ form: "P{} vs <p>", html: css("P{display:none}", "<p>{T}</p>"), expected: "hidden" },
+	{ form: "p{} vs <P>", html: css("p{display:none}", "<P>{T}</P>"), expected: "hidden" },
+	{ form: "Hangul class name", html: css(".\uc228\uae40{display:none}", '<p class="\uc228\uae40">{T}</p>'), expected: "hidden" },
+	{ form: "upper-case property and value", html: css(".x{DISPLAY:NONE}"), expected: "hidden" },
+	// elements whose contents a reader never sees
+	{ form: "<noscript>", html: "<noscript><p>{T}</p></noscript>", expected: "hidden" },
+	{ form: "<template>", html: "<template><p>{T}</p></template>", expected: "hidden" },
+	{ form: "<script>", html: '<script>var note = "{T}"</script>', expected: "hidden" },
+	{ form: "<style> content", html: '<style>.x::after{content:"{T}"}</style>', expected: "hidden" },
+	{ form: "<title> in <head>", html: "<head><title>{T}</title></head>", expected: "hidden" },
+	{ form: "<svg> text", html: "<svg><text>{T}</text></svg>", expected: "hidden" },
+	{ form: "closed <dialog>", html: "<dialog><p>{T}</p></dialog>", expected: "hidden" },
+	{ form: "open <dialog>", html: "<dialog open><p>{T}</p></dialog>", expected: "visible" },
+	{ form: "closed <details> body", html: "<details><summary>More</summary><p>{T}</p></details>", expected: "visible" },
+	// which <style> elements apply
+	{ form: "<style> inside <template> is inert", html: '<template><style>.x{display:none}</style></template><p class="x">{T}</p>', expected: "visible" },
+	{ form: "<style> inside <noscript> applies only without scripts", html: '<noscript><style>.x{display:none}</style></noscript><p class="x">{T}</p>', expected: "visible" },
+	{ form: "<style> inside a hidden element still applies", html: '<div hidden><style>.x{display:none}</style></div><p class="x">{T}</p>', expected: "hidden" },
+	{ form: "<style> inside <svg> applies to the page", html: '<svg><style>.x{display:none}</style></svg><p class="x">{T}</p>', expected: "hidden" },
+	{ form: '<style media="print">', html: '<style media="print">.x{display:none}</style><p class="x">{T}</p>', expected: "visible" },
+	{ form: '<style media="all">', html: '<style media="all">.x{display:none}</style><p class="x">{T}</p>', expected: "hidden" },
+	{ form: '<style type="text/plain">', html: '<style type="text/plain">.x{display:none}</style><p class="x">{T}</p>', expected: "visible" },
+	{ form: "external stylesheet (not evaluated)", html: '<link rel="stylesheet" href="hide.css"><p class="d-none">{T}</p>', expected: "visible" },
+]
+
+const CASES = ROWS.flatMap((row) =>
+	(["en", "ko"] as const).map((lang) => [`${row.form} [${lang}] -> ${row.expected}`, row.html.replaceAll("{T}", TARGET[lang]), TARGET[lang], row.expected] as const),
+)
+
+describe("reader-visible text: one row per hiding form, English and Korean", () => {
+	test.each(CASES)("#given %s #when extracted #then the target is that", (_name, html, target, expected) => {
+		const { text } = extractHtml(`${html}<blockquote>${CONTROL}</blockquote>`)
+		expect(text).toContain(CONTROL)
+		expect(text.includes(target) ? "visible" : "hidden").toBe(expected)
+	})
+})

package/dist/skills/ulw-research/scripts/markdown-closers.mjs

@@ -0,0 +1,126 @@
+// markdown-closers.mjs - the Markdown closer runs a converter writes after a piece of text, read with
+// the CommonMark inline grammar instead of a hand-written pattern. A closer run is any sequence of:
+// an inline link ending `](dest "title")` (the destination either in <...> or bare with balanced
+// parentheses, the optional title in "...", '...' or (...), backslash escapes inside both), a full or
+// collapsed reference ending `][ref]` / `][]`, a whole image `![alt](...)` or `![alt][ref]` (its alt
+// text is not context), the `[` that opened a link whose text is all markup (`[![x](i.png)](/p)`),
+// an emphasis, strike or code delimiter, a bare `)`, `]` or `>`, and a backslash-escaped closer
+// (`\*`, `\_`, `\]`, `\)`, `\~`, a backtick), which stands for the raw character and is skipped like
+// it. An escaped opener (`\[`, `\(`) is a real character and ends the run. Shared by the conversion
+// probe's sign reading and its link-syntax spans. Pure; no imports.
+
+const SIMPLE = new Set(["*", "_", "~", "`", ")", "]", ">"])
+const BREAK = "\u0001"
+
+/** Whether the character at `index` is backslash-escaped (an odd run of backslashes before it). */
+export function escapedAt(text, index) {
+	let count = 0
+	for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) count++
+	return count % 2 === 1
+}
+
+/** The end (exclusive) of an inline link target `dest "title")` that starts right after its "(", or -1. */
+export function inlineTargetEnd(text, from) {
+	let i = from
+	const space = () => {
+		while (text[i] === " " || text[i] === "\t") i++
+	}
+	space()
+	if (text[i] === "<") {
+		for (i++; i < text.length && text[i] !== ">"; i++) {
+			if (text[i] === "\\") i++
+			else if (text[i] === "<" || text[i] === BREAK) return -1
+		}
+		if (text[i++] !== ">") return -1
+	} else {
+		let depth = 0
+		for (; i < text.length; i++) {
+			const ch = text[i]
+			if (ch === "\\") i++
+			else if (ch === "(") depth++
+			else if (ch === ")" && depth === 0) break
+			else if (ch === ")") depth--
+			else if (ch === " " || ch === "\t" || ch === BREAK) break
+		}
+		if (depth !== 0) return -1
+	}
+	const destEnd = i
+	space()
+	const open = text[i]
+	if (i > destEnd && (open === '"' || open === "'" || open === "(")) {
+		const close = open === "(" ? ")" : open
+		for (i++; i < text.length && text[i] !== close; i++) {
+			if (text[i] === "\\") i++
+			else if (text[i] === BREAK || (open === "(" && text[i] === "(")) return -1
+		}
+		if (text[i++] !== close) return -1
+		space()
+	}
+	return text[i] === ")" ? i + 1 : -1
+}
+
+/** The unescaped "[" that the unescaped "]" at `close` closes (brackets balance), or -1. */
+function openerOf(text, close) {
+	let depth = 0
+	for (let i = close; i >= 0 && text[i] !== BREAK; i--) {
+		if ((text[i] !== "[" && text[i] !== "]") || escapedAt(text, i)) continue
+		depth += text[i] === "]" ? 1 : -1
+		if (depth === 0) return i
+	}
+	return -1
+}
+
+/** The "](" positions whose inline target ends exactly at `end`, leftmost first (so a title holding "](" is not cut). */
+function inlineLinkClose(text, end) {
+	const from = Math.max(0, text.lastIndexOf(BREAK, end - 1))
+	for (let k = text.indexOf("](", from); k !== -1 && k < end; k = text.indexOf("](", k + 1)) {
+		if (!escapedAt(text, k) && inlineTargetEnd(text, k + 2) === end) return k
+	}
+	return -1
+}
+
+/** Where the link or image tail ending at `end` starts, and whether its "[" is still open; null when none ends there. */
+function linkTail(text, end) {
+	let close = -1
+	if (text[end - 1] === ")") close = inlineLinkClose(text, end)
+	else if (text[end - 1] === "]" && !escapedAt(text, end - 1)) {
+		const ref = openerOf(text, end - 1)
+		if (ref > 0 && text[ref - 1] === "]" && !escapedAt(text, ref - 1)) close = ref - 1
+	}
+	if (close === -1) return null
+	const open = openerOf(text, close)
+	if (open > 0 && text[open - 1] === "!" && !escapedAt(text, open - 1)) return { start: open - 1, opened: 0 }
+	return { start: close, opened: open === -1 ? 0 : 1 }
+}
+
+/** `text` without the Markdown closer run it ends with. */
+export function stripClosers(text) {
+	let end = text.length
+	let owed = 0
+	for (;;) {
+		const tail = linkTail(text, end)
+		if (tail) {
+			end = tail.start
+			owed += tail.opened
+			continue
+		}
+		const ch = text[end - 1]
+		if (SIMPLE.has(ch)) end -= escapedAt(text, end - 1) ? 2 : 1
+		else if (ch === "[" && owed > 0 && !escapedAt(text, end - 1)) {
+			end--
+			owed--
+		} else return text.slice(0, end)
+	}
+}
+
+/** [start, end) spans of every inline link or image with its target (an image from its "!"), for link-syntax cover. */
+export function inlineLinkSpans(text) {
+	const spans = []
+	for (let k = text.indexOf("]("); k !== -1; k = text.indexOf("](", k + 1)) {
+		const end = escapedAt(text, k) ? -1 : inlineTargetEnd(text, k + 2)
+		if (end === -1) continue
+		const open = openerOf(text, k)
+		spans.push([open > 0 && text[open - 1] === "!" ? open - 1 : k, end])
+	}
+	return spans
+}

package/dist/skills/ulw-research/scripts/md-lite-boundaries.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test"
+
+import { parseMarkdown } from "./md-lite.mjs"
+import { parseNumeral } from "./numerals.mjs"
+
+describe("Markdown list continuation boundaries", () => {
+	test("#given a continuation after a list item #when parsed #then a later marker stays paragraph text", () => {
+		const text = "1. a\ncontinued\n2. b"
+		const { blocks } = parseMarkdown(text)
+		expect(blocks.map((block: { kind: string; text: string }) => [block.kind, block.text])).toEqual([
+			["list_item", "a"],
+			["paragraph", "continued\n2. b"],
+		])
+	})
+
+	test("#given numbers beside a list continuation #when parsed #then fidelity numerals retain source offsets", () => {
+		const text = "1. a 12%\ncontinued\n2. b 34%"
+		const { blocks } = parseMarkdown(text)
+		const found = blocks.flatMap((block: { text: string; start: number }) => {
+			const numerals = []
+			for (let numeral = parseNumeral(block.text); numeral; numeral = parseNumeral(block.text, numeral.span[1])) {
+				const [start, end] = numeral.span
+				numerals.push([numeral.value, text.slice(block.start + start, block.start + end)])
+			}
+			return numerals
+		})
+		expect(found).toEqual([["12", "12%"], ["2", "2"], ["34", "34%"]])
+	})
+})
+
+describe("Markdown closing fence indentation", () => {
+	test.each(["```", "~~~"])("#given a four-space %s closing candidate #when parsed #then the code runs to EOF", (fence: string) => {
+		const text = `${fence}\ncode 12\n    ${fence}\nclaim 34`
+		const { blocks, problems } = parseMarkdown(text)
+		expect(blocks.map((block: { kind: string; text: string }) => [block.kind, block.text])).toEqual([
+			["code", `code 12\n    ${fence}\nclaim 34`],
+		])
+		expect(problems).toEqual([{ code: "unterminated_fence", line: 1, start: 0 }])
+	})
+
+	test.each([0, 1, 2, 3])("#given a closing fence indented %s spaces #when parsed #then later prose is outside code", (spaces: number) => {
+		const { blocks, problems } = parseMarkdown(`\`\`\`\ncode\n${" ".repeat(spaces)}\`\`\`\nclaim 34`)
+		expect(blocks.map((block: { kind: string }) => block.kind)).toEqual(["code", "paragraph"])
+		expect(problems).toEqual([])
+	})
+})

package/dist/skills/ulw-research/scripts/md-lite.mjs

@@ -113,7 +113,7 @@ export function parseMarkdown(text) {
 			const codeStart = Math.min(line.next, source.length)
 			let close = lines.length
 			for (let k = i + 1; k < lines.length; k++) {
-				const candidate = lines[k].raw.trim()
+				const candidate = lines[k].raw.replace(/^ {0,3}/, "").trimEnd()
 				if (candidate.startsWith(open[0].repeat(open.length)) && /^(`+|~+)$/.test(candidate)) {
 					close = k
 					break

package/dist/skills/ulw-research/scripts/number-grammar.mjs

@@ -0,0 +1,33 @@
+// number-grammar.mjs - the one grouped-number grammar. A grouped number is a 1-3 digit leading
+// group, then one or more 3-digit groups joined by ONE separator type, with no digit right after the
+// last group, then an optional decimal part. "12,3451" is therefore not "12,345" plus "1". A period
+// groups only when the reading is unambiguous: two or more period groups ("1.234.567") or one group
+// before a decimal comma ("1.234,5"); a lone "1.234" is a decimal, as numerals.mjs reads it. Shared by
+// numerals.mjs (comma grouping), the conversion probe (every separator), the value-mode unit check,
+// and the converted-half display check. Pure; no imports.
+
+/** Separators a thousands group may use: comma, period, space, NBSP, narrow NBSP, thin space, figure space. */
+export const GROUP_SEPARATORS = Object.freeze([",", ".", " ", "\u00A0", "\u202F", "\u2009", "\u2007"])
+
+const literal = (sep) => (sep === "." ? "\\." : sep === " " ? " " : sep === "," ? "," : `\\u${sep.charCodeAt(0).toString(16).padStart(4, "0")}`)
+const decimalAfter = (sep) => (sep === "," ? "\\." : sep === "." ? "," : "[.,]")
+
+/** Regex source of one grouped number using any of `separators` (one type per number); no flags needed. */
+export function groupedNumberSource(separators = GROUP_SEPARATORS) {
+	const one = (sep) => sep === "."
+		? "\\d{1,3}(?:(?:\\.\\d{3}(?!\\d)){2,}(?:,\\d+)?|\\.\\d{3}(?!\\d),\\d+)"
+		: `\\d{1,3}(?:${literal(sep)}\\d{3}(?!\\d))+(?:${decimalAfter(sep)}\\d+)?`
+	return `(?<!\\d)(?:${separators.map(one).join("|")})`
+}
+
+/** A grouped number or a plain one ("4.22", "12,3451" read as 12.3451), as regex source. */
+export const NUMBER_SOURCE = `(?:${groupedNumberSource()}|(?<!\\d)\\d+(?:[.,]\\d+)?)`
+
+const WHOLE = new Map(GROUP_SEPARATORS.map((sep) => [sep, new RegExp(`^${groupedNumberSource([sep])}$`)]))
+
+/** The plain decimal a number token spells: group separators dropped, a decimal comma read as a point. */
+export function plainDecimal(token) {
+	const sep = GROUP_SEPARATORS.find((candidate) => WHOLE.get(candidate).test(token))
+	const ungrouped = sep === undefined ? token : token.split(sep).join("")
+	return ungrouped.replace(",", ".")
+}

package/dist/skills/ulw-research/scripts/number-grammar.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+
+import { NUMBER_SOURCE, groupedNumberSource, plainDecimal } from "./number-grammar.mjs"
+import { parseNumeral } from "./numerals.mjs"
+
+const numbers = (text: string) => [...text.matchAll(new RegExp(NUMBER_SOURCE, "g"))].map((match) => match[0])
+
+describe("the one grouped-number grammar", () => {
+	for (const [text, expected] of [
+		["12,3451", ["12,3451"]],
+		["212,34515,678", ["212,34515", "678"]],
+		["12,345.6 and 1 234 567", ["12,345.6", "1 234 567"]],
+		["1\u2009234\u2009567", ["1\u2009234\u2009567"]],
+		["2,500 300", ["2,500", "300"]],
+		["2023 500", ["2023", "500"]],
+		["1.234,5", ["1.234,5"]],
+		["1.234.567 and 1.234", ["1.234.567", "1.234"]],
+	] as const) {
+		test(`#given ${JSON.stringify(text)} #when tokenized #then ${JSON.stringify(expected)}`, () => expect(numbers(text)).toEqual([...expected]))
+	}
+
+	test("#given grouped and plain tokens #when normalized #then group separators drop and a decimal comma reads as a point", () => {
+		expect(["12,345.6", "1 234 567", "1.234,5", "12,3451", "4.22"].map(plainDecimal)).toEqual(["12345.6", "1234567", "1234.5", "12.3451", "4.22"])
+	})
+
+	test("#given a single period group #when normalized #then it is a decimal, as parseNumeral reads it", () => {
+		expect(["1.234", "1.234.567"].map(plainDecimal)).toEqual(["1.234", "1234567"])
+		expect(parseNumeral("1.234 units")?.value).toBe("1.234")
+	})
+
+	test("#given comma grouping #when parseNumeral reads it #then only a well-formed group is one value", () => {
+		expect(new RegExp(`^${groupedNumberSource([","])}$`).test("1,237")).toBe(true)
+		expect(parseNumeral("1,237 units")?.value).toBe("1237")
+		expect(parseNumeral("12,3451 units")?.value).not.toBe("123451")
+	})
+})

package/dist/skills/ulw-research/scripts/numerals.mjs

@@ -6,9 +6,12 @@
 // English number words one to twelve, an adjacent currency symbol or unit, and an adjacent bounding
 // qualifier. No numeral is ever passed through Number(). Plain Node ESM, sibling imports only.
 
+import { groupedNumberSource } from "./number-grammar.mjs"
 import { add, fromDecimal, mul, toDecimal } from "./rational.mjs"
 import { normalizeUnit } from "./units.mjs"
 
+/** European digit grouping ("1.234.567"): two or more dot groups of three digits, never a version. */
+export const DOT_GROUPED = "\\d{1,3}(?:\\.\\d{3}){2,}"
 const MONTH = "(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\\.?"
 /** Stripped before claim detection: dates, versions, figure refs, times, bare years. */
 export const NOT_CLAIMS = [
@@ -19,7 +22,7 @@ export const NOT_CLAIMS = [
 	/(?:19|20)\d{2}\s*\uB144/g,
 	new RegExp(`\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?(?:,?\\s+\\d{4})?`, "gi"),
 	new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}(?:\\s+\\d{4})?`, "gi"),
-	/\bv\d+(?:\.\d+)*\b|\b\d+(?:\.\d+){2,}\b/gi,
+	new RegExp(`\\bv\\d+(?:\\.\\d+)*\\b|\\b(?!${DOT_GROUPED}(?![\\d,]|\\.\\d))\\d+(?:\\.\\d+){2,}\\b`, "gi"),
 	/\b(?:version|ver\.?|release)\s*\d+(?:\.\d+)*/gi,
 	/\b(?:fig(?:ure)?\.?|table|chart|section|step|phase|wave|part)\s*\d+(?:\.\d+)*/gi,
 	/(?:\uADF8\uB9BC|\uB3C4\uD45C|\uD45C|\uBC84\uC804)\s*\d+(?:\.\d+)*/g,
@@ -45,8 +48,8 @@ const BIG = new Map([["\uB9CC", 10000n], ["\uC5B5", 100000000n], ["\uC870", 1000
 /** A scale word that starts a longer word is not a scale: jogak (pieces), mankeum (as much as). */
 const KO_GROUP = /^(\s?)(?:(\uCC9C)?([\uB9CC\uC5B5\uC870])|(\uCC9C))(?![\uAC01\uD07C])/
 const KO_NEXT = new RegExp(`^\\s?(${NUM})(\uCC9C)?([\uB9CC\uC5B5\uC870])?`, "u")
-const LATIN_SCALE = /^(?:(k|K|M|bn|B)|\s(thousand|million|billion|trillion|bn))(?![\p{L}\d])/u
-const LATIN_FACTOR = { k: 1000n, K: 1000n, M: 1000000n, bn: 1000000000n, B: 1000000000n, thousand: 1000n, million: 1000000n, billion: 1000000000n, trillion: 1000000000000n }
+const LATIN_SCALE = /^(?:(k|K|M|mn|bn|B)|\s(thousand|million|billion|trillion|mn|bn))(?![\p{L}\d])/u
+const LATIN_FACTOR = { k: 1000n, K: 1000n, M: 1000000n, mn: 1000000n, bn: 1000000000n, B: 1000000000n, thousand: 1000n, million: 1000000n, billion: 1000000000n, trillion: 1000000000000n }
 const CURRENCY = "$\u20AC\u00A3\u00A5\u20A9"
 const SYMBOL_UNIT = /^\s?(%p|%|\u2030|\u00D7|\u00B0C|\u00B0F|\u2103|\u2109)/
 const LATIN_UNIT = /^\s?([A-Za-z]+)(?![\p{L}\d])/u
@@ -60,15 +63,23 @@ const RANGE_SEP = /^(?:\s?[-\u2013~]\s?|\sto\s)/
 const SIGN = "-\u2212"
 /** Bounding qualifiers: before the value (Korean and English) and right after it (Korean). */
 const QUALIFIERS_BEFORE = ["up to", "at least", "at most", "more than", "less than", "about", "approximately", "nearly", "over", "under", "\uCD5C\uB300", "\uCD5C\uC18C", "\uC57D"]
-const QUALIFIER_AFTER = /^\s?(\uC774\uC0C1|\uC774\uD558|\uBBF8\uB9CC|\uCD08\uACFC|\uB0B4\uC678|\uAE4C\uC9C0)/
+/** Korean bounding qualifiers written right after a value (isang, iha, miman, chogwa, naeoe, kkaji). */
+export const QUALIFIERS_AFTER = Object.freeze(["\uC774\uC0C1", "\uC774\uD558", "\uBBF8\uB9CC", "\uCD08\uACFC", "\uB0B4\uC678", "\uAE4C\uC9C0"])
+const QUALIFIER_AFTER = new RegExp(`^\\s?(${QUALIFIERS_AFTER.join("|")})`)
 
-/** "1,237" -> "1237"; a malformed group ("1,23") keeps only the leading plain number. */
+/** Comma grouping from the one grouped-number grammar (number-grammar.mjs). */
+const COMMA_GROUPED = new RegExp(`^${groupedNumberSource([","])}$`)
+
+/** "1,237" -> "1237"; a malformed group ("1,23", "12,3451") keeps only the leading plain number. */
 function cleanDigits(raw) {
-	if (/^\d{1,3}(?:,\d{3})+(?:\.\d+)?$/.test(raw)) return { digits: raw.replace(/,/g, ""), length: raw.length }
+	if (COMMA_GROUPED.test(raw)) return { digits: raw.replace(/,/g, ""), length: raw.length }
 	const plain = /^\d+(?:\.\d+)?/.exec(raw)[0]
 	return { digits: plain, length: plain.length }
 }
 
+/** A numeral's digits, reading a European period grouping ("1.234.567") as one integer. */
+const digitsOf = (raw) => (new RegExp(`^${DOT_GROUPED}$`).test(raw) ? { digits: raw.replace(/\./g, ""), length: raw.length } : cleanDigits(raw))
+
 /** The bare-year and four-digit-date patterns: a numeral they cover can still be a value. */
 const YEAR_SHAPED = new Set([NOT_CLAIMS[0], NOT_CLAIMS[12]])
 
@@ -95,7 +106,7 @@ function findStart(text, from, ranges) {
 	let digit = null
 	for (const match of text.slice(from).matchAll(new RegExp(NUM, "gu"))) {
 		const at = from + match.index
-		const candidate = { at, ...cleanDigits(match[0]) }
+		const candidate = { at, ...digitsOf(match[0]) }
 		const end = at + candidate.length
 		const cover = covering(at)
 		const lifted = cover.every(([s, e, yearShaped]) => yearShaped && s === at && e <= end)

package/dist/skills/ulw-research/scripts/numerals.test.ts

@@ -37,6 +37,9 @@ describe("parseNumeral", () => {
 		expect(parseNumeral("1.2k")?.value).toBe("1200")
 		expect(parseNumeral("$3M")).toMatchObject({ value: "3000000", raw: "$3M", unitRaw: "$" })
 		expect(parseNumeral("2.5bn")?.value).toBe("2500000000")
+		expect(parseNumeral("5mn users")?.value).toBe("5000000")
+		expect(parseNumeral("1.234.567 users")?.value).toBe("1234567")
+		expect(parseNumeral("build 0.30.14 shipped")).toBeNull()
 		expect(parseNumeral("$4B")?.value).toBe("4000000000")
 		expect(parseNumeral("3 million users")?.value).toBe("3000000")
 		expect(parseNumeral("5 km")).toMatchObject({ value: "5", unitRaw: "km" })