@opacedev/astro-ai-content-checker 0.3.1

package/node_modules/@opacedev/ai-content-checker-core/dist/patterns/en-signals-v4.js

@@ -0,0 +1,388 @@
+import { ABSTRACT_CLAIM_RE, ABSTRACT_PUNCH_RE, CONCRETE_ACTION_VERB_RE, CONTRAST_VARIANT_RES, MIC_DROP_CONTRAST_RE, REGISTER_FUNCTION_WORDS, REGISTER_LONG_WORD_LEN, V4_THRESHOLDS, } from "./en-signals-v4-data.js";
+import { REFERENCE_CORPUS } from "./en-signals-v4-corpus.js";
+import { NOT_JUST_CONTRAST } from "./en-signals-v2-data.js";
+import { NEG_PARALLELISM_RE } from "./en-signals-v3-data.js";
+const T = V4_THRESHOLDS;
+function countWords(text) {
+    return (text.match(/\S+/g) ?? []).length;
+}
+function countMatches(re, text) {
+    const g = new RegExp(re.source, re.flags.includes("g") ? re.flags : re.flags + "g");
+    let n = 0;
+    while (g.exec(text) !== null) {
+        n += 1;
+        if (g.lastIndex === 0)
+            break;
+    }
+    return n;
+}
+/** Terminator-preserving sentence split inside one paragraph (same split the
+ * v3 staccato rule uses, so the two layers agree on sentence boundaries). */
+function paragraphSentences(paraText) {
+    return paraText.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+/** Digit / currency / percent token — the concrete-specific marker. */
+const NUMERIC_RE = /[£$€]?\d|\d%/;
+/** Capitalised word after a lowercase word — proper-noun-mid-sentence proxy. */
+const MID_CAP_RE = /(?<=[a-z][,;]?\s)[A-Z][a-z]{2,}/;
+function isAbstractShort(sentence) {
+    if (NUMERIC_RE.test(sentence))
+        return false;
+    if (MID_CAP_RE.test(sentence))
+        return false;
+    return ABSTRACT_PUNCH_RE.test(sentence);
+}
+// ─── Sentence-length spectral flatness (windowed DFT) ────────────────
+// The empiricist's slFlat signal with the plan's length-artefact correction:
+// flatness is computed on fixed 12-sentence windows only, then averaged, so
+// series length never enters the statistic and short texts are exempt.
+export function spectralFlatness(sentenceWordCounts) {
+    const W = T.spectralWindowSentences;
+    const windows = Math.floor(sentenceWordCounts.length / W);
+    if (windows < T.spectralMinWindows)
+        return null;
+    const EPS = 1e-9;
+    let sum = 0;
+    for (let w = 0; w < windows; w += 1) {
+        const seg = sentenceWordCounts.slice(w * W, (w + 1) * W);
+        const mean = seg.reduce((a, b) => a + b, 0) / W;
+        const x = seg.map((v) => v - mean);
+        let logSum = 0;
+        let linSum = 0;
+        const bins = Math.floor(W / 2);
+        for (let k = 1; k <= bins; k += 1) {
+            let re = 0;
+            let im = 0;
+            for (let n = 0; n < W; n += 1) {
+                const ang = (2 * Math.PI * k * n) / W;
+                re += x[n] * Math.cos(ang);
+                im -= x[n] * Math.sin(ang);
+            }
+            const p = re * re + im * im + EPS;
+            logSum += Math.log(p);
+            linSum += p;
+        }
+        const flat = Math.exp(logSum / bins) / (linSum / bins);
+        sum += flat;
+    }
+    return sum / windows;
+}
+// ─── Conditional-compression estimator ───────────────────────────────
+// Deterministic LZ77 bit-cost estimate: greedy longest match (min 4, max 258
+// chars) against a hash-chain index over [dictionary + already-scanned
+// target]; literals cost 9 bits, a match costs 13 + log2(distance) bits —
+// a deflate-shaped model, not deflate itself (see module header).
+const HASH_SPAN = 4;
+function hashAt(s, i) {
+    return (((s.charCodeAt(i) * 131 + s.charCodeAt(i + 1)) * 131 + s.charCodeAt(i + 2)) * 131 +
+        s.charCodeAt(i + 3)) >>> 0;
+}
+const MAX_CHAIN = 32;
+const MAX_MATCH = 258;
+function indexInto(index, s, from, to) {
+    for (let i = from; i <= to - HASH_SPAN; i += 1) {
+        const h = hashAt(s, i);
+        let chain = index.get(h);
+        if (!chain) {
+            chain = [];
+            index.set(h, chain);
+        }
+        chain.push(i);
+        if (chain.length > MAX_CHAIN * 2)
+            chain.splice(0, chain.length - MAX_CHAIN);
+    }
+}
+/** Cached hash-chain index of the shipped reference corpus (built once). */
+let corpusIndex = null;
+function getCorpusIndex() {
+    if (corpusIndex === null) {
+        corpusIndex = new Map();
+        indexInto(corpusIndex, REFERENCE_CORPUS, 0, REFERENCE_CORPUS.length);
+    }
+    return corpusIndex;
+}
+/**
+ * Estimated LZ77 cost in bits of `target`, optionally conditioned on the
+ * shipped reference corpus as a pre-loaded dictionary.
+ */
+export function lzCostBits(target, withCorpusPrior) {
+    const dict = withCorpusPrior ? REFERENCE_CORPUS : "";
+    const combined = withCorpusPrior ? dict + target : target;
+    const base = dict.length;
+    // Self-referential chains for the target region, built as we scan.
+    const selfIndex = new Map();
+    const dictIndex = withCorpusPrior ? getCorpusIndex() : null;
+    let bits = 0;
+    let i = base;
+    while (i < combined.length) {
+        let bestLen = 0;
+        let bestDist = 0;
+        if (i + HASH_SPAN <= combined.length) {
+            const h = hashAt(combined, i);
+            const tryChain = (chain, offset) => {
+                if (!chain)
+                    return;
+                const start = Math.max(0, chain.length - MAX_CHAIN);
+                for (let c = chain.length - 1; c >= start; c -= 1) {
+                    const j = chain[c] + offset;
+                    if (j >= i)
+                        continue;
+                    let len = 0;
+                    const maxLen = Math.min(MAX_MATCH, combined.length - i);
+                    while (len < maxLen && combined.charCodeAt(j + len) === combined.charCodeAt(i + len))
+                        len += 1;
+                    if (len > bestLen) {
+                        bestLen = len;
+                        bestDist = i - j;
+                    }
+                }
+            };
+            tryChain(selfIndex.get(h), base);
+            if (dictIndex)
+                tryChain(dictIndex.get(h), 0);
+        }
+        if (bestLen >= HASH_SPAN) {
+            bits += 13 + Math.log2(bestDist);
+            // Index the covered positions (sampled every 2 to bound cost).
+            for (let k = i; k < i + bestLen && k + HASH_SPAN <= combined.length; k += 2) {
+                const h2 = hashAt(combined, k);
+                let chain = selfIndex.get(h2);
+                if (!chain) {
+                    chain = [];
+                    selfIndex.set(h2, chain);
+                }
+                chain.push(k - base);
+                if (chain.length > MAX_CHAIN * 2)
+                    chain.splice(0, chain.length - MAX_CHAIN);
+            }
+            i += bestLen;
+        }
+        else {
+            bits += 9;
+            if (i + HASH_SPAN <= combined.length) {
+                const h2 = hashAt(combined, i);
+                let chain = selfIndex.get(h2);
+                if (!chain) {
+                    chain = [];
+                    selfIndex.set(h2, chain);
+                }
+                chain.push(i - base);
+                if (chain.length > MAX_CHAIN * 2)
+                    chain.splice(0, chain.length - MAX_CHAIN);
+            }
+            i += 1;
+        }
+    }
+    return bits;
+}
+/** Relative compression gain from the human-corpus prior (0 = no gain). */
+export function compressionGain(text) {
+    const solo = lzCostBits(text, false);
+    if (solo <= 0)
+        return 0;
+    const cond = lzCostBits(text, true);
+    return 1 - cond / solo;
+}
+export function registerProfile(text) {
+    const tokens = text.toLowerCase().match(/[a-z][a-z'’-]*/g) ?? [];
+    const counts = new Map();
+    let long = 0;
+    for (const t of tokens) {
+        counts.set(t, (counts.get(t) ?? 0) + 1);
+        if (t.length >= REGISTER_LONG_WORD_LEN)
+            long += 1;
+    }
+    const n = Math.max(1, tokens.length);
+    return {
+        func: REGISTER_FUNCTION_WORDS.map((w) => (counts.get(w) ?? 0) / n),
+        longWordShare: long / n,
+        tokenCount: tokens.length,
+    };
+}
+let refProfile = null;
+export function referenceRegisterProfile() {
+    if (refProfile === null)
+        refProfile = registerProfile(REFERENCE_CORPUS);
+    return refProfile;
+}
+export function registerDistance(text) {
+    const p = registerProfile(text);
+    const r = referenceRegisterProfile();
+    let l1 = 0;
+    for (let i = 0; i < p.func.length; i += 1)
+        l1 += Math.abs(p.func[i] - r.func[i]);
+    return { funcL1: l1, longWordDelta: p.longWordShare - r.longWordShare };
+}
+function collectMetrics(doc) {
+    const { text, wordCount, paragraphs } = doc;
+    // Sentence series for the spectral estimator: terminator-split across the
+    // whole document (paragraph splits preserved via per-paragraph splitting).
+    const allSentences = [];
+    for (const p of paragraphs)
+        allSentences.push(...paragraphSentences(p.text));
+    const counts = allSentences.map(countWords).filter((c) => c > 0);
+    const flat = spectralFlatness(counts);
+    const gain = wordCount >= T.compressionMinWords && wordCount <= T.compressionMaxWords
+        ? compressionGain(text)
+        : null;
+    const reg = registerDistance(text);
+    // Punchline fragments.
+    let punchCount = 0;
+    let punchFinal = 0;
+    for (const p of paragraphs) {
+        const sents = paragraphSentences(p.text);
+        for (let i = 0; i < sents.length; i += 1) {
+            const s = sents[i];
+            const wc = countWords(s);
+            if (wc > 0 && wc <= 8 && /[.!?]$/.test(s) && isAbstractShort(s)) {
+                punchCount += 1;
+                if (i === sents.length - 1)
+                    punchFinal += 1;
+            }
+        }
+    }
+    const punchRate = allSentences.length > 0 ? punchCount / allSentences.length : 0;
+    // Mic-drop paragraphs.
+    let micDrops = 0;
+    for (const p of paragraphs) {
+        const sents = paragraphSentences(p.text);
+        if (sents.length < 4)
+            continue;
+        const closer = sents[sents.length - 1];
+        const closerWc = countWords(closer);
+        const setupWcs = sents.slice(0, -1).map(countWords).filter((c) => c >= 12);
+        if (setupWcs.length < 3)
+            continue;
+        const setupMean = setupWcs.reduce((a, b) => a + b, 0) / setupWcs.length;
+        if (closerWc > 0 && closerWc <= 8 && closerWc <= 0.45 * setupMean &&
+            !NUMERIC_RE.test(closer) && !MID_CAP_RE.test(closer) &&
+            MIC_DROP_CONTRAST_RE.test(closer)) {
+            micDrops += 1;
+        }
+    }
+    // Contrast constructions (rate layer over the existing detections).
+    let contrastCount = 0;
+    for (const re of NOT_JUST_CONTRAST)
+        contrastCount += countMatches(re, text);
+    contrastCount += countMatches(NEG_PARALLELISM_RE, text);
+    for (const re of CONTRAST_VARIANT_RES)
+        contrastCount += countMatches(re, text);
+    const contrastPer1000 = wordCount > 0 ? contrastCount / (wordCount / 1000) : 0;
+    // Rhetorical vs procedural. Heuristic (documented): CONCRETE = the sentence
+    // contains a number/currency/percent token, a mid-sentence capitalised word
+    // (proper-noun proxy) or a specific action verb; ABSTRACT = not concrete
+    // AND (linking-verb + intangible pay-off word, or a ≤8-word declarative).
+    let abstract = 0;
+    let concrete = 0;
+    for (const s of allSentences) {
+        const isConcrete = NUMERIC_RE.test(s) || MID_CAP_RE.test(s) || CONCRETE_ACTION_VERB_RE.test(s);
+        if (isConcrete) {
+            concrete += 1;
+        }
+        else if (ABSTRACT_CLAIM_RE.test(s) || countWords(s) <= 8) {
+            abstract += 1;
+        }
+    }
+    const share = allSentences.length > 0 ? abstract / allSentences.length : 0;
+    return {
+        wordCount,
+        sentenceCount: allSentences.length,
+        spectralFlatness: flat,
+        compressionGain: gain,
+        registerFuncL1: reg.funcL1,
+        registerLongWordDelta: reg.longWordDelta,
+        punchlineCount: punchCount,
+        punchlineRate: punchRate,
+        punchlineParagraphFinal: punchFinal,
+        micDropParagraphs: micDrops,
+        contrastCount,
+        contrastPer1000,
+        ratioSentences: allSentences.length,
+        ratioAbstract: abstract,
+        ratioConcrete: concrete,
+        ratioAbstractShare: share,
+    };
+}
+/**
+ * Standalone metric computation for the calibration script
+ * (tests/battery/calibrate.mjs). Mirrors exactly what collectV4Issues
+ * measures; not part of the public package API.
+ */
+export function computeV4Metrics(text) {
+    const paragraphs = [];
+    const re = /\n\s*\n/g;
+    let last = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        paragraphs.push({ text: text.slice(last, m.index), start: last });
+        last = m.index + m[0].length;
+    }
+    paragraphs.push({ text: text.slice(last), start: last });
+    return collectMetrics({
+        text,
+        wordCount: countWords(text),
+        sentences: [],
+        paragraphs: paragraphs.filter((p) => p.text.trim().length > 0),
+    });
+}
+// ─── Rule evaluation ─────────────────────────────────────────────────
+const round = (v, dp = 3) => Math.round(v * 10 ** dp) / 10 ** dp;
+export function collectV4Issues(ctx) {
+    const m = collectMetrics(ctx);
+    const { pushEx } = ctx;
+    if (m.spectralFlatness !== null && m.spectralFlatness < T.spectralFlatnessMax) {
+        pushEx("sentence-length-spectral-flatness", `window-averaged spectral flatness ${round(m.spectralFlatness)} (threshold ${T.spectralFlatnessMax})`, null, null, {
+            extra: {
+                spectral_flatness: round(m.spectralFlatness),
+                window_sentences: T.spectralWindowSentences,
+                sentence_count: m.sentenceCount,
+            },
+        });
+    }
+    if (m.compressionGain !== null && m.compressionGain < T.compressionGainMin) {
+        pushEx("conditional-compression", `human-prior compression gain ${round(m.compressionGain)} (threshold ${T.compressionGainMin})`, null, null, {
+            extra: { compression_gain: round(m.compressionGain), reference_corpus: "en-signals-v4-corpus 2026.08.5 (public-domain, pre-1929)" },
+        });
+    }
+    if (m.wordCount >= T.registerMinWords &&
+        m.registerFuncL1 > T.registerFuncL1Min &&
+        m.registerLongWordDelta > T.registerLongWordDeltaMin) {
+        pushEx("lexical-register-distance", `function-word L1 ${round(m.registerFuncL1)} + long-word share +${round(m.registerLongWordDelta)} vs human reference`, null, null, {
+            extra: {
+                function_word_l1: round(m.registerFuncL1),
+                long_word_share_delta: round(m.registerLongWordDelta),
+                genre_caveat: "specialised genres legitimately measure as distant; corroboration only",
+            },
+        });
+    }
+    if (m.punchlineCount >= T.punchlineMinCount &&
+        m.punchlineRate >= T.punchlineMinRate &&
+        m.punchlineParagraphFinal >= T.punchlineMinParagraphFinal) {
+        pushEx("punchline-fragment-density", `${m.punchlineCount} abstract punchline fragments in ${m.sentenceCount} sentences (${m.punchlineParagraphFinal} paragraph-final)`, null, null, {
+            count: m.punchlineCount,
+            extra: { punchline_rate: round(m.punchlineRate), paragraph_final: m.punchlineParagraphFinal },
+        });
+    }
+    if (m.micDropParagraphs >= T.micDropMinParagraphs) {
+        pushEx("mic-drop-paragraph", `${m.micDropParagraphs} paragraphs end in a short abstract contrast closer`, null, null, { count: m.micDropParagraphs });
+    }
+    if (m.contrastCount >= T.contrastMinCount && m.contrastPer1000 >= T.contrastMinPer1000) {
+        pushEx("contrast-density", `${m.contrastCount} contrast constructions (${round(m.contrastPer1000, 1)}/1000 words)`, null, null, {
+            count: m.contrastCount,
+            extra: { rate_per_1000_words: round(m.contrastPer1000, 1) },
+        });
+    }
+    if (m.ratioSentences >= T.ratioMinSentences &&
+        m.ratioAbstract >= T.ratioMinAbstract &&
+        m.ratioAbstractShare >= T.ratioMinShare &&
+        m.ratioConcrete <= T.ratioMaxConcrete) {
+        pushEx("rhetorical-procedural-ratio", `${m.ratioAbstract} abstract-claim vs ${m.ratioConcrete} concrete-action sentences of ${m.ratioSentences}`, null, null, {
+            count: m.ratioAbstract,
+            extra: {
+                abstract_sentences: m.ratioAbstract,
+                concrete_sentences: m.ratioConcrete,
+                abstract_share: round(m.ratioAbstractShare),
+            },
+        });
+    }
+}

package/node_modules/@opacedev/ai-content-checker-core/dist/protected/extract.d.ts

@@ -0,0 +1,17 @@
+import type { ProtectedSpan } from "@opacedev/ai-content-checker-contracts";
+type Source = {
+    content: string;
+    content_hash?: string;
+};
+type Policy = {
+    configured_terms?: Array<{
+        text: string;
+        kind?: "name" | "organisation";
+    }>;
+    user_spans?: Array<{
+        start_utf16: number;
+        end_utf16: number;
+    }>;
+};
+export declare function extractProtectedSpans(source: Source, policy?: Policy): ProtectedSpan[];
+export {};

package/node_modules/@opacedev/ai-content-checker-core/dist/protected/extract.js

@@ -0,0 +1,75 @@
+import { rangeFromUtf16 } from "../source/offsets.js";
+import { prefixedSha256 } from "../source/utf8.js";
+const RULES = [
+    ["code", /```[\s\S]*?```|`[^`\n]+`/g], ["url", /https?:\/\/[^\s<>)\]]+/g], ["email", /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi],
+    ["citation", /\[[0-9]+\]|\((?:[A-Z][A-Za-z-]+(?:\s+(?:and|&)\s+[A-Z][A-Za-z-]+)*(?:\s+et al\.)?),?\s+\d{4}[a-z]?\)|\b[A-Z][A-Za-z-]+(?:\s+(?:and|&)\s+[A-Z][A-Za-z-]+)*\s+et al\.,?\s*\(?\d{4}[a-z]?\)?/g], ["quote", /[“"][^”"\n]+[”"]/g],
+    ["currency", /(?:£|\$|€)\s?\d[\d,]*(?:\.\d+)?/g], ["date", /\b(?:\d{1,2}\s+[A-Z][a-z]+\s+\d{4}|\d{4}-\d{2}-\d{2})\b/g],
+    ["time", /\b\d{1,2}:\d{2}(?:\s?[ap]m)?\b/gi], ["unit", /\b\d+(?:\.\d+)?\s?(?:kg|g|km|m|cm|mm|GB|MB|%|°C)\b/g], ["number", /\b\d[\d,]*(?:\.\d+)?%?\b/g]
+];
+// Deterministic, precision-first entity rules. It is acceptable to miss a name; it is not acceptable to flag ordinary sentence-start words.
+const HONORIFIC_NAME = /\b(?:Dr|Mr|Mrs|Ms|Prof|Sir|Dame)\.?\s+[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}/g;
+const NAME_RUN = /\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){1,2}\b/g;
+const ORG_SUFFIXED = /\b(?:[A-Z][A-Za-z&.'-]*\s+){1,5}(?:Ltd\.?|Limited|LLC|Inc\.?|plc|GmbH|&\s?Co\.?|Agency|Council|University)(?!\w)/g;
+const ORG_ACRONYM = /\b[A-Z]{2,6}(?:\.[A-Z]{2,6})*\b/g;
+const NAME_STOPLIST = new Set("The A An This That These Those It He She They We You I In On At For To From With By Of And But Or Nor If As Is Are Was Were Be Been Not No Yes See Run New Our Your Their His Her Its My Do Does Did Will Would Can Could Should May Might Must Have Has Had So Then There Here What Which Who Whose When Where Why How All Any Each Per Both More Most Some Such Other Also Just Only Now Today Yesterday Tomorrow Please Note".split(" "));
+const ACRONYM_STOPLIST = new Set(["AM", "PM", "GMT", "UTC", "BST", "CET", "CEST", "EST", "EDT", "PST", "PDT", "EUR", "USD", "GBP", "JPY", "CHF", "AI", "IT", "TV", "OK", "PS", "NB", "ID", "IP", "FAQ", "API", "URL", "URI", "HTML", "CSS", "SQL", "PDF", "HTTP", "HTTPS", "VAT", "ASAP", "DIY", "CEO", "CTO", "CFO", "COO", "UK", "EU", "US", "USA", "RSVP", "ETA", "FYI", "QA", "DNA", "GPS", "SMS"]);
+function atSentenceStart(content, index) { const before = content.slice(0, index).replace(/[\s"“”'‘’(\[]+$/, ""); return before === "" || /[.!?:;…]$/.test(before); }
+function extractEntitySpans(content) {
+    const found = [];
+    const overlaps = (start, end) => found.some(x => start < x.start + x.text.length && x.start < end);
+    for (const m of content.matchAll(ORG_SUFFIXED)) {
+        let text = m[0], start = m.index;
+        for (;;) {
+            const lead = /^([A-Z][A-Za-z&.'-]*)\s+/.exec(text);
+            if (lead && NAME_STOPLIST.has(lead[1])) {
+                start += lead[0].length;
+                text = text.slice(lead[0].length);
+            }
+            else
+                break;
+        }
+        if (/\s/.test(text))
+            found.push({ kind: "organisation", text, start });
+    }
+    for (const m of content.matchAll(ORG_ACRONYM)) {
+        if (!ACRONYM_STOPLIST.has(m[0]) && !overlaps(m.index, m.index + m[0].length))
+            found.push({ kind: "organisation", text: m[0], start: m.index });
+    }
+    for (const m of content.matchAll(HONORIFIC_NAME)) {
+        if (!overlaps(m.index, m.index + m[0].length))
+            found.push({ kind: "name", text: m[0], start: m.index });
+    }
+    for (const m of content.matchAll(NAME_RUN)) {
+        if (atSentenceStart(content, m.index) || overlaps(m.index, m.index + m[0].length))
+            continue;
+        if (m[0].split(/\s+/).some(token => NAME_STOPLIST.has(token)))
+            continue;
+        found.push({ kind: "name", text: m[0], start: m.index });
+    }
+    return found;
+}
+export function extractProtectedSpans(source, policy = {}) {
+    const hash = source.content_hash ?? prefixedSha256(source.content);
+    const spans = [];
+    const add = (text, start, kind, origin, protection = "exact") => { const r = rangeFromUtf16(source.content, start, start + text.length); spans.push({ id: `ps_${kind}_${start}_${prefixedSha256(text).slice(7, 15)}`, kind, text, ...r, normalised_value: text, policy: protection, source: origin, confidence: null, content_hash: hash }); };
+    for (const [kind, regex] of RULES) {
+        regex.lastIndex = 0;
+        for (const m of source.content.matchAll(regex))
+            add(m[0], m.index, kind, "deterministic", kind === "date" || kind === "number" ? "equivalent_format" : "exact");
+    }
+    for (const entity of extractEntitySpans(source.content))
+        add(entity.text, entity.start, entity.kind, "deterministic");
+    for (const term of policy.configured_terms ?? []) {
+        let at = 0;
+        while ((at = source.content.indexOf(term.text, at)) >= 0) {
+            add(term.text, at, term.kind ?? "name", "user");
+            at += term.text.length;
+        }
+    }
+    for (const selected of policy.user_spans ?? [])
+        add(source.content.slice(selected.start_utf16, selected.end_utf16), selected.start_utf16, "user_selected", "user");
+    const unique = new Map();
+    for (const span of spans)
+        unique.set(`${span.start_utf16}:${span.end_utf16}:${span.kind}:${span.policy}`, span);
+    return [...unique.values()].sort((a, b) => a.start_utf16 - b.start_utf16 || (b.end_utf16 - b.start_utf16) - (a.end_utf16 - a.start_utf16) || a.id.localeCompare(b.id));
+}

package/node_modules/@opacedev/ai-content-checker-core/dist/protected/validate.d.ts

@@ -0,0 +1,3 @@
+import type { GateResult, ProtectedSpan } from "@opacedev/ai-content-checker-contracts";
+export declare function validateProtected(source: string, candidate: string, spans: ProtectedSpan[]): GateResult;
+export declare function validateAdditions(source: string, candidate: string): GateResult;

package/node_modules/@opacedev/ai-content-checker-core/dist/protected/validate.js

@@ -0,0 +1,17 @@
+export function validateProtected(source, candidate, spans) {
+    const failures = [];
+    for (const span of spans) {
+        const count = (candidate.split(span.text).length - 1);
+        if (count === 0)
+            failures.push({ protected_span_id: span.id, expected_hash: span.content_hash, observed: "missing" });
+        else if (count > source.split(span.text).length - 1)
+            failures.push({ protected_span_id: span.id, expected_hash: span.content_hash, observed: "duplicated" });
+    }
+    return { id: "protected_spans.exact", version: "1.0.0", status: failures.length ? "fail" : "pass", hard: true, summary: failures.length ? `${failures.length} protected item(s) changed` : "Protected items remain present", failures, limitations: [] };
+}
+export function validateAdditions(source, candidate) {
+    const pattern = /https?:\/\/[^\s<>)\]]+|```[\s\S]*?```|`[^`\n]+`|\[[0-9]+\]|[“"][^”"\n]+[”"]/g;
+    const original = new Set(source.match(pattern) ?? []);
+    const added = (candidate.match(pattern) ?? []).filter(x => !original.has(x));
+    return { id: "unsupported_additions", version: "1.0.0", status: added.length ? "fail" : "pass", hard: true, summary: added.length ? `${added.length} unsupported reference(s) added` : "No unsupported URLs, citations, quotations or code added", failures: added.map(observed => ({ observed })), limitations: [] };
+}

package/node_modules/@opacedev/ai-content-checker-core/dist/provenance/c2pa-text.d.ts

@@ -0,0 +1,55 @@
+/**
+ * C2PA text content credentials — detection only, never removal.
+ *
+ * C2PA Specification 2.3 (December 2025) added §A.8 "Embedding Manifests into
+ * Unstructured Text": a C2PA Manifest Store carried inside the text itself as
+ * non-rendering Unicode variation selectors, so that Content Credentials
+ * survive a copy and paste. The spec is explicit about the carrier set:
+ *
+ *   "Unicode variation selectors (U+FE00-U+FE0F and U+E0100-U+E01EF) are used
+ *    because they are specifically designed to be visually non-rendering while
+ *    remaining part of the valid Unicode character set."
+ *                                    — C2PA Specification 2.4, §A.8.2
+ *
+ * Those are the same code points this tool's hidden-character check flags, and
+ * U+FE00-U+FE0F carry fix:"remove", so the safe-fix path would strip every byte
+ * of the manifest whose value is 0-15. That silently breaks the magic number
+ * and the credential stops being detectable at all — not reported as corrupt,
+ * simply gone. This module exists so the checker can see a credential before it
+ * is offered a fix that would destroy it.
+ *
+ * Nothing here weakens the hidden-character detection. Every carrier is still
+ * found, still counted and still shown. The credential's characters are made
+ * ineligible for the automatic fix, and removing them becomes a separate,
+ * deliberate choice.
+ */
+/** §A.8.3.2 — variationSelectorToByte. Returns null for anything else. */
+export declare const variationSelectorToByte: (codePoint: number) => number | null;
+/** True for any code point §A.8 can use as a manifest carrier, sentinel included. */
+export declare const isCredentialCarrier: (codePoint: number) => boolean;
+export interface C2paTextCredential {
+    /** UTF-16 offsets covering the U+FEFF sentinel and the whole wrapper. */
+    start_utf16: number;
+    end_utf16: number;
+    /** §A.8.2.3 version field. */
+    version: number;
+    /** §A.8.2.3 manifestLength, in bytes. */
+    manifest_length: number;
+    /**
+     * "ok" when the declared manifest is complete;
+     * "truncated" maps to the spec's manifest.text.corruptedWrapper condition.
+     */
+    status: "ok" | "truncated";
+}
+/**
+ * §A.8.4.2 detection algorithm: scan for U+FEFF, read the contiguous run of
+ * variation selectors that follows, decode the first eight bytes and compare
+ * them with the magic number.
+ */
+export declare function detectC2paTextCredentials(text: string): C2paTextCredential[];
+/** True when the span touches any detected credential. */
+export declare const withinCredential: (credentials: readonly C2paTextCredential[], span: {
+    start_utf16: number;
+    end_utf16: number;
+}) => boolean;
+export declare const credentialNotice: (credentials: readonly C2paTextCredential[]) => string;

package/node_modules/@opacedev/ai-content-checker-core/dist/provenance/c2pa-text.js

@@ -0,0 +1,86 @@
+/**
+ * C2PA text content credentials — detection only, never removal.
+ *
+ * C2PA Specification 2.3 (December 2025) added §A.8 "Embedding Manifests into
+ * Unstructured Text": a C2PA Manifest Store carried inside the text itself as
+ * non-rendering Unicode variation selectors, so that Content Credentials
+ * survive a copy and paste. The spec is explicit about the carrier set:
+ *
+ *   "Unicode variation selectors (U+FE00-U+FE0F and U+E0100-U+E01EF) are used
+ *    because they are specifically designed to be visually non-rendering while
+ *    remaining part of the valid Unicode character set."
+ *                                    — C2PA Specification 2.4, §A.8.2
+ *
+ * Those are the same code points this tool's hidden-character check flags, and
+ * U+FE00-U+FE0F carry fix:"remove", so the safe-fix path would strip every byte
+ * of the manifest whose value is 0-15. That silently breaks the magic number
+ * and the credential stops being detectable at all — not reported as corrupt,
+ * simply gone. This module exists so the checker can see a credential before it
+ * is offered a fix that would destroy it.
+ *
+ * Nothing here weakens the hidden-character detection. Every carrier is still
+ * found, still counted and still shown. The credential's characters are made
+ * ineligible for the automatic fix, and removing them becomes a separate,
+ * deliberate choice.
+ */
+/** §A.8.2.2 — magic = 0x4332504154585400, "C2PATXT\0". */
+const MAGIC = [0x43, 0x32, 0x50, 0x41, 0x54, 0x58, 0x54, 0x00];
+/** §A.8.2.2 — 8-byte magic, 1-byte version, 4-byte big-endian manifestLength. */
+const HEADER_BYTES = 13;
+/** §A.8.4.1 — the wrapper is prefixed with a single U+FEFF. */
+const SENTINEL = 0xfeff;
+/** §A.8.3.2 — variationSelectorToByte. Returns null for anything else. */
+export const variationSelectorToByte = (codePoint) => codePoint >= 0xfe00 && codePoint <= 0xfe0f
+    ? codePoint - 0xfe00
+    : codePoint >= 0xe0100 && codePoint <= 0xe01ef
+        ? codePoint - 0xe0100 + 16
+        : null;
+/** True for any code point §A.8 can use as a manifest carrier, sentinel included. */
+export const isCredentialCarrier = (codePoint) => codePoint === SENTINEL || variationSelectorToByte(codePoint) !== null;
+/**
+ * §A.8.4.2 detection algorithm: scan for U+FEFF, read the contiguous run of
+ * variation selectors that follows, decode the first eight bytes and compare
+ * them with the magic number.
+ */
+export function detectC2paTextCredentials(text) {
+    const found = [];
+    for (let i = 0; i < text.length;) {
+        const codePoint = text.codePointAt(i);
+        const width = codePoint > 0xffff ? 2 : 1;
+        if (codePoint !== SENTINEL) {
+            i += width;
+            continue;
+        }
+        const bytes = [];
+        let cursor = i + width;
+        while (cursor < text.length) {
+            const next = text.codePointAt(cursor);
+            const byte = variationSelectorToByte(next);
+            if (byte === null)
+                break;
+            bytes.push(byte);
+            cursor += next > 0xffff ? 2 : 1;
+        }
+        if (bytes.length < HEADER_BYTES || !MAGIC.every((value, index) => bytes[index] === value)) {
+            i += width;
+            continue;
+        }
+        const manifestLength = ((bytes[9] << 24) | (bytes[10] << 16) | (bytes[11] << 8) | bytes[12]) >>> 0;
+        found.push({
+            start_utf16: i,
+            end_utf16: cursor,
+            version: bytes[8],
+            manifest_length: manifestLength,
+            status: bytes.length >= HEADER_BYTES + manifestLength ? "ok" : "truncated",
+        });
+        i = cursor;
+    }
+    return found;
+}
+/** True when the span touches any detected credential. */
+export const withinCredential = (credentials, span) => credentials.some((credential) => span.start_utf16 < credential.end_utf16 && span.end_utf16 > credential.start_utf16);
+export const credentialNotice = (credentials) => {
+    const one = credentials.length === 1;
+    const truncated = credentials.some((credential) => credential.status === "truncated");
+    return `This draft carries ${one ? "a C2PA content credential" : `${credentials.length} C2PA content credentials`} embedded in the text itself (C2PA 2.3 §A.8, Unicode variation selectors)${truncated ? ", at least one of which is already incomplete" : ""}. The hidden characters listed below include ${one ? "its" : "their"} bytes. Removing them destroys the credential permanently, and it cannot be rebuilt from the visible text, so they are excluded from the automatic fix.`;
+};