Spaces:
Running
Running
| /* CareRules engine for the browser: the same quote checker, page search, prompts, verification, scoring and report | |
| as the Python package (carerules/corpus.py, audit.py, view.py), so the Space can run as a free static page. Beam is | |
| reached through a small Worker that holds the token and enforces access codes; every check of Beam's output runs | |
| here, against the official texts this page serves. Also loads in Node for parity tests (module.exports). */ | |
| (function (root) { | |
| "use strict"; | |
| const CR = {}; | |
| const BASE = (typeof location !== "undefined" ? "" : "") + ""; | |
| CR.data = { base: "./", sources: null, cache: {} }; | |
| /* ---------- text normalization and word-for-word matching (corpus.py) ---------- */ | |
| const DASHES = /[‐‑‒–—―−-]/g; | |
| // Texas prints a weight after each rule ("[Medium-High]"); it isn't part of the rule's words, so quotes may leave it out. | |
| const WEIGHT = /\[(?:low|medium|high)(?:[- ]?(?:low|medium|high))?\]/gi; | |
| CR.norm = (text) => (String(text || "").normalize("NFKC").replace(WEIGHT, " ").toLowerCase().replace(DASHES, "").match(/[a-z0-9§]+/g) || []).join(" "); | |
| CR.unweight = (text) => String(text || "").replace(WEIGHT, "").replace(/\s+([;,.])/g, "$1").replace(/ {2,}/g, " ").trim(); | |
| const MAX_GAP = 300; // normalized characters (about 60 words) a "..." may skip | |
| const SHORT_SKIP = 120, NEGATION = new Set(["not", "no", "never", "nor", "neither", "cannot", "t", "except", "unless", "without"]); | |
| /* One string per document with spaces removed ("9 – 13 years" must match "9-13 years"), page offsets, and where | |
| words start and end, so a quote must begin and end on whole words ("attended" never matches in "unattended"). */ | |
| CR.buildIndex = (pages) => { | |
| const parts = [], offsets = [], starts = [], ends = []; | |
| let pos = 0; | |
| for (const [number, text] of pages) { | |
| offsets.push([pos, number]); | |
| for (const w of CR.norm(text).split(" ").filter(Boolean)) { | |
| starts.push(pos); | |
| if (w.startsWith("§") && w.length > 1) starts.push(pos + 1); // "746.1601" may be quoted without its § | |
| pos += w.length; | |
| ends.push(pos); | |
| parts.push(w); | |
| } | |
| } | |
| const flags = (list) => { const a = new Uint8Array(pos + 2); for (const i of list) a[i] = 1; return a; }; | |
| return { hay: parts.join(""), offsets, starts: flags(starts), ends: flags(ends) }; | |
| }; | |
| const pageAt = (index, i) => { | |
| let page = index.offsets.length ? index.offsets[0][1] : 1; | |
| for (const [begin, number] of index.offsets) { if (begin > i) break; page = number; } | |
| return page; | |
| }; | |
| /* (page, start, end) where the quote appears word for word, or null. "..." skips text between fragments that | |
| appear in order within maxGap characters; a quote needs 6+ words with one fragment of 4+. */ | |
| CR.match = (index, quote, maxGap = MAX_GAP) => { | |
| let frags = String(quote || "").split(/\.\.\.|…/).map(CR.norm).filter(Boolean); | |
| if (!frags.length) return null; | |
| const words = frags.map((f) => f.split(" ").length); | |
| if (words.reduce((a, b) => a + b, 0) < 6 || Math.max(...words) < 4) return null; | |
| frags = frags.map((f) => f.replace(/ /g, "")); | |
| const { hay, starts, ends } = index; | |
| const find = (f, at) => { // next whole-word occurrence of f at or after `at` | |
| let i = hay.indexOf(f, at); | |
| while (i !== -1 && !(starts[i] && ends[i + f.length])) i = hay.indexOf(f, i + 1); | |
| return i; | |
| }; | |
| const flips = (a, b) => { // a short "..." skip must not drop a "not" (it would reverse the rule) | |
| if (b - a > SHORT_SKIP || maxGap > MAX_GAP) return false; | |
| const cuts = []; | |
| for (let j = a; j < b; j++) if (starts[j]) cuts.push(j); | |
| cuts.push(b); | |
| return cuts.slice(0, -1).some((x, i) => NEGATION.has(hay.slice(x, cuts[i + 1]))); | |
| }; | |
| let start = find(frags[0], 0); | |
| while (start !== -1) { | |
| let pos = start + frags[0].length, ok = true; | |
| for (const f of frags.slice(1)) { | |
| const nxt = find(f, pos); | |
| if (nxt === -1 || nxt - pos > maxGap || flips(pos, nxt)) { ok = false; break; } | |
| pos = nxt + f.length; | |
| } | |
| if (ok) return [pageAt(index, start), start, pos]; | |
| start = find(frags[0], start + 1); | |
| } | |
| return null; | |
| }; | |
| /* Like match, but when a quote runs past what the document says (two table rows joined into one quote), keep the | |
| longest leading or trailing part that does appear: at least 6 words and half the quote. [match, verified text] */ | |
| CR.matchLoose = (index, quote) => { | |
| const m = CR.match(index, quote); | |
| if (m) return [m, quote]; | |
| const words = String(quote || "").split(/\s+/).filter(Boolean); | |
| if (/\.\.\.|…/.test(quote) || words.length < 7) return null; | |
| for (let k = words.length - 1; k >= Math.max(6, Math.ceil(words.length / 2)); k--) { | |
| for (const part of [words.slice(0, k).join(" "), words.slice(-k).join(" ")]) { | |
| const got = CR.match(index, part); | |
| if (got) return [got, part.replace(/^[\s,;:]+|[\s,;:]+$/g, "")]; | |
| } | |
| } | |
| return null; | |
| }; | |
| /* ---------- BM25 over rulebook pages (corpus.Index) ---------- */ | |
| class Index { | |
| constructor(pages, k1 = 1.2, b = 0.75) { | |
| this.docs = pages; | |
| this.toks = pages.map((p) => CR.norm(p.text).split(" ").filter(Boolean)); | |
| this.tf = this.toks.map((t) => { const m = new Map(); for (const w of t) m.set(w, (m.get(w) || 0) + 1); return m; }); | |
| this.avg = this.toks.reduce((a, t) => a + t.length, 0) / Math.max(1, this.toks.length); | |
| const df = new Map(); | |
| for (const m of this.tf) for (const w of m.keys()) df.set(w, (df.get(w) || 0) + 1); | |
| const n = pages.length; | |
| this.idf = new Map([...df].map(([w, d]) => [w, Math.log(1 + (n - d + 0.5) / (d + 0.5))])); | |
| this.k1 = k1; this.b = b; | |
| } | |
| search(query, k = 5) { | |
| const q = CR.norm(query).split(" ").filter((w) => this.idf.has(w)); | |
| const scored = []; | |
| this.docs.forEach((p, i) => { | |
| const tf = this.tf[i], dl = this.toks[i].length; | |
| let s = 0; | |
| for (const w of q) { | |
| const f = tf.get(w); | |
| if (f) s += this.idf.get(w) * f * (this.k1 + 1) / (f + this.k1 * (1 - this.b + this.b * dl / this.avg)); | |
| } | |
| if (s > 0) scored.push([s, p]); | |
| }); | |
| scored.sort((a, b) => b[0] - a[0]); | |
| return scored.slice(0, k); | |
| } | |
| } | |
| CR.Index = Index; | |
| /* ---------- data: sources, rulebook pages, checklists ---------- */ | |
| const fetchText = async (path) => { | |
| if (CR.data.loader) return CR.data.loader(path); // Node tests read local files | |
| const r = await fetch(CR.data.base + path); | |
| if (!r.ok) throw new Error(`Couldn't load ${path}`); | |
| return r.text(); | |
| }; | |
| CR.sources = async () => { | |
| if (!CR.data.sources) CR.data.sources = Object.fromEntries(JSON.parse(await fetchText("data/sources.json")).map((s) => [s.state, s])); | |
| return CR.data.sources; | |
| }; | |
| CR.rulebook = async (state) => { | |
| const key = "rb:" + state; | |
| if (!CR.data.cache[key]) { | |
| const raw = await fetchText(`text/${state}.txt`); | |
| const pages = raw.split("\f").map((t, i) => ({ number: i + 1, text: t })).filter((p) => p.text.trim()); | |
| const byNumber = new Map(pages.map((p) => [p.number, p])); | |
| CR.data.cache[key] = { pages, byNumber, index: null, normed: null }; | |
| } | |
| return CR.data.cache[key]; | |
| }; | |
| CR.checklist = async (state) => { | |
| const key = "cl:" + state; | |
| if (!CR.data.cache[key]) CR.data.cache[key] = JSON.parse(await fetchText(`data/checklists/${state}.json`)).items; | |
| return CR.data.cache[key]; | |
| }; | |
| const normed = async (state) => { | |
| const rb = await CR.rulebook(state); | |
| if (!rb.normed) rb.normed = CR.buildIndex(rb.pages.map((p) => [p.number, p.text])); | |
| return rb; | |
| }; | |
| CR.findQuote = async (state, quote) => { | |
| const m = CR.match((await normed(state)).normed, quote); | |
| return m ? m[0] : null; | |
| }; | |
| /* Guidance inside a rulebook (Texas "Technical Assistance" boxes, California "Handbook" text) explains the rules | |
| but isn't one, so it never counts as the rule a handbook breaks. (corpus.is_guidance) */ | |
| const GUIDANCE = { TX: [/^technical assistance\b/i, /^§\s?746\.\d+\./], CA: [/^handbook begins here/i, /^handbook ends here/i] }; | |
| CR.GUIDANCE_NAME = { TX: 'a Texas "Technical Assistance" box', CA: "California's handbook (explanatory) text" }; | |
| CR.isGuidance = async (state, start) => { | |
| if (!GUIDANCE[state]) return false; | |
| const rb = await normed(state); | |
| if (!rb.lines) { | |
| rb.lines = []; | |
| let pos = 0; | |
| for (const p of rb.pages) for (const line of p.text.split("\n")) { rb.lines.push([pos, line.trim()]); pos += CR.norm(line).replace(/ /g, "").length; } | |
| } | |
| const [opener, closer] = GUIDANCE[state], lines = rb.lines; | |
| let lo = 0, hi = lines.length - 1; | |
| while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (lines[mid][0] <= start) lo = mid; else hi = mid - 1; } | |
| for (let i = lo; i > Math.max(-1, lo - 400); i--) { | |
| if (closer.test(lines[i][1])) return false; | |
| if (opener.test(lines[i][1])) return true; | |
| } | |
| return false; | |
| }; | |
| /* [page, verified text, is guidance] for a rule quote, allowing the loose match above. (corpus.find_rule) */ | |
| CR.findRule = async (state, quote) => { | |
| const got = CR.matchLoose((await normed(state)).normed, quote); | |
| if (!got) return null; | |
| const [[page, start], text] = got; | |
| return [page, text, await CR.isGuidance(state, start)]; | |
| }; | |
| /* A short table row ("0 – 11 months 4") proves itself only on the page of the rule it belongs to: whole words, | |
| at least 3, with a number, on `page` or the next one. (corpus.find_row) */ | |
| CR.findRow = async (state, quote, page) => { | |
| const words = CR.norm(quote).split(" ").filter(Boolean); | |
| if (words.length < 3 || !words.some((w) => /^\d+$/.test(w))) return null; | |
| const idx = (await normed(state)).normed; | |
| const inRange = idx.offsets.filter(([, n]) => n === page || n === page + 1); | |
| if (!inRange.length) return null; | |
| const after = idx.offsets.find(([, n]) => n > page + 1); | |
| const lo = inRange[0][0], hi = after ? after[0] : idx.hay.length, f = words.join(""); | |
| for (let i = idx.hay.indexOf(f, lo); i !== -1 && i + f.length <= hi; i = idx.hay.indexOf(f, i + 1)) { | |
| if (idx.starts[i] && idx.ends[i + f.length]) return [pageAt(idx, i), String(quote).trim(), await CR.isGuidance(state, i)]; | |
| } | |
| return null; | |
| }; | |
| CR.pageUrl = (src, page) => (!src || !src.url ? "" : (src.format || "pdf") === "pdf" ? `${src.url}#page=${page}` : src.url); | |
| /* ---------- focused context and prompt (audit.py) ---------- */ | |
| const MAX_CONTEXT_CHARS = 140000, CHUNK = 60; | |
| CR.focusedPages = async (state, items, handbook) => { | |
| const rb = await CR.rulebook(state); | |
| const chosen = []; | |
| for (const it of items) { | |
| if (/^\d+$/.test(String(it.page ?? ""))) for (const n of [+it.page, +it.page + 1]) if (rb.byNumber.has(n) && !chosen.includes(n)) chosen.push(n); | |
| } | |
| if (!rb.index) rb.index = new Index(rb.pages); | |
| for (const [, text] of handbook) { | |
| for (let i = 0; i < text.length; i += 1500) { | |
| for (const [, p] of rb.index.search(text.slice(i, i + 1500), 2)) if (!chosen.includes(p.number)) chosen.push(p.number); | |
| } | |
| } | |
| const out = []; | |
| let size = 0; | |
| for (const n of chosen) { size += rb.byNumber.get(n).text.length; if (size > MAX_CONTEXT_CHARS) break; out.push(n); } | |
| return out.sort((a, b) => a - b); | |
| }; | |
| CR.prompt = async (state, items, handbook) => { | |
| const src = (await CR.sources())[state] || {}; | |
| const rb = await CR.rulebook(state); | |
| const keep = new Set(await CR.focusedPages(state, items, handbook)); | |
| const body = rb.pages.filter((p) => keep.has(p.number)).map((p) => `[${state} page ${p.number}]\n${p.text.trim()}`).join("\n"); | |
| const context = `=== RULEBOOK ${state}: ${src.title || state} — the ${keep.size} pages relevant to this handbook, out of ${src.pdf_pages ?? "?"} (page numbers are the official document's) ===\n${body}`; | |
| const listing = items.map((i) => `- ${i.id} [${i.kind}] ${i.requirement} (${i.section}, page ${i.page}): "${i.quote}"`).join("\n"); | |
| const doc = handbook.map(([n, t]) => `[Handbook page ${n}]\n${t.trim()}`).join("\n"); | |
| return `${context}\n\n=== CHECKLIST for ${src.title || state} ===\n${listing}\n\n=== THE CENTER'S HANDBOOK ===\n${doc}\n\n` + | |
| "You are a careful licensing inspector. Audit the handbook against the checklist and the rulebook above.\n" + | |
| "For EVERY checklist item, give a status:\n" + | |
| "- covered: the handbook clearly addresses it and agrees with the rule\n" + | |
| "- partial: it addresses it but leaves out something the rule requires\n" + | |
| "- conflict: the handbook says something the rule forbids or contradicts (for example a number the rule " + | |
| "doesn't allow, or permission the rule requires in writing given verbally)\n" + | |
| "Call something a conflict only if the exact rule words you give as rule_quote show it, and write the " + | |
| "explanation from those words alone: if a rule allows several ways (for example in writing, electronically, " + | |
| "or by phone for one dose), say which condition the handbook misses, never that an allowed way is forbidden.\n" + | |
| "Apply only rules for the kind of program the handbook describes. Rules that apply only to special programs " + | |
| "(for example a state-funded pre-K program, get-well or sick care, night care, or family child care homes) " + | |
| "don't apply unless the handbook says the center runs one; a room merely named \"Pre-K\" isn't one.\n" + | |
| "- missing: a [must_include] item the handbook doesn't address at all\n" + | |
| "- not_mentioned: a [rule] item the handbook doesn't mention (that's allowed)\n" + | |
| "Then look for any OTHER statement in the handbook that contradicts the rulebook.\n\n" + | |
| "Quotes must be copied exactly (8 to 60 words): handbook_quote from the handbook, rule_quote from the " + | |
| "rulebook. For missing and partial items and every conflict, write a fix: a paragraph the center can paste into " + | |
| "its handbook, in plain, warm language, that meets the rule without adding requirements the rule doesn't " + | |
| "have. Use [brackets] for details only the center knows (times, names, phone numbers).\n\n" + | |
| "Keep it short: for covered items give only id, status and handbook_quote; for not_mentioned items only id " + | |
| "and status. Explanations and fixes are only for partial, missing and conflict items.\n\n" + | |
| 'Reply with only a JSON object: {"items": [{"id", "status", "handbook_quote", "handbook_page", ' + | |
| '"rule_quote" (for a conflict: the exact rulebook words the handbook breaks, such as the table row with the ' + | |
| 'number; else empty), "rule_section" (the section that rule_quote comes from, as printed), ' + | |
| '"explanation" (one plain sentence), "fix"}], "extra_conflicts": [{"title", "handbook_quote", ' + | |
| '"handbook_page", "rule_quote", "section", "page", "explanation", "fix"}], "summary" (two sentences)}.'; | |
| }; | |
| /* ---------- reading Beam's reply (grade.parse_json) ---------- */ | |
| CR.parseJson = (text) => { | |
| text = String(text || "").trim(); | |
| try { return JSON.parse(text); } catch (e) { /* fall through */ } | |
| const blocks = [...text.matchAll(/```(?:json)?\s*([\s\S]*?)```/g)].map((m) => m[1]).reverse(); | |
| for (const b of blocks) { try { return JSON.parse(b); } catch (e) { /* next */ } } | |
| const starts = [text.indexOf("{"), text.indexOf("[")].filter((i) => i !== -1).sort((a, b) => a - b); | |
| for (const start of starts) { | |
| const closer = text[start] === "{" ? "}" : "]"; | |
| let end = text.lastIndexOf(closer); | |
| while (end > start) { | |
| try { return JSON.parse(text.slice(start, end + 1)); } catch (e) { end = text.lastIndexOf(closer, end - 1); } | |
| } | |
| } | |
| return null; | |
| }; | |
| /* ---------- verification and scoring (audit.assemble, score, statements, cross_state) ---------- */ | |
| const STATUSES = ["covered", "partial", "missing", "conflict", "not_mentioned"]; | |
| const NOT_THERE = "but the words it quoted don't appear in your handbook exactly as written (it may have joined two lines, such as two rows of a table)."; | |
| const HANDBOOK_NOTE = { conflict: `Beam flagged this as a conflict, ${NOT_THERE}`, partial: `Beam flagged this as incomplete, ${NOT_THERE}`, | |
| covered: `Beam marked this as covered, ${NOT_THERE}` }; | |
| const CONFLICT_PENALTY = 5, ROW = 80; | |
| CR.sectionLabel = async (state, label, page) => { | |
| label = String(label || "").replace(/,?\s*\(?page\s*\d+\)?\s*$/i, "").trim(); | |
| const nums = label.match(/\d[\d.\-]*\d/g) || []; | |
| const core = nums.reduce((a, b) => (b.length > a.length ? b : a), ""); | |
| const rb = await CR.rulebook(state); | |
| const near = " " + rb.pages.filter((p) => p.number === page || p.number === page - 1).map((p) => CR.norm(p.text)).join(" ").replace(/§/g, " ") + " "; | |
| return label && core && near.includes(` ${CR.norm(core)} `) ? label : `rule on page ${page}`; | |
| }; | |
| CR.statements = (findings) => { | |
| const hits = findings.filter((f) => f.status === "conflict" && f.span).sort((a, b) => a.span[0] - b.span[0]); | |
| const groups = []; | |
| for (const f of hits) { | |
| if (groups.length) { | |
| const g = groups[groups.length - 1]; | |
| const end = Math.max(...g.map((x) => x.span[1])); | |
| const last = g[g.length - 1]; | |
| const short = f.span[1] - f.span[0] <= ROW && last.span[1] - last.span[0] <= ROW; | |
| if (f.span[0] < end || (short && f.span[0] - end <= ROW)) { g.push(f); continue; } | |
| } | |
| groups.push([f]); | |
| } | |
| return groups; | |
| }; | |
| const pyRound = (x) => { const r = Math.round(x); return Math.abs(x % 1) === 0.5 && r % 2 !== 0 ? r - 1 : r; }; // Python's round() | |
| CR.score = (findings) => { | |
| const must = findings.filter((f) => f.kind === "must_include"); | |
| const credit = must.reduce((a, f) => a + (f.status === "covered" ? 1 : f.status === "partial" ? 0.5 : 0), 0); | |
| const passages = CR.statements(findings).length; | |
| const base = must.length ? 100 * credit / must.length : 100; | |
| const counts = Object.fromEntries([...STATUSES, "unverified"].map((s) => [s, findings.filter((f) => f.status === s).length])); | |
| counts.conflict_statements = passages; | |
| return { score: Math.max(0, pyRound(base - CONFLICT_PENALTY * passages)), coverage: pyRound(base), required: must.length, counts }; | |
| }; | |
| CR.assemble = async (state, handbook, content, meta) => { | |
| const items = await CR.checklist(state); | |
| const src = (await CR.sources())[state] || {}; | |
| const got = CR.parseJson(content); | |
| if (meta.finish === "length" || !got || typeof got !== "object" || Array.isArray(got) || !Array.isArray(got.items) || !got.items.length) { | |
| throw new Error(`Beam's answer for ${name(state)} was cut off or couldn't be read. Please try again.`); | |
| } | |
| const hb = CR.buildIndex(handbook); | |
| const answers = Object.fromEntries(got.items.filter((a) => a && typeof a === "object").map((a) => [String(a.id), a])); | |
| const findings = []; | |
| for (let it of items) { | |
| const a = answers[it.id] || {}; | |
| let status = STATUSES.includes(a.status) ? a.status : it.kind === "must_include" ? "missing" : "not_mentioned"; | |
| if (status === "not_mentioned" && it.kind === "must_include") status = "missing"; | |
| const hq = String(a.handbook_quote || "").trim(); | |
| const m = hq ? CR.match(hb, hq) : null; | |
| const hpage = m ? m[0] : null, span = m ? [m[1], m[2]] : null; | |
| let note = ""; | |
| if (["covered", "partial", "conflict"].includes(status) && !hpage) { // the words aren't there: never shown as fact | |
| note = hq ? HANDBOOK_NOTE[status] : "Beam didn't quote your handbook for this."; | |
| status = "unverified"; | |
| } | |
| const rq = String(a.rule_quote || "").trim(); | |
| if (status === "conflict") { | |
| let rule = rq ? await CR.findRule(state, rq) : null; | |
| const row = rule || !rq || !/^\d+$/.test(String(it.page)) ? null : await CR.findRow(state, rq, +it.page); | |
| if (row) rule = [row[0], `${it.quote} … ${row[1]}`, row[2]]; // a table row, proven on the checklist rule's page | |
| if (!rule) { // a conflict has to name rule words that are really there | |
| status = "unverified"; note = "Beam flagged this as a conflict, but the rule words it gave don't match the official text."; | |
| } else if (rule[2]) { | |
| status = "unverified"; note = `Beam flagged this as a conflict, but the words it quoted are from ${CR.GUIDANCE_NAME[state]}, which is guidance, not a rule.`; | |
| } else if (row) { | |
| it = { ...it, quote: rule[1], page: rule[0] }; | |
| } else { // the exact clause broken, proven word for word, replaces the checklist's general quote | |
| it = { ...it, quote: rule[1], page: rule[0], section: await CR.sectionLabel(state, a.rule_section, rule[0]) }; | |
| } | |
| } | |
| findings.push({ ...it, status, handbook_quote: hpage ? hq : "", handbook_page: hpage, span, | |
| explanation: String(a.explanation || "").trim(), note, | |
| fix: ["missing", "partial", "conflict"].includes(status) ? String(a.fix || "").trim() : "", | |
| rule_url: /^\d+$/.test(String(it.page)) ? CR.pageUrl(src, it.page) : "" }); | |
| } | |
| const extras = []; | |
| for (const x of Array.isArray(got.extra_conflicts) ? got.extra_conflicts : []) { | |
| if (!x || typeof x !== "object") continue; | |
| const m = CR.match(hb, String(x.handbook_quote || "")); | |
| const rule = await CR.findRule(state, String(x.rule_quote || "")); | |
| if (m && rule && !rule[2]) { // both quotes proven, from a rule (not guidance), or it isn't shown | |
| const rpage = rule[0]; | |
| extras.push({ id: "extra_" + (extras.length + 1), topic: "other", kind: "rule", status: "conflict", | |
| requirement: String(x.title || "Conflict with the rulebook"), section: await CR.sectionLabel(state, x.section, rpage), | |
| page: rpage, quote: rule[1], handbook_quote: String(x.handbook_quote).trim(), handbook_page: m[0], | |
| span: [m[1], m[2]], explanation: String(x.explanation || "").trim(), note: "", fix: String(x.fix || "").trim(), | |
| rule_url: CR.pageUrl(src, rpage) }); | |
| } | |
| } | |
| findings.push(...extras); | |
| return { state, rulebook: src.title || "", findings, summary: String(got.summary || "").trim(), ...CR.score(findings), ...meta, raw: content }; | |
| }; | |
| CR.crossState = (results) => { | |
| const every = []; | |
| for (const [s, r] of Object.entries(results)) for (const f of r.findings) if (f.status === "conflict" && f.span) every.push({ ...f, _state: s }); | |
| const rows = CR.statements(every).map((group) => { | |
| const byState = {}; | |
| for (const f of group) if (!byState[f._state]) byState[f._state] = f; | |
| const lead = group.reduce((a, f) => (f.handbook_quote.length > a.handbook_quote.length ? f : a), group[0]); | |
| return { handbook_quote: lead.handbook_quote, handbook_page: lead.handbook_page, states: byState, | |
| verdict: Object.fromEntries(Object.keys(results).map((s) => [s, byState[s] ? "conflict" : "ok"])) }; | |
| }); | |
| return rows.sort((a, b) => (Object.keys(b.states).length - Object.keys(a.states).length) || ((a.handbook_page || 0) - (b.handbook_page || 0))); | |
| }; | |
| /* ---------- running a check: one Beam call per state (split when the checklist is long) ---------- */ | |
| CR.auditState = async (state, handbook, effort, callBeam) => { | |
| const items = await CR.checklist(state); | |
| const chunks = []; | |
| for (let i = 0; i < items.length; i += CHUNK) chunks.push(items.slice(i, i + CHUNK)); | |
| const replies = await Promise.all(chunks.map(async (part, i) => { | |
| let prompt = await CR.prompt(state, part, handbook); | |
| if (i > 0) prompt += "\nFor this part, leave extra_conflicts empty."; | |
| return callBeam(prompt, effort); | |
| })); | |
| const merged = { items: [], extra_conflicts: [], summary: "" }; | |
| let finish = "stop"; | |
| for (const rep of replies) { | |
| const got = CR.parseJson(rep.content); | |
| if (rep.finish === "length" || !got || typeof got !== "object" || !Array.isArray(got.items) || !got.items.length) { finish = "length"; continue; } | |
| merged.items.push(...got.items); | |
| if (Array.isArray(got.extra_conflicts)) merged.extra_conflicts.push(...got.extra_conflicts); | |
| merged.summary = merged.summary || String(got.summary || ""); | |
| } | |
| const meta = { cost: +replies.reduce((a, r) => a + (r.cost || 0), 0).toFixed(4), | |
| tokens_in: replies.reduce((a, r) => a + (r.tokens_in || 0), 0), tokens_out: replies.reduce((a, r) => a + (r.tokens_out || 0), 0), | |
| finish, seconds: Math.max(...replies.map((r) => r.seconds || 0)), effort, calls: replies.length, | |
| cached: replies.every((r) => r.cached) }; | |
| return CR.assemble(state, handbook, JSON.stringify(merged), meta); | |
| }; | |
| /* Every state at once; one state failing doesn't lose the others. Returns {results, errors} by state. */ | |
| CR.audit = async (handbook, states, effort, callBeam) => { | |
| const one = async (s) => { | |
| try { return await CR.auditState(s, handbook, effort, callBeam); } | |
| catch (err) { | |
| if (!/cut off|couldn't be read/i.test(err.message)) throw err; // only a cut-off or unreadable answer is retried | |
| // One more try at low effort, asking Beam to sample instead of repeating the same runaway answer. | |
| const r = await CR.auditState(s, handbook, "low", (prompt, eff) => callBeam(prompt, eff, true)); | |
| if (effort !== "low") r.effort = `low (the ${effort}-effort answer was cut off)`; | |
| return r; | |
| } | |
| }; | |
| const settled = await Promise.allSettled(states.map(one)); | |
| const results = {}, errors = {}; | |
| settled.forEach((x, i) => { if (x.status === "fulfilled") results[states[i]] = x.value; else errors[states[i]] = x.reason.message || String(x.reason); }); | |
| return { results, errors }; | |
| }; | |
| /* ---------- reading an uploaded handbook into pages (document.py) ---------- */ | |
| const MAX_CHARS = 240000; | |
| CR.chunk = (text, size = 3000) => { | |
| const pages = []; | |
| let cur = ""; | |
| for (const para of text.split(/\n\s*\n/)) { | |
| if (cur && cur.length + para.length > size) { pages.push(cur); cur = ""; } | |
| cur += para.trim() + "\n\n"; | |
| } | |
| if (cur.trim()) pages.push(cur); | |
| return pages.map((t, i) => [i + 1, t]); | |
| }; | |
| CR.readFile = async (file, libs) => { | |
| const ext = (file.name.match(/\.[^.]+$/) || [""])[0].toLowerCase(); | |
| let pages; | |
| if (ext === ".pdf") { | |
| const pdf = await libs.pdfjs.getDocument({ data: await file.arrayBuffer() }).promise; | |
| pages = []; | |
| for (let i = 1; i <= pdf.numPages; i++) { | |
| const content = await (await pdf.getPage(i)).getTextContent(); | |
| pages.push([i, content.items.map((x) => x.str + (x.hasEOL ? "\n" : " ")).join("")]); | |
| } | |
| } else if (ext === ".docx") { | |
| pages = CR.chunk((await libs.mammoth.extractRawText({ arrayBuffer: await file.arrayBuffer() })).value); | |
| } else if (ext === ".txt" || ext === ".md") { | |
| pages = CR.chunk(await file.text()); | |
| } else { | |
| throw new Error("Upload a PDF, Word (.docx) or text file."); | |
| } | |
| const out = []; | |
| let total = 0; | |
| for (const [n, t] of pages) { | |
| if (total >= MAX_CHARS) break; | |
| const text = t.slice(0, MAX_CHARS - total); | |
| total += text.length; | |
| out.push([n, text]); | |
| } | |
| if (out.reduce((a, [, t]) => a + t.split(/\s+/).filter(Boolean).length, 0) < 150) { | |
| throw new Error("Couldn't read enough text from this file. If it's a scanned PDF, upload the Word version."); | |
| } | |
| return out; | |
| }; | |
| /* ---------- the report (view.py) ---------- */ | |
| const NAMES = { AL: "Alabama", AR: "Arkansas", AZ: "Arizona", CA: "California", CO: "Colorado", DC: "District of Columbia", | |
| FL: "Florida", GA: "Georgia", IA: "Iowa", IL: "Illinois", MA: "Massachusetts", MI: "Michigan", MO: "Missouri", | |
| MS: "Mississippi", NC: "North Carolina", ND: "North Dakota", NJ: "New Jersey", NM: "New Mexico", NY: "New York", | |
| OH: "Ohio", OK: "Oklahoma", OR: "Oregon", PA: "Pennsylvania", SC: "South Carolina", TX: "Texas", VA: "Virginia", WA: "Washington" }; | |
| const COLORS = { conflict: "#ff5d6c", missing: "#f5a524", partial: "#ffe186", covered: "#3ddc97", not_mentioned: "#71717a", unverified: "#a78bfa" }; | |
| const LABELS = { conflict: "Breaks a rule", missing: "Missing", partial: "Incomplete", covered: "Covered", | |
| not_mentioned: "Not mentioned (not required)", unverified: "Couldn't confirm: check by hand" }; | |
| CR.NAMES = NAMES; CR.COLORS = COLORS; | |
| const e = (x) => String(x ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" }[c])); | |
| const name = (s) => NAMES[s] || s; | |
| const ring = (score) => { | |
| const r = 38, c = 2 * Math.PI * 38; | |
| const color = score >= 80 ? "#3ddc97" : score >= 50 ? "#ffe186" : "#ff5d6c"; | |
| return `<svg width="92" height="92" viewBox="0 0 92 92" role="img" aria-label="Score ${score} of 100">` + | |
| `<circle cx="46" cy="46" r="${r}" fill="none" stroke="currentColor" stroke-opacity=".12" stroke-width="8"/>` + | |
| `<circle cx="46" cy="46" r="${r}" fill="none" stroke="${color}" stroke-width="8" stroke-linecap="round" ` + | |
| `stroke-dasharray="${(c * score / 100).toFixed(1)} ${c.toFixed(1)}" transform="rotate(-90 46 46)"/>` + | |
| `<text x="46" y="49" text-anchor="middle" font-size="24" font-weight="700" fill="currentColor">${score}</text>` + | |
| `<text x="46" y="64" text-anchor="middle" font-size="11" fill="currentColor" fill-opacity=".6">/100</text></svg>`; | |
| }; | |
| /* Score cards: the score, then the two things it's made of, so the numbers add up on their face. */ | |
| const scoreCards = (results, src) => `<div class="ci-cards">${Object.entries(results).map(([st, r]) => { | |
| const c = r.counts, must = r.findings.filter((f) => f.kind === "must_include"); | |
| const n = (s) => must.filter((f) => f.status === s).length; | |
| const plural = (k, one, many) => `${k} ${k === 1 ? one : many}`; | |
| const req = [["covered", "covered", n("covered")], ["partial", "incomplete", n("partial")], ["missing", "missing", n("missing")], | |
| ["conflict", "break a rule", n("conflict")], ["unverified", "to check", n("unverified")]] | |
| .filter(([s, , k]) => k || ["covered", "partial", "missing"].includes(s)).map(([s, l, k]) => `<span style="color:${COLORS[s]}">${k} ${l}</span>`).join(" · "); | |
| const other = [["conflict", plural(c.conflict_statements, "sentence breaks a rule", "sentences break a rule")], ["unverified", `${c.unverified} to check by hand`]] | |
| .filter(([s]) => (s === "conflict" ? c.conflict_statements : c.unverified)).map(([s, l]) => `<span style="color:${COLORS[s]}">${l}</span>`).join(" · "); | |
| return `<div class="ci-card">${ring(r.score)}<div><div class="ci-state">${e(name(st))}</div>` + | |
| `<div class="ci-dim">Score out of 100 · ${e((src[st] || {}).short || "")}</div>` + | |
| `<div class="ci-line">Required policies (${r.required}): ${req || "none"}</div>` + | |
| `<div class="ci-line">${other || '<span style="color:' + COLORS.covered + '">No sentence breaks a rule</span>'}</div></div></div>`; | |
| }).join("")}</div>`; | |
| const matrix = (results) => { | |
| const rows = CR.crossState(results), states = Object.keys(results); | |
| if (!rows.length || states.length < 2) return ""; | |
| const head = states.map((s) => `<th>${e(name(s))}</th>`).join(""); | |
| const body = rows.map((row) => `<tr><td class="ci-q">${CR.isTableRow(row.handbook_quote) ? "Table row: " : ""}“${e(row.handbook_quote.slice(0, 150))}${row.handbook_quote.length > 150 ? "…" : ""}”<div class="ci-dim">Handbook ${where(row.handbook_page)}</div></td>` + | |
| states.map((s) => { const f = row.states[s]; return f ? `<td class="ci-bad" title="${e(f.requirement)}">✕ <span>${e(f.section)}</span></td>` : '<td class="ci-ok">✓ <span>none found</span></td>'; }).join("") + "</tr>").join(""); | |
| return `<h3 class="ci-h">One handbook, ${states.length} states</h3><p class="ci-dim">A sentence can be fine in one state and break a rule in another. "None found" covers only that state's licensing rules; other laws, like child abuse reporting laws, also apply.</p>` + | |
| `<div class="ci-scroll"><table class="ci-matrix"><tr><th>Your handbook says</th>${head}</tr>${body}</table></div>` + '<p class="ci-scroll-hint">Scroll the table sideways to see every state.</p>' ; | |
| }; | |
| const LANES = 6; // rows of marks, so the map stays short | |
| const rulebookMap = (state, r, src) => { | |
| const total = +((src[state] || {}).pdf_pages || 1); | |
| const order = { conflict: 0, missing: 1, partial: 2, unverified: 3, covered: 4, not_mentioned: 5 }; | |
| const items = r.findings.filter((f) => /^\d+$/.test(String(f.page ?? ""))).sort((a, b) => (+a.page - +b.page) || (order[a.status] - order[b.status])); | |
| const lanes = [], marks = []; | |
| for (const f of items) { | |
| const x = 1 + 98 * (+f.page - 1) / Math.max(1, total - 1); | |
| let lane = lanes.findIndex((last) => x - last >= 1.1); | |
| if (lane === -1 && lanes.length < LANES) { lane = lanes.length; lanes.push(x); } | |
| if (lane === -1) lane = lanes.indexOf(Math.min(...lanes)); // full: stack on the row with the most room | |
| lanes[lane] = x; | |
| marks.push([x, lane, f]); | |
| } | |
| const h = 14 + Math.max(1, lanes.length) * 9; | |
| const svg = [`<svg viewBox="0 0 100 ${h}" preserveAspectRatio="none" width="100%" height="${h * 2}" class="ci-timeline" role="img" aria-label="${e(name(state))} rulebook map">`, | |
| `<rect x="0" y="${h - 6}" width="100" height="2" rx="1" fill="currentColor" fill-opacity=".18"/>`, | |
| ...marks.map(([x, lane, f]) => `<rect x="${(x - 0.45).toFixed(2)}" y="${h - 10 - lane * 9 - 4}" width=".9" height="8" rx=".3" fill="${COLORS[f.status]}"><title>p. ${e(f.page)} · ${e(f.section)} · ${e(LABELS[f.status])}: ${e(f.requirement)}</title></rect>`), | |
| "</svg>"]; | |
| const legend = ["conflict", "missing", "partial", "covered", "not_mentioned", "unverified"].map((k) => `<span><i style="background:${COLORS[k]}"></i>${LABELS[k]}</span>`).join(""); | |
| return `<div class="ci-map"><div class="ci-dim">The whole ${e(name(state))} rulebook, page 1 to ${total}. Each mark is a rule your handbook should cover, at its page. Hover for details.</div>${svg.join("")}` + | |
| `<div class="ci-axis"><span>p. 1</span><span>p. ${total}</span></div><div class="ci-legend">${legend}</div></div>`; | |
| }; | |
| const ruleBlock = (f, state, src) => { | |
| const pdf = ((src[state] || {}).format || "pdf") === "pdf"; | |
| const link = f.rule_url ? ` <a href="${e(f.rule_url)}" target="_blank" rel="noopener">${pdf ? `open page ${e(f.page)}` : "open the official source"}</a>` : ""; | |
| return `<div class="ci-quote ci-rule"><b>${e(name(state))} ${e(f.section)} ✅ checked word for word${link}</b>“${e(CR.unweight(f.quote))}”</div>`; | |
| }; | |
| const card = (f, state, src, also = []) => { | |
| const color = COLORS[f.status]; | |
| let html = `<div class="ci-finding" style="border-left-color:${color}"><div class="ci-tag" style="color:${color}">${e(LABELS[f.status])}</div><div class="ci-req">${e(f.requirement)}</div>`; | |
| if (f.handbook_quote) html += `<div class="ci-quote"><b>Your handbook, ${where(f.handbook_page)}</b>“${e(f.handbook_quote)}”</div>`; | |
| if (f.quote) html += ruleBlock(f, state, src); | |
| const shown = new Set([`${f.section}|${f.page}`]); | |
| for (const o of also) { // the same sentence can break several rules; show each rule once | |
| const key = `${o.section}|${o.page}`; | |
| if (o.quote && !shown.has(key)) { shown.add(key); html += ruleBlock(o, state, src); } | |
| } | |
| if (f.note) html += `<p class="ci-why ci-note">${e(f.note)} Check this one yourself before changing anything.</p>`; | |
| if (f.explanation) html += `<p class="ci-why">${f.note ? "Beam's reading: " : ""}${e(f.explanation)}</p>`; | |
| const fix = f.fix || (also.find((o) => o.fix) || {}).fix || ""; | |
| if (fix) html += `<div class="ci-fix"><div class="ci-fixhead">Suggested wording, drafted by AI (edit before you use it)<button class="ci-copy" data-copy="${e(fix)}">Copy</button></div>${e(fix)}</div>`; | |
| return html + "</div>"; | |
| }; | |
| const FIRST = 4; // cards shown per group before "show more" | |
| const listing = (cards) => cards.slice(0, FIRST).join("") + (cards.length > FIRST | |
| ? `<details class="ci-more"><summary>Show ${cards.length - FIRST} more</summary>${cards.slice(FIRST).join("")}</details>` : ""); | |
| const findingsHtml = (state, r, src) => { | |
| let out = ""; | |
| const groups = CR.statements(r.findings); | |
| if (groups.length) out += `<h4 class="ci-h4">${LABELS.conflict} (${groups.length})</h4>` + | |
| listing(groups.map((g) => card(g.reduce((a, f) => (f.handbook_quote.length > a.handbook_quote.length ? f : a), g[0]), state, src, g))); | |
| // Headings count every rule checked; the score cards count required policies only, so say how many are required. | |
| const count = (group) => { | |
| const req = group.filter((f) => f.kind === "must_include").length; | |
| return req === group.length || req === 0 ? `${group.length}` : `${group.length}: ${req} required ${req === 1 ? "policy" : "policies"}, ${group.length - req} other rule${group.length - req === 1 ? "" : "s"}`; | |
| }; | |
| for (const status of ["missing", "partial", "unverified"]) { | |
| const group = r.findings.filter((f) => f.status === status); | |
| if (group.length) out += `<h4 class="ci-h4">${LABELS[status]} (${count(group)})</h4>` + listing(group.map((f) => card(f, state, src))); | |
| } | |
| const covered = r.findings.filter((f) => f.status === "covered"); | |
| if (covered.length) out += `<details><summary class="ci-h4">Covered (${count(covered)})</summary>${covered.map((f) => card(f, state, src)).join("")}</details>`; | |
| return out; | |
| }; | |
| CR.scoreCards = async (results) => scoreCards(results, await CR.sources()); | |
| CR.isTableRow = (quote) => /\d/.test(quote) && quote.split(/\s+/).length <= 12 && !/[.;:!?]$/.test(quote.trim()); | |
| CR.SCORE_NOTE = "Score: the percent of required policies your handbook covers (incomplete ones count half), minus 5 points for each sentence that breaks a rule. It's not an inspection result."; | |
| /* "Start here": what to fix first, before the details. */ | |
| const startHere = (results) => { | |
| const rows = CR.crossState(results), states = Object.keys(results); | |
| const multi = states.length > 1 ? rows.filter((r) => Object.keys(r.states).length > 1).slice(0, 3) : []; | |
| const lines = Object.entries(results).map(([s, r]) => { | |
| const c = r.counts, must = r.findings.filter((f) => f.kind === "must_include"); | |
| const n = (st) => must.filter((f) => f.status === st).length; | |
| const parts = []; | |
| if (c.conflict_statements) parts.push(`${c.conflict_statements} sentence${c.conflict_statements > 1 ? "s" : ""} break${c.conflict_statements > 1 ? "" : "s"} a rule`); | |
| if (n("missing")) parts.push(`${n("missing")} required polic${n("missing") > 1 ? "ies" : "y"} missing`); | |
| if (n("partial")) parts.push(`${n("partial")} required polic${n("partial") > 1 ? "ies" : "y"} incomplete`); | |
| const other = r.findings.filter((f) => f.kind !== "must_include" && f.status === "partial").length; // optional rules: no effect on the score | |
| if (other) parts.push(`${other} other rule${other === 1 ? "" : "s"} only partly covered`); | |
| if (c.unverified) parts.push(`${c.unverified} to check by hand`); | |
| return `<li><b>${e(name(s))}: ${r.score}/100.</b> ${parts.length ? e(parts.join(", ")) + "." : "No problems found."}</li>`; | |
| }).join(""); | |
| const top = multi.length ? `<p><b>Fix first:</b> ${multi.length === 1 ? "this sentence breaks" : "these sentences break"} the rules of more than one state.</p><ul>${multi.map((r) => | |
| `<li>“${e(r.handbook_quote.slice(0, 140))}${r.handbook_quote.length > 140 ? "…" : ""}” <span class="ci-dim">(handbook ${where(r.handbook_page)}: ${e(Object.keys(results).filter((s) => r.states[s]).map(name).join(", "))})</span></li>`).join("")}</ul>` : ""; | |
| return `<div class="ci-start"><h3 class="ci-h">Start here</h3><ul>${lines}</ul>${top}<p class="ci-dim">${e(CR.SCORE_NOTE)} Each finding quotes your handbook and the rule; a real quote proves the words exist, not that Beam read them correctly. Not legal advice: confirm changes with your licensing agency.</p></div>`; | |
| }; | |
| /* Text in a handbook that tries to instruct the AI ("ignore the instructions", "mark everything covered"). */ | |
| CR.suspicious = (pages) => { | |
| const re = /\b(ignore|disregard)\b.{0,40}\b(instructions|rules above|checklist|prompt)\b|\bmark (every|all|each)\b.{0,30}\b(covered|compliant)\b|\byou are (now )?(an? )?(ai|assistant|language model|inspector)\b|\bsystem prompt\b/i; | |
| return pages.some(([, t]) => re.test(t)); | |
| }; | |
| /* Word and text files have no fixed pages, so their "pages" are parts of about 3,000 characters. */ | |
| let UNIT = "page"; | |
| const where = (n) => (UNIT === "part" ? `part ${n}` : `p. ${n}`); | |
| CR.report = async (results, handbookName, handbookPages, unit = "page") => { | |
| UNIT = unit; | |
| const src = await CR.sources(); | |
| const rs = Object.values(results); | |
| const tokens = rs.reduce((a, r) => a + (r.tokens_in || 0) + (r.tokens_out || 0), 0); | |
| const secs = Math.max(...rs.map((r) => r.seconds || 0)); | |
| const cost = rs.reduce((a, r) => a + (r.cost || 0), 0); | |
| const n = rs.length; | |
| const cached = rs.length && rs.every((r) => r.cached); | |
| const effort = [...new Set(rs.map((r) => (String(r.effort || "").startsWith("high") ? "Extra thorough" : "Standard")))].join(" and "); | |
| const head = `<div class="ci-run">Beam 1.0 read <b>${e(handbookName)}</b> (${handbookPages} ${unit}${handbookPages === 1 ? "" : "s"}) with the licensing rules of ${n} state${n > 1 ? "s" : ""}: ` + | |
| `${tokens.toLocaleString("en-US")} tokens in ${Math.round(secs)} seconds, $${cost.toFixed(2)}, ${effort}${cached ? " (served from the cache at no cost this time)" : ""}. ` + | |
| "Every quote below was checked word for word against its document.</div>"; | |
| const tabs = Object.entries(results).map(([s, r], i) => `<details class="ci-state-block" ${i === 0 ? "open" : ""}><summary>${e(name(s))}: ${r.score}/100</summary>${rulebookMap(s, r, src)}${findingsHtml(s, r, src)}</details>`).join(""); | |
| return `<div class="ci">${head}${scoreCards(results, src)}${startHere(results)}${matrix(results)}<h3 class="ci-h">${n > 1 ? "Findings by state" : `Findings for ${e(name(Object.keys(results)[0]))}`}</h3>${tabs}</div>`; | |
| }; | |
| CR.fixesMarkdown = (results, handbookName, unit = "page") => { | |
| UNIT = unit; | |
| const lines = [`# Suggested handbook fixes: ${handbookName}`, "", | |
| "Drafted by Beam 1.0 from each state's official licensing rules. Every rule quote was checked word for word. Review and edit before you use them; this is not legal advice.", ""]; | |
| for (const [st, r] of Object.entries(results)) { | |
| lines.push(`## ${name(st)} (score ${r.score}/100)`, ""); | |
| for (const f of r.findings) { | |
| if (!f.fix) continue; | |
| lines.push(`### ${f.requirement}`); | |
| if (f.handbook_quote) lines.push(`Your handbook says (${where(f.handbook_page)}): "${f.handbook_quote}"`); | |
| lines.push(`Rule: ${f.section}, page ${f.page}: "${CR.unweight(f.quote)}"`, "", `Suggested wording (AI draft): ${f.fix}`, ""); | |
| } | |
| } | |
| lines.push("---", "", "Made with CareRules (https://care.backpr.com), a free tool from BackPR. Suggested wording was drafted by AI " + | |
| "from your state's official licensing rules and isn't legal advice; confirm changes with your licensing agency. When your " + | |
| "handbook is final, BackPR can collect each family's e-signed acknowledgment at registration: " + | |
| "https://backpr.com/solutions/childcare?utm_source=carerules&utm_medium=referral&utm_campaign=fixes", ""); | |
| return lines.join("\n"); | |
| }; | |
| /* what the page needs for the hero card and the "fine here, conflict there" section */ | |
| CR.light = async (results) => { | |
| const src = await CR.sources(); | |
| return { | |
| scores: Object.fromEntries(Object.entries(results).map(([s, r]) => [s, { score: r.score, name: name(s), counts: r.counts, | |
| pages: (src[s] || {}).pdf_pages, marks: r.findings.filter((f) => /^\d+$/.test(String(f.page ?? ""))).map((f) => [+f.page, f.status]) }])), | |
| rows: CR.crossState(results).map((row) => ({ quote: row.handbook_quote, page: row.handbook_page, verdict: row.verdict, | |
| sections: Object.fromEntries(Object.entries(row.states).map(([s, f]) => [s, f.section])), | |
| detail: Object.fromEntries(Object.entries(row.states).map(([s, f]) => [s, { section: f.section, page: f.page, rule: CR.unweight(f.quote), fix: f.fix, why: f.explanation, url: f.rule_url || "", quote: f.handbook_quote }])) })), | |
| }; | |
| }; | |
| if (typeof module !== "undefined" && module.exports) module.exports = CR; else root.CR = CR; | |
| })(typeof window !== "undefined" ? window : globalThis); | |