@opacedev/astro-ai-content-checker 0.3.1

package/node_modules/@opacedev/ai-content-checker-core/dist/unicode/data.js

@@ -0,0 +1,137 @@
+// Carrier and confusable tables for the deterministic Unicode inspection.
+// Data adapted in part from the MIT-licensed `watermarks-remover` (Guillaume Meyer and
+// contributors) carrier tables and the MIT-licensed `avoid-ai-writing` lookalike maps,
+// extended from Unicode 16 format-character and confusables data. Future coverage
+// changes should be edits to these constants, not to the inspection logic.
+export const UNICODE_RULES_VERSION = "unicode:2026.08.2";
+const MSG_INVISIBLE = (what) => `An invisible ${what} is present.`;
+const MSG_BIDI = "A bidirectional formatting control is present.";
+const BIDI_LIMIT = "Bidirectional controls are required for correct display of mixed right-to-left and left-to-right text.";
+export const CARRIER_RULES = [
+    // Soft hyphen and combining grapheme joiner
+    { from: 0x00ad, name: "SOFT HYPHEN", severity: "low", fix: "remove", message: "A discretionary soft hyphen is present." },
+    { from: 0x034f, name: "COMBINING GRAPHEME JOINER", severity: "medium", fix: "remove", message: MSG_INVISIBLE("combining grapheme joiner"), limitation: "The combining grapheme joiner has rare legitimate uses in collation and diacritic ordering." },
+    // Script-specific format characters
+    { from: 0x061c, name: "ARABIC LETTER MARK", severity: "medium", fix: "review", message: MSG_BIDI, limitation: BIDI_LIMIT },
+    { from: 0x070f, name: "SYRIAC ABBREVIATION MARK", severity: "medium", fix: "review", message: "A Syriac abbreviation mark format character is present.", limitation: "This character is legitimate inside Syriac-script text." },
+    { from: 0x0890, to: 0x0891, name: cp => cp === 0x0890 ? "ARABIC POUND MARK ABOVE" : "ARABIC PIASTRE MARK ABOVE", severity: "medium", fix: "review", message: "An Arabic prepended format mark is present.", limitation: "This character is legitimate inside Arabic-script text." },
+    { from: 0x08e2, name: "ARABIC DISPUTED END OF AYAH", severity: "medium", fix: "review", message: "An Arabic prepended format mark is present.", limitation: "This character is legitimate inside Arabic-script text." },
+    { from: 0x180b, to: 0x180d, name: cp => `MONGOLIAN FREE VARIATION SELECTOR-${cp - 0x180a}`, severity: "medium", fix: "remove", message: MSG_INVISIBLE("Mongolian free variation selector"), context: "variation", limitation: "Free variation selectors are legitimate inside Mongolian-script text." },
+    { from: 0x180e, name: "MONGOLIAN VOWEL SEPARATOR", severity: "medium", fix: "remove", message: MSG_INVISIBLE("Mongolian vowel separator"), limitation: "This character is legitimate inside Mongolian-script text." },
+    { from: 0x180f, name: "MONGOLIAN FREE VARIATION SELECTOR-4", severity: "medium", fix: "remove", message: MSG_INVISIBLE("Mongolian free variation selector"), context: "variation", limitation: "Free variation selectors are legitimate inside Mongolian-script text." },
+    // Zero-width and joining controls
+    { from: 0x200b, name: "ZERO WIDTH SPACE", severity: "medium", fix: "remove", message: MSG_INVISIBLE("zero-width space") },
+    { from: 0x200c, name: "ZERO WIDTH NON-JOINER", severity: "medium", fix: "remove", message: MSG_INVISIBLE("zero-width non-joiner"), context: "joiner", limitation: "The zero-width non-joiner is standard orthography in Persian and several Indic languages." },
+    { from: 0x200d, name: "ZERO WIDTH JOINER", severity: "medium", fix: "remove", message: MSG_INVISIBLE("zero-width joiner"), context: "joiner", limitation: "The zero-width joiner is standard in emoji sequences and several complex scripts." },
+    // Bidirectional controls
+    { from: 0x200e, name: "LEFT-TO-RIGHT MARK", severity: "medium", fix: "review", message: MSG_BIDI, limitation: BIDI_LIMIT },
+    { from: 0x200f, name: "RIGHT-TO-LEFT MARK", severity: "medium", fix: "review", message: MSG_BIDI, limitation: BIDI_LIMIT },
+    { from: 0x202a, to: 0x202e, name: cp => ["LEFT-TO-RIGHT EMBEDDING", "RIGHT-TO-LEFT EMBEDDING", "POP DIRECTIONAL FORMATTING", "LEFT-TO-RIGHT OVERRIDE", "RIGHT-TO-LEFT OVERRIDE"][cp - 0x202a], severity: "medium", fix: "review", message: MSG_BIDI, limitation: BIDI_LIMIT },
+    { from: 0x2066, to: 0x2069, name: cp => ["LEFT-TO-RIGHT ISOLATE", "RIGHT-TO-LEFT ISOLATE", "FIRST STRONG ISOLATE", "POP DIRECTIONAL ISOLATE"][cp - 0x2066], severity: "medium", fix: "review", message: MSG_BIDI, limitation: BIDI_LIMIT },
+    // Word joiner, invisible operators and deprecated format characters
+    { from: 0x2060, name: "WORD JOINER", severity: "medium", fix: "remove", message: MSG_INVISIBLE("word joiner") },
+    { from: 0x2061, to: 0x2064, name: cp => ["FUNCTION APPLICATION", "INVISIBLE TIMES", "INVISIBLE SEPARATOR", "INVISIBLE PLUS"][cp - 0x2061], severity: "medium", fix: "remove", message: MSG_INVISIBLE("mathematical operator character"), limitation: "Invisible operators are legitimate inside machine-generated mathematical notation." },
+    { from: 0x206a, to: 0x206f, name: cp => ["INHIBIT SYMMETRIC SWAPPING", "ACTIVATE SYMMETRIC SWAPPING", "INHIBIT ARABIC FORM SHAPING", "ACTIVATE ARABIC FORM SHAPING", "NATIONAL DIGIT SHAPES", "NOMINAL DIGIT SHAPES"][cp - 0x206a], severity: "medium", fix: "remove", message: "A deprecated invisible format character is present.", limitation: "These characters are deprecated by Unicode and have no place in modern interchange text." },
+    // BOM, interlinear annotation, replacement
+    { from: 0xfeff, name: "BYTE ORDER MARK", severity: "low", fix: "remove", message: "A byte-order mark is present." },
+    { from: 0xfff9, to: 0xfffb, name: cp => ["INTERLINEAR ANNOTATION ANCHOR", "INTERLINEAR ANNOTATION SEPARATOR", "INTERLINEAR ANNOTATION TERMINATOR"][cp - 0xfff9], severity: "medium", fix: "review", message: "An interlinear annotation control is present.", limitation: "Interlinear annotation controls are legitimate in Japanese ruby markup pipelines." },
+    { from: 0xfffd, name: "REPLACEMENT CHARACTER", severity: "high", fix: "review", message: "A replacement character may indicate damaged text." },
+    // Supplementary-plane format characters
+    { from: 0x110bd, name: "KAITHI NUMBER SIGN", severity: "medium", fix: "review", message: "A Kaithi number-sign format character is present.", limitation: "This character is legitimate inside Kaithi-script text." },
+    { from: 0x110cd, name: "KAITHI NUMBER SIGN ABOVE", severity: "medium", fix: "review", message: "A Kaithi number-sign format character is present.", limitation: "This character is legitimate inside Kaithi-script text." },
+    // Tag characters: the classic covert payload carrier
+    { from: 0xe0001, name: "LANGUAGE TAG", severity: "high", fix: "remove", message: "A deprecated invisible language tag is present." },
+    { from: 0xe0020, to: 0xe007f, name: cp => cp === 0xe007f ? "CANCEL TAG" : `TAG ${String.fromCodePoint(cp - 0xe0000) === " " ? "SPACE" : `CHARACTER '${String.fromCodePoint(cp - 0xe0000)}'`}`, severity: "high", fix: "remove", message: "An invisible tag character is present; tag runs are a known covert payload carrier.", limitation: "Tag characters have no legitimate use in ordinary interchange text outside emoji flag sequences." },
+    // Variation selectors
+    { from: 0xfe00, to: 0xfe0f, name: cp => `VARIATION SELECTOR-${cp - 0xfe00 + 1}`, severity: "medium", fix: "remove", message: MSG_INVISIBLE("variation selector"), context: "variation", limitation: "Variation selectors are legitimate after emoji-capable and CJK base characters." },
+    { from: 0xe0100, to: 0xe01ef, name: cp => `VARIATION SELECTOR-${cp - 0xe0100 + 17}`, severity: "medium", fix: "review", message: MSG_INVISIBLE("supplementary variation selector"), context: "variation_sup", limitation: "Supplementary variation selectors are legitimate after CJK ideographs to select registered glyph variants." },
+    // Space separators beyond U+0020
+    { from: 0x00a0, name: "NO-BREAK SPACE", severity: "note", fix: "space", message: "A non-breaking space is present.", limitation: "Non-breaking spaces are standard French and general typographic practice." },
+    { from: 0x1680, name: "OGHAM SPACE MARK", severity: "low", fix: "space", message: "An unusual space character is present.", limitation: "This character is legitimate inside Ogham-script text." },
+    { from: 0x2000, to: 0x2008, name: cp => ["EN QUAD", "EM QUAD", "EN SPACE", "EM SPACE", "THREE-PER-EM SPACE", "FOUR-PER-EM SPACE", "SIX-PER-EM SPACE", "FIGURE SPACE", "PUNCTUATION SPACE"][cp - 0x2000], severity: "low", fix: "space", message: "A typographic space that substitutes for an ordinary space is present.", limitation: "Fixed-width spaces are legitimate in carefully typeset material." },
+    { from: 0x2009, name: "THIN SPACE", severity: "note", fix: "space", message: "A thin space is present.", limitation: "Thin spaces are standard French and general typographic practice." },
+    { from: 0x200a, name: "HAIR SPACE", severity: "low", fix: "space", message: "A hair space that substitutes for an ordinary space is present.", limitation: "Hair spaces are legitimate in carefully typeset material." },
+    { from: 0x202f, name: "NARROW NO-BREAK SPACE", severity: "note", fix: "space", message: "A narrow no-break space is present.", limitation: "Narrow no-break spaces are standard French punctuation spacing and appear in Mongolian text." },
+    { from: 0x205f, name: "MEDIUM MATHEMATICAL SPACE", severity: "note", fix: "space", message: "A medium mathematical space is present.", limitation: "This space is legitimate inside typeset mathematical notation." },
+    { from: 0x3000, name: "IDEOGRAPHIC SPACE", severity: "note", fix: "space", message: "An ideographic space is present.", limitation: "Ideographic spaces are standard in Chinese and Japanese text." },
+    // Line and paragraph separators
+    { from: 0x2028, name: "LINE SEPARATOR", severity: "low", fix: "review", message: "A Unicode line separator is present instead of a conventional line break." },
+    { from: 0x2029, name: "PARAGRAPH SEPARATOR", severity: "low", fix: "review", message: "A Unicode paragraph separator is present instead of a conventional line break." }
+];
+// Large carrier ranges. These are checked by range scan rather than expanded
+// into the per-code-point lookup table, which would cost ~137k entries and blow
+// the browser inspection budget. Coverage changes still belong here, not in the
+// inspection logic.
+export const CARRIER_RANGE_RULES = [
+    { from: 0xe000, to: 0xf8ff, name: "PRIVATE USE CHARACTER", severity: "medium", fix: "review", message: "A private-use area character is present; its meaning is defined only by a private agreement between sender and receiver.", limitation: "Private-use characters are legitimate in icon fonts and legacy vendor symbols such as platform logos; a single one is routine." },
+    { from: 0xf0000, to: 0xffffd, name: "SUPPLEMENTARY PRIVATE USE CHARACTER", severity: "medium", fix: "review", message: "A supplementary private-use area character is present; its meaning is defined only by a private agreement between sender and receiver.", limitation: "Private-use characters are legitimate in icon fonts and legacy vendor symbols; a single one is routine." },
+    { from: 0x100000, to: 0x10fffd, name: "SUPPLEMENTARY PRIVATE USE CHARACTER", severity: "medium", fix: "review", message: "A supplementary private-use area character is present; its meaning is defined only by a private agreement between sender and receiver.", limitation: "Private-use characters are legitimate in icon fonts and legacy vendor symbols; a single one is routine." }
+];
+// Latin-lookalike confusables. Floor: avoid-ai-writing CYRILLIC_LOOKALIKES/GREEK_LOOKALIKES and
+// watermarks-remover LATIN_CONFUSABLES; extended from Unicode confusables data.
+export const CONFUSABLES = new Map([
+    // Cyrillic lower case
+    [0x0430, { name: "CYRILLIC SMALL LETTER A", latin: "a" }],
+    [0x0432, { name: "CYRILLIC SMALL LETTER VE", latin: "b" }],
+    [0x0435, { name: "CYRILLIC SMALL LETTER IE", latin: "e" }],
+    [0x043a, { name: "CYRILLIC SMALL LETTER KA", latin: "k" }],
+    [0x043c, { name: "CYRILLIC SMALL LETTER EM", latin: "m" }],
+    [0x043d, { name: "CYRILLIC SMALL LETTER EN", latin: "h" }],
+    [0x043e, { name: "CYRILLIC SMALL LETTER O", latin: "o" }],
+    [0x0440, { name: "CYRILLIC SMALL LETTER ER", latin: "p" }],
+    [0x0441, { name: "CYRILLIC SMALL LETTER ES", latin: "c" }],
+    [0x0442, { name: "CYRILLIC SMALL LETTER TE", latin: "t" }],
+    [0x0443, { name: "CYRILLIC SMALL LETTER U", latin: "y" }],
+    [0x0445, { name: "CYRILLIC SMALL LETTER HA", latin: "x" }],
+    [0x0455, { name: "CYRILLIC SMALL LETTER DZE", latin: "s" }],
+    [0x0456, { name: "CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I", latin: "i" }],
+    [0x0458, { name: "CYRILLIC SMALL LETTER JE", latin: "j" }],
+    [0x0461, { name: "CYRILLIC SMALL LETTER OMEGA", latin: "w" }],
+    [0x0475, { name: "CYRILLIC SMALL LETTER IZHITSA", latin: "v" }],
+    [0x04bb, { name: "CYRILLIC SMALL LETTER SHHA", latin: "h" }],
+    [0x0501, { name: "CYRILLIC SMALL LETTER KOMI DE", latin: "d" }],
+    [0x051b, { name: "CYRILLIC SMALL LETTER QA", latin: "q" }],
+    [0x051d, { name: "CYRILLIC SMALL LETTER WE", latin: "w" }],
+    // Cyrillic upper case
+    [0x0405, { name: "CYRILLIC CAPITAL LETTER DZE", latin: "S" }],
+    [0x0406, { name: "CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I", latin: "I" }],
+    [0x0408, { name: "CYRILLIC CAPITAL LETTER JE", latin: "J" }],
+    [0x0410, { name: "CYRILLIC CAPITAL LETTER A", latin: "A" }],
+    [0x0412, { name: "CYRILLIC CAPITAL LETTER VE", latin: "B" }],
+    [0x0415, { name: "CYRILLIC CAPITAL LETTER IE", latin: "E" }],
+    [0x041a, { name: "CYRILLIC CAPITAL LETTER KA", latin: "K" }],
+    [0x041c, { name: "CYRILLIC CAPITAL LETTER EM", latin: "M" }],
+    [0x041d, { name: "CYRILLIC CAPITAL LETTER EN", latin: "H" }],
+    [0x041e, { name: "CYRILLIC CAPITAL LETTER O", latin: "O" }],
+    [0x0420, { name: "CYRILLIC CAPITAL LETTER ER", latin: "P" }],
+    [0x0421, { name: "CYRILLIC CAPITAL LETTER ES", latin: "C" }],
+    [0x0422, { name: "CYRILLIC CAPITAL LETTER TE", latin: "T" }],
+    [0x0423, { name: "CYRILLIC CAPITAL LETTER U", latin: "Y" }],
+    [0x0425, { name: "CYRILLIC CAPITAL LETTER HA", latin: "X" }],
+    [0x0500, { name: "CYRILLIC CAPITAL LETTER KOMI DE", latin: "D" }],
+    // Greek lower case
+    [0x03b1, { name: "GREEK SMALL LETTER ALPHA", latin: "a" }],
+    [0x03b9, { name: "GREEK SMALL LETTER IOTA", latin: "i" }],
+    [0x03ba, { name: "GREEK SMALL LETTER KAPPA", latin: "k" }],
+    [0x03bd, { name: "GREEK SMALL LETTER NU", latin: "v" }],
+    [0x03bf, { name: "GREEK SMALL LETTER OMICRON", latin: "o" }],
+    [0x03c1, { name: "GREEK SMALL LETTER RHO", latin: "p" }],
+    [0x03c5, { name: "GREEK SMALL LETTER UPSILON", latin: "u" }],
+    [0x03f2, { name: "GREEK LUNATE SIGMA SYMBOL", latin: "c" }],
+    // Greek upper case
+    [0x0391, { name: "GREEK CAPITAL LETTER ALPHA", latin: "A" }],
+    [0x0392, { name: "GREEK CAPITAL LETTER BETA", latin: "B" }],
+    [0x0395, { name: "GREEK CAPITAL LETTER EPSILON", latin: "E" }],
+    [0x0396, { name: "GREEK CAPITAL LETTER ZETA", latin: "Z" }],
+    [0x0397, { name: "GREEK CAPITAL LETTER ETA", latin: "H" }],
+    [0x0399, { name: "GREEK CAPITAL LETTER IOTA", latin: "I" }],
+    [0x039a, { name: "GREEK CAPITAL LETTER KAPPA", latin: "K" }],
+    [0x039c, { name: "GREEK CAPITAL LETTER MU", latin: "M" }],
+    [0x039d, { name: "GREEK CAPITAL LETTER NU", latin: "N" }],
+    [0x039f, { name: "GREEK CAPITAL LETTER OMICRON", latin: "O" }],
+    [0x03a1, { name: "GREEK CAPITAL LETTER RHO", latin: "P" }],
+    [0x03a4, { name: "GREEK CAPITAL LETTER TAU", latin: "T" }],
+    [0x03a5, { name: "GREEK CAPITAL LETTER UPSILON", latin: "Y" }],
+    [0x03a7, { name: "GREEK CAPITAL LETTER CHI", latin: "X" }],
+    [0x03f9, { name: "GREEK CAPITAL LUNATE SIGMA SYMBOL", latin: "C" }]
+]);

package/node_modules/@opacedev/ai-content-checker-core/dist/unicode/inspect.d.ts

@@ -0,0 +1,16 @@
+import { rangeFromUtf16 } from "../source/offsets.js";
+import { UNICODE_RULES_VERSION } from "./data.js";
+export { UNICODE_RULES_VERSION };
+export interface UnicodeFinding {
+    id: string;
+    code_point: string;
+    name: string;
+    severity: "note" | "low" | "medium" | "high";
+    message: string;
+    suggestion: string;
+    span: ReturnType<typeof rangeFromUtf16>;
+    matched_text_hash: string;
+    fix: "remove" | "space" | "review";
+    limitations: string[];
+}
+export declare function inspectUnicode(text: string): UnicodeFinding[];

package/node_modules/@opacedev/ai-content-checker-core/dist/unicode/inspect.js

@@ -0,0 +1,84 @@
+import { rangeFromUtf16 } from "../source/offsets.js";
+import { prefixedSha256 } from "../source/utf8.js";
+import { CARRIER_RANGE_RULES, CARRIER_RULES, CONFUSABLES, UNICODE_RULES_VERSION } from "./data.js";
+export { UNICODE_RULES_VERSION };
+const TABLE = new Map();
+for (const rule of CARRIER_RULES) {
+    for (let cp = rule.from; cp <= (rule.to ?? rule.from); cp++) {
+        TABLE.set(cp, { name: typeof rule.name === "function" ? rule.name(cp) : rule.name, severity: rule.severity, fix: rule.fix, message: rule.message, context: rule.context, limitation: rule.limitation });
+    }
+}
+const BASE_LIMIT = "Unicode controls can be legitimate in multilingual text; this finding is not evidence of authorship.";
+// Emoji-capable neighbours for ZWJ sequences and variation selectors: pictographs, skin-tone modifiers, VS16, keycap bases.
+const EMOJI_SIDE = /[\p{Extended_Pictographic}\u{1F3FB}-\u{1F3FF}\uFE0F0-9#*]/u;
+// Scripts whose orthography legitimately uses ZWJ/ZWNJ between letters (cursive joining and Indic conjunct control).
+const JOINING_SCRIPT = /[\p{sc=Arabic}\p{sc=Syriac}\p{sc=Nko}\p{sc=Mongolian}\p{sc=Devanagari}\p{sc=Bengali}\p{sc=Gurmukhi}\p{sc=Gujarati}\p{sc=Oriya}\p{sc=Tamil}\p{sc=Telugu}\p{sc=Kannada}\p{sc=Malayalam}\p{sc=Sinhala}\p{sc=Myanmar}\p{sc=Khmer}\p{sc=Tibetan}]/u;
+const CJK_BASE = /[\p{sc=Han}\p{sc=Hiragana}\p{sc=Katakana}\p{sc=Mongolian}]/u;
+function contextualise(rule, cp, prev, next) {
+    if (rule.context === "joiner") {
+        if ((cp === 0x200d) && prev && next && EMOJI_SIDE.test(prev) && EMOJI_SIDE.test(next))
+            return undefined; // legitimate emoji ZWJ sequence
+        if (prev && next && JOINING_SCRIPT.test(prev) && JOINING_SCRIPT.test(next))
+            return undefined; // legitimate cursive/Indic joining control
+        return rule;
+    }
+    if (rule.context === "variation") {
+        if (prev && EMOJI_SIDE.test(prev))
+            return undefined; // presentation selector on an emoji-capable base
+        if (prev && CJK_BASE.test(prev))
+            return { ...rule, severity: "note", fix: "review", message: `${rule.message} It follows a base character that commonly takes glyph variants.` };
+        return rule;
+    }
+    if (rule.context === "variation_sup") {
+        if (prev && CJK_BASE.test(prev))
+            return { ...rule, severity: "note", message: `${rule.message} It follows a CJK ideograph and may select a registered glyph variant.` };
+        return rule;
+    }
+    return rule;
+}
+/** Range-scanned carriers (private-use areas) that are too large to expand into TABLE. */
+function rangeRule(cp) {
+    for (const rule of CARRIER_RANGE_RULES) {
+        if (cp >= rule.from && cp <= (rule.to ?? rule.from))
+            return { name: typeof rule.name === "function" ? rule.name(cp) : rule.name, severity: rule.severity, fix: rule.fix, message: rule.message, context: rule.context, limitation: rule.limitation };
+    }
+    return undefined;
+}
+export function inspectUnicode(text) {
+    const findings = [];
+    let prev = "";
+    for (let i = 0; i < text.length;) {
+        const cp = text.codePointAt(i);
+        const width = cp > 0xffff ? 2 : 1;
+        const raw = text.slice(i, i + width);
+        const base = TABLE.get(cp) ?? (cp >= 0xe000 ? rangeRule(cp) : undefined);
+        if (base) {
+            const next = i + width < text.length ? String.fromCodePoint(text.codePointAt(i + width)) : "";
+            const rule = contextualise(base, cp, prev, next);
+            if (rule) {
+                findings.push({ id: `unicode_${i}_${cp.toString(16)}`, code_point: `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`, name: rule.name, severity: rule.severity, message: rule.message, suggestion: rule.fix === "review" ? "Review the surrounding script and direction before editing." : "Preview the deterministic change before approval.", span: rangeFromUtf16(text, i, i + width), matched_text_hash: prefixedSha256(raw), fix: rule.fix, limitations: rule.limitation ? [BASE_LIMIT, rule.limitation] : [BASE_LIMIT] });
+            }
+        }
+        if (cp >= 0xd800 && cp <= 0xdfff) {
+            findings.push({ id: `unicode_${i}_surrogate`, code_point: `U+${cp.toString(16).toUpperCase()}`, name: "UNPAIRED SURROGATE", severity: "high", message: "An unpaired UTF-16 surrogate cannot be encoded as valid UTF-8.", suggestion: "Replace or remove it after checking the source encoding.", span: { start_utf16: i, end_utf16: i + 1, start_codepoint: Array.from(text.slice(0, i)).length, end_codepoint: Array.from(text.slice(0, i)).length + 1 }, matched_text_hash: prefixedSha256("�"), fix: "review", limitations: ["The displayed replacement may differ from the original invalid code unit."] });
+        }
+        prev = raw;
+        i += width;
+    }
+    const tokens = [...text.matchAll(/[\p{L}\p{N}_-]+/gu)];
+    for (const token of tokens) {
+        const value = token[0];
+        if (!/\p{Script=Latin}/u.test(value) || !/\p{Script=Cyrillic}|\p{Script=Greek}/u.test(value))
+            continue;
+        let local = 0;
+        for (const char of value) {
+            const cp = char.codePointAt(0), entry = CONFUSABLES.get(cp);
+            if (entry) {
+                const start = token.index + local;
+                findings.push({ id: `unicode_${start}_homoglyph_${cp.toString(16)}`, code_point: `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`, name: entry.name, severity: "medium", message: `A mixed-script token contains a character visually confusable with Latin '${entry.latin}'.`, suggestion: "Verify the intended spelling; homoglyphs are never replaced automatically.", span: rangeFromUtf16(text, start, start + char.length), matched_text_hash: prefixedSha256(char), fix: "review", limitations: ["Mixed scripts can be legitimate in names and multilingual text; this is contextual evidence only."] });
+            }
+            local += char.length;
+        }
+    }
+    return findings;
+}

package/node_modules/@opacedev/ai-content-checker-core/dist/verdict/combine.d.ts

@@ -0,0 +1,162 @@
+import type { EditorialSignalsResult } from "../patterns/en-signals-v2.js";
+import type { UnicodeFinding } from "../unicode/inspect.js";
+export declare const COMBINED_VERDICT_VERSION = "combined:2026.08.8";
+/** Evidence tier assigned to a single character finding. */
+export type EvidenceTier = "deliberate" | "supporting" | "excluded";
+/** Watermark scan outcome. Only "detected" is treated as evidence. */
+export type WatermarkOutcome = "detected" | "not_detected" | "not_available" | "not_supported";
+/**
+ * AXIS A. The only authorship reading the engine publishes, and the only place
+ * the words "AI" and "human" may appear as a verdict. `not_assessed` means no
+ * trained model ran; it never means "human".
+ */
+export type AiReading = "ai_like" | "uncertain" | "human_like" | "not_assessed";
+/**
+ * AXIS B. What was done to the text.
+ *  - `clean`       nothing reportable, or only characters with a documented
+ *                  legitimate use.
+ *  - `attention`   something is present that has no ordinary authoring
+ *                  explanation and is worth an editor's eye.
+ *  - `manipulated` the shape of a deliberate payload or a generator's mark:
+ *                  something wrote into this text on purpose.
+ */
+export type IntegrityStatus = "clean" | "attention" | "manipulated";
+/** AXIS C. How much editorial feedback the named writing rules produced. */
+export type SuggestionLevel = "none" | "some" | "many";
+export type ConfidenceBand = "low" | "medium" | "high";
+export interface CombinedEvidenceItem {
+    /** The finding id it came from, so a UI can link the verdict back to the row. */
+    finding_id: string;
+    code_point: string;
+    name: string;
+    tier: EvidenceTier;
+    /** Why this character landed in this tier. */
+    rationale: string;
+}
+/** One integrity finding on axis B. Never carries an authorship claim. */
+export interface IntegrityFinding {
+    /** Stable id of the rule that fired, so a UI can link back to the row. */
+    applied: string;
+    /** The status this finding argues for on its own. */
+    status: IntegrityStatus;
+    /** Plain-English description of what was found in the text. */
+    reason: string;
+}
+/** A trained-model reading. The ONLY permitted source of an AI probability. */
+export interface ModelReading {
+    /** Model identifier, e.g. "local-signals-cycle2". */
+    name: string;
+    /** Model/artefact version string. */
+    version?: string;
+    /** Probability in [0,1] that a machine composed this text. */
+    probability: number;
+    /** The operating point the model was calibrated to, in the shipped runtime. */
+    threshold: number;
+    /** The band below which the model declines to give a reading, e.g. a word floor. */
+    below_reliable_range?: boolean;
+}
+export interface CombinedVerdictInput {
+    /** The writing-signals result. Omitted when style.patterns was not requested. */
+    signals?: EditorialSignalsResult;
+    /** Every Unicode finding, carriers and homoglyphs alike. */
+    unicodeFindings?: readonly UnicodeFinding[];
+    /** The inspected text. Required to grade homoglyphs and carrier runs; without
+     *  it homoglyphs are graded down to supporting and runs are not detected. */
+    text?: string;
+    /** The watermark scan outcome, when a watermark method ran. */
+    watermark?: {
+        outcome: WatermarkOutcome;
+    };
+    /** A trained-model reading, when one ran. Nothing else may set axis A. */
+    model?: ModelReading;
+}
+export interface CombinedVerdictResult {
+    /**
+     * AXIS A — the AI reading. Set only from `input.model`. Character evidence,
+     * writing rules and the watermark scan can never reach this object.
+     */
+    ai_probability: {
+        /** The model that produced the reading, or null when none ran. */
+        source: string | null;
+        /** The model's probability, or null when no model ran. */
+        value: number | null;
+        /** The operating point the reading was compared against. */
+        threshold: number | null;
+        reading: AiReading;
+        confidence: ConfidenceBand | "not_assessed";
+        reason: string;
+    };
+    /**
+     * AXIS B — text integrity and provenance. Reports manipulation of the text.
+     * It may say the text contains hidden characters. It never says the text is AI.
+     */
+    text_integrity: {
+        status: IntegrityStatus;
+        /** The finding that set the status, or null when the status is `clean`. */
+        applied: string | null;
+        reason: string;
+        /** Every integrity finding that fired, in precedence order. */
+        findings: IntegrityFinding[];
+        character_evidence: {
+            /** Deliberate carriers with near-zero innocent explanation. */
+            deliberate: CombinedEvidenceItem[];
+            /** Characters that corroborate but never raise a status on their own. */
+            supporting: CombinedEvidenceItem[];
+            /** Characters with a documented legitimate use, excluded from the status. */
+            excluded: CombinedEvidenceItem[];
+            /** Homoglyph substitutions inside an otherwise-Latin word. */
+            interior_homoglyph_count: number;
+            /** Longest run of adjacent invisible carriers with no visible character between them. */
+            longest_carrier_run: number;
+        };
+        watermark: {
+            outcome: WatermarkOutcome;
+            counted_as_evidence: boolean;
+        };
+        confidence: ConfidenceBand;
+    };
+    /**
+     * AXIS C — editorial suggestions from the named writing rules. Feedback on
+     * phrasing and structure. Never an authorship judgement, never counted as one.
+     */
+    editorial: {
+        suggestion_level: SuggestionLevel;
+        /** The rules' own score, carried through and never rewritten here. */
+        score: number | null;
+        /** The distinct writing-rule categories that fired, verbatim from the rules tier. */
+        categories_hit: readonly string[] | null;
+        finding_count: number | null;
+        confidence: ConfidenceBand | "not_assessed";
+        reason: string;
+        /**
+         * The rules' internal three-way distribution, published verbatim for
+         * transparency. Its `ai_like` member is a rules-tier artefact and is NOT an
+         * AI probability; axis A is the only AI probability the engine publishes.
+         */
+        rule_probabilities: EditorialSignalsResult["probabilities"] | null;
+    };
+    /** Which streams were available to this verdict. */
+    inputs_considered: Array<"model" | "writing_signals" | "invisible_unicode" | "homoglyphs" | "watermark">;
+    version: string;
+    /** Plain-English claim boundaries. Always includes the axis and authorship boundaries. */
+    limitations: [string, ...string[]];
+    description: string;
+}
+export declare function isPrivateUse(cp: number): boolean;
+/**
+ * Compute the three independent readings. Nothing here merges them: each axis
+ * is derived only from its own evidence, and `assertAxisIndependence` throws
+ * rather than let a collapsed verdict be published.
+ */
+export declare function computeCombinedVerdict(input: CombinedVerdictInput): CombinedVerdictResult;
+/**
+ * Contract 1, enforced rather than documented. Publishing a collapsed verdict is
+ * a correctness failure, so it throws instead of degrading quietly.
+ *
+ * The three things that must never happen again:
+ *   1. an AI reading that no model produced;
+ *   2. an integrity or editorial string that talks about AI or human authorship;
+ *   3. an integrity status that character evidence and the watermark scan do not
+ *      independently justify.
+ */
+export declare function assertAxisIndependence(result: CombinedVerdictResult, input: CombinedVerdictInput): void;