oh-my-opencode 5.0.0-beta.89 → 5.0.0-beta.90

package/dist/skills/ulw-research/scripts/format-extract.mjs

@@ -0,0 +1,229 @@
+// format-extract.mjs - read a pointed-at HTML or Markdown document and return the facts a
+// design-spec.md draft needs (render with design-spec.renderDesignSpec). Nothing is guessed:
+// a value the document does not state is left out, and the renderer writes `TODO: ask`.
+//
+// Static input only. fetchHtml downloads exactly the given URL with plain fetch; external
+// stylesheets are never followed (each is recorded as a note). A page that renders its
+// content client-side is the orchestrator's job: render it with the browser skill, save the
+// HTML, and pass the saved file. PDF input is rejected with UnsupportedFormatError.
+// Plain Node ESM, node: builtins and siblings only.
+
+import { readFileSync } from "node:fs"
+import { extname } from "node:path"
+
+import { cssFacts } from "./format-extract-css.mjs"
+import { parseHtml, proseText } from "./html-lite.mjs"
+
+export const UNSUPPORTED_MESSAGE = "unsupported: point at the HTML or Markdown source"
+export const FETCH_TIMEOUT_MS = 15_000
+
+const S_MARKER = /\[S\d+\]/
+const SOURCE_ANCHOR = /\[(?:\uCD9C\uCC98|source(?:\s*\d+)?)\]/i
+const LINEAGE_TOKEN = /\b(?:MEASURED|ASSUMED|DERIVED)\b/
+const MD_FOOTNOTE = /\[\^[^\]\s]+\]/
+const HEADING_NUMBER = /^(\d{1,3}(?:\.\d{1,3})*)\.?(?=\s|$)/
+const FENCE = /^\s{0,3}(`{3,}|~{3,})/
+const MD_HEADING = /^(#{1,6})\s+(.*?)\s*#*\s*$/
+/**
+ * @typedef {{ hex: string, count: number, roles: string[] }} ExtractColor
+ * @typedef {{
+ *   origin: string | undefined, bytes: number,
+ *   tokens: { light: Map<string, string>, dark: Map<string, string> },
+ *   fonts: { body?: string, heading?: string, mono?: string }, colors: ExtractColor[], breakpoints: number[],
+ *   headingNumbering: "double-digit" | "decimal" | "none" | "unknown",
+ *   citationStyle: "bracket-S" | "bracket-source" | "footnote" | "unknown",
+ *   lineageMode: "inline" | "section" | "unknown", figureContainers: string[],
+ *   skeleton: { level: number, text: string }[],
+ *   measure: { fontSize?: string, lineHeight?: string, maxWidth?: string }, notes: string[],
+ * }} Extract
+ */
+
+const HTML_EXTENSIONS = new Set([".html", ".htm", ".xhtml"])
+const MD_EXTENSIONS = new Set([".md", ".markdown"])
+
+export class UnsupportedFormatError extends Error {
+	constructor(detail) {
+		super(UNSUPPORTED_MESSAGE)
+		this.name = "UnsupportedFormatError"
+		this.code = "unsupported"
+		this.detail = detail
+	}
+}
+
+function rejectPdf(source, origin) {
+	if (/\.pdf$/i.test(String(origin ?? ""))) throw new UnsupportedFormatError(`pdf origin: ${origin}`)
+	if (String(source).trimStart().startsWith("%PDF-")) throw new UnsupportedFormatError("pdf bytes")
+}
+
+/** @returns {Extract} */
+function baseExtract(source, origin) {
+	return {
+		origin,
+		bytes: Buffer.byteLength(String(source), "utf8"),
+		tokens: { light: new Map(), dark: new Map() },
+		fonts: {},
+		colors: [],
+		breakpoints: [],
+		headingNumbering: "unknown",
+		citationStyle: "unknown",
+		lineageMode: "unknown",
+		figureContainers: [],
+		skeleton: [],
+		measure: {},
+		notes: [],
+	}
+}
+
+/** h2 numbers ("01", "1.2", or null) -> double-digit when every numbered h2 uses two digits. */
+function classifyNumbering(numbers) {
+	if (!numbers.length) return "unknown"
+	const numbered = numbers.filter(Boolean)
+	if (numbered.length * 2 < numbers.length) return "none"
+	return numbered.every((number) => /^\d{2}$/.test(number)) ? "double-digit" : "decimal"
+}
+
+function headingNumber(text) {
+	return HEADING_NUMBER.exec(text)?.[1] ?? null
+}
+
+function citationFacts(text, hasFootnotes, hasLineageAttribute) {
+	const style = S_MARKER.test(text) ? "bracket-S" : SOURCE_ANCHOR.test(text) ? "bracket-source" : hasFootnotes ? "footnote" : "unknown"
+	let lineage = "unknown"
+	if (hasLineageAttribute || LINEAGE_TOKEN.test(text) || S_MARKER.test(text)) lineage = "inline"
+	else if (SOURCE_ANCHOR.test(text)) lineage = "section"
+	return { style, lineage }
+}
+
+function walk(node, visit) {
+	for (const child of node.children) {
+		visit(child)
+		walk(child, visit)
+	}
+}
+
+function classesOf(node) {
+	return String(node.attrs.class ?? "").split(/\s+/).filter(Boolean)
+}
+
+/** Previous element sibling whose whole text is a heading number (a `.sec-no` style eyebrow). */
+function eyebrowNumber(heading) {
+	const siblings = heading.parent.children.filter((child) => child.tag !== "#text" || child.text.trim())
+	const previous = siblings[siblings.indexOf(heading) - 1]
+	if (!previous || previous.tag === "#text" || /^h[1-6]$/.test(previous.tag)) return null
+	const text = proseText(previous)
+	return HEADING_NUMBER.test(text) && headingNumber(text) === text.replace(/\.$/, "") ? headingNumber(text) : null
+}
+
+/** Nearest `<figure>` or fig/chart-classed ancestor of an img or svg. */
+function figureContainer(node) {
+	for (let cur = node.parent; cur && cur.tag !== "body"; cur = cur.parent) {
+		const classes = classesOf(cur)
+		if (cur.tag === "figure" || classes.some((name) => /fig|chart/i.test(name))) return cur
+	}
+	return null
+}
+
+function rankByCount(names) {
+	const counts = new Map()
+	for (const name of names) counts.set(name, (counts.get(name) ?? 0) + 1)
+	return [...counts].sort((a, b) => b[1] - a[1]).map(([name]) => name)
+}
+
+/** @returns {Extract} throws UnsupportedFormatError on PDF input. */
+export function extractFromHtml(source, { origin } = {}) {
+	rejectPdf(source, origin)
+	const extract = baseExtract(source, origin)
+	const root = parseHtml(source)
+	const styles = []
+	const headings = []
+	const containers = []
+	let hasFootnotes = false
+	let hasLineageAttribute = false
+	let scripts = 0
+	walk(root, (node) => {
+		if (node.tag === "style") styles.push(node.raw ?? "")
+		else if (node.tag === "script") scripts++
+		else if (node.tag === "link" && /(?:^|\s)stylesheet(?:\s|$)/i.test(node.attrs.rel ?? "")) {
+			extract.notes.push(`skipped external stylesheet: ${node.attrs.href ?? "(no href)"}`)
+		} else if (/^h[1-6]$/.test(node.tag)) headings.push(node)
+		else if (node.tag === "img" || node.tag === "svg") {
+			const container = figureContainer(node)
+			if (container) containers.push(...classesOf(container))
+		} else if (node.tag === "sup" && node.children.some((child) => child.tag === "a" && /^#/.test(child.attrs.href ?? ""))) hasFootnotes = true
+		else if (node.attrs?.role === "doc-noteref") hasFootnotes = true
+		if (node.attrs && Object.hasOwn(node.attrs, "data-lineage")) hasLineageAttribute = true
+	})
+	const css = styles.join("\n")
+	for (const match of css.matchAll(/@import\s+(?:url\()?\s*["']?([^"')\s;]+)/gi)) extract.notes.push(`skipped @import: ${match[1]}`)
+	if (styles.length > 1) extract.notes.push(`${styles.length} <style> blocks concatenated`)
+	if (css.trim()) Object.assign(extract, cssFacts(css))
+	if (!extract.fonts.heading && extract.fonts.body) extract.notes.push("no heading font-family rule; headings inherit the body stack")
+
+	const body = root.children.find((child) => child.tag === "html")?.children.find((child) => child.tag === "body")
+		?? root.children.find((child) => child.tag === "body")
+		?? root
+	const text = proseText(body)
+	if (scripts && text.length < 200) {
+		extract.notes.push(`little static text with ${scripts} <script> tags: if the page renders client-side, render it with the browser skill and pass the saved HTML`)
+	}
+	const citation = citationFacts(text, hasFootnotes, hasLineageAttribute)
+	extract.citationStyle = citation.style
+	extract.lineageMode = citation.lineage
+	const h2 = headings.filter((node) => node.tag === "h2")
+	extract.headingNumbering = classifyNumbering(h2.map((node) => headingNumber(proseText(node)) ?? eyebrowNumber(node)))
+	extract.skeleton = headings
+		.filter((node) => node.tag === "h1" || node.tag === "h2")
+		.map((node) => ({ level: Number(node.tag[1]), text: proseText(node) }))
+	extract.figureContainers = rankByCount(containers)
+	return extract
+}
+
+/** Markdown carries structure only: skeleton, heading numbering, citation style. @returns {Extract} */
+export function extractFromMarkdown(source, { origin } = {}) {
+	rejectPdf(source, origin)
+	const extract = baseExtract(source, origin)
+	const prose = []
+	let fence = null
+	for (const line of String(source).split(/\r?\n/)) {
+		const fenceMatch = FENCE.exec(line)
+		if (fence) {
+			if (fenceMatch && fenceMatch[1][0] === fence[0] && fenceMatch[1].length >= fence.length && line.trim() === fenceMatch[1]) fence = null
+			continue
+		}
+		if (fenceMatch) {
+			fence = fenceMatch[1]
+			continue
+		}
+		prose.push(line.replace(/`[^`]*`/g, ""))
+		const heading = MD_HEADING.exec(line)
+		if (heading && heading[1].length <= 2) extract.skeleton.push({ level: heading[1].length, text: heading[2] })
+	}
+	const text = prose.join("\n")
+	extract.citationStyle = citationFacts(text, MD_FOOTNOTE.test(text), false).style
+	extract.headingNumbering = classifyNumbering(extract.skeleton.filter((entry) => entry.level === 2).map((entry) => headingNumber(entry.text)))
+	extract.notes.push("markdown source: tokens, fonts, colors, breakpoints, figures, and measure are not carried by Markdown")
+	return extract
+}
+
+/** Dispatch on the file extension: .html/.htm/.xhtml, .md/.markdown; anything else (PDF included) is unsupported. @returns {Extract} */
+export function extractFromPath(filePath) {
+	const extension = extname(filePath).toLowerCase()
+	if (HTML_EXTENSIONS.has(extension)) return extractFromHtml(readFileSync(filePath, "utf8"), { origin: filePath })
+	if (MD_EXTENSIONS.has(extension)) return extractFromMarkdown(readFileSync(filePath, "utf8"), { origin: filePath })
+	throw new UnsupportedFormatError(`extension ${extension || "(none)"}: ${filePath}`)
+}
+
+/** GET exactly `url` (plain fetch, 15 s timeout, no browser) and return the body text. */
+export async function fetchHtml(url) {
+	if (/\.pdf$/i.test(new URL(url).pathname)) throw new UnsupportedFormatError(`pdf url: ${url}`)
+	const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) })
+	const type = response.headers.get("content-type") ?? ""
+	if (!response.ok || /pdf/i.test(type)) {
+		await response.body?.cancel()
+		if (!response.ok) throw new Error(`fetch failed: HTTP ${response.status} for ${url}`)
+		throw new UnsupportedFormatError(`pdf response: ${url}`)
+	}
+	const text = await response.text()
+	if (text.trimStart().startsWith("%PDF-")) throw new UnsupportedFormatError(`pdf bytes: ${url}`)
+	return text
+}

package/dist/skills/ulw-research/scripts/format-extract.test.ts

@@ -0,0 +1,243 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { createServer, type Server } from "node:http"
+import type { AddressInfo } from "node:net"
+import { once } from "node:events"
+import { join } from "node:path"
+
+import { DESIGN_SPEC_SECTIONS } from "./contracts.mjs"
+import { renderDesignSpec } from "./design-spec.mjs"
+import {
+	UnsupportedFormatError,
+	extractFromHtml,
+	extractFromMarkdown,
+	extractFromPath,
+	fetchHtml,
+} from "./format-extract.mjs"
+
+const FIXTURES = join(import.meta.dir, "tests", "fixtures")
+const HTML_PATH = join(FIXTURES, "reference-report.html")
+const MD_PATH = join(FIXTURES, "reference.md")
+const html = readFileSync(HTML_PATH, "utf8")
+const markdown = readFileSync(MD_PATH, "utf8")
+const UNSUPPORTED = "unsupported: point at the HTML or Markdown source"
+
+function sectionBody(spec: string, heading: string): string {
+	const start = spec.indexOf(`## ${heading}\n`)
+	const rest = spec.slice(start + heading.length + 4)
+	const next = rest.search(/^## /m)
+	return next === -1 ? rest : rest.slice(0, next)
+}
+
+function bulletLines(body: string): string[] {
+	return body.split("\n").filter((line) => line.startsWith("- "))
+}
+
+describe("extractFromHtml on the reference report", () => {
+	const extract = extractFromHtml(html, { origin: HTML_PATH })
+
+	test("#given light and dark token blocks #when extracted #then both maps carry at least 8 tokens", () => {
+		expect(extract.tokens.light.size).toBeGreaterThanOrEqual(8)
+		expect(extract.tokens.dark.size).toBeGreaterThanOrEqual(8)
+		expect(extract.tokens.light.get("--bg")).toBe("#faf6ef")
+		expect(extract.tokens.dark.get("--accent")).toBe("#f8b878")
+	})
+
+	test("#given body, heading, and code font rules #when extracted #then the three stacks resolve through var()", () => {
+		expect(extract.fonts).toEqual({
+			body: '"Inter Display", "Noto Sans KR", sans-serif',
+			heading: "Fraunces, Georgia, serif",
+			mono: '"Iosevka Term", ui-monospace, monospace',
+		})
+	})
+
+	test("#given two min-width media queries #when extracted #then breakpoints are [560, 640]", () => {
+		expect(extract.breakpoints).toEqual([560, 640])
+	})
+
+	test("#given 01-style h2 numbering and [S1] markers #when extracted #then numbering, citation, and lineage are detected", () => {
+		expect(extract.headingNumbering).toBe("double-digit")
+		expect(extract.citationStyle).toBe("bracket-S")
+		expect(extract.lineageMode).toBe("inline")
+	})
+
+	test("#given img and svg inside .fig containers #when extracted #then figureContainers contains fig", () => {
+		expect(extract.figureContainers).toContain("fig")
+	})
+
+	test("#given the fixture headings #when extracted #then the skeleton has one entry per h1 and h2", () => {
+		const count = (html.match(/<h[12][\s>]/g) ?? []).length
+		expect(extract.skeleton).toHaveLength(count)
+		expect(extract.skeleton[0]).toEqual({ level: 1, text: "How a small team ships every week" })
+		expect(extract.skeleton[1]).toEqual({ level: 2, text: "01 The release cadence" })
+	})
+
+	test("#given body size, line height, and a measure token #when extracted #then measure is resolved", () => {
+		expect(extract.measure).toEqual({ fontSize: "17px", lineHeight: "1.7", maxWidth: "720px" })
+	})
+
+	test("#given repeated hex colors #when extracted #then at most 8 colors are ranked by count with selector roles", () => {
+		expect(extract.colors.length).toBeLessThanOrEqual(8)
+		const counts = extract.colors.map((color: { count: number }) => color.count)
+		expect(counts).toEqual([...counts].sort((a, b) => b - a))
+		const accent = extract.colors.find((color: { hex: string }) => color.hex === "#c2410c")
+		expect(accent?.roles).toEqual(expect.arrayContaining(["accent", "link"]))
+		const background = extract.colors.find((color: { hex: string }) => color.hex === "#faf6ef")
+		expect(background?.roles).toContain("background")
+	})
+
+	test("#given the source #when extracted #then origin and utf-8 byte count are recorded", () => {
+		expect(extract.origin).toBe(HTML_PATH)
+		expect(extract.bytes).toBe(Buffer.byteLength(html, "utf8"))
+	})
+
+	test("#given the extract #when rendered #then the 8 design-spec sections appear in contract order", () => {
+		const spec = renderDesignSpec(extract)
+		const positions = DESIGN_SPEC_SECTIONS.map((heading: string) => spec.indexOf(`\n## ${heading}\n`))
+		expect(positions.every((at: number) => at > 0)).toBe(true)
+		expect(positions).toEqual([...positions].sort((a, b) => a - b))
+		expect(sectionBody(spec, "Tokens")).toContain("--bg: #faf6ef;")
+		expect(sectionBody(spec, "Tokens")).not.toContain("TODO: ask")
+	})
+})
+
+describe("extractFromMarkdown on the reference markdown", () => {
+	const extract = extractFromMarkdown(markdown, { origin: MD_PATH })
+
+	test("#given h1, h2, h3, and a fenced pseudo-heading #when extracted #then the skeleton keeps h1 and h2 outside fences", () => {
+		expect(extract.skeleton).toEqual([
+			{ level: 1, text: "작은 팀은 어떻게 매주 배포하는가" },
+			{ level: 2, text: "01 배포 주기" },
+			{ level: 2, text: "02 리뷰 없이 일하는 방식" },
+			{ level: 2, text: "03 출처" },
+		])
+	})
+
+	test("#given [S1] markers and 01-style headings #when extracted #then citation style and numbering are detected", () => {
+		expect(extract.citationStyle).toBe("bracket-S")
+		expect(extract.headingNumbering).toBe("double-digit")
+	})
+
+	test("#given markdown input #when rendered #then every CSS-derived line reads TODO: ask", () => {
+		const spec = renderDesignSpec(extract)
+		for (const heading of ["Tokens", "Typography", "Layout"]) {
+			const lines = bulletLines(sectionBody(spec, heading))
+			expect(lines.length).toBeGreaterThan(0)
+			for (const line of lines) expect(line).toEndWith("TODO: ask")
+		}
+		expect(sectionBody(spec, "Figures")).toContain("- Containers: TODO: ask")
+		expect(extract.tokens.light.size + extract.tokens.dark.size).toBe(0)
+	})
+})
+
+describe("unsupported inputs", () => {
+	test("#given a .pdf path #when extracted from the path #then the typed unsupported error is thrown", () => {
+		const attempt = () => extractFromPath(join(FIXTURES, "reference.pdf"))
+		expect(attempt).toThrow(UnsupportedFormatError)
+		expect(attempt).toThrow(UNSUPPORTED)
+	})
+
+	test("#given PDF bytes passed as HTML #when extracted #then the typed unsupported error is thrown", () => {
+		expect(() => extractFromHtml("%PDF-1.7\n1 0 obj", { origin: "report" })).toThrow(UnsupportedFormatError)
+	})
+
+	test("#given an html path #when extracted from the path #then it dispatches to the HTML extractor", () => {
+		const extract = extractFromPath(HTML_PATH)
+		expect(extract.origin).toBe(HTML_PATH)
+		expect(extract.breakpoints).toEqual([560, 640])
+	})
+})
+
+describe("extractFromHtml edge cases", () => {
+	test("#given only external stylesheets #when rendered #then Tokens reads TODO: ask and a note names the skipped href", () => {
+		const source = '<html><head><link rel="stylesheet" href="css/site.css"></head><body><h1>Only links</h1></body></html>'
+		const extract = extractFromHtml(source, { origin: "external.html" })
+		const spec = renderDesignSpec(extract)
+		const tokens = bulletLines(sectionBody(spec, "Tokens"))
+		expect(tokens.length).toBeGreaterThan(0)
+		for (const line of tokens) expect(line).toEndWith("TODO: ask")
+		expect(extract.notes.some((note: string) => note.includes("css/site.css"))).toBe(true)
+		expect(sectionBody(spec, "Extracted from")).toContain("css/site.css")
+	})
+
+	test("#given a numeric eyebrow sibling before each h2 #when extracted #then numbering is double-digit", () => {
+		const source = '<body><h1>T</h1><div><span class="sec-no">01</span><h2>First</h2></div><div><span class="sec-no">02</span><h2>Second</h2></div></body>'
+		expect(extractFromHtml(source, { origin: "x.html" }).headingNumbering).toBe("double-digit")
+	})
+
+	test("#given decimal, bare, and absent h2 headings #when extracted #then numbering is decimal, none, and unknown", () => {
+		const numbering = (body: string) => extractFromHtml(`<body>${body}</body>`, { origin: "x.html" }).headingNumbering
+		expect(numbering("<h2>1. Intro</h2><h2>2. Method</h2>")).toBe("decimal")
+		expect(numbering("<h2>Intro</h2><h2>Method</h2>")).toBe("none")
+		expect(numbering("<h1>Only a title</h1>")).toBe("unknown")
+	})
+
+	test("#given [출처] anchors and no lineage tokens #when extracted #then citation is bracket-source and lineage is section", () => {
+		const source = '<body><h2>A</h2><p>Fact one. <a class="src" href="https://example.org/a">[출처]</a></p><p>Fact two <a href="https://example.org/b">[Source 2]</a></p></body>'
+		const extract = extractFromHtml(source, { origin: "x.html" })
+		expect(extract.citationStyle).toBe("bracket-source")
+		expect(extract.lineageMode).toBe("section")
+	})
+
+	test("#given a MEASURED token with source anchors #when extracted #then lineage is inline", () => {
+		const source = '<body><p>Latency 42 ms MEASURED <a href="https://example.org/a">[출처]</a></p></body>'
+		expect(extractFromHtml(source, { origin: "x.html" }).lineageMode).toBe("inline")
+	})
+
+	test("#given sup footnote references #when extracted #then citation style is footnote", () => {
+		const source = '<body><p>Claim<sup><a href="#fn1">1</a></sup></p><ol><li id="fn1">Note</li></ol></body>'
+		expect(extractFromHtml(source, { origin: "x.html" }).citationStyle).toBe("footnote")
+	})
+
+	test("#given no citations, fonts, or headings #when rendered #then unknown fields read TODO: ask", () => {
+		const extract = extractFromHtml("<body><p>Plain text only.</p></body>", { origin: "x.html" })
+		expect(extract.citationStyle).toBe("unknown")
+		expect(extract.lineageMode).toBe("unknown")
+		expect(extract.fonts).toEqual({})
+		const spec = renderDesignSpec(extract)
+		expect(sectionBody(spec, "Citations")).toContain("- Style: TODO: ask")
+		expect(sectionBody(spec, "Citations")).toContain("- Lineage: TODO: ask")
+		expect(sectionBody(spec, "Typography")).toContain("- Heading font: TODO: ask")
+	})
+})
+
+describe("fetchHtml", () => {
+	let server: Server
+	let base = ""
+
+	beforeAll(async () => {
+		server = createServer((request, response) => {
+			if (request.url === "/report.html") {
+				response.writeHead(200, { "content-type": "text/html; charset=utf-8" })
+				response.end(html)
+			} else if (request.url === "/paper") {
+				response.writeHead(200, { "content-type": "application/pdf" })
+				response.end("%PDF-1.7")
+			} else {
+				response.writeHead(404, { "content-type": "text/plain" })
+				response.end("missing")
+			}
+		})
+		server.listen(0, "127.0.0.1")
+		await once(server, "listening")
+		base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`
+	})
+
+	afterAll(async () => {
+		server.close()
+		server.closeAllConnections()
+		await once(server, "close")
+	})
+
+	test("#given an html url #when fetched #then the body text is returned", async () => {
+		expect(await fetchHtml(`${base}/report.html`)).toBe(html)
+	})
+
+	test("#given a pdf response #when fetched #then the typed unsupported error is thrown", async () => {
+		await expect(fetchHtml(`${base}/paper`)).rejects.toThrow(UnsupportedFormatError)
+	})
+
+	test("#given a 404 response #when fetched #then the error names the status", async () => {
+		await expect(fetchHtml(`${base}/missing`)).rejects.toThrow("404")
+	})
+})

package/dist/skills/ulw-research/scripts/gates-figures.mjs

@@ -0,0 +1,173 @@
+// gates-figures.mjs - visual gates: G2 palette, G8 chart without figure, G9 chart svg text,
+// G10 Korean serif/brush fonts.
+//
+// Each gate is { codes, skip?(ctx), run(ctx) -> Defect[] } over the context built by
+// gates-static.mjs. Plain Node ESM, sibling imports only.
+
+import { fontFamilies, hexColors, normalizeHex, resolveVar } from "./css-lite.mjs"
+import { decodeEntities, proseText } from "./html-lite.mjs"
+
+const ALWAYS_ALLOWED = new Set(["#ffffff", "#000000"])
+const MAX_PALETTE = 20
+const SVG_PAINT = /(?:fill|stroke|stop-color|flood-color|lighting-color)\s*(?:=\s*["']?|:\s*)(#[0-9a-f]{3,8})(?![\w-])/gi
+const SVG_FONT = /font-family\s*(?:=\s*("[^"]*"|'[^']*')|:\s*([^;"'>]+))/gi
+const ICON_MAX = 32
+const CHART_MIN = 200
+const ICON_NAME = /icon|logo/i
+const ICON_HOSTS = new Set(["a", "button", "nav", "header", "footer", "h1", "h2", "h3", "h4", "h5", "h6"])
+const CAPTION_CLASS = /^(?:caption|fig-?cap(?:tion)?)$/
+const DEFAULT_FONT_SIZE = 16
+const MIN_TITLE_CHARS = 4
+const MIN_TICKS = 3
+const NUMERIC = /^[-+\u2212]?[$\u20AC\u00A3\u00A5\u20A9]?\d[\d,.:]*\s?(?:%|[a-z\uAC00-\uD7A3]{0,3})$/i
+const SERIF_FAMILY = /nanummyeongjo|applemyungjo|gungsuh|batang|nanumbrush|nanumpen|\uAD81\uC11C|\uBC14\uD0D5|\uBA85\uC870/
+
+function pixels(value) {
+	const match = /^\s*(\d+(?:\.\d+)?)\s*(?:px)?\s*$/i.exec(value ?? "")
+	return match ? Number(match[1]) : null
+}
+
+/** Largest declared dimension: width/height attributes or style, else the viewBox. */
+function declaredSize(node) {
+	const style = node.attrs.style ?? ""
+	const fromStyle = (prop) => pixels(new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i").exec(style)?.[1])
+	const sizes = [pixels(node.attrs.width), pixels(node.attrs.height), fromStyle("width"), fromStyle("height")].filter((n) => n !== null)
+	if (sizes.length) return Math.max(...sizes)
+	const box = String(node.attrs.viewbox ?? "").trim().split(/[\s,]+/).map(Number)
+	return box.length === 4 && box.every(Number.isFinite) ? Math.max(box[2], box[3]) : null
+}
+
+function isIcon(ctx, node) {
+	const size = declaredSize(node)
+	if (size !== null && size <= ICON_MAX) return true
+	if (ICON_NAME.test(`${node.attrs.class ?? ""} ${node.attrs.id ?? ""}`)) return true
+	return Boolean(ctx.util.closest(node, (cur) => ICON_HOSTS.has(cur.tag)))
+}
+
+const isFigure = (ctx) => (cur) => cur.tag === "figure" || ctx.util.classTokens(cur).includes("fig")
+
+function hasCaption(ctx, figure) {
+	return ctx.util.descendants(figure).some((node) => (node.tag === "figcaption" || ctx.util.classTokens(node).some((token) => CAPTION_CLASS.test(token))) && proseText(node).length > 0)
+}
+
+function visuals(ctx) {
+	return ctx.elements.map(({ node }) => node).filter((node) => (node.tag === "img" || node.tag === "svg") && !isIcon(ctx, node))
+}
+
+function label(node) {
+	if (node.tag === "img") {
+		const src = node.attrs.src ?? ""
+		return `<img src="${src.length > 48 ? `${src.slice(0, 48)}...` : src}">`
+	}
+	return `<svg${node.attrs.width ? ` width="${node.attrs.width}"` : ""}${node.attrs.height ? ` height="${node.attrs.height}"` : ""}>`
+}
+
+function svgTexts(raw) {
+	return [...raw.matchAll(/<text\b([^>]*)>([\s\S]*?)<\/text\s*>/gi)]
+		.map((match) => ({
+			size: Number(/font-size\s*(?:=\s*["']?|:\s*)(\d+(?:\.\d+)?)/i.exec(match[1])?.[1] ?? DEFAULT_FONT_SIZE),
+			value: decodeEntities(match[2].replace(/<[^>]*>/g, "")).replace(/\s+/g, " ").trim(),
+		}))
+		.filter((text) => text.value)
+}
+
+function missingChartLabels(raw) {
+	const texts = svgTexts(raw)
+	const title = decodeEntities(/<title\b[^>]*>([\s\S]*?)<\/title\s*>/i.exec(raw)?.[1] ?? "").trim()
+	if (!texts.length && !title) return null
+	const maxSize = Math.max(0, ...texts.map((text) => text.size))
+	const missing = []
+	if (!title && !texts.some((text) => text.size === maxSize && [...text.value].length >= MIN_TITLE_CHARS)) missing.push("title")
+	const ticks = texts.filter((text) => NUMERIC.test(text.value)).length
+	if (ticks < MIN_TICKS) missing.push(`numeric ticks (${ticks} < ${MIN_TICKS})`)
+	if (!texts.some((text) => /\p{L}/u.test(text.value) && !NUMERIC.test(text.value))) missing.push("text label")
+	return missing
+}
+
+function colorUses(ctx) {
+	const uses = new Map()
+	const add = (hex, node) => {
+		const color = normalizeHex(hex)
+		if (!color) return
+		const entry = uses.get(color) ?? { node, count: 0 }
+		entry.count++
+		uses.set(color, entry)
+	}
+	for (const { node, css } of [...ctx.styleBlocks, ...ctx.styleAttrs]) for (const hex of hexColors(css)) add(hex, node)
+	for (const node of ctx.all) {
+		if (node.tag !== "svg") continue
+		for (const key of ["fill", "stroke", "stop-color"]) if (node.attrs[key]) add(node.attrs[key], node)
+		for (const match of (node.raw ?? "").matchAll(SVG_PAINT)) add(match[1], node)
+	}
+	return uses
+}
+
+function fontDeclarations(ctx) {
+	const found = []
+	for (const { node, css } of ctx.styleBlocks) for (const { families } of fontFamilies(css)) found.push({ node, families })
+	for (const { node, css } of ctx.styleAttrs) for (const { families } of fontFamilies(`x{${resolveVar(css, ctx.tokens)}}`)) found.push({ node, families })
+	for (const node of ctx.all) {
+		if (node.tag !== "svg") continue
+		const values = [node.attrs["font-family"], ...[...(node.raw ?? "").matchAll(SVG_FONT)].map((m) => m[1] ?? m[2])].filter(Boolean)
+		for (const value of values) for (const { families } of fontFamilies(`x{font-family:${value}}`)) found.push({ node, families })
+	}
+	return found
+}
+
+export const figureGates = [
+	{
+		codes: ["palette_off_token"],
+		skip: (ctx) => ctx.palette.size === 0,
+		run(ctx) {
+			const palette = new Set([...ctx.palette].map(normalizeHex))
+			const defects = []
+			for (const [color, { node, count }] of colorUses(ctx)) {
+				if (defects.length >= MAX_PALETTE) break
+				if (palette.has(color) || ALWAYS_ALLOWED.has(color)) continue
+				defects.push(ctx.defect("palette_off_token", node, `color ${color} is not in the design-spec palette (${count} use${count === 1 ? "" : "s"})`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["chart_without_figure"],
+		run(ctx) {
+			return visuals(ctx)
+				.filter((node) => {
+					const figure = ctx.util.closest(node, isFigure(ctx))
+					return !figure || !hasCaption(ctx, figure)
+				})
+				.map((node) => ctx.defect("chart_without_figure", node, `${label(node)} has no figure container with a non-empty caption`))
+		},
+	},
+	{
+		codes: ["chart_svg_no_text", "chart_svg_missing_labels"],
+		run(ctx) {
+			const defects = []
+			for (const node of visuals(ctx)) {
+				if (node.tag !== "svg") continue
+				if (!((declaredSize(node) ?? 0) >= CHART_MIN || ctx.util.closest(node, isFigure(ctx)))) continue
+				const missing = missingChartLabels(node.raw ?? "")
+				if (missing === null) defects.push(ctx.defect("chart_svg_no_text", node, `${label(node)} chart has no <text> and no <title>`))
+				else if (missing.length) defects.push(ctx.defect("chart_svg_missing_labels", node, `${label(node)} chart is missing: ${missing.join(", ")}`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["korean_serif_font"],
+		run(ctx) {
+			const defects = []
+			const seen = new Set()
+			for (const { node, families } of fontDeclarations(ctx)) {
+				for (const family of families) {
+					const key = family.toLowerCase().replace(/[\s"'_-]/g, "")
+					if (!SERIF_FAMILY.test(key) || seen.has(key)) continue
+					seen.add(key)
+					defects.push(ctx.defect("korean_serif_font", node, `serif or brush Korean font family "${family}"`))
+				}
+			}
+			return defects
+		},
+	},
+]