@opacedev/astro-ai-content-checker 0.3.1

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

@@ -0,0 +1,16 @@
+export interface MethodDescriptor {
+    id: string;
+    category: "unicode" | "pattern" | "watermark";
+    version: string;
+    state: "available" | "unsupported";
+    privacy_routes: readonly ["browser"];
+    limitations: readonly string[];
+}
+export declare const listMethods: () => Readonly<{
+    privacy_routes: readonly "browser"[];
+    limitations: readonly string[];
+    id: string;
+    category: "unicode" | "pattern" | "watermark";
+    version: string;
+    state: "available" | "unsupported";
+}>[];

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

@@ -0,0 +1,7 @@
+const METHODS = Object.freeze([
+    Object.freeze({ id: "unicode.invisible", category: "unicode", version: "unicode:2026.08.1", state: "available", privacy_routes: ["browser"], limitations: ["Controls can be legitimate in multilingual text."] }),
+    Object.freeze({ id: "unicode.homoglyph", category: "unicode", version: "unicode:2026.08.1", state: "available", privacy_routes: ["browser"], limitations: ["Mixed scripts require contextual human review."] }),
+    Object.freeze({ id: "style.patterns", category: "pattern", version: "en-gb:2026.08.1", state: "available", privacy_routes: ["browser"], limitations: ["Editorial pattern findings are not authorship evidence."] }),
+    Object.freeze({ id: "watermark.anthropic", category: "watermark", version: "adapter-placeholder/1", state: "unsupported", privacy_routes: ["browser"], limitations: ["No official detector interface is available."] })
+]);
+export const listMethods = () => METHODS.map(method => Object.freeze({ ...method, privacy_routes: Object.freeze([...method.privacy_routes]), limitations: Object.freeze([...method.limitations]) }));

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

@@ -0,0 +1,17 @@
+export interface DiffSegment {
+    type: "equal" | "insert" | "delete";
+    text: string;
+    source_start: number;
+    source_end: number;
+    candidate_start: number;
+    candidate_end: number;
+}
+export interface ContentDiff {
+    version: "lcs-token/1.0.0";
+    source_hash: string;
+    candidate_hash: string;
+    change_count: number;
+    segments: DiffSegment[];
+    fallback: boolean;
+}
+export declare function diff(source: string, candidate: string): ContentDiff;

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

@@ -0,0 +1,76 @@
+import { prefixedSha256 } from "../source/utf8.js";
+const tokens = (s) => s.match(/\s+|[^\s]+/g) ?? [];
+export function diff(source, candidate) {
+    if (source.length + candidate.length > 80_000)
+        return lineDiff(source, candidate);
+    const a = tokens(source), b = tokens(candidate);
+    if (a.length * b.length > 2_000_000)
+        return lineDiff(source, candidate);
+    const matches = hirschberg(a, b);
+    let i = 0, j = 0, sp = 0, cp = 0, mi = 0;
+    const out = [];
+    const push = (type, text, ss, se, cs, ce) => { const last = out.at(-1); if (last?.type === type && last.source_end === ss && last.candidate_end === cs) {
+        last.text += text;
+        last.source_end = se;
+        last.candidate_end = ce;
+    }
+    else
+        out.push({ type, text, source_start: ss, source_end: se, candidate_start: cs, candidate_end: ce }); };
+    while (i < a.length || j < b.length) {
+        const match = matches[mi];
+        if (match && i === match[0] && j === match[1]) {
+            const t = a[i];
+            push("equal", t, sp, sp + t.length, cp, cp + t.length);
+            sp += t.length;
+            cp += t.length;
+            i++;
+            j++;
+            mi++;
+        }
+        else if (j < b.length && (!match || j < match[1])) {
+            const t = b[j];
+            push("insert", t, sp, sp, cp, cp + t.length);
+            cp += t.length;
+            j++;
+        }
+        else {
+            const t = a[i];
+            push("delete", t, sp, sp + t.length, cp, cp);
+            sp += t.length;
+            i++;
+        }
+    }
+    return { version: "lcs-token/1.0.0", source_hash: prefixedSha256(source), candidate_hash: prefixedSha256(candidate), change_count: out.filter(x => x.type !== "equal").length, segments: out, fallback: false };
+}
+function rowScores(a, a0, a1, b, b0, b1, reverse = false) { const width = b1 - b0; let previous = new Uint32Array(width + 1), current = new Uint32Array(width + 1); for (let ai = 0; ai < a1 - a0; ai++) {
+    const av = a[reverse ? a1 - 1 - ai : a0 + ai];
+    for (let bj = 0; bj < width; bj++) {
+        const bv = b[reverse ? b1 - 1 - bj : b0 + bj];
+        current[bj + 1] = av === bv ? previous[bj] + 1 : Math.max(previous[bj + 1], current[bj]);
+    }
+    const swap = previous;
+    previous = current;
+    current = swap;
+    current.fill(0);
+} return previous; }
+function hirschberg(a, b) { const out = []; const walk = (a0, a1, b0, b1) => { if (a0 >= a1 || b0 >= b1)
+    return; if (a1 - a0 === 1) {
+    for (let j = b0; j < b1; j++)
+        if (a[a0] === b[j]) {
+            out.push([a0, j]);
+            break;
+        }
+    return;
+} const mid = (a0 + a1) >> 1; let left = rowScores(a, a0, mid, b, b0, b1), right = rowScores(a, mid, a1, b, b0, b1, true); let split = 0, best = -1; for (let j = 0; j <= b1 - b0; j++) {
+    const score = left[j] + right[b1 - b0 - j];
+    if (score > best) {
+        best = score;
+        split = j;
+    }
+} left = undefined; right = undefined; walk(a0, mid, b0, b0 + split); walk(mid, a1, b0 + split, b1); }; walk(0, a.length, 0, b.length); return out; }
+function lineDiff(source, candidate) { const segments = source === candidate ? (source ? [{ type: "equal", text: source, source_start: 0, source_end: source.length, candidate_start: 0, candidate_end: candidate.length }] : []) : []; if (source !== candidate) {
+    if (source)
+        segments.push({ type: "delete", text: source, source_start: 0, source_end: source.length, candidate_start: 0, candidate_end: 0 });
+    if (candidate)
+        segments.push({ type: "insert", text: candidate, source_start: source.length, source_end: source.length, candidate_start: 0, candidate_end: candidate.length });
+} return { version: "lcs-token/1.0.0", source_hash: prefixedSha256(source), candidate_hash: prefixedSha256(candidate), change_count: segments.filter(item => item.type !== "equal").length, segments, fallback: true }; }

package/node_modules/@opacedev/ai-content-checker-core/dist/fixes/preview.d.ts

@@ -0,0 +1,27 @@
+import type { ProtectedSpan } from "@opacedev/ai-content-checker-contracts";
+import type { UnicodeFinding } from "../unicode/inspect.js";
+import { type ContentDiff } from "../diff/diff.js";
+export interface FixPreview {
+    source_hash: string;
+    candidate_hash: string;
+    candidate: string;
+    applied_finding_ids: string[];
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+    diff: ContentDiff;
+}
+/**
+ * A C2PA text credential (C2PA 2.4 §A.8) is carried in the same variation
+ * selectors the hidden-character check flags, and U+FE00-U+FE0F carry
+ * fix:"remove". Removing them destroys the credential permanently and it cannot
+ * be rebuilt from the visible text, so the safe-fix path holds those characters
+ * back by default. Detection is untouched: every carrier is still found, still
+ * counted and still reported. Set allow_c2pa_credential_removal when the caller
+ * has taken a deliberate, confirmed decision to destroy the credential.
+ */
+export interface FixPreviewOptions {
+    allow_c2pa_credential_removal?: boolean;
+}
+export declare function previewSafeFixes(source: string, findings: UnicodeFinding[], selectedFindingIds: string[], protectedSpans?: ProtectedSpan[], options?: FixPreviewOptions): FixPreview;

package/node_modules/@opacedev/ai-content-checker-core/dist/fixes/preview.js

@@ -0,0 +1,47 @@
+import { diff } from "../diff/diff.js";
+import { prefixedSha256 } from "../source/utf8.js";
+import { detectC2paTextCredentials, withinCredential } from "../provenance/c2pa-text.js";
+export function previewSafeFixes(source, findings, selectedFindingIds, protectedSpans = [], options = {}) {
+    const credentials = options.allow_c2pa_credential_removal ? [] : detectC2paTextCredentials(source);
+    const selected = new Set(selectedFindingIds), edits = [], skipped = [];
+    for (const f of findings) {
+        if (!selected.has(f.id))
+            continue;
+        const raw = source.slice(f.span.start_utf16, f.span.end_utf16);
+        if (!f.id.startsWith("unicode_") || f.span.end_utf16 <= f.span.start_utf16 || f.matched_text_hash !== prefixedSha256(raw)) {
+            skipped.push({ id: f.id, reason: "invalid_finding_provenance" });
+            continue;
+        }
+        if (f.code_point === "U+FEFF" && f.span.start_utf16 !== 0) {
+            skipped.push({ id: f.id, reason: "invalid_bom_position" });
+            continue;
+        }
+        if (f.fix === "review") {
+            skipped.push({ id: f.id, reason: "user_review" });
+            continue;
+        }
+        if (withinCredential(credentials, f.span)) {
+            skipped.push({ id: f.id, reason: "c2pa_text_credential" });
+            continue;
+        }
+        if (protectedSpans.some(p => f.span.start_utf16 < p.end_utf16 && f.span.end_utf16 > p.start_utf16)) {
+            skipped.push({ id: f.id, reason: "protected_span" });
+            continue;
+        }
+        if (edits.some(e => f.span.start_utf16 < e.end && f.span.end_utf16 > e.start)) {
+            skipped.push({ id: f.id, reason: "overlapping_edit" });
+            continue;
+        }
+        edits.push({ start: f.span.start_utf16, end: f.span.end_utf16, value: f.fix === "space" ? " " : "", id: f.id });
+    }
+    edits.sort((a, b) => b.start - a.start);
+    let candidate = source;
+    for (const e of edits)
+        candidate = candidate.slice(0, e.start) + e.value + candidate.slice(e.end);
+    return deepFreeze({ source_hash: prefixedSha256(source), candidate_hash: prefixedSha256(candidate), candidate, applied_finding_ids: edits.map(e => e.id).reverse(), skipped, diff: diff(source, candidate) });
+}
+function deepFreeze(value) { if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        deepFreeze(child);
+} return value; }

package/node_modules/@opacedev/ai-content-checker-core/dist/gates/policy.d.ts

@@ -0,0 +1,14 @@
+import type { GateResult, ProtectedSpan } from "@opacedev/ai-content-checker-contracts";
+export interface GatePolicy {
+    mode?: "strict" | "manual_review";
+    expected_source_hash?: string;
+    language?: string;
+    max_length_ratio?: number;
+    allow_html?: boolean;
+}
+export declare function validateCandidate(source: {
+    content: string;
+    content_hash?: string;
+    content_type?: string;
+    language?: string;
+}, candidate: string, spans: ProtectedSpan[], policy?: GatePolicy): GateResult[];

package/node_modules/@opacedev/ai-content-checker-core/dist/gates/policy.js

@@ -0,0 +1,16 @@
+import { validateAdditions, validateProtected } from "../protected/validate.js";
+import { prefixedSha256 } from "../source/utf8.js";
+export function validateCandidate(source, candidate, spans, policy = {}) {
+    const gates = [validateProtected(source.content, candidate, spans), validateAdditions(source.content, candidate)];
+    const current = prefixedSha256(source.content), expected = policy.expected_source_hash ?? source.content_hash ?? current;
+    gates.push({ id: "source_version", version: "1.0.0", status: current === expected ? "pass" : "fail", hard: true, summary: current === expected ? "Source hash matches" : "Source changed since protection", failures: current === expected ? [] : [{ expected_hash: expected, observed: current }], limitations: [] });
+    const executable = /<\s*(?:script|iframe|object|embed|form)\b|\son\w+\s*=|javascript:/i.test(candidate);
+    gates.push({ id: "html_safety", version: "1.0.0", status: executable ? "fail" : "pass", hard: true, summary: executable ? "Executable or unsafe HTML found" : "No executable HTML found", failures: executable ? [{ observed: "executable_markup" }] : [], limitations: ["This deterministic gate is not a complete HTML sanitiser."] });
+    const max = policy.max_length_ratio ?? 2;
+    const ratio = source.content.length ? candidate.length / source.content.length : 1;
+    gates.push({ id: "language_length", version: "1.0.0", status: ratio > max ? "fail" : "pass", hard: true, summary: ratio > max ? "Candidate exceeds the configured length bound" : "Candidate is within the configured length bound", failures: ratio > max ? [{ observed_ratio: ratio, max_ratio: max }] : [], limitations: ["CORE-10 does not infer language; it preserves the requested language as a host-reviewed constraint."] });
+    const leakage = /\b(?:protected_span_id|system prompt|<\|(?:system|assistant|user)\|>)\b/i.test(candidate);
+    gates.push({ id: "output_safety", version: "1.0.0", status: leakage ? "fail" : "pass", hard: true, summary: leakage ? "Prompt or protected-ID leakage found" : "No prompt/control-token leakage found", failures: leakage ? [{ observed: "control_or_prompt_marker" }] : [], limitations: [] });
+    gates.push({ id: "semantic_entailment", version: "unconfigured/1", status: "not_configured", hard: true, summary: "Semantic entailment is not configured in the deterministic core", failures: [], limitations: ["Strict policy must treat this required semantic gate as blocking when generation depends on semantic fidelity."] });
+    return gates;
+}

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

@@ -0,0 +1,15 @@
+export { inspect, type InspectOptions } from "./inspect.js";
+export { extractProtectedSpans } from "./protected/extract.js";
+export { validateCandidate, type GatePolicy } from "./gates/policy.js";
+export { diff, type ContentDiff, type DiffSegment } from "./diff/diff.js";
+export { previewSafeFixes, type FixPreview, type FixPreviewOptions } from "./fixes/preview.js";
+export { detectC2paTextCredentials, variationSelectorToByte, isCredentialCarrier, withinCredential, credentialNotice, type C2paTextCredential } from "./provenance/c2pa-text.js";
+export { buildReceipt, verifyReceipt, type ReceiptInput } from "./receipts/build.js";
+export { registerPatternPack, type PatternPack } from "./patterns/en-gb-v1.js";
+export { listMethods, type MethodDescriptor } from "./capabilities.js";
+export { projectVisibleText, type VisibleTextProjection, type SourceMapRun } from "./source/visible-text.js";
+export { inspectUnicode, UNICODE_RULES_VERSION, type UnicodeFinding } from "./unicode/inspect.js";
+export { inspectSignalsV2, computeEditorialSignals, EN_SIGNALS_PATTERN_VERSION, type EditorialSignalsResult, type SignalsClassification } from "./patterns/en-signals-v2.js";
+export { prefixedSha256, sha256Hex, utf8Bytes } from "./source/utf8.js";
+export { computeCombinedVerdict, assertAxisIndependence, COMBINED_VERDICT_VERSION, type CombinedVerdictInput, type CombinedVerdictResult, type CombinedEvidenceItem, type EvidenceTier, type WatermarkOutcome, type ModelReading, type IntegrityFinding, type AiReading, type IntegrityStatus, type SuggestionLevel, type ConfidenceBand } from "./verdict/combine.js";
+export { CHECKER_RESULT_RUNTIME_VERSION, CYCLE5_MODEL_IDENTITY, CHECKER_SCORE_SCALE, CHECKER_HONESTY_LINE, CHECKER_LEVELS, levelForCycle5Score, formatCheckerScoreTexts, presentCycle5Result, notAssessedAiPattern, composeCheckerAxes, buildContentFreeSharePayload, assertCheckerResultInvariants, type CheckerLevelId, type Cycle5BandId, type CheckerEvidenceInput, type Cycle5SectionInput, type Cycle5PresentationInput, type PresentedCycle5Section, type PresentedCycle5Result, type SharePayloadInput } from "./report/checker-result.js";

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

@@ -0,0 +1,15 @@
+export { inspect } from "./inspect.js";
+export { extractProtectedSpans } from "./protected/extract.js";
+export { validateCandidate } from "./gates/policy.js";
+export { diff } from "./diff/diff.js";
+export { previewSafeFixes } from "./fixes/preview.js";
+export { detectC2paTextCredentials, variationSelectorToByte, isCredentialCarrier, withinCredential, credentialNotice } from "./provenance/c2pa-text.js";
+export { buildReceipt, verifyReceipt } from "./receipts/build.js";
+export { registerPatternPack } from "./patterns/en-gb-v1.js";
+export { listMethods } from "./capabilities.js";
+export { projectVisibleText } from "./source/visible-text.js";
+export { inspectUnicode, UNICODE_RULES_VERSION } from "./unicode/inspect.js";
+export { inspectSignalsV2, computeEditorialSignals, EN_SIGNALS_PATTERN_VERSION } from "./patterns/en-signals-v2.js";
+export { prefixedSha256, sha256Hex, utf8Bytes } from "./source/utf8.js";
+export { computeCombinedVerdict, assertAxisIndependence, COMBINED_VERDICT_VERSION } from "./verdict/combine.js";
+export { CHECKER_RESULT_RUNTIME_VERSION, CYCLE5_MODEL_IDENTITY, CHECKER_SCORE_SCALE, CHECKER_HONESTY_LINE, CHECKER_LEVELS, levelForCycle5Score, formatCheckerScoreTexts, presentCycle5Result, notAssessedAiPattern, composeCheckerAxes, buildContentFreeSharePayload, assertCheckerResultInvariants } from "./report/checker-result.js";

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

@@ -0,0 +1,8 @@
+import type { AnalysisRequest, AnalysisResult } from "@opacedev/ai-content-checker-contracts";
+export interface InspectOptions {
+    now?: () => string;
+    analysisId?: () => string;
+    onProgress?: (phase: "validating" | "mapping_text" | "unicode_checks" | "protected_spans" | "writing_patterns" | "complete") => void;
+    signal?: AbortSignal;
+}
+export declare function inspect(request: AnalysisRequest, options?: InspectOptions): Promise<AnalysisResult>;

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

@@ -0,0 +1,84 @@
+import { projectVisibleText } from "./source/visible-text.js";
+import { prefixedSha256 } from "./source/utf8.js";
+import { inspectUnicode, UNICODE_RULES_VERSION } from "./unicode/inspect.js";
+import { extractProtectedSpans } from "./protected/extract.js";
+import { inspectPatterns, runRegisteredPacks } from "./patterns/en-gb-v1.js";
+import { computeEditorialSignals, EN_SIGNALS_PATTERN_VERSION } from "./patterns/en-signals-v2.js";
+import { computeCombinedVerdict } from "./verdict/combine.js";
+const limits = (message) => [message, "Authorship cannot be proved from this check."];
+const WRITING_SIGNAL_RULES_RUN = 116; // 3 en-gb-v1 rules + 113 weighted signal categories (v2 51 + v3 55 + v4 rhythm 7)
+export async function inspect(request, options = {}) {
+    const now = options.now ?? (() => new Date().toISOString()), started = now();
+    const progress = (p) => { if (options.signal?.aborted)
+        throw new DOMException("Inspection cancelled", "AbortError"); options.onProgress?.(p); };
+    progress("validating");
+    if (request.schema_version !== "1.0" || !request.contract_version.startsWith("1."))
+        throw new Error("contract_incompatible");
+    if (request.source.content.length > 250000)
+        throw new Error("request_too_large");
+    if (hasUnpairedSurrogate(request.source.content))
+        throw new Error("invalid_unicode_unpaired_surrogate");
+    const sourceHash = prefixedSha256(request.source.content);
+    progress("mapping_text");
+    const projection = projectVisibleText(request.source.content, request.source.content_type);
+    progress("unicode_checks");
+    const unicode = inspectUnicode(request.source.content);
+    progress("protected_spans");
+    const protectedSpans = extractProtectedSpans({ ...request.source, content_hash: sourceHash });
+    progress("writing_patterns");
+    const patternFindings = [...inspectPatterns(projection.text), ...runRegisteredPacks(projection.text)];
+    const editorialSignals = request.checks.includes("style.patterns") ? computeEditorialSignals(projection.text) : undefined;
+    const methods = [];
+    for (const id of request.checks) {
+        const methodStarted = now();
+        if (id.startsWith("unicode.")) {
+            methods.push(method(id, "unicode", "Opace deterministic Unicode inspection", UNICODE_RULES_VERSION, unicode.length ? "attention" : "pass", unicode.map(x => ({ type: "unicode_finding", ...x })), limits("Unicode controls can be legitimate in multilingual text."), methodStarted, now(), "browser"));
+        }
+        else if (id === "style.patterns") {
+            const signalsAttention = patternFindings.length > 0 || (editorialSignals?.status === "scored" && editorialSignals.classification !== "human_like");
+            const evidence = patternFindings.length ? patternFindings.map(x => ({ type: "pattern_finding", rule_id: x.rule_id, span: x.span })) : [{ type: "scope_note", rules_run: WRITING_SIGNAL_RULES_RUN, note: "No selected writing-signal rule matched. This is not evidence of human authorship." }];
+            if (editorialSignals)
+                evidence.push({ type: "editorial_signals", ...editorialSignals });
+            methods.push(method(id, "pattern", "Opace writing-signal rules", EN_SIGNALS_PATTERN_VERSION, signalsAttention ? "attention" : "pass", evidence, limits("Writing patterns are editorial prompts, not detector or watermark evidence."), methodStarted, now(), "browser"));
+        }
+        else if (id === "watermark.anthropic") {
+            methods.push({ ...method(id, "watermark", "Anthropic official text-watermark detector", "unavailable-2026-08-26", "unsupported", [], ["No official detector call was available. Local style or public SynthID tests are not substitutes.", "Not yet available in this release."], methodStarted, now(), "browser"), availability: "not_available", native_outcome: "not_available" });
+        }
+        else
+            methods.push(method(id, "detector", id, "unsupported/1", "unsupported", [], ["This requested method is not implemented in the deterministic browser core.", "Not yet available in this release."], methodStarted, now(), "browser"));
+    }
+    // 2026.08.8: the three-axis verdict. Character forensics used to be discarded
+    // at verdict time, then (2026.08.7) briefly allowed to escalate the verdict to
+    // ai_like, which was the opposite error: a hidden character proves text
+    // MANIPULATION, not AI ORIGIN. verdict/combine.ts now publishes three readings
+    // that are never merged — the AI probability (a trained model only, and no
+    // model runs in this deterministic core), the text-integrity and provenance
+    // findings, and the editorial suggestions. Protected spans are not an input.
+    const watermarkOutcome = request.checks.includes("watermark.anthropic") ? "not_available" : "not_supported";
+    const combinedVerdict = computeCombinedVerdict({ signals: editorialSignals, unicodeFindings: unicode, text: request.source.content, watermark: { outcome: watermarkOutcome } });
+    const combinedRaised = combinedVerdict.text_integrity.status !== "clean";
+    const summary = { pass: 0, attention: 0, fail: 0, inconclusive: 0, unsupported: 0, not_configured: 0, not_run: 0, error: 0 };
+    for (const item of methods)
+        summary[item.status]++;
+    progress("complete");
+    const result = { schema_version: "1.0", contract_version: "1.0.0", request_id: request.request_id, analysis_id: options.analysisId?.() ?? `analysis_${sourceHash.slice(7, 23)}`, source: { content_hash: sourceHash, normalised_hash: prefixedSha256(projection.text.normalize("NFC")), content_type: request.source.content_type, language: request.source.language, word_count: (projection.text.trim().match(/\S+/g) ?? []).length }, protected_spans: protectedSpans, pattern_findings: patternFindings, methods, summary, combined_verdict: combinedVerdict, limitations: [...new Set(["Authorship cannot be proved from these checks.", ...projection.limitations, ...(combinedRaised ? combinedVerdict.limitations : [])])], started_at: started, completed_at: now() };
+    return deepFreeze(result);
+}
+function method(id, category, provider, version, status, evidence, limitations, started_at, completed_at, privacy_route) { if (!limitations.length)
+    throw new Error("method_limitations_required"); return { id, category, provider_or_method: provider, version, status, score: null, threshold: null, segments: [], evidence, limitations: limitations, started_at, completed_at, privacy_route }; }
+function deepFreeze(value) { if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        deepFreeze(child);
+} return value; }
+function hasUnpairedSurrogate(value) { for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 0xd800 && code <= 0xdbff) {
+        const next = value.charCodeAt(i + 1);
+        if (!(next >= 0xdc00 && next <= 0xdfff))
+            return true;
+        i++;
+    }
+    else if (code >= 0xdc00 && code <= 0xdfff)
+        return true;
+} return false; }

package/node_modules/@opacedev/ai-content-checker-core/dist/patterns/en-gb-v1.d.ts

@@ -0,0 +1,12 @@
+import type { PatternFinding } from "@opacedev/ai-content-checker-contracts";
+export { inspectSignalsV2, computeEditorialSignals, EN_SIGNALS_PATTERN_VERSION, type EditorialSignalsResult, type SignalsClassification } from "./en-signals-v2.js";
+export declare const EN_GB_PATTERN_VERSION = "en-gb:2026.08.1";
+export declare function inspectPatterns(text: string): PatternFinding[];
+export interface PatternPack {
+    id: string;
+    version: string;
+    rules: readonly string[];
+    inspect(text: string): PatternFinding[];
+}
+export declare function registerPatternPack(pack: PatternPack): () => void;
+export declare const runRegisteredPacks: (text: string) => PatternFinding[];

package/node_modules/@opacedev/ai-content-checker-core/dist/patterns/en-gb-v1.js

@@ -0,0 +1,68 @@
+import { alignUtf16Range, rangeFromUtf16 } from "../source/offsets.js";
+import { prefixedSha256 } from "../source/utf8.js";
+import { inspectSignalsV2 } from "./en-signals-v2.js";
+export { inspectSignalsV2, computeEditorialSignals, EN_SIGNALS_PATTERN_VERSION } from "./en-signals-v2.js";
+export const EN_GB_PATTERN_VERSION = "en-gb:2026.08.1";
+const PHRASES = ["in today's rapidly evolving landscape", "game-changer", "in conclusion", "it is important to note", "delve into"];
+// A rule's match length is measured on a lower-cased or trimmed copy of the
+// line, so the end boundary can land inside a surrogate pair when the match
+// runs up to an emoji (arena texts open list lines with one). Align the span
+// outward to whole code points BEFORE slicing, so the recorded offsets, the
+// evidence text and `matched_text_hash` all describe the same characters.
+const finding = (text, start, rule, severity, message, suggestion, evidence) => {
+    const raw = evidence.matched === undefined ? text.slice(start, start + 1) : String(evidence.matched);
+    const [alignedStart, alignedEnd] = alignUtf16Range(text, start, start + raw.length);
+    const matched = evidence.matched === undefined ? undefined : text.slice(alignedStart, alignedEnd);
+    return { rule_id: rule, rule_version: EN_GB_PATTERN_VERSION, severity, message, suggestion, span: rangeFromUtf16(text, alignedStart, alignedEnd), matched_text_hash: prefixedSha256(matched ?? ""), evidence: matched === undefined ? evidence : { ...evidence, matched } };
+};
+// Combined entry point: en-gb v1 rules plus the en-signals v2 pack adapted
+// from the MIT `avoid-ai-writing` engine (see en-signals-v2.ts). A v2 finding
+// whose span exactly duplicates a v1 finding's span is dropped so the same
+// phrase is not reported twice.
+export function inspectPatterns(text) {
+    const v1 = inspectPatternsV1(text);
+    const v1Spans = new Set(v1.map(f => `${f.span.start_utf16}:${f.span.end_utf16}`));
+    const v2 = inspectSignalsV2(text).filter(f => !v1Spans.has(`${f.span.start_utf16}:${f.span.end_utf16}`));
+    return [...v1, ...v2].sort((a, b) => a.span.start_utf16 - b.span.start_utf16 || a.rule_id.localeCompare(b.rule_id));
+}
+function inspectPatternsV1(text) {
+    const findings = [];
+    const lower = text.toLocaleLowerCase("en-GB");
+    for (const phrase of PHRASES) {
+        let at = 0, count = 0;
+        while ((at = lower.indexOf(phrase, at)) >= 0) {
+            count++;
+            at += phrase.length;
+        }
+        if (count >= 1) {
+            const start = lower.indexOf(phrase);
+            findings.push(finding(text, start, "style.overused_phrase", count > 1 ? "medium" : "low", "A stock phrase may make the passage feel generic.", "Review whether a more specific statement would be clearer.", { matched: text.slice(start, start + phrase.length), count, threshold: 1 }));
+        }
+    }
+    const sentences = text.split(/(?<=[.!?])\s+/).filter(Boolean);
+    const openings = new Map();
+    let cursor = 0;
+    for (const sentence of sentences) {
+        const start = text.indexOf(sentence, cursor);
+        cursor = start + sentence.length;
+        const opening = sentence.trim().split(/\s+/).slice(0, 3).join(" ").toLocaleLowerCase("en-GB");
+        if (opening.split(" ").length >= 2)
+            (openings.get(opening) ?? (openings.set(opening, []), openings.get(opening))).push(start);
+    }
+    for (const [opening, starts] of openings)
+        if (starts.length >= 3)
+            findings.push(finding(text, starts[0], "style.repeated_opening", "medium", "Several sentences begin the same way.", "Vary only the openings that genuinely benefit from it.", { matched: text.slice(starts[0], starts[0] + opening.length), count: starts.length, threshold: 3 }));
+    const transitions = (lower.match(/\b(?:moreover|furthermore|additionally|consequently|therefore|however)\b/g) ?? []).length;
+    const wordCount = text.trim() ? text.trim().split(/\s+/).length : 0;
+    if (wordCount >= 40 && transitions / wordCount > 0.04) {
+        const m = /\b(?:moreover|furthermore|additionally|consequently|therefore|however)\b/i.exec(text);
+        findings.push(finding(text, m.index, "style.transition_density", "low", "Transition words are unusually dense.", "Remove transitions that do not clarify the relationship between sentences.", { matched: m[0], count: transitions, word_count: wordCount, threshold_ratio: 0.04 }));
+    }
+    return findings.sort((a, b) => a.span.start_utf16 - b.span.start_utf16 || a.rule_id.localeCompare(b.rule_id));
+}
+const packs = new Map();
+export function registerPatternPack(pack) { if (!/^[a-z][a-z0-9.-]+$/.test(pack.id) || !pack.version || !pack.rules.length)
+    throw new Error("invalid_pattern_pack"); if (packs.has(pack.id))
+    throw new Error("duplicate_pattern_pack"); const frozen = Object.freeze({ ...pack, rules: Object.freeze([...pack.rules]) }); packs.set(pack.id, frozen); return () => { if (packs.get(pack.id) === frozen)
+    packs.delete(pack.id); }; }
+export const runRegisteredPacks = (text) => [...packs.values()].flatMap(pack => pack.inspect(text));

package/node_modules/@opacedev/ai-content-checker-core/dist/patterns/en-signals-v2-data.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Rule data for the en-signals v2 editorial-signals engine.
+ *
+ * Adapted to TypeScript from the MIT-licensed `avoid-ai-writing` detector
+ * (`detector/patterns.js`, Conor Bronsdon and contributors) recorded in
+ * `source-snapshots/avoid-ai-writing/`. See THIRD_PARTY_NOTICES.md.
+ *
+ * Everything in this module is a documented writing-pattern rule or a
+ * stylometric threshold. All of it is Tier B evidence in BRIEF.md §21 terms:
+ * editorial hints about style, never proof of authorship.
+ */
+export interface Tier1Phrase {
+    pattern: RegExp;
+    replace: string;
+    clarity?: boolean;
+}
+export interface Tier2Conditional {
+    word: string;
+    pattern: RegExp;
+    suggestion: string;
+}
+export declare const CYRILLIC_LOOKALIKES: Record<string, string>;
+export declare const GREEK_LOOKALIKES: Record<string, string>;
+export declare const ROLEPLAY_VERBS: RegExp;
+export declare const TIER1: Record<string, string>;
+export declare const TIER1_PHRASES: readonly Tier1Phrase[];
+export declare const TIER2: Record<string, string>;
+export declare const TIER2_CONDITIONAL: readonly Tier2Conditional[];
+export declare const TIER3: readonly string[];
+export declare const TIER3_PHRASES: readonly RegExp[];
+export declare const TRANSITIONS: readonly RegExp[];
+export declare const CHATBOT_ARTIFACTS: readonly RegExp[];
+export declare const SYCOPHANTIC: readonly RegExp[];
+export declare const FILLERS: readonly RegExp[];
+export declare const GENERIC_CONCLUSIONS: readonly RegExp[];
+export declare const LETS_PATTERNS: readonly RegExp[];
+export declare const REASONING_ARTIFACTS: readonly RegExp[];
+export declare const ACKNOWLEDGMENT_LOOPS: readonly RegExp[];
+export declare const SIGNIFICANCE_INFLATION: readonly RegExp[];
+export declare const VAGUE_ATTRIBUTIONS: readonly RegExp[];
+export declare const HOLLOW_INTENSIFIERS: readonly RegExp[];
+export declare const EMOTIONAL_FLATLINE: readonly RegExp[];
+export declare const LINGERING_ATTENTION: readonly RegExp[];
+export declare const NOVELTY_INFLATION: readonly RegExp[];
+export declare const CUTOFF_DISCLAIMERS: readonly RegExp[];
+export declare const AI_PLACEHOLDERS: readonly RegExp[];
+export declare const AI_CITATION_MARKUP: readonly RegExp[];
+export declare const AI_UTM_SOURCE: readonly RegExp[];
+export declare const TEMPLATE_PHRASES: readonly RegExp[];
+export declare const FALSE_CONCESSION: readonly RegExp[];
+export declare const RHETORICAL_QUESTIONS: readonly RegExp[];
+export declare const HEDGE_STACK: readonly RegExp[];
+export declare const FUTURE_NARRATIVE: readonly RegExp[];
+export declare const REAL_ACTUAL_INFLATION: readonly RegExp[];
+export declare const FORMULAIC_OPENERS: readonly RegExp[];
+export declare const SPECULATIVE_OPENERS: readonly RegExp[];
+export declare const PARENTHETICAL_HEDGE: readonly RegExp[];
+export declare const CONFIDENCE_CALIBRATION: readonly RegExp[];
+export declare const SOCIAL_CTA_CLOSER: readonly RegExp[];
+export declare const NOT_JUST_CONTRAST: readonly RegExp[];
+export declare const FUNCTION_WORD_IN_TITLE: RegExp;
+export declare const MD_HEADING_PREFIX: RegExp;
+export declare const TITLE_CASE_HEADER: RegExp;
+export declare const SEPARATOR_DASH_RE: RegExp;
+export declare const VERSION_HEADING_DASH_RE: RegExp;
+export declare const FUNC_WORDS: ReadonlySet<string>;
+export declare const ISSUE_WEIGHTS: Record<string, number>;
+export interface CategoryMeta {
+    severity: "note" | "low" | "medium" | "high";
+    message: string;
+    suggestion: string;
+}
+export declare const CATEGORY_META: Record<string, CategoryMeta>;