@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/analytics/canonical-integrity-engine.d.ts

@@ -0,0 +1,51 @@
+/**
+ * CanonicalIntegrityEngine — Audit de Conformité, Boucles & Chaînes d'URLs Canoniques
+ *
+ * Parité : Sitebulb & Screaming Frog Canonical Analysis.
+ *
+ * Détecte les anomalies d'URLs canoniques détruisant le signal SEO :
+ * 1. Balises canoniques multiples : Présence de plusieurs balises canonical sur la même page (ignorées par Google).
+ * 2. URLs relatives vs absolues : Détecte les balises canonical écrites en chemin relatif (/page au lieu de https://...).
+ * 3. Cibles invalides :
+ *    - Cible en erreur HTTP (404, 410, 500).
+ *    - Cible en redirection HTTP (301, 302) au lieu de l'URL finale.
+ * 4. Chaînes & Boucles canoniques :
+ *    - Chaîne : URL A -> canonique B -> canonique C.
+ *    - Boucle : URL A -> canonique B -> canonique A (boucle infinie).
+ * 5. Conflits d'indexation Noindex :
+ *    - Page marquée noindex mais se déclarant elle-même canonique.
+ *    - Canonique pointant vers une page bloquée par noindex.
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface PageCanonicalInput {
+    url: string;
+    canonicals: string[];
+    statusCode?: number;
+    hasNoindex?: boolean;
+}
+export type CanonicalIssueType = "multiple_canonicals" | "missing_canonical" | "relative_canonical_url" | "canonical_chain" | "canonical_loop" | "canonical_to_error" | "canonical_to_redirect" | "canonical_noindex_conflict";
+export interface CanonicalIssue {
+    url: string;
+    canonicalTarget?: string;
+    type: CanonicalIssueType;
+    severity: "critical" | "warning" | "info";
+    detail: string;
+    chain?: string[];
+}
+export interface CanonicalAuditReport {
+    totalPagesAudited: number;
+    selfCanonicalCount: number;
+    canonicalizedCount: number;
+    issuesCount: number;
+    issues: CanonicalIssue[];
+    healthScore: number;
+    summary: string;
+    generatedAt: string;
+}
+export declare class CanonicalIntegrityEngine {
+    audit(pages: PageCanonicalInput[]): CanonicalAuditReport;
+    private traceCanonicalChain;
+    private normalizeUrl;
+    private emptyReport;
+}

package/dist/analytics/canonical-loop-cluster-detector.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CanonicalLoopClusterDetector
+ * Detects circular canonical loops, multi-hop canonical chains, canonical-redirect
+ * conflicts, and dead canonical destinations across crawled URL graphs.
+ */
+export type CanonicalLoopIssueType = "circular_canonical_loop" | "multi_hop_canonical_chain" | "canonical_to_redirect" | "canonical_to_broken_status" | "cross_domain_canonical";
+export interface CanonicalNodeInput {
+    url: string;
+    canonicalUrl?: string;
+    statusCode?: number;
+    redirectDestination?: string;
+}
+export interface CanonicalCycle {
+    cyclePath: string[];
+    length: number;
+}
+export interface CanonicalChain {
+    originUrl: string;
+    hops: string[];
+    terminalUrl: string;
+    hopCount: number;
+}
+export interface CanonicalAuditFinding {
+    type: CanonicalLoopIssueType;
+    severity: "critical" | "warning" | "info";
+    description: string;
+    affectedUrls: string[];
+    recommendedFix: string;
+}
+export interface CanonicalLoopAuditReport {
+    totalUrlsAudited: number;
+    selfCanonicalCount: number;
+    distinctCanonicalCount: number;
+    healthScore: number;
+    cycles: CanonicalCycle[];
+    chains: CanonicalChain[];
+    findings: CanonicalAuditFinding[];
+    terminalMapping: Record<string, string>;
+}
+export declare class CanonicalLoopClusterDetector {
+    /**
+     * Analyzes an array of URL nodes with their canonical declarations and redirect targets.
+     */
+    analyze(nodes: CanonicalNodeInput[]): CanonicalLoopAuditReport;
+    private normalizeUrl;
+    private isCrossDomain;
+}

package/dist/analytics/canvas-replay-capture.d.ts

@@ -0,0 +1,41 @@
+/**
+ * CanvasReplayCapture — clean-room HTML5 canvas frame/snapshot recording & serialization.
+ * Inspired by OpenReplay / PostHog canvas recording.
+ * Handles: 2D & WebGL canvas snapshots, diffing, compression estimation, replay playback packets.
+ * AGPL-3.0-or-later
+ */
+export interface CanvasSnapshotMeta {
+    canvasId: string;
+    width: number;
+    height: number;
+    contextType: "2d" | "webgl" | "webgl2" | "bitmaprenderer";
+    timestamp: number;
+}
+export interface CanvasFrame {
+    canvasId: string;
+    timestamp: number;
+    dataUrlOrBase64: string;
+    isKeyframe: boolean;
+    byteSize: number;
+}
+export interface CanvasStreamStats {
+    canvasId: string;
+    totalFrames: number;
+    keyframesCount: number;
+    totalBytes: number;
+    durationMs: number;
+    estimatedFps: number;
+}
+export declare class CanvasReplayCapture {
+    private streams;
+    private metas;
+    registerCanvas(meta: CanvasSnapshotMeta): void;
+    appendFrame(canvasId: string, frame: {
+        timestamp: number;
+        dataUrlOrBase64: string;
+        isKeyframe?: boolean;
+    }): CanvasFrame;
+    getFrames(canvasId: string, fromTimestamp?: number, toTimestamp?: number): CanvasFrame[];
+    getStats(canvasId: string): CanvasStreamStats;
+    clearStream(canvasId: string): void;
+}

package/dist/analytics/captcha-gate-verifier.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Self-hosted Captcha Verification Gate
+ *
+ * Clean-room, fail-closed verification client for a Turnstile-compatible
+ * challenge endpoint. It is intentionally provider-agnostic: any endpoint that
+ * accepts a form-urlencoded `secret` / `response` pair and answers with
+ * `{ success, hostname, action, challenge_ts, "error-codes" }` works.
+ *
+ * (Gap parity: Swetrix "Custom Captcha & Verification Gates".)
+ *
+ * Edge-safe: uses the global `fetch`, `AbortSignal.timeout` and `URL` only.
+ * No Node.js built-in modules are imported.
+ */
+export interface CaptchaVerifyInput {
+    token: string;
+    remoteIp?: string;
+    expectedHostname?: string;
+    action?: string;
+    idempotencyKey?: string;
+}
+export type CaptchaFailureCode = "missing_token" | "missing_secret" | "timeout" | "network_error" | "replay" | "hostname_mismatch" | "action_mismatch" | "challenge_failed" | "invalid_response";
+export interface CaptchaVerifyResult {
+    success: boolean;
+    code?: CaptchaFailureCode;
+    errors: string[];
+    challengeTs: string | null;
+    hostname: string | null;
+    action: string | null;
+}
+export type CaptchaFetcher = (url: string, init: {
+    method: "POST";
+    body: URLSearchParams;
+    signal: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    json(): Promise<unknown>;
+}>;
+export interface CaptchaGateOptions {
+    secretKey: string;
+    fetcher?: CaptchaFetcher;
+    verifyUrl?: string;
+    timeoutMs?: number;
+    replayWindowMs?: number;
+    now?: () => number;
+}
+export declare class CaptchaGateVerifier {
+    private readonly secretKey;
+    private readonly fetcher;
+    private readonly verifyUrl;
+    private readonly timeoutMs;
+    private readonly replayWindowMs;
+    private readonly now;
+    private readonly consumedAt;
+    constructor(options: CaptchaGateOptions);
+    verify(input: CaptchaVerifyInput): Promise<CaptchaVerifyResult>;
+    prune(): void;
+    getTrackedTokenCount(): number;
+    private challengeFailure;
+    private failure;
+    private wasConsumed;
+    private recordConsumption;
+    private consumptionKeys;
+    private static normalizeVerifyUrl;
+    private static normalizePositiveNumber;
+    private static normalizeNonNegativeNumber;
+}

package/dist/analytics/cart-abandonment-analyzer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * CartAbandonmentAnalyzer — Détection des paniers abandonnés et opportunités de relance (Parité Matomo Ecommerce / PostHog).
+ *
+ * Analyse le cycle de vie des paniers d'achat en ligne :
+ * - Détection des sessions avec ajout panier sans finalisation dans le délai imparti (abandon)
+ * - Entonnoir de passage en caisse (Ajout panier -> Checkout -> Livraison -> Paiement -> Commande)
+ * - Chiffre d'affaires à risque et articles les plus abandonnés
+ * - Génération de déclencheurs de récupération de panier avec payload prêt pour email/webhook
+ */
+export type CartEventType = "cart_add" | "cart_remove" | "cart_update" | "checkout_start" | "checkout_shipping" | "checkout_payment" | "order_complete";
+export interface CartItem {
+    id: string;
+    name: string;
+    price: number;
+    quantity: number;
+    category?: string;
+    imageUrl?: string;
+}
+export interface RawCartEvent {
+    sessionId: string;
+    userId?: string;
+    userEmail?: string;
+    eventType: CartEventType;
+    timestamp: number | string;
+    cartId?: string;
+    items?: CartItem[];
+    cartTotal?: number;
+    currency?: string;
+    checkoutStep?: number;
+}
+export interface AbandonedCartCandidate {
+    cartId: string;
+    sessionId: string;
+    userId?: string;
+    userEmail?: string;
+    currency: string;
+    cartTotal: number;
+    itemsCount: number;
+    items: CartItem[];
+    lastActionTimestamp: string;
+    lastStep: CartEventType;
+    idleMinutes: number;
+    recoveryPotential: "high" | "medium" | "low";
+}
+export interface CartAbandonmentReport {
+    summary: {
+        totalCartsInitiated: number;
+        completedOrdersCount: number;
+        abandonedCartsCount: number;
+        cartAbandonmentRatePct: number;
+        totalRevenueAtRisk: number;
+        averageAbandonedCartValue: number;
+        currency: string;
+    };
+    funnel: Array<{
+        step: string;
+        label: string;
+        sessionsCount: number;
+        dropOffCount: number;
+        dropOffRatePct: number;
+    }>;
+    topAbandonedProducts: Array<{
+        id: string;
+        name: string;
+        occurrencesCount: number;
+        totalLostRevenue: number;
+    }>;
+    recoveryCandidates: AbandonedCartCandidate[];
+}
+export interface CartAbandonmentOptions {
+    abandonmentThresholdMinutes?: number;
+    referenceTimestamp?: number | string;
+    defaultCurrency?: string;
+}
+export declare class CartAbandonmentAnalyzer {
+    /**
+     * Analyse les événements de panier et identifie les abandons et opportunités de relance.
+     */
+    static analyze(events: RawCartEvent[], options?: CartAbandonmentOptions): CartAbandonmentReport;
+}

package/dist/analytics/cdn-edge-cache-hit-ratio-forecaster.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CdnEdgeCacheHitRatioForecaster
+ * Evaluates HTTP cache headers (Cache-Control, s-maxage, stale-while-revalidate) and request patterns,
+ * diagnosing cache-busting anti-patterns and forecasting origin server offload and TTFB gains.
+ */
+export interface PageCacheProfileInput {
+    url: string;
+    cacheControlHeader?: string;
+    varyHeader?: string;
+    hasSetCookieHeader: boolean;
+    hasDynamicQueryParams: boolean;
+    monthlyRequests: number;
+    currentEdgeStatus: "HIT" | "MISS" | "BYPASS" | "EXPIRED" | "DYNAMIC";
+    originTtfbMs: number;
+    edgeTtfbMs: number;
+}
+export type CacheabilityGrade = "optimal_edge_cached" | "suboptimal_stale_revalidate" | "uncacheable_anti_pattern";
+export interface PageCacheEvaluation {
+    url: string;
+    grade: CacheabilityGrade;
+    currentHitRatioEst: number;
+    potentialHitRatioEst: number;
+    antiPatternsDetected: string[];
+    recommendedCacheControlHeader: string;
+    estimatedTtfbSavingsMs: number;
+}
+export interface CdnCacheForecastReport {
+    totalPagesAudited: number;
+    totalMonthlyRequests: number;
+    currentAverageHitRatio: number;
+    potentialAverageHitRatio: number;
+    estimatedMonthlyOriginRequestsSaved: number;
+    overallCacheEfficiencyScore: number;
+    evaluations: PageCacheEvaluation[];
+    strategicEdgeRecommendations: string[];
+}
+export declare class CdnEdgeCacheHitRatioForecaster {
+    /**
+     * Forecasts edge cache hit ratios and recommends Cache-Control headers.
+     */
+    forecast(pages: PageCacheProfileInput[]): CdnCacheForecastReport;
+}

package/dist/analytics/cdn-edge-routing-latency-analyzer.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CdnEdgeRoutingLatencyAnalyzer
+ * Analyzes multi-CDN edge routing performance, POP latency distributions,
+ * Edge Cache Hit Ratios (CHR), and cross-continental misrouting anomalies.
+ */
+export type CdnProvider = "cloudflare" | "fastly" | "cloudfront" | "akamai" | "vercel_edge" | "unknown";
+export type EdgeCacheStatus = "HIT" | "MISS" | "DYNAMIC" | "BYPASS" | "REVALIDATED";
+export interface EdgeTelemetrySample {
+    id?: string;
+    url: string;
+    provider: CdnProvider;
+    pop: string;
+    clientCountry?: string;
+    clientContinent?: string;
+    dnsMs: number;
+    tcpMs: number;
+    tlsMs: number;
+    ttfbMs: number;
+    cacheStatus: EdgeCacheStatus;
+    httpVersion?: string;
+    timestamp?: string;
+}
+export interface PopPerformanceMetric {
+    pop: string;
+    sampleCount: number;
+    p50TtfbMs: number;
+    p75TtfbMs: number;
+    p90TtfbMs: number;
+    p99TtfbMs: number;
+    avgTlsMs: number;
+    cacheHitRatio: number;
+    misroutedSampleCount: number;
+}
+export interface EdgeRoutingAnomaly {
+    type: "transcontinental_routing_penalty" | "low_cache_hit_ratio" | "high_tls_overhead" | "outdated_http_protocol" | "elevated_tail_latency";
+    severity: "critical" | "warning" | "info";
+    description: string;
+    affectedPop?: string;
+    measuredMetric: number;
+    threshold: number;
+}
+export interface CdnEdgeAuditReport {
+    totalSamples: number;
+    primaryProvider: CdnProvider;
+    overallScore: number;
+    overallCacheHitRatio: number;
+    globalP50TtfbMs: number;
+    globalP75TtfbMs: number;
+    globalP90TtfbMs: number;
+    popBreakdown: PopPerformanceMetric[];
+    anomalies: EdgeRoutingAnomaly[];
+    recommendations: string[];
+}
+export declare class CdnEdgeRoutingLatencyAnalyzer {
+    private static readonly CONTINENT_MAP;
+    /**
+     * Analyzes edge routing telemetry data points.
+     */
+    analyze(samples: EdgeTelemetrySample[]): CdnEdgeAuditReport;
+    private percentile;
+}

package/dist/analytics/channel-grouping.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Campaign Taxonomy & Default Channel Grouping Engine — RudderStack & GA4 Parity
+ *
+ * Normalise et classifie les sources de trafic, paramètres UTM et identifiants publicitaires
+ * de clic (gclid, fbclid, ttclid, msclkid) selon la nomenclature standard des canaux :
+ * - Paid Search (Google Ads, Bing Ads, gclid, cpc, ppc, paidsearch)
+ * - Organic Search (Google, Bing, Yahoo, DuckDuckGo, Ecosia, Qwant, Baidu)
+ * - Paid Social (Facebook Ads, Instagram, TikTok Ads, LinkedIn Ads, fbclid, ttclid)
+ * - Organic Social (Twitter / X, LinkedIn, Reddit, Pinterest, YouTube, TikTok)
+ * - Email (newsletter, email, sendgrid, mailchimp)
+ * - Affiliate / Partenaires
+ * - Display / Bannières
+ * - Referral (sites référents)
+ * - Direct (aucun referrer ni paramètre)
+ */
+export type DefaultChannel = "Paid Search" | "Organic Search" | "Paid Social" | "Organic Social" | "Email" | "Affiliate" | "Display" | "Referral" | "Direct";
+export interface CampaignParams {
+    utmSource?: string | null;
+    utmMedium?: string | null;
+    utmCampaign?: string | null;
+    utmTerm?: string | null;
+    utmContent?: string | null;
+    gclid?: string | null;
+    fbclid?: string | null;
+    ttclid?: string | null;
+    msclkid?: string | null;
+    referrer?: string | null;
+}
+export interface NormalizedCampaign {
+    channel: DefaultChannel;
+    source: string;
+    medium: string;
+    campaign: string;
+    isPaid: boolean;
+    clickIdentifier?: {
+        type: "gclid" | "fbclid" | "ttclid" | "msclkid";
+        value: string;
+    };
+}
+/**
+ * Classifie les paramètres d'une visite pour déterminer son canal marketing exact.
+ */
+export declare function classifyChannel(params: CampaignParams): NormalizedCampaign;
+/**
+ * Extrait les paramètres de campagne directement depuis une URL complète et son Referrer.
+ */
+export declare function extractCampaignFromUrl(urlString: string, referrer?: string): NormalizedCampaign;

package/dist/analytics/churn-risk-calculator.d.ts

@@ -0,0 +1,73 @@
+/**
+ * LynxSEO Engine - Churn Risk & Retention Cohort Calculator
+ * Parité PostHog Retention & Amplitude Churn Prediction.
+ *
+ * Analyse mathématique des cohortes de rétention (Jour, Semaine, Mois)
+ * et modélisation du risque d'attrition (churn hazard rate, health score, vélocité d'activité).
+ */
+import type { ChurnRiskLevel } from "./customer-ltv-modeler";
+export type { ChurnRiskLevel };
+export type RetentionGranularity = "day" | "week" | "month";
+export interface RawUserActivity {
+    userId: string;
+    timestamp: string | number;
+    eventType?: string;
+    properties?: Record<string, unknown>;
+}
+export interface CohortPeriodMetric {
+    periodIndex: number;
+    periodLabel: string;
+    activeUsers: number;
+    percentage: number;
+}
+export interface CohortRetentionRow {
+    cohortKey: string;
+    cohortDate: string;
+    cohortSize: number;
+    periods: CohortPeriodMetric[];
+}
+export interface UserHealthScore {
+    userId: string;
+    firstSeenIso: string;
+    lastSeenIso: string;
+    totalEvents: number;
+    daysSinceLastActive: number;
+    activityVelocityRatio: number;
+    healthScore: number;
+    predictedChurnProbability: number;
+    churnRiskLevel: ChurnRiskLevel;
+    signals: string[];
+}
+export interface ChurnRetentionAnalysisOptions {
+    granularity?: RetentionGranularity;
+    maxPeriods?: number;
+    referenceDate?: string | number;
+    inactivityThresholdDays?: number;
+    minEventsForHealthScoring?: number;
+}
+export interface RetentionAnalysisResult {
+    granularity: RetentionGranularity;
+    cohorts: CohortRetentionRow[];
+    overallAverageRetention: Array<{
+        periodIndex: number;
+        averagePercentage: number;
+    }>;
+    userHealthScores: UserHealthScore[];
+    summary: {
+        totalTrackedUsers: number;
+        activeUsersCount: number;
+        atRiskUsersCount: number;
+        churnedUsersCount: number;
+        averageHealthScore: number;
+        estimatedChurnRatePct: number;
+    };
+}
+export declare class ChurnRiskCalculator {
+    /**
+     * Calcule les cohortes de rétention réelles et les scores de risque de churn.
+     */
+    analyze(events: RawUserActivity[], options?: ChurnRetentionAnalysisOptions): RetentionAnalysisResult;
+    private getCohortKey;
+    private getPeriodDifference;
+    private getPeriodLabel;
+}

package/dist/analytics/client-error-tracker.d.ts

@@ -0,0 +1,83 @@
+/**
+ * LynxSEO Engine - Client-Side Error & Exception Tracker
+ * Parité Rybbit Error Tracking, PostHog Exception Monitoring & Sentry Lite.
+ *
+ * Agrégation, empreinte canonique (fingerprinting), dé-duplication et
+ * analyse d'impact des exceptions JavaScript et rejets de promesses non gérés côté client.
+ */
+export type ClientErrorStatus = "unresolved" | "investigating" | "resolved" | "ignored";
+export interface RawClientErrorEvent {
+    id?: string;
+    siteId: string;
+    timestamp: string | number;
+    message: string;
+    errorType?: string;
+    source?: string;
+    lineno?: number;
+    colno?: number;
+    stackTrace?: string;
+    url: string;
+    userId?: string;
+    sessionId?: string;
+    browser?: string;
+    os?: string;
+}
+export interface AggregatedErrorGroup {
+    fingerprint: string;
+    title: string;
+    errorType: string;
+    firstSeenIso: string;
+    lastSeenIso: string;
+    totalOccurrences: number;
+    affectedUsersCount: number;
+    affectedSessionsCount: number;
+    sampleStackTrace?: string;
+    sampleSource?: string;
+    sampleLineno?: number;
+    sampleColno?: number;
+    topFailingUrls: Array<{
+        url: string;
+        count: number;
+    }>;
+    topBrowsers: Array<{
+        browser: string;
+        count: number;
+    }>;
+    status: ClientErrorStatus;
+}
+export interface ClientErrorAnalysisOptions {
+    totalRecordedSessions?: number;
+    groupByUrl?: boolean;
+    statusOverrides?: Record<string, ClientErrorStatus>;
+}
+export interface ClientErrorTrackingReport {
+    siteId: string;
+    totalErrors: number;
+    uniqueErrorGroupsCount: number;
+    totalAffectedUsers: number;
+    totalAffectedSessions: number;
+    errorFreeSessionsRatePct: number;
+    groups: AggregatedErrorGroup[];
+    timeline: Array<{
+        timestampSlot: string;
+        count: number;
+    }>;
+    summary: {
+        criticalUnresolvedCount: number;
+        mostFrequentErrorTitle?: string;
+        worstFailingUrl?: string;
+    };
+}
+export declare class ClientErrorTracker {
+    /**
+     * Analyse et regroupe les exceptions clientes brutes par empreinte de pile.
+     */
+    analyze(siteId: string, events: RawClientErrorEvent[], options?: ClientErrorAnalysisOptions): ClientErrorTrackingReport;
+    /**
+     * Calcule une empreinte stable de regroupement (Fingerprint).
+     */
+    private computeFingerprint;
+    private normalizeTitle;
+    private sanitizeUrl;
+    private simpleHash;
+}

package/dist/analytics/client-side-hydration-mismatch-differ.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ClientSideHydrationMismatchDiffer
+ * Diagnoses React 19 and TanStack Start DOM hydration mismatches between
+ * server-rendered HTML and client-hydrated virtual DOM to eliminate CLS and CPU re-render thrashing.
+ */
+export interface HydrationDiffInput {
+    url: string;
+    ssrHtml: string;
+    clientHtml: string;
+    componentName?: string;
+}
+export type HydrationMismatchCause = "locale_date_time_drift" | "client_storage_leak" | "random_math_or_id_generation" | "browser_window_dimension_leak" | "unmatched_dom_tag" | "attribute_value_drift";
+export interface HydrationMismatchItem {
+    selector?: string;
+    cause: HydrationMismatchCause;
+    severity: "critical" | "warning";
+    serverValue: string;
+    clientValue: string;
+    description: string;
+    fixRecommendation: string;
+}
+export interface HydrationDiffReport {
+    url: string;
+    componentName?: string;
+    hasMismatch: boolean;
+    totalMismatches: number;
+    severity: "none" | "moderate" | "severe";
+    score: number;
+    mismatches: HydrationMismatchItem[];
+    remediationSnippet: string;
+}
+export declare class ClientSideHydrationMismatchDiffer {
+    /**
+     * Compares SSR HTML against client HTML and categorizes hydration mismatches.
+     */
+    diff(input: HydrationDiffInput): HydrationDiffReport;
+    private normalizeHtml;
+    private detectTextAndAttributeMismatches;
+    private generateRemediationGuide;
+}

package/dist/analytics/client-side-memory-leak-dom-detached-nodes-auditor.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ClientSideMemoryLeakDomDetachedNodesAuditor
+ * Detects and diagnoses client-side JavaScript memory leaks in Single Page Applications (SPAs),
+ * profiling detached DOM tree fragments, uncleaned event listeners, uncleared timers,
+ * and heap size inflation across synthetic client-side navigation transitions.
+ */
+export interface SpaNavigationStepSample {
+    route: string;
+    timestampMs: number;
+    jsHeapSizeMb: number;
+    totalDomNodes: number;
+    detachedDomNodes: number;
+    activeEventListeners: number;
+    activeTimersCount?: number;
+}
+export interface LeakingComponentCandidate {
+    componentHint?: string;
+    suspectedCause: "detached_dom" | "event_listener_leak" | "timer_leak" | "unbounded_cache";
+    growthRate: number;
+    severity: "high" | "medium" | "low";
+    recommendation: string;
+}
+export interface DomDetachedNodesMemoryAuditReport {
+    hasMemoryLeak: boolean;
+    leakRiskScore: number;
+    status: "healthy" | "moderate_leak" | "critical_leak";
+    heapGrowthMb: number;
+    detachedNodesDelta: number;
+    eventListenersDelta: number;
+    suspectedComponents: LeakingComponentCandidate[];
+    summary: string;
+}
+export declare class ClientSideMemoryLeakDomDetachedNodesAuditor {
+    audit(samples: SpaNavigationStepSample[]): DomDetachedNodesMemoryAuditReport;
+}