@opacedev/astro-ai-content-checker 0.3.1

package/node_modules/@opacedev/ai-content-checker-core/dist/report/checker-result.js

@@ -0,0 +1,419 @@
+/** Portable result/presentation semantics shared by every checker surface. */
+export const CHECKER_RESULT_RUNTIME_VERSION = "checker-result:2026.09.1";
+export const CYCLE5_MODEL_IDENTITY = {
+    identity: "tier3-cycle5-v1",
+    serverRegistryIdentity: "tier3-cycle5-full",
+    segmentationContract: "segments-v3",
+    inputContract: "raw-v1",
+    featuresContract: "features-v1",
+    scoringContract: "margin-v1",
+    flagRule: {
+        expression: "max(m1, m2 + 0.34) >= 3.570935",
+        primaryMargin: 3.570935,
+        secondaryGap: 0.34
+    }
+};
+export const CHECKER_SCORE_SCALE = "zero_to_one_pattern_similarity";
+export const CHECKER_HONESTY_LINE = "No AI checker can prove who wrote a text — this is a pattern reading.";
+export const CHECKER_LEVELS = {
+    "signal-strongly-ai": {
+        name: "Strongly AI",
+        support: "This draft very strongly matches AI writing — the kind of match we rarely see in human work."
+    },
+    "signal-likely-ai": {
+        name: "Likely AI",
+        support: "Much of this draft reads like AI writing."
+    },
+    "signal-potentially-ai": {
+        name: "Potentially AI",
+        support: "Parts of this draft resemble AI writing, but the match is not strong enough to be sure."
+    },
+    "signal-unclear": {
+        name: "Unclear",
+        support: "We can't call this one either way. Some passages read slightly machine-like, but people write that way too."
+    },
+    "signal-likely-human": {
+        name: "Likely human",
+        support: "This reads like human writing. Nothing here matches the AI patterns we test for — though a heavily disguised AI draft can slip past any checker, ours included."
+    }
+};
+const BAND_TO_LEVEL = {
+    very_likely_ai: "signal-strongly-ai",
+    uncertain: "signal-potentially-ai",
+    likely_human: "signal-unclear",
+    very_likely_human: "signal-likely-human"
+};
+const METHOD_STATUSES = new Set(["pass", "attention", "fail", "inconclusive", "unsupported", "not_configured", "not_run", "error"]);
+const CONTENT_KEYS = new Set(["content", "text", "passage", "excerpt", "source_uri", "candidate", "route_path", "evidence"]);
+function probability(value, name) {
+    if (!Number.isFinite(value) || value < 0 || value > 1)
+        throw new RangeError(`${name} must be a finite zero-to-one score.`);
+    return value;
+}
+/**
+ * Map the model's measured band to the five product bands. The secondary
+ * threshold only refines the model's uncertain band; it never decides the
+ * underlying model flag, which remains the margin-v1 rule.
+ */
+export function levelForCycle5Score(rawScore, bandId, secondaryThreshold) {
+    probability(rawScore, "rawScore");
+    const level = BAND_TO_LEVEL[bandId];
+    if (!level)
+        throw new Error(`Unknown Cycle-5 band: ${String(bandId)}`);
+    if (bandId === "uncertain" && secondaryThreshold !== undefined) {
+        probability(secondaryThreshold, "secondaryThreshold");
+        if (rawScore >= secondaryThreshold)
+            return "signal-likely-ai";
+    }
+    return level;
+}
+/**
+ * Format every score in one run together. Precision rises only for values
+ * which would otherwise print the same number beside different level names.
+ */
+export function formatCheckerScoreTexts(entries, startDecimals = 2, maxDecimals = 6) {
+    if (!Number.isInteger(startDecimals) || !Number.isInteger(maxDecimals) || startDecimals < 0 || maxDecimals < startDecimals) {
+        throw new RangeError("Score precision bounds are invalid.");
+    }
+    entries.forEach((entry, index) => probability(entry.rawScore, `entries[${index}].rawScore`));
+    const decimals = entries.map(() => startDecimals);
+    for (let pass = startDecimals; pass < maxDecimals; pass += 1) {
+        const groups = new Map();
+        entries.forEach((entry, index) => {
+            const text = entry.rawScore.toFixed(decimals[index]);
+            const group = groups.get(text);
+            if (group)
+                group.push(index);
+            else
+                groups.set(text, [index]);
+        });
+        let changed = false;
+        for (const group of groups.values()) {
+            if (new Set(group.map((index) => entries[index].level)).size > 1) {
+                for (const index of group)
+                    decimals[index] = decimals[index] + 1;
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return entries.map((entry, index) => entry.rawScore.toFixed(decimals[index]));
+}
+const DEFAULT_AI_LIMITATIONS = [
+    "The score is a zero-to-one pattern-similarity reading, not a percentage of the text written by AI.",
+    "This result does not prove authorship, and edited or out-of-register writing may be missed."
+];
+/** Build the only canonical five-band AI presentation used by pages, reports and shares. */
+export function presentCycle5Result(input) {
+    probability(input.rawScore, "rawScore");
+    probability(input.primaryDisplayThreshold, "primaryDisplayThreshold");
+    probability(input.secondaryDisplayThreshold, "secondaryDisplayThreshold");
+    if (!input.sections.length)
+        throw new Error("An assessed Cycle-5 result requires at least one scored section.");
+    const sections = input.sections.map((section, position) => {
+        if (!Number.isInteger(section.index) || section.index !== position)
+            throw new Error("Scored sections must be zero-based and in source order.");
+        if (!Number.isInteger(section.startUtf16) || !Number.isInteger(section.endUtf16) || section.startUtf16 < 0 || section.endUtf16 <= section.startUtf16) {
+            throw new Error(`Section ${section.index} has an invalid UTF-16 range.`);
+        }
+        if (position > 0 && section.startUtf16 < input.sections[position - 1].endUtf16)
+            throw new Error("Scored section ranges must not overlap or move backwards.");
+        if (!Number.isInteger(section.wordCount) || section.wordCount < 0)
+            throw new Error(`Section ${section.index} has an invalid word count.`);
+        if (section.passage === undefined && section.locator === undefined)
+            throw new Error(`Section ${section.index} needs a passage or a content-free locator.`);
+        return {
+            index: section.index,
+            start_utf16: section.startUtf16,
+            end_utf16: section.endUtf16,
+            word_count: section.wordCount,
+            raw_score: probability(section.rawScore, `sections[${section.index}].rawScore`),
+            raw_margin: finiteNumber(section.rawMargin, `sections[${section.index}].rawMargin`),
+            display_score: "",
+            level: levelForCycle5Score(section.rawScore, section.bandId, input.secondaryDisplayThreshold),
+            band_id: section.bandId,
+            ...(section.passage === undefined ? {} : { passage: section.passage }),
+            ...(section.locator === undefined ? {} : { locator: { ...section.locator } }),
+            evidence: section.evidence.map((item) => ({ ...item }))
+        };
+    });
+    const strongest = sections.reduce((best, section) => section.raw_score > best.raw_score ? section : best, sections[0]);
+    if (Math.abs(strongest.raw_score - input.rawScore) > Number.EPSILON)
+        throw new Error("The run-wide score must equal the strongest section's raw score.");
+    if (Math.abs(strongest.raw_margin - input.rawMargin) > Number.EPSILON)
+        throw new Error("The run-wide margin must equal the strongest section's raw margin.");
+    const margins = sections.map((section) => section.raw_margin).sort((a, b) => b - a);
+    const primaryFired = margins[0] >= CYCLE5_MODEL_IDENTITY.flagRule.primaryMargin;
+    const secondaryFired = margins.length > 1 && margins[1] + CYCLE5_MODEL_IDENTITY.flagRule.secondaryGap >= CYCLE5_MODEL_IDENTITY.flagRule.primaryMargin;
+    const expectedFlagged = primaryFired || secondaryFired;
+    const expectedReason = primaryFired ? "primary" : secondaryFired ? "secondary" : null;
+    if (input.flagged !== expectedFlagged || input.flagReason !== expectedReason)
+        throw new Error("The supplied flag state contradicts the Cycle-5 margin rule.");
+    const level = levelForCycle5Score(input.rawScore, input.bandId, input.secondaryDisplayThreshold);
+    const display = formatCheckerScoreTexts([
+        { rawScore: input.rawScore, level },
+        ...sections.map((section) => ({ rawScore: section.raw_score, level: section.level }))
+    ]);
+    sections.forEach((section, index) => { section.display_score = display[index + 1]; });
+    const limits = [...new Set([...(input.limitations ?? []), ...DEFAULT_AI_LIMITATIONS])];
+    const result = {
+        ai_pattern: {
+            assessment_status: "assessed",
+            method_status: input.flagged ? "attention" : "pass",
+            source: input.source,
+            raw_score: input.rawScore,
+            raw_margin: input.rawMargin,
+            display_score: display[0],
+            score_scale: CHECKER_SCORE_SCALE,
+            level,
+            primary_display_threshold: input.primaryDisplayThreshold,
+            secondary_display_threshold: input.secondaryDisplayThreshold,
+            flagged: input.flagged,
+            flag_reason: input.flagReason,
+            strongest_section_index: strongest.index,
+            reason: input.reason ?? CHECKER_LEVELS[level].support,
+            limitations: limits
+        },
+        sections
+    };
+    return deepFreeze(result);
+}
+export function notAssessedAiPattern(reason = "No trained model ran on this text, so the AI-pattern reading is not assessed.") {
+    return deepFreeze({
+        assessment_status: "not_assessed",
+        method_status: "not_run",
+        source: null,
+        raw_score: null,
+        raw_margin: null,
+        display_score: null,
+        score_scale: CHECKER_SCORE_SCALE,
+        level: null,
+        primary_display_threshold: null,
+        secondary_display_threshold: null,
+        flagged: null,
+        flag_reason: null,
+        strongest_section_index: null,
+        reason,
+        limitations: [...DEFAULT_AI_LIMITATIONS]
+    });
+}
+/**
+ * Reuse the compiled core's independent integrity/editorial axes without
+ * letting either one manufacture an AI result.
+ */
+export function composeCheckerAxes(combined, presented) {
+    if (presented) {
+        if (combined.ai_probability.source !== presented.ai_pattern.source || combined.ai_probability.value !== presented.ai_pattern.raw_score) {
+            throw new Error("The trained-model reading and the five-band presentation describe different runs.");
+        }
+    }
+    else if (combined.ai_probability.reading !== "not_assessed" || combined.ai_probability.value !== null) {
+        throw new Error("A model result cannot be discarded and replaced with not_assessed.");
+    }
+    const textStatus = combined.text_integrity.status;
+    const editorialLevel = combined.editorial.suggestion_level;
+    return deepFreeze({
+        ai_pattern: presented?.ai_pattern ?? notAssessedAiPattern(),
+        text_integrity: {
+            method_status: textStatus === "clean" ? "pass" : "attention",
+            reading: textStatus,
+            reason: combined.text_integrity.reason,
+            findings: combined.text_integrity.findings.map((finding) => ({ ...finding })),
+            limitations: [...combined.limitations]
+        },
+        editorial: {
+            method_status: editorialLevel === "none" ? "pass" : "attention",
+            reading: editorialLevel,
+            reason: combined.editorial.reason,
+            findings: (combined.editorial.categories_hit ?? []).map((category) => ({ category })),
+            limitations: [...combined.limitations]
+        }
+    });
+}
+/** Build a share/export object whose type cannot accept draft text or evidence. */
+export function buildContentFreeSharePayload(input) {
+    if (!Number.isInteger(input.wordCount) || input.wordCount < 0)
+        throw new Error("Share word count must be a non-negative integer.");
+    const date = new Date(input.generatedAt);
+    if (!Number.isFinite(date.valueOf()))
+        throw new Error("Share generation time must be a valid date-time.");
+    const payload = {
+        version: 1,
+        result_id: input.resultId,
+        level: input.presented.ai_pattern.level,
+        display_score: input.presented.ai_pattern.display_score,
+        sections: input.presented.sections.map((section) => ({
+            index: section.index,
+            raw_score: section.raw_score,
+            display_score: section.display_score,
+            level: section.level
+        })),
+        word_count: input.wordCount,
+        date: date.toISOString().slice(0, 10),
+        model_version: input.modelVersion,
+        honesty_line: CHECKER_HONESTY_LINE,
+        contains_content: false
+    };
+    assertContentFree(payload);
+    return deepFreeze(payload);
+}
+function assertContentFree(value, path = "share") {
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertContentFree(item, `${path}[${index}]`));
+        return;
+    }
+    if (typeof value !== "object" || value === null)
+        return;
+    for (const [key, item] of Object.entries(value)) {
+        if (CONTENT_KEYS.has(key.toLowerCase()))
+            throw new Error(`${path}.${key} is content-bearing and cannot appear in a share payload.`);
+        assertContentFree(item, `${path}.${key}`);
+    }
+}
+/**
+ * Producer-side semantic checks complement the additive-field-tolerant JSON
+ * Schema. Run this immediately before serialising, sharing or rendering.
+ */
+export function assertCheckerResultInvariants(result) {
+    if (result.schema_version !== "1.0" || !/^1\./u.test(result.contract_version))
+        throw new Error("Unsupported checker result contract.");
+    for (const method of result.methods)
+        if (!METHOD_STATUSES.has(method.status))
+            throw new Error(`Unknown method status: ${String(method.status)}`);
+    if (result.exports.receipt.contains_content !== false)
+        throw new Error("The default receipt must be content-free.");
+    if (result.exports.share.contains_content !== false)
+        throw new Error("The share export must be content-free.");
+    if (result.exports.share.payload)
+        assertContentFree(result.exports.share.payload);
+    if (result.provenance.safe_fixes.preview_first !== true || result.provenance.safe_fixes.explicit_approval_required !== true || result.provenance.safe_fixes.automatic_homoglyph_replacement !== false || result.provenance.safe_fixes.c2pa_wrapper_protected !== true) {
+        throw new Error("Safe-fix and C2PA wrapper invariants were weakened.");
+    }
+    for (const watermark of result.provenance.watermarks) {
+        if (watermark.method_id === "watermark.anthropic" && (watermark.method_status !== "unsupported" || !["not_available", "not_supported"].includes(watermark.outcome))) {
+            throw new Error("watermark.anthropic must remain unsupported until an official interface exists.");
+        }
+    }
+    const ai = result.axes.ai_pattern;
+    if (ai.assessment_status === "assessed") {
+        if (!result.route.model)
+            throw new Error("Only a trained model may set the AI-pattern reading.");
+        assertCycle5Identity(result.route.model);
+        if (!result.sections.length)
+            throw new Error("An assessed result needs scored sections.");
+        const ordered = [...result.sections].sort((a, b) => a.index - b.index);
+        ordered.forEach((section, index) => {
+            if (section.index !== index || section !== result.sections[index])
+                throw new Error("Scored sections must remain in source order.");
+            if (!section.band_id)
+                throw new Error(`Section ${section.index} has no measured band identity.`);
+            const bandId = section.band_id;
+            const expectedLevel = ai.secondary_display_threshold === null && bandId === "uncertain"
+                ? section.level
+                : levelForCycle5Score(section.raw_score, bandId, ai.secondary_display_threshold ?? undefined);
+            if (section.level !== expectedLevel || (bandId === "uncertain" && ai.secondary_display_threshold === null && !["signal-potentially-ai", "signal-likely-ai"].includes(section.level))) {
+                throw new Error(`Section ${section.index} level does not match its raw score and measured band.`);
+            }
+        });
+        const strongest = result.sections.reduce((best, section) => section.raw_score > best.raw_score ? section : best, result.sections[0]);
+        if (ai.strongest_section_index !== strongest.index || ai.raw_score !== strongest.raw_score || ai.raw_margin !== strongest.raw_margin)
+            throw new Error("The run-wide result does not identify the strongest section.");
+        if (ai.level !== strongest.level)
+            throw new Error("The run-wide level does not match the strongest section.");
+        if (ai.source !== result.route.model.identity)
+            throw new Error("The AI-pattern source does not match the executed model.");
+        if (result.source.section_count !== result.sections.length)
+            throw new Error("The source section count does not match the scored section set.");
+        if (ai.method_status !== (ai.flagged ? "attention" : "pass"))
+            throw new Error("The AI method status contradicts its flag state.");
+        result.sections.forEach((section, index) => {
+            if (index > 0 && section.start_utf16 < result.sections[index - 1].end_utf16)
+                throw new Error("Scored section ranges overlap or move backwards.");
+            if (section.locator && (section.locator.content_hash !== result.source.content_hash || section.locator.start_utf16 !== section.start_utf16 || section.locator.end_utf16 !== section.end_utf16)) {
+                throw new Error(`Section ${section.index} locator does not match its source or range.`);
+            }
+        });
+        const margins = result.sections.map((section) => section.raw_margin).sort((a, b) => b - a);
+        const primaryFired = margins[0] >= CYCLE5_MODEL_IDENTITY.flagRule.primaryMargin;
+        const secondaryFired = margins.length > 1 && margins[1] + CYCLE5_MODEL_IDENTITY.flagRule.secondaryGap >= CYCLE5_MODEL_IDENTITY.flagRule.primaryMargin;
+        const expectedFlagged = primaryFired || secondaryFired;
+        const expectedReason = primaryFired ? "primary" : secondaryFired ? "secondary" : null;
+        if (ai.flagged !== expectedFlagged || ai.flag_reason !== expectedReason)
+            throw new Error("The AI flag state contradicts the recorded Cycle-5 margins.");
+        const expected = formatCheckerScoreTexts([
+            { rawScore: ai.raw_score, level: ai.level },
+            ...result.sections.map((section) => ({ rawScore: section.raw_score, level: section.level }))
+        ]);
+        if (ai.display_score !== expected[0] || result.sections.some((section, index) => section.display_score !== expected[index + 1])) {
+            throw new Error("Visible/exported scores were not produced by the run-wide formatter.");
+        }
+        if (result.profile === "full_checker" && (!result.exports.report.available || !result.exports.report.complete_evidence)) {
+            throw new Error("An assessed full-checker result requires a complete report export.");
+        }
+    }
+    else {
+        if (ai.raw_score !== null || ai.raw_margin !== null || ai.display_score !== null || ai.level !== null || ai.flagged !== null || ai.strongest_section_index !== null) {
+            throw new Error("An unassessed, withheld or errored AI axis cannot publish a score or level.");
+        }
+        if (result.sections.length)
+            throw new Error("An unassessed result cannot publish model-scored sections.");
+    }
+    if (result.route.model === null && ai.assessment_status === "assessed")
+        throw new Error("Deterministic evidence cannot set the AI-pattern reading.");
+    assertRouteConsistency(result);
+    if (result.abuse_controls.request_body_logging !== "excluded" && result.abuse_controls.request_body_logging !== "not_applicable") {
+        throw new Error("A checker route may not claim readiness while request-body logging is unconfigured.");
+    }
+}
+function assertRouteConsistency(result) {
+    const { route, abuse_controls: controls } = result;
+    if (route.kind === "browser_model") {
+        if (route.content_transfer !== "none" || route.privacy_route !== "browser" || route.model?.precision !== "int8")
+            throw new Error("Browser-model route metadata is inconsistent.");
+    }
+    else if (route.kind === "eu_server") {
+        if (route.content_transfer !== "eu_server" || route.consent !== "explicit" || route.model?.precision !== "fp32")
+            throw new Error("EU-server route metadata is inconsistent.");
+        if (!["browser_pow_token", "chrome_extension_challenge_token", "wordpress_challenge_token"].includes(controls.channel_authentication))
+            throw new Error("EU-server results require their real channel authentication class.");
+    }
+    else if (route.kind === "wordpress_same_site") {
+        if (route.content_transfer !== "same_site" || route.privacy_route !== "wordpress_local" || controls.channel_authentication !== "same_site_nonce")
+            throw new Error("WordPress same-site route metadata is inconsistent.");
+    }
+    else if (route.kind === "loopback_engine") {
+        if (route.content_transfer !== "loopback" || route.privacy_route !== "local_service" || controls.channel_authentication !== "loopback_bearer")
+            throw new Error("Loopback route metadata is inconsistent.");
+    }
+    else if (route.kind === "deterministic_only") {
+        if (route.content_transfer !== "none" || route.model !== null || result.axes.ai_pattern.assessment_status === "assessed")
+            throw new Error("A deterministic-only route cannot publish a model result.");
+    }
+}
+function assertCycle5Identity(model) {
+    if (model.identity !== CYCLE5_MODEL_IDENTITY.identity ||
+        model.segmentation_contract !== CYCLE5_MODEL_IDENTITY.segmentationContract ||
+        model.input_contract !== CYCLE5_MODEL_IDENTITY.inputContract ||
+        model.features_contract !== CYCLE5_MODEL_IDENTITY.featuresContract ||
+        model.scoring_contract !== CYCLE5_MODEL_IDENTITY.scoringContract ||
+        model.flag_rule.expression !== CYCLE5_MODEL_IDENTITY.flagRule.expression ||
+        model.flag_rule.primary_margin !== CYCLE5_MODEL_IDENTITY.flagRule.primaryMargin ||
+        model.flag_rule.secondary_gap !== CYCLE5_MODEL_IDENTITY.flagRule.secondaryGap)
+        throw new Error("The assessed result does not identify the current Cycle-5 contracts and margin rule.");
+    if (model.precision === "fp32" && model.registry_identity !== CYCLE5_MODEL_IDENTITY.serverRegistryIdentity) {
+        throw new Error("The fp32 server route must identify the Cycle-5 server registry entry.");
+    }
+}
+function finiteNumber(value, name) {
+    if (!Number.isFinite(value))
+        throw new RangeError(`${name} must be finite.`);
+    return value;
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return Object.freeze(value);
+}

package/node_modules/@opacedev/ai-content-checker-core/dist/source/offsets.d.ts

@@ -0,0 +1,34 @@
+export interface OffsetRange {
+    [key: string]: unknown;
+    start_utf16: number;
+    end_utf16: number;
+    start_codepoint: number;
+    end_codepoint: number;
+}
+/**
+ * Snap a UTF-16 span outward to code-point boundaries.
+ *
+ * A boundary landing inside a surrogate pair is moved to the edge of the
+ * enclosing pair: `start` snaps down to the high surrogate, `end` snaps up past
+ * the low surrogate. The span therefore always covers whole code points and can
+ * never cut an astral character in half. Non-astral text is untouched, and the
+ * result is never narrower than the input, so a finding is never dropped.
+ *
+ * Call this before slicing the matched text at a span-construction site, so the
+ * slice, its hash and the recorded offsets all describe the same characters.
+ */
+export declare function alignUtf16Range(text: string, start: number, end: number): [number, number];
+/**
+ * Count the code points preceding a UTF-16 offset.
+ *
+ * This stays strict: an offset inside a surrogate pair has no meaningful
+ * code-point index, so it throws rather than inventing one. Callers that build
+ * spans go through `alignUtf16Range`/`rangeFromUtf16`, which snap the boundary
+ * out to the enclosing pair first, so the throw is now reserved for genuinely
+ * invalid input rather than for ordinary emoji-bearing text. Unpaired
+ * surrogates are rejected earlier by `inspect()` validation
+ * (`invalid_unicode_unpaired_surrogate`) and are not a split boundary here, so
+ * the alignment path only ever sees well-formed pairs.
+ */
+export declare function utf16ToCodePointOffset(text: string, offset: number): number;
+export declare function rangeFromUtf16(text: string, start: number, end: number): OffsetRange;

package/node_modules/@opacedev/ai-content-checker-core/dist/source/offsets.js

@@ -0,0 +1,51 @@
+const isHighSurrogate = (code) => code >= 0xd800 && code <= 0xdbff;
+const isLowSurrogate = (code) => code >= 0xdc00 && code <= 0xdfff;
+/**
+ * True when `offset` falls between the two halves of a well-formed surrogate
+ * pair. A lone surrogate never satisfies both sides, so unpaired input is
+ * deliberately not treated as a split boundary here.
+ */
+function splitsSurrogatePair(text, offset) {
+    return offset > 0 && offset < text.length &&
+        isHighSurrogate(text.charCodeAt(offset - 1)) && isLowSurrogate(text.charCodeAt(offset));
+}
+/**
+ * Snap a UTF-16 span outward to code-point boundaries.
+ *
+ * A boundary landing inside a surrogate pair is moved to the edge of the
+ * enclosing pair: `start` snaps down to the high surrogate, `end` snaps up past
+ * the low surrogate. The span therefore always covers whole code points and can
+ * never cut an astral character in half. Non-astral text is untouched, and the
+ * result is never narrower than the input, so a finding is never dropped.
+ *
+ * Call this before slicing the matched text at a span-construction site, so the
+ * slice, its hash and the recorded offsets all describe the same characters.
+ */
+export function alignUtf16Range(text, start, end) {
+    return [splitsSurrogatePair(text, start) ? start - 1 : start, splitsSurrogatePair(text, end) ? end + 1 : end];
+}
+/**
+ * Count the code points preceding a UTF-16 offset.
+ *
+ * This stays strict: an offset inside a surrogate pair has no meaningful
+ * code-point index, so it throws rather than inventing one. Callers that build
+ * spans go through `alignUtf16Range`/`rangeFromUtf16`, which snap the boundary
+ * out to the enclosing pair first, so the throw is now reserved for genuinely
+ * invalid input rather than for ordinary emoji-bearing text. Unpaired
+ * surrogates are rejected earlier by `inspect()` validation
+ * (`invalid_unicode_unpaired_surrogate`) and are not a split boundary here, so
+ * the alignment path only ever sees well-formed pairs.
+ */
+export function utf16ToCodePointOffset(text, offset) {
+    if (!Number.isInteger(offset) || offset < 0 || offset > text.length)
+        throw new RangeError("invalid_utf16_offset");
+    if (splitsSurrogatePair(text, offset))
+        throw new RangeError("split_surrogate");
+    return Array.from(text.slice(0, offset)).length;
+}
+export function rangeFromUtf16(text, start, end) {
+    if (end <= start)
+        throw new RangeError("empty_or_reversed_range");
+    const [alignedStart, alignedEnd] = alignUtf16Range(text, start, end);
+    return { start_utf16: alignedStart, end_utf16: alignedEnd, start_codepoint: utf16ToCodePointOffset(text, alignedStart), end_codepoint: utf16ToCodePointOffset(text, alignedEnd) };
+}

package/node_modules/@opacedev/ai-content-checker-core/dist/source/utf8.d.ts

@@ -0,0 +1,3 @@
+export declare function utf8Bytes(value: string): Uint8Array;
+export declare function sha256Hex(value: string): string;
+export declare const prefixedSha256: (value: string) => string;

package/node_modules/@opacedev/ai-content-checker-core/dist/source/utf8.js

@@ -0,0 +1,58 @@
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+export function utf8Bytes(value) {
+    return new TextEncoder().encode(value);
+}
+export function sha256Hex(value) {
+    const source = utf8Bytes(value);
+    const bitLength = source.length * 8;
+    const paddedLength = Math.ceil((source.length + 9) / 64) * 64;
+    const bytes = new Uint8Array(paddedLength);
+    bytes.set(source);
+    bytes[source.length] = 0x80;
+    const view = new DataView(bytes.buffer);
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x100000000), false);
+    const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(offset + i * 4, false);
+        for (let i = 16; i < 64; i++) {
+            const a = w[i - 15], b = w[i - 2];
+            w[i] = ((rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3)) + w[i - 16] + (rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10)) + w[i - 7]) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + s1 + ch + K[i] + w[i]) >>> 0;
+            const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (s0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    return Array.from(h, n => n.toString(16).padStart(8, "0")).join("");
+}
+export const prefixedSha256 = (value) => `sha256:${sha256Hex(value)}`;

package/node_modules/@opacedev/ai-content-checker-core/dist/source/visible-text.d.ts

@@ -0,0 +1,12 @@
+export interface SourceMapRun {
+    visible_start_utf16: number;
+    visible_end_utf16: number;
+    source_start_utf16: number;
+    source_end_utf16: number;
+}
+export interface VisibleTextProjection {
+    text: string;
+    runs: SourceMapRun[];
+    limitations: string[];
+}
+export declare function projectVisibleText(source: string, contentType: "plain_text" | "html" | "markdown"): VisibleTextProjection;

package/node_modules/@opacedev/ai-content-checker-core/dist/source/visible-text.js

@@ -0,0 +1,30 @@
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\u00a0" };
+const decodeEntity = (raw) => { if (raw[1] !== "#")
+    return ENTITIES[raw.slice(1, -1)] ?? raw; const value = raw[2]?.toLowerCase() === "x" ? Number.parseInt(raw.slice(3, -1), 16) : Number.parseInt(raw.slice(2, -1), 10); return Number.isInteger(value) && value >= 0 && value <= 0x10ffff && !(value >= 0xd800 && value <= 0xdfff) ? String.fromCodePoint(value) : raw; };
+export function projectVisibleText(source, contentType) {
+    if (contentType === "plain_text")
+        return { text: source, runs: source ? [{ visible_start_utf16: 0, visible_end_utf16: source.length, source_start_utf16: 0, source_end_utf16: source.length }] : [], limitations: [] };
+    if (contentType === "markdown") {
+        const text = source.replace(/```[\s\S]*?```/g, m => m).replace(/!?(\[([^\]]*)\])\(([^)]+)\)/g, (_m, _a, label) => label).replace(/(^|\s)[*_]{1,3}([^*_]+)[*_]{1,3}/g, "$1$2");
+        return { text, runs: text ? [{ visible_start_utf16: 0, visible_end_utf16: text.length, source_start_utf16: 0, source_end_utf16: source.length }] : [], limitations: ["Markdown mapping is projection-level; protected extractors retain exact source ranges."] };
+    }
+    let text = "", cursor = 0;
+    const runs = [];
+    const excluded = /<(script|style|template|noscript)\b[^>]*>[\s\S]*?<\/\1\s*>|<!--[\s\S]*?-->/gi;
+    const safe = source.replace(excluded, m => " ".repeat(m.length));
+    const token = /<[^>]*>|&(?:#x?[0-9a-f]+|[a-z]+);/gi;
+    let match;
+    const append = (value, start, end) => { if (!value)
+        return; const v = text.length; text += value; runs.push({ visible_start_utf16: v, visible_end_utf16: text.length, source_start_utf16: start, source_end_utf16: end }); };
+    while ((match = token.exec(safe))) {
+        append(safe.slice(cursor, match.index), cursor, match.index);
+        const raw = match[0];
+        if (/^<(br|\/?(?:p|div|section|article|li|h[1-6]|blockquote|tr))\b/i.test(raw))
+            append("\n", match.index, token.lastIndex);
+        else if (raw[0] === "&")
+            append(decodeEntity(raw), match.index, token.lastIndex);
+        cursor = token.lastIndex;
+    }
+    append(safe.slice(cursor), cursor, safe.length);
+    return { text, runs, limitations: ["HTML projection is deterministic text extraction, not sanitisation."] };
+}

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

@@ -0,0 +1,22 @@
+export declare const UNICODE_RULES_VERSION = "unicode:2026.08.2";
+export type CarrierSeverity = "note" | "low" | "medium" | "high";
+export type CarrierFix = "remove" | "space" | "review";
+/** joiner: exempt inside emoji ZWJ sequences and between cursive/Indic letters. variation: exempt after emoji-capable bases, downgraded after Han/Mongolian. variation_sup: downgraded after Han ideographs. */
+export type CarrierContext = "joiner" | "variation" | "variation_sup";
+export interface CarrierRule {
+    from: number;
+    to?: number;
+    name: string | ((cp: number) => string);
+    severity: CarrierSeverity;
+    fix: CarrierFix;
+    message: string;
+    context?: CarrierContext;
+    limitation?: string;
+}
+export declare const CARRIER_RULES: readonly CarrierRule[];
+export declare const CARRIER_RANGE_RULES: readonly CarrierRule[];
+export interface Confusable {
+    name: string;
+    latin: string;
+}
+export declare const CONFUSABLES: ReadonlyMap<number, Confusable>;