@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/google-policy-sentinel.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 🛡️ Google Algorithmic Policy & Deprecation Sentinel (2024-2026 Rules)
+ * Verified against Google Search Status Dashboard & Search Central Documentation.
+ *
+ * Checks website elements against Google's official policies and deprecations:
+ * - September 2026 Spam Update (Started 2026-09-24, global rollout across all languages)
+ * - Site Reputation Abuse (November 2024 policy; regional algorithmic enforcement effective August 30, 2026)
+ * - Scaled Content Abuse & Expired Domain Abuse policies
+ * - Google-Extended vs Search Gen-AI Controls (Gemini training/grounding vs Search/Discover)
+ * - Client-rendered dynamic schema warning (Product markup slowing Shopping crawl)
+ * - FAQPage rich results retirement (May 2026)
+ * - HowTo rich results removal (September 2023)
+ * - YMYL expanded scope for political, health, and financial advice (September 2025)
+ * - Google Business Profile .business.site websites deprecation
+ * - Search Console URL Inspection mobileUsabilityResult deprecation
+ *
+ * Also isolates unverified third-party claims (e.g. SAFE detector on Search, unverified updates)
+ * so audits never hallucinate rumors as verified Google facts.
+ */
+export interface PolicyCheckResult {
+    policyName: string;
+    enforcementDate: string;
+    status: "compliant" | "risk_detected" | "deprecated_feature_used" | "info_advisory";
+    severity: "critical" | "high" | "warning" | "info";
+    description: string;
+    remedy: string;
+    primarySource?: string;
+}
+export interface UnverifiedClaimRecord {
+    claim: string;
+    verdict: "refuted" | "unverified_for_search" | "third_party_speculation";
+    fact: string;
+    primarySource: string;
+}
+export interface GooglePolicyAuditSummary {
+    domain: string;
+    totalChecksCount: number;
+    deprecatedCount: number;
+    risksCount: number;
+    advisoryCount: number;
+    isFullyCompliant: boolean;
+    activeSpamUpdateInRollout: boolean;
+    policyResults: PolicyCheckResult[];
+    unverifiedClaims: UnverifiedClaimRecord[];
+}
+export declare class GooglePolicySentinel {
+    /**
+     * Primary canonical ledger of unverified rumors & third-party claims.
+     * Guarantees that audits never present speculative assertions as Google facts.
+     */
+    static readonly UNVERIFIED_CLAIMS: UnverifiedClaimRecord[];
+    /**
+     * Scans page elements and schema types against active Google policies.
+     */
+    static auditPagePolicies(input: {
+        domain: string;
+        schemaTypesFound: string[];
+        hasThirdPartyParasiteSubfolder: boolean;
+        hasGbpBusinessSiteLink: boolean;
+        isYmylNiche: boolean;
+        hasAuthorCredentials: boolean;
+        hasScaledAiContentWithoutReview?: boolean;
+        hasExpiredDomainRepurposing?: boolean;
+        hasGoogleExtendedBlocked?: boolean;
+        hasClientSideRenderedProductSchema?: boolean;
+        usesGscMobileUsabilityApi?: boolean;
+    }): GooglePolicyAuditSummary;
+}

package/dist/gorgias-sync-engine.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 🎧 `gorgias-sync-engine.ts` — Synchronisation native Gorgias Helpdesk API.
+ *
+ * Implémente :
+ * - Création ou mise à jour de fiche client Gorgias (`/api/customers`).
+ * - Création automatique de ticket de support ou de feedback qualifié (`/api/tickets`) si le client signale un problème (NPS < 6 ou question ouverte).
+ * - Authentification Basic Auth (`username:api_key`) sur `https://{domain}.gorgias.com/api`.
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+export interface GorgiasConfig {
+    domain: string;
+    email: string;
+    apiKey: string;
+}
+export interface GorgiasCustomerPayload {
+    email: string;
+    name?: string;
+    phone?: string;
+    zeroPartyAnswers?: Record<string, unknown>;
+    couponCode?: string;
+}
+export interface GorgiasTicketPayload {
+    customerEmail: string;
+    customerName?: string;
+    subject: string;
+    messageBody: string;
+    tags?: string[];
+}
+export interface GorgiasSyncResult {
+    ok: boolean;
+    customerId?: number;
+    ticketId?: number;
+    error?: string;
+}
+export declare class GorgiasSyncEngine {
+    static getBaseUrl(domain: string): string;
+    static getAuthHeader(email: string, apiKey: string): string;
+    /**
+     * Crée ou met à jour le profil client dans Gorgias.
+     */
+    static syncCustomer(config: GorgiasConfig, payload: GorgiasCustomerPayload, customFetch?: typeof fetch): Promise<GorgiasSyncResult>;
+    /**
+     * Crée un ticket de suivi dans Gorgias (ex: NPS détracteur ou question ouverte).
+     */
+    static createTicket(config: GorgiasConfig, payload: GorgiasTicketPayload, customFetch?: typeof fetch): Promise<GorgiasSyncResult>;
+}

package/dist/governance/schema-discovery.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Schema Auto-Discovery & Tracking Plan Generator — RudderStack Data Governance Parity
+ *
+ * Analyse automatiquement un échantillon d'événements bruts (JSON/objets) pour :
+ * 1. Découvrir les noms d'événements uniques et leurs fréquences.
+ * 2. Déduire les types de propriétés (string, number, boolean, array, object).
+ * 3. Déterminer les champs obligatoires (taux de présence >= presenceThreshold, défaut: 90%).
+ * 4. Détecter les plages numériques (minimum, maximum) et les énumérations à faible cardinalité (allowedValues).
+ * 5. Générer ou mettre à jour un Tracking Plan prêt pour le `TrackingPlanValidator`.
+ */
+import type { GovernanceTrackingPlan, ViolationPolicy } from "./tracking-plan";
+export interface SchemaDiscoveryOptions {
+    projectId: string;
+    planName: string;
+    version?: string;
+    /**
+     * Seuil de présence (entre 0 et 1) pour qu'une propriété soit considérée comme obligatoire.
+     * Défaut: 0.90 (90%)
+     */
+    presenceThreshold?: number;
+    /**
+     * Seuil de cardinalité pour inférer une énumération (allowedValues).
+     * Si le nombre de valeurs distinctes <= enumThreshold, une liste de valeurs autorisées est générée.
+     * Défaut: 8
+     */
+    enumThreshold?: number;
+    allowUnplannedEvents?: boolean;
+    defaultViolationPolicy?: ViolationPolicy;
+}
+/**
+ * Déduit un Tracking Plan gouverné à partir d'une collection d'événements bruts.
+ */
+export declare function inferTrackingPlanFromEvents(rawEvents: Array<Record<string, unknown>>, options: SchemaDiscoveryOptions): GovernanceTrackingPlan;
+/**
+ * Fusionne un Tracking Plan existant avec de nouvelles règles découvertes (évolution de schéma).
+ */
+export declare function mergeTrackingPlans(basePlan: GovernanceTrackingPlan, discoveredPlan: GovernanceTrackingPlan, bumpVersion?: string): GovernanceTrackingPlan;

package/dist/governance/tracking-plan.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Tracking Plan & Schema Governance — RudderStack Data Governance Parity
+ *
+ * Valide les événements entrants par rapport à un contrat de données (Tracking Plan) :
+ * - Détection du schema drift (propriétés manquantes, types erronés, valeurs non autorisées)
+ * - Politiques de violation configurables : `allow_with_warning`, `drop`, ou `quarantine`
+ * - File de mise en quarantaine (`QuarantineStore`) pour inspecter et rejouer les événements rejetés.
+ */
+export type ViolationType = "unplanned_event" | "missing_required_property" | "invalid_property_type" | "unallowed_value" | "unplanned_property";
+export type ViolationPolicy = "allow_with_warning" | "drop" | "quarantine";
+export interface TrackingViolation {
+    type: ViolationType;
+    property?: string;
+    message: string;
+    expected?: unknown;
+    actual?: unknown;
+}
+export interface PropertyRule {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    allowedValues?: unknown[];
+    minimum?: number;
+    maximum?: number;
+    regex?: string;
+}
+export interface EventRule {
+    eventName: string;
+    description?: string;
+    requiredProperties?: string[];
+    properties?: Record<string, PropertyRule>;
+    allowUnplannedProperties?: boolean;
+    violationPolicy?: ViolationPolicy;
+}
+export interface TrackingPlan {
+    id: string;
+    projectId: string;
+    name: string;
+    version: string;
+    allowUnplannedEvents: boolean;
+    defaultViolationPolicy: ViolationPolicy;
+    rules: Record<string, EventRule>;
+}
+export type GovernanceTrackingPlan = TrackingPlan;
+export interface ValidationReport {
+    valid: boolean;
+    eventName: string;
+    policyAction: "pass" | "warn" | "drop" | "quarantine";
+    violations: TrackingViolation[];
+}
+export interface QuarantinedEvent {
+    id: string;
+    projectId: string;
+    eventName: string;
+    rawPayload: Record<string, unknown>;
+    violations: TrackingViolation[];
+    quarantinedAt: string;
+    status: "quarantined" | "resolved" | "dropped";
+}
+export declare class TrackingPlanValidator {
+    /**
+     * Valide un événement par rapport au Tracking Plan.
+     */
+    static validate(event: Record<string, unknown>, plan: TrackingPlan): ValidationReport;
+    private static policyToAction;
+}
+/**
+ * File d'isolement en mémoire / cache pour les événements rejetés par la gouvernance.
+ */
+export declare class QuarantineStore {
+    private store;
+    quarantine(item: Omit<QuarantinedEvent, "id" | "quarantinedAt" | "status">): QuarantinedEvent;
+    list(projectId: string, filter?: {
+        eventName?: string;
+        limit?: number;
+    }): QuarantinedEvent[];
+    get(id: string): QuarantinedEvent | undefined;
+    resolve(id: string): QuarantinedEvent | undefined;
+    clear(): void;
+}
+export declare const quarantineStore: QuarantineStore;

package/dist/gsc-auto-sync-scheduler.d.ts

@@ -0,0 +1,80 @@
+/**
+ * ⏰ Google Search Console 24h Auto-Sync & Decay Scheduler
+ *
+ *
+ * Automatically monitors GSC performance deltas (7-day and 28-day windows):
+ * 1. Striking Distance Detector (#4 to #20 with high impressions).
+ * 2. Content Decay Detector (> 30% drop in clicks or impressions).
+ * 3. Emerging Queries (zero previous impressions now trending).
+ * 4. Automated Alert Dispatching payloads for Discord / Slack / Email.
+ */
+export interface GscKeywordMetric {
+    query: string;
+    page?: string;
+    clicks: number;
+    impressions: number;
+    ctr: number;
+    position: number;
+}
+export interface GscHistoricalComparison {
+    currentPeriod: GscKeywordMetric[];
+    previousPeriod: GscKeywordMetric[];
+}
+export interface StrikingDistanceOpportunity {
+    query: string;
+    page?: string;
+    position: number;
+    impressions: number;
+    currentClicks: number;
+    estimatedPotentialClicks: number;
+    priorityScore: number;
+    action: string;
+}
+export interface ContentDecayAnomaly {
+    query: string;
+    page?: string;
+    previousClicks: number;
+    currentClicks: number;
+    clicksDropPercent: number;
+    previousPosition: number;
+    currentPosition: number;
+    severity: "critical" | "warning";
+    remediationAdvice: string;
+}
+export interface EmergingQuery {
+    query: string;
+    impressions: number;
+    position: number;
+    detectedDate: string;
+}
+export interface GscSyncAnalysisReport {
+    timestamp: string;
+    totalTrackedQueries: number;
+    totalClicksDelta: {
+        current: number;
+        previous: number;
+        diff: number;
+        diffPercent: number;
+    };
+    strikingDistanceCount: number;
+    strikingDistanceOpportunities: StrikingDistanceOpportunity[];
+    decayCount: number;
+    decayAnomalies: ContentDecayAnomaly[];
+    emergingCount: number;
+    emergingQueries: EmergingQuery[];
+    alertTriggered: boolean;
+    alertSummary: string;
+}
+export declare class GscAutoSyncScheduler {
+    /**
+     * Compares two GSC periods to detect striking distance opportunities and traffic decays.
+     */
+    static analyzeHistoricalDeltas(input: GscHistoricalComparison): GscSyncAnalysisReport;
+    /**
+     * Parses raw Google Search Console CSV / TSV exports into structured GscKeywordMetric rows.
+     * Supports standard English ("Top queries", "Clicks", "Impressions", "CTR", "Position")
+     * and French ("Principales requêtes", "Clics", "Impressions", "CTR", "Position"),
+     * with comma, semicolon, or tab delimiters, respecting quoted cells.
+     */
+    static parseGscCsv(csvText: string, defaultPage?: string): GscKeywordMetric[];
+}

package/dist/gsc-disavow-export-engine.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 🛡️ GscDisavowExportEngine
+ *
+ * Génère et valide des fichiers `disavow.txt` 100% conformes aux spécifications
+ * strictes du Google Search Console Disavow Tool :
+ * - Format UTF-8 / ASCII strict
+ * - Directives `domain:exemple.com` pour désavouer un domaine ou sous-domaine entier
+ * - URLs spécifiques complètes avec protocole `http://` ou `https://`
+ * - Commentaires d'audit horodatés et motivés `# Motifs de désaveu`
+ * - Détection et suppression des doublons et URLs mal formatées
+ *
+ * Pure In-Memory, 0 dépendance, < 0.05ms.
+ */
+export interface DisavowEntry {
+    target: string;
+    type: "domain" | "url";
+    toxicityScore?: number;
+    reason?: string;
+    sourceDomain?: string;
+}
+export interface DisavowGenerationOptions {
+    siteUrl?: string;
+    includeHeaderComments?: boolean;
+    includeReasonComments?: boolean;
+    minToxicityThreshold?: number;
+}
+export interface DisavowValidationResult {
+    isValid: boolean;
+    totalEntries: number;
+    domainCount: number;
+    urlCount: number;
+    formattedContent: string;
+    errors: string[];
+    warnings: string[];
+}
+export declare class GscDisavowExportEngine {
+    /**
+     * Génère un fichier disavow.txt conforme pour Google Search Console.
+     */
+    static generate(entries: DisavowEntry[], options?: DisavowGenerationOptions): DisavowValidationResult;
+    /**
+     * Parse un fichier disavow.txt existant pour validation.
+     */
+    static parse(rawText: string): DisavowValidationResult;
+}

package/dist/headings-outline-engine.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 🦁 LynxSEO Engine - Headings Hierarchy & Markdown Outline Engine (v3.2.0)
+ *
+ * Parses H1..H6 heading tags, validates semantic hierarchy,
+ * detects skipped heading levels (e.g., H1 -> H3), and generates structured Markdown outlines.
+ */
+export interface HeadingItem {
+    tag: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+    level: number;
+    text: string;
+    id?: string;
+}
+export interface HeadingValidationResult {
+    isValid: boolean;
+    h1Count: number;
+    totalHeadings: number;
+    skippedLevels: Array<{
+        from: number;
+        to: number;
+        text: string;
+    }>;
+    warnings: string[];
+}
+export declare class HeadingsOutlineEngine {
+    /**
+     * Parses heading elements from raw HTML string.
+     */
+    static parseHtml(html: string): HeadingItem[];
+    /**
+     * Generates a clean Markdown outline with indentation and hashtags.
+     */
+    static toMarkdown(headings: HeadingItem[]): string;
+    /**
+     * Validates semantic heading progression and identifies hierarchy issues.
+     */
+    static validate(headings: HeadingItem[]): HeadingValidationResult;
+}

package/dist/heatmap-rum.d.ts

@@ -0,0 +1,67 @@
+export interface HeatmapPoint {
+    x: number;
+    y: number;
+    hits?: number;
+    element?: string | null;
+}
+export interface HeatmapCell {
+    x: number;
+    y: number;
+    intensity: number;
+    hits: number;
+}
+export interface ScrollDepthBin {
+    depth: number;
+    count: number;
+    intensity: number;
+}
+export interface RumVitals {
+    lcp: number | null;
+    cls: number | null;
+    inp: number | null;
+    ttfb: number | null;
+}
+export interface RumRecord extends RumVitals {
+    visitorId: string;
+    device: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    recordedAt: string;
+}
+export interface HeatmapRumState {
+    clicks: HeatmapPoint[];
+    moves: HeatmapPoint[];
+    scrolls: number[];
+    rum: RumRecord[];
+    updatedAt: string;
+}
+export interface AggregationBucket {
+    device: string;
+    viewportKey: string;
+    count: number;
+    lcp: number | null;
+    cls: number | null;
+    inp: number | null;
+    ttfb: number | null;
+    clicks: number;
+    scrolls: number;
+}
+export declare function createHeatmapRumState(now?: Date): HeatmapRumState;
+export declare function recordClick(state: HeatmapRumState, point: HeatmapPoint, now?: Date): HeatmapRumState;
+export declare function recordMove(state: HeatmapRumState, point: HeatmapPoint, now?: Date): HeatmapRumState;
+export declare function recordScroll(state: HeatmapRumState, depth: number, now?: Date): HeatmapRumState;
+export declare function recordRum(state: HeatmapRumState, record: Omit<RumRecord, "recordedAt">, now?: Date): HeatmapRumState;
+export declare function generateClickHeatmap(state: HeatmapRumState, gridSize?: number): HeatmapCell[];
+export declare function generateMoveHeatmap(state: HeatmapRumState, gridSize?: number): HeatmapCell[];
+export declare function generateScrollHeatmap(state: HeatmapRumState, bins?: number): ScrollDepthBin[];
+export declare function aggregateRum(state: HeatmapRumState): {
+    lcp: number | null;
+    cls: number | null;
+    inp: number | null;
+    ttfb: number | null;
+    count: number;
+};
+export declare function aggregateByDeviceViewport(state: HeatmapRumState): AggregationBucket[];
+export declare function poorVitalsCount(state: HeatmapRumState): number;

package/dist/html-diff-engine.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 🔍 HtmlDiffEngine
+ *
+ * Implements line-by-line HTML diffing and semantic DOM change detection
+ * between raw HTML and rendered DOM, or between two crawl revisions.
+ * Identifies modifications to critical SEO elements:
+ * - <title>
+ * - <meta name="robots">
+ * - <link rel="canonical">
+ * - <h1>
+ * - JSON-LD schemas
+ * - Injected or removed <script> tags
+ */
+export interface LineDiffItem {
+    type: "add" | "delete" | "unchanged";
+    lineNumA?: number;
+    lineNumB?: number;
+    content: string;
+}
+export interface CriticalSeoTagShift {
+    element: "title" | "canonical" | "meta_robots" | "meta_description" | "h1" | "json_ld" | "scripts";
+    valueA?: string | null;
+    valueB?: string | null;
+    changeType: "added" | "removed" | "modified" | "unchanged";
+    severity: "CRITICAL" | "HIGH" | "INFO";
+}
+export interface HtmlDiffResult {
+    addedLinesCount: number;
+    deletedLinesCount: number;
+    unchangedLinesCount: number;
+    lines: LineDiffItem[];
+    criticalTagShifts: CriticalSeoTagShift[];
+    hasSeoRisk: boolean;
+}
+export declare class HtmlDiffEngine {
+    /**
+     * Extracts critical SEO tags from an HTML string using lightweight regex
+     */
+    private static extractCriticalTags;
+    /**
+     * Compares two HTML strings and computes line-by-line diff and semantic shifts
+     */
+    static compare(htmlA: string, htmlB: string): HtmlDiffResult;
+}

package/dist/html-snapshot-replay.d.ts

@@ -0,0 +1,47 @@
+/**
+ * ⚡ HTML Snapshot & Offline Replay Engine
+ *
+ * Replays archived pages with WACZ-compatible snapshot semantics.
+ * Allows replaying audited HTML snapshots in an isolated iframe or web preview:
+ * - Rewrites relative assets (<img src>, <script src>, <link href>, <iframe src>, <source>, <video>, <audio>) to absolute URLs.
+ * - Rewrites srcset attributes across image and picture elements.
+ * - Rewrites CSS url(...) declarations in <style> blocks and inline style attributes.
+ * - Neutralizes or proxies <a href> navigation to prevent escaping the audit sandbox.
+ * - Freezes <form> submissions to prevent accidental data submission to production servers.
+ * - Injects an optional "Time Machine / Audit Replay" notification banner with audit metadata.
+ */
+export interface SnapshotReplayOptions {
+    /** The original URL of the page being replayed */
+    pageUrl: string;
+    /** Custom rewriter function for links and assets. Defaults to converting relative URLs to absolute. */
+    urlRewriter?: (url: string, type: "asset" | "link") => string;
+    /** Whether to neutralize <a href> clicks (set to "#" or disabled) or allow rewritten links. Default: "inert" */
+    linkBehavior?: "inert" | "proxy" | "external";
+    /** Whether to freeze form submissions (add onsubmit="return false"). Default: true */
+    freezeForms?: boolean;
+    /** Whether to inject an audit header banner at the top of <body>. Default: false */
+    injectBanner?: boolean;
+    bannerMetadata?: {
+        auditDate?: string;
+        healthScore?: number;
+        title?: string;
+    };
+}
+export declare class HtmlSnapshotReplayEngine {
+    /**
+     * Resolves a potentially relative URL against the base page URL.
+     */
+    static resolveUrl(relativeOrAbsolute: string, baseUrl: string): string;
+    /**
+     * Rewrites srcset string (e.g. "image-320w.jpg 320w, /path/image-640w.jpg 640w")
+     */
+    static rewriteSrcset(srcset: string, baseUrl: string, rewriter?: (u: string, type: "asset") => string): string;
+    /**
+     * Rewrites CSS url(...) declarations inside styles
+     */
+    static rewriteCssUrls(css: string, baseUrl: string, rewriter?: (u: string, type: "asset") => string): string;
+    /**
+     * Processes and transforms an archived HTML document for safe, isolated offline replay.
+     */
+    static prepareReplayHtml(html: string, options: SnapshotReplayOptions): string;
+}

package/dist/humanity-ai-scrubber.d.ts

@@ -1,14 +1,21 @@
 /**
  * 🧹 Humanity AI Scrubber & Anti-AI Watermark Engine
- * Detects and removes robotic LLM patterns, clichés, em-dash abuses, and filler phrases.
+ * Detects and removes invisible Unicode watermarks, robotic LLM patterns,
+ * clichés, em-dash abuses, and filler phrases.
  * Computes a rigorous Humanity Score (0-100) and produces humanized copy.
  */
 export interface AiClichéMatch {
     pattern: string;
     count: number;
-    category: "filler_word" | "robotic_intro" | "excessive_punctuation" | "overused_transition";
+    category: "filler_word" | "robotic_intro" | "excessive_punctuation" | "overused_transition" | "invisible_watermark";
     suggestion: string;
 }
+export interface ScrubStats {
+    unicodeRemoved: number;
+    formatControlRemoved: number;
+    emDashesReplaced: number;
+    clichesReplaced: number;
+}
 export interface HumanityScrubReport {
     humanityScore: number;
     aiProbabilityScore: number;
@@ -18,12 +25,79 @@ export interface HumanityScrubReport {
     isHumanSounding: boolean;
     scrubbedText: string;
     improvementRecommendations: string[];
+    stats: ScrubStats;
+}
+export interface SevenSweepsAudit {
+    overallCopyScore: number;
+    sweeps: {
+        clarity: {
+            score: number;
+            issues: string[];
+            status: "PASS" | "WARN" | "FAIL";
+        };
+        voiceTone: {
+            score: number;
+            issues: string[];
+            status: "PASS" | "WARN" | "FAIL";
+        };
+        cadenceRhythm: {
+            score: number;
+            sentenceLengthVariance: number;
+            issues: string[];
+            status: "PASS" | "WARN" | "FAIL";
+        };
+        specificity: {
+            score: number;
+            numbersAndEvidenceCount: number;
+            issues: string[];
+            status: "PASS" | "WARN" | "FAIL";
+        };
+        emotionPersuasion: {
+            score: number;
+            powerWordCount: number;
+            issues: string[];
+            status: "PASS" | "WARN" | "FAIL";
+        };
+        zeroFluff: {
+            score: number;
+            fillerWordRatio: number;
+            issues: string[];
+            status: "PASS" | "WARN" | "FAIL";
+        };
+        proofPolish: {
+            score: number;
+            issues: string[];
+            status: "PASS" | "WARN" | "FAIL";
+        };
+    };
+    keyRecommendations: string[];
 }
 export declare class HumanityAiScrubber {
+    static readonly WATERMARK_CHARS: string[];
     private static readonly BANNED_AI_WORDS;
+    private static readonly AI_PHRASE_REPLACEMENTS;
     private static readonly ROBOTIC_INTROS;
     /**
      * Analyzes text and returns a comprehensive Humanity Score and scrubbed output.
      */
-    static analyzeAndScrub(text: string, language?: string): HumanityScrubReport;
+    static analyzeAndScrub(text: string, _language?: string): HumanityScrubReport;
+    /**
+     * Replaces em-dashes with contextually appropriate punctuation.
+     */
+    private static replaceEmDashesContextually;
+    /**
+     * Clean up whitespace and punctuation spacing.
+     */
+    private static cleanWhitespace;
+    /**
+     * 🖋️ The Seven Sweeps Copy Editing Framework
+     * 1. Clarity
+     * 2. Voice & Tone
+     * 3. Cadence & Rhythm
+     * 4. Specificity
+     * 5. Emotion & Persuasion
+     * 6. Zero Fluff
+     * 7. Proof & Polish
+     */
+    static auditSevenSweeps(text: string): SevenSweepsAudit;
 }

package/dist/i18n/index.d.ts

@@ -0,0 +1 @@
+export * from "./translator";