@opacedev/astro-ai-content-checker 0.3.1

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

@@ -0,0 +1,48 @@
+import type { IntegrityReceipt, MethodResult, GateResult } from "@opacedev/ai-content-checker-contracts";
+export interface ReceiptInput {
+    receipt_id: string;
+    product_version: string;
+    created_at: string;
+    source: {
+        content: string;
+        content_type: "plain_text" | "html" | "markdown";
+        language: string;
+        normalised_text?: string;
+    };
+    policy: {
+        id: string;
+        version: string;
+        requested_checks: string[];
+        allowed_routes: Array<"browser" | "wordpress_local" | "local_service" | "hub_provider" | "commercial_byok">;
+        retain_content: boolean;
+    };
+    methods: MethodResult[];
+    rewrite?: {
+        source_hash: string;
+        candidate_hash: string;
+        generator: {
+            route: "browser" | "wordpress_local" | "local_service" | "hub_provider" | "commercial_byok";
+            provider: string;
+            model: string;
+            prompt_template: string;
+            parameters?: Record<string, unknown>;
+        };
+        gates: GateResult[];
+        selected_candidate: string | null;
+        candidate_content?: string;
+    } | null;
+    approval: {
+        actor_id?: string;
+        at?: string;
+        scope: "whole" | "sentences" | "none";
+        sentence_ids?: string[];
+    };
+    limitations: string[];
+    contains_content: boolean;
+}
+export declare function buildReceipt(input: ReceiptInput): Promise<IntegrityReceipt>;
+export declare function verifyReceipt(receipt: IntegrityReceipt): {
+    valid: boolean;
+    errors: string[];
+    payload_hash: string;
+};

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

@@ -0,0 +1,61 @@
+import canonicalize from "canonicalize";
+import { prefixedSha256 } from "../source/utf8.js";
+const payloadForHash = (receipt) => { const clone = structuredClone(receipt); delete clone.integrity?.payload_hash; delete clone.integrity?.signature; return clone; };
+const canonical = (value) => { const output = canonicalize(value); if (output === undefined)
+    throw new Error("receipt_canonicalisation_failed"); return output; };
+export async function buildReceipt(input) {
+    if (input.contains_content !== input.policy.retain_content)
+        throw new Error("receipt_content_consent_mismatch");
+    if (input.contains_content && input.rewrite && !input.rewrite.candidate_content)
+        throw new Error("receipt_candidate_content_required");
+    const sourceHash = prefixedSha256(input.source.content), normalisedHash = prefixedSha256(input.source.normalised_text ?? input.source.content);
+    const source = { content_hash: sourceHash, normalised_hash: normalisedHash, content_type: input.source.content_type, language: input.source.language, word_count: (input.source.content.trim().match(/\S+/g) ?? []).length };
+    if (input.contains_content)
+        source.content = input.source.content;
+    const rewrite = input.rewrite ? (() => { const { candidate_content, source_content: _callerSourceContent, ...metadata } = input.rewrite; return { ...metadata, ...(input.contains_content ? { source_content: input.source.content, candidate_content } : {}) }; })() : null;
+    const receipt = { schema_version: "1.0", contract_version: "1.0.0", product_version: input.product_version, receipt_id: input.receipt_id, created_at: input.created_at, source, policy: input.policy, methods: input.methods, rewrite, approval: input.approval, limitations: input.limitations, contains_content: input.contains_content, integrity: { canonicalisation: "RFC8785", payload_hash: "sha256:" + "0".repeat(64) } };
+    receipt.integrity.payload_hash = prefixedSha256(canonical(payloadForHash(receipt)));
+    return deepFreeze(receipt);
+}
+export function verifyReceipt(receipt) { const errors = validateReceiptShape(receipt); let expected = ""; try {
+    expected = prefixedSha256(canonical(payloadForHash(receipt)));
+    if (expected !== receipt?.integrity?.payload_hash)
+        errors.push("payload_hash_mismatch");
+}
+catch {
+    errors.push("receipt_canonicalisation_failed");
+} return { valid: errors.length === 0, errors: [...new Set(errors)], payload_hash: expected }; }
+const isHash = (value) => typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value);
+const isTime = (value) => typeof value === "string" && !Number.isNaN(Date.parse(value));
+function validateReceiptShape(receipt) { const e = []; if (!receipt || typeof receipt !== "object")
+    return ["invalid_receipt"]; if (receipt.schema_version !== "1.0")
+    e.push("unsupported_schema"); if (typeof receipt.contract_version !== "string" || !receipt.contract_version.startsWith("1."))
+    e.push("contract_incompatible"); for (const key of ["product_version", "receipt_id"])
+    if (typeof receipt[key] !== "string" || !receipt[key])
+        e.push(`missing_${key}`); if (!isTime(receipt.created_at))
+    e.push("invalid_created_at"); if (!receipt.source || !isHash(receipt.source.content_hash) || !isHash(receipt.source.normalised_hash) || !Number.isInteger(receipt.source.word_count) || receipt.source.word_count < 0 || !["plain_text", "html", "markdown"].includes(receipt.source.content_type) || typeof receipt.source.language !== "string")
+    e.push("invalid_source"); if (!receipt.policy || typeof receipt.policy.retain_content !== "boolean" || !Array.isArray(receipt.policy.requested_checks) || !Array.isArray(receipt.policy.allowed_routes))
+    e.push("invalid_policy"); if (typeof receipt.contains_content !== "boolean")
+    e.push("invalid_contains_content"); if (receipt.policy && receipt.contains_content !== receipt.policy.retain_content)
+    e.push("receipt_content_consent_mismatch"); if (receipt.source && receipt.contains_content !== Object.hasOwn(receipt.source, "content"))
+    e.push("receipt_content_flag_mismatch"); if (receipt.rewrite) {
+    if (!isHash(receipt.rewrite.source_hash) || !isHash(receipt.rewrite.candidate_hash) || !receipt.rewrite.generator || !Array.isArray(receipt.rewrite.gates) || !(typeof receipt.rewrite.selected_candidate === "string" || receipt.rewrite.selected_candidate === null))
+        e.push("invalid_rewrite");
+    const hasSource = Object.hasOwn(receipt.rewrite, "source_content"), hasCandidate = Object.hasOwn(receipt.rewrite, "candidate_content");
+    if (receipt.contains_content ? (!hasSource || !hasCandidate) : (hasSource || hasCandidate))
+        e.push("rewrite_content_flag_mismatch");
+} if (!Array.isArray(receipt.methods))
+    e.push("invalid_methods");
+else
+    for (const method of receipt.methods) {
+        if (!method || typeof method.id !== "string" || typeof method.version !== "string" || !["pass", "attention", "fail", "inconclusive", "unsupported", "not_configured", "not_run", "error"].includes(method.status) || !isTime(method.started_at) || !isTime(method.completed_at) || !Array.isArray(method.limitations) || !method.limitations.length)
+            e.push("invalid_method");
+    } if (!receipt.approval || !["whole", "sentences", "none"].includes(receipt.approval.scope))
+    e.push("invalid_approval"); if (!Array.isArray(receipt.limitations) || !receipt.limitations.length)
+    e.push("invalid_limitations"); if (receipt.integrity?.canonicalisation !== "RFC8785" || !isHash(receipt.integrity?.payload_hash))
+    e.push("invalid_integrity"); return e; }
+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/report/checker-result.d.ts

@@ -0,0 +1,241 @@
+import type { CheckerResult } from "@opacedev/ai-content-checker-contracts";
+import type { CombinedVerdictResult } from "../verdict/combine.js";
+/** Portable result/presentation semantics shared by every checker surface. */
+export declare const CHECKER_RESULT_RUNTIME_VERSION: "checker-result:2026.09.1";
+export declare const CYCLE5_MODEL_IDENTITY: {
+    readonly identity: "tier3-cycle5-v1";
+    readonly serverRegistryIdentity: "tier3-cycle5-full";
+    readonly segmentationContract: "segments-v3";
+    readonly inputContract: "raw-v1";
+    readonly featuresContract: "features-v1";
+    readonly scoringContract: "margin-v1";
+    readonly flagRule: {
+        readonly expression: "max(m1, m2 + 0.34) >= 3.570935";
+        readonly primaryMargin: 3.570935;
+        readonly secondaryGap: 0.34;
+    };
+};
+export declare const CHECKER_SCORE_SCALE: "zero_to_one_pattern_similarity";
+export declare const CHECKER_HONESTY_LINE: "No AI checker can prove who wrote a text \u2014 this is a pattern reading.";
+export declare const CHECKER_LEVELS: {
+    readonly "signal-strongly-ai": {
+        readonly name: "Strongly AI";
+        readonly support: "This draft very strongly matches AI writing — the kind of match we rarely see in human work.";
+    };
+    readonly "signal-likely-ai": {
+        readonly name: "Likely AI";
+        readonly support: "Much of this draft reads like AI writing.";
+    };
+    readonly "signal-potentially-ai": {
+        readonly name: "Potentially AI";
+        readonly support: "Parts of this draft resemble AI writing, but the match is not strong enough to be sure.";
+    };
+    readonly "signal-unclear": {
+        readonly name: "Unclear";
+        readonly support: "We can't call this one either way. Some passages read slightly machine-like, but people write that way too.";
+    };
+    readonly "signal-likely-human": {
+        readonly name: "Likely human";
+        readonly 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.";
+    };
+};
+export type CheckerLevelId = keyof typeof CHECKER_LEVELS;
+export type Cycle5BandId = "very_likely_ai" | "uncertain" | "likely_human" | "very_likely_human";
+/**
+ * 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 declare function levelForCycle5Score(rawScore: number, bandId: Cycle5BandId, secondaryThreshold?: number): CheckerLevelId;
+/**
+ * Format every score in one run together. Precision rises only for values
+ * which would otherwise print the same number beside different level names.
+ */
+export declare function formatCheckerScoreTexts(entries: readonly {
+    rawScore: number;
+    level: CheckerLevelId;
+}[], startDecimals?: number, maxDecimals?: number): string[];
+export interface CheckerEvidenceInput {
+    id: string;
+    kind: "trained_model" | "measured_pattern" | "editorial_rule" | "character" | "provenance" | "watermark" | "limitation";
+    summary: string;
+    detail?: string;
+    basis?: string;
+}
+export interface Cycle5SectionInput {
+    index: number;
+    startUtf16: number;
+    endUtf16: number;
+    wordCount: number;
+    rawScore: number;
+    rawMargin: number;
+    bandId: Cycle5BandId;
+    passage?: string;
+    locator?: {
+        content_hash: string;
+        start_utf16: number;
+        end_utf16: number;
+    };
+    evidence: readonly CheckerEvidenceInput[];
+}
+export interface Cycle5PresentationInput {
+    source: string;
+    rawScore: number;
+    rawMargin: number;
+    bandId: Cycle5BandId;
+    /** Probability-space display equivalent of the primary margin boundary. It never decides the flag. */
+    primaryDisplayThreshold: number;
+    /** Probability-space display equivalent of m2 + gap. It refines the visible band but never decides the flag. */
+    secondaryDisplayThreshold: number;
+    flagged: boolean;
+    flagReason: "primary" | "secondary" | null;
+    sections: readonly Cycle5SectionInput[];
+    reason?: string;
+    limitations?: readonly string[];
+}
+export interface PresentedCycle5Section {
+    index: number;
+    start_utf16: number;
+    end_utf16: number;
+    word_count: number;
+    raw_score: number;
+    raw_margin: number;
+    display_score: string;
+    level: CheckerLevelId;
+    band_id: Cycle5BandId;
+    passage?: string;
+    locator?: {
+        content_hash: string;
+        start_utf16: number;
+        end_utf16: number;
+    };
+    evidence: CheckerEvidenceInput[];
+}
+export interface PresentedCycle5Result {
+    ai_pattern: {
+        assessment_status: "assessed";
+        method_status: "pass" | "attention";
+        source: string;
+        raw_score: number;
+        raw_margin: number;
+        display_score: string;
+        score_scale: typeof CHECKER_SCORE_SCALE;
+        level: CheckerLevelId;
+        primary_display_threshold: number;
+        secondary_display_threshold: number;
+        flagged: boolean;
+        flag_reason: "primary" | "secondary" | null;
+        strongest_section_index: number;
+        reason: string;
+        limitations: [string, ...string[]];
+    };
+    sections: PresentedCycle5Section[];
+}
+/** Build the only canonical five-band AI presentation used by pages, reports and shares. */
+export declare function presentCycle5Result(input: Cycle5PresentationInput): Readonly<PresentedCycle5Result>;
+export declare function notAssessedAiPattern(reason?: string): Readonly<{
+    assessment_status: "not_assessed";
+    method_status: "not_run";
+    source: null;
+    raw_score: null;
+    raw_margin: null;
+    display_score: null;
+    score_scale: "zero_to_one_pattern_similarity";
+    level: null;
+    primary_display_threshold: null;
+    secondary_display_threshold: null;
+    flagged: null;
+    flag_reason: null;
+    strongest_section_index: null;
+    reason: string;
+    limitations: [string, ...string[]];
+}>;
+/**
+ * Reuse the compiled core's independent integrity/editorial axes without
+ * letting either one manufacture an AI result.
+ */
+export declare function composeCheckerAxes(combined: CombinedVerdictResult, presented?: Readonly<PresentedCycle5Result>): Readonly<{
+    ai_pattern: {
+        assessment_status: "assessed";
+        method_status: "pass" | "attention";
+        source: string;
+        raw_score: number;
+        raw_margin: number;
+        display_score: string;
+        score_scale: typeof CHECKER_SCORE_SCALE;
+        level: CheckerLevelId;
+        primary_display_threshold: number;
+        secondary_display_threshold: number;
+        flagged: boolean;
+        flag_reason: "primary" | "secondary" | null;
+        strongest_section_index: number;
+        reason: string;
+        limitations: [string, ...string[]];
+    } | Readonly<{
+        assessment_status: "not_assessed";
+        method_status: "not_run";
+        source: null;
+        raw_score: null;
+        raw_margin: null;
+        display_score: null;
+        score_scale: "zero_to_one_pattern_similarity";
+        level: null;
+        primary_display_threshold: null;
+        secondary_display_threshold: null;
+        flagged: null;
+        flag_reason: null;
+        strongest_section_index: null;
+        reason: string;
+        limitations: [string, ...string[]];
+    }>;
+    text_integrity: {
+        method_status: "pass" | "attention";
+        reading: import("../verdict/combine.js").IntegrityStatus;
+        reason: string;
+        findings: {
+            applied: string;
+            status: import("../verdict/combine.js").IntegrityStatus;
+            reason: string;
+        }[];
+        limitations: [string, ...string[]];
+    };
+    editorial: {
+        method_status: "pass" | "attention";
+        reading: import("../verdict/combine.js").SuggestionLevel;
+        reason: string;
+        findings: {
+            category: string;
+        }[];
+        limitations: [string, ...string[]];
+    };
+}>;
+export interface SharePayloadInput {
+    resultId: string;
+    generatedAt: string;
+    wordCount: number;
+    modelVersion: string;
+    presented: Readonly<PresentedCycle5Result>;
+}
+/** Build a share/export object whose type cannot accept draft text or evidence. */
+export declare function buildContentFreeSharePayload(input: SharePayloadInput): Readonly<{
+    version: 1;
+    result_id: string;
+    level: "signal-strongly-ai" | "signal-likely-ai" | "signal-potentially-ai" | "signal-unclear" | "signal-likely-human";
+    display_score: string;
+    sections: {
+        index: number;
+        raw_score: number;
+        display_score: string;
+        level: "signal-strongly-ai" | "signal-likely-ai" | "signal-potentially-ai" | "signal-unclear" | "signal-likely-human";
+    }[];
+    word_count: number;
+    date: string;
+    model_version: string;
+    honesty_line: "No AI checker can prove who wrote a text — this is a pattern reading.";
+    contains_content: false;
+}>;
+/**
+ * Producer-side semantic checks complement the additive-field-tolerant JSON
+ * Schema. Run this immediately before serialising, sharing or rendering.
+ */
+export declare function assertCheckerResultInvariants(result: CheckerResult): void;