@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/analytics/content-readability-flesch-kincaid-engine.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Content Readability Flesch-Kincaid Engine (Batch 17 - Gap 4)
+ *
+ * Content readability, sentence complexity & syllable density analyzer inspired by
+ * Clearscope, Surfer SEO Content Editor & Yoast Readability Score.
+ *
+ * Computes Flesch Reading Ease (FRE), Flesch-Kincaid Grade Level (FKGL),
+ * and Gunning Fog index. Flags run-on sentences and overly dense vocabulary
+ * to maximize SEO engagement and dwell time.
+ */
+export interface ReadabilityMetrics {
+    totalWords: number;
+    totalSentences: number;
+    totalSyllables: number;
+    complexWordsCount: number;
+    averageSentenceLengthWords: number;
+    averageSyllablesPerWord: number;
+    fleschReadingEaseScore: number;
+    fleschKincaidGradeLevel: number;
+    gunningFogIndex: number;
+    readingEaseCategory: "very_easy" | "easy" | "fairly_easy" | "standard" | "fairly_difficult" | "difficult" | "very_confusing";
+}
+export interface ReadabilityAuditReport {
+    metrics: ReadabilityMetrics;
+    runOnSentences: string[];
+    polysyllabicWordsSample: string[];
+    isOptimalForWebSeo: boolean;
+    actionableRecommendations: string[];
+}
+export declare class ContentReadabilityFleschKincaidEngine {
+    /**
+     * Analyzes an article's text or HTML and generates readability metrics and recommendations.
+     */
+    static analyzeReadability(rawTextOrHtml: string): ReadabilityAuditReport;
+    /**
+     * English syllable counter heuristics.
+     */
+    private static countSyllables;
+}

package/dist/analytics/content-security-policy-directive-violation-auditor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ContentSecurityPolicyDirectiveViolationAuditor
+ * Audits Content-Security-Policy (CSP) headers against modern web security standards,
+ * detecting unsafe-inline/eval directives, clickjacking exposure, missing fallback policies, and mixed content risks.
+ */
+export type CspVulnerability = "missing_csp_header" | "unsafe_inline_in_scripts" | "unsafe_eval_in_scripts" | "unsafe_inline_in_styles" | "missing_default_src_fallback" | "missing_frame_ancestors_clickjacking_defense" | "missing_object_src_restriction" | "missing_base_uri_restriction" | "wildcard_allowed_in_script_or_connect";
+export interface CspDirectiveAuditResult {
+    directiveName: string;
+    rawValues: string[];
+    isRestricted: boolean;
+    warnings: string[];
+}
+export interface CspAuditReport {
+    hasCspHeader: boolean;
+    securityScore: number;
+    isStrictCspCompliant: boolean;
+    vulnerabilities: CspVulnerability[];
+    parsedDirectives: Record<string, CspDirectiveAuditResult>;
+    remediationDirectives: string[];
+    suggestedStrictCspHeader: string;
+}
+export declare class ContentSecurityPolicyDirectiveViolationAuditor {
+    /**
+     * Audits a raw Content-Security-Policy header string.
+     */
+    audit(rawHeader?: string): CspAuditReport;
+}

package/dist/analytics/content-security-policy-frame-ancestors-clickjacking-auditor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ContentSecurityPolicyFrameAncestorsClickjackingAuditor
+ * Audits CSP 'frame-ancestors' and legacy X-Frame-Options headers against Clickjacking (UI Redressing),
+ * verifying secure frame isolation and deprecating obsolete ALLOW-FROM directives.
+ */
+export interface FrameSecurityHeadersInput {
+    url: string;
+    responseHeaders: Record<string, string>;
+}
+export type ClickjackingDefenseStatus = "fully_protected_none" | "same_origin_protected" | "whitelisted_ancestors" | "wildcard_insecure" | "vulnerable_no_framing_restrictions";
+export interface ClickjackingAuditReport {
+    url: string;
+    defenseStatus: ClickjackingDefenseStatus;
+    clickjackingProtectionScore: number;
+    hasCspFrameAncestors: boolean;
+    cspDirectiveValue: string | null;
+    hasXFrameOptions: boolean;
+    xFrameOptionsValue: string | null;
+    isAllowFromDeprecated: boolean;
+    securityWarnings: string[];
+    recommendedCspHeader: string;
+}
+export declare class ContentSecurityPolicyFrameAncestorsClickjackingAuditor {
+    private static readonly FRAME_ANCESTORS_REGEX;
+    /**
+     * Audits framing security headers for clickjacking defense.
+     */
+    audit(input: FrameSecurityHeadersInput): ClickjackingAuditReport;
+}

package/dist/analytics/conversion-funnel-latency-sensitivity-scorer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ConversionFunnelLatencySensitivityScorer
+ * Statistical model correlating page load latency (TTFB / LCP) with e-commerce
+ * and SaaS funnel conversion dropoffs, revenue degradation, and speed ROI projections.
+ */
+export interface FunnelStepLatencyData {
+    stepName: string;
+    visitors: number;
+    conversions: number;
+    averageLatencyMs: number;
+    averageOrderValue?: number;
+    latencyBuckets?: {
+        rangeLabel: string;
+        minLatencyMs: number;
+        maxLatencyMs: number;
+        visitors: number;
+        conversions: number;
+    }[];
+}
+export interface StepSensitivityAnalysis {
+    stepName: string;
+    baselineConversionRate: number;
+    averageLatencyMs: number;
+    sensitivityLevel: "critical" | "high" | "medium" | "low";
+    elasticityPer100ms: number;
+    annualRevenueAtRisk: number;
+    projectedGains: {
+        gain100msFaster: number;
+        gain250msFaster: number;
+        gain500msFaster: number;
+    };
+}
+export interface FunnelLatencyImpactReport {
+    totalFunnelVisitors: number;
+    totalConversions: number;
+    overallConversionRate: number;
+    currency: string;
+    totalAnnualRevenueAtRisk: number;
+    highestImpactStep: string;
+    stepAnalyses: StepSensitivityAnalysis[];
+    projectedTotalAnnualGain: {
+        faster100ms: number;
+        faster250ms: number;
+        faster500ms: number;
+    };
+    recommendations: string[];
+}
+export declare class ConversionFunnelLatencySensitivityScorer {
+    /**
+     * Analyzes conversion funnel steps and computes latency sensitivity & financial impact.
+     */
+    analyze(steps: FunnelStepLatencyData[], options?: {
+        currency?: string;
+        defaultAov?: number;
+    }): FunnelLatencyImpactReport;
+}

package/dist/analytics/conversion-path-length-engine.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ConversionPathLengthEngine — Analyse de longueur de chemin & délai temporel (Time Lag)
+ *
+ * Parité : Google Analytics 4 (Attribution: Path Length & Time Lag) & Matomo Multi Channel Attribution.
+ *
+ * Calcule :
+ * 1. La distribution du nombre de points de contact avant conversion (Path Length).
+ * 2. La distribution du temps écoulé entre le premier point de contact et la conversion (Time Lag en jours).
+ * 3. La valeur monétaire et le volume de conversions générés par palier.
+ * 4. Recommandations de fenêtres de retargeting publicitaire (lookback window).
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface JourneyTouchpoint {
+    channel: string;
+    timestamp: string | Date;
+    campaign?: string;
+}
+export interface CustomerConversionJourney {
+    customerId: string;
+    conversionId: string;
+    conversionValue: number;
+    conversionTimestamp: string | Date;
+    touchpoints: JourneyTouchpoint[];
+}
+export interface PathLengthBucket {
+    label: string;
+    minTouches: number;
+    maxTouches: number | null;
+    conversionCount: number;
+    conversionPercentage: number;
+    totalValue: number;
+    valuePercentage: number;
+}
+export interface TimeLagBucket {
+    label: string;
+    minDays: number;
+    maxDays: number | null;
+    conversionCount: number;
+    conversionPercentage: number;
+    totalValue: number;
+    valuePercentage: number;
+}
+export interface ConversionPathReport {
+    totalConversions: number;
+    totalRevenue: number;
+    averageTouchpointsPerConversion: number;
+    medianTouchpoints: number;
+    averageDaysToConversion: number;
+    medianDaysToConversion: number;
+    pathLengthBuckets: PathLengthBucket[];
+    timeLagBuckets: TimeLagBucket[];
+    recommendedLookbackWindowDays: number;
+    summaryMessage: string;
+    generatedAt: string;
+}
+export declare class ConversionPathLengthEngine {
+    calculate(journeys: CustomerConversionJourney[]): ConversionPathReport;
+    private getMedian;
+    private getPercentile;
+    private emptyReport;
+}

package/dist/analytics/cookie-consent-compliance-auditor.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Cookie Consent Compliance Auditor (Batch 11 - Gap 4)
+ *
+ * Automated GDPR, ePrivacy, and CCPA cookie consent auditor.
+ * Detects pre-consent cookie drops, unclassified cookies, unauthorized
+ * third-party trackers, missing expiration limits (e.g. > 13 months under CNIL/EDPB),
+ * and computes overall consent compliance scores and remediation directives.
+ */
+export type CookieCategory = "strictly_necessary" | "analytics" | "marketing" | "functional" | "unclassified";
+export interface ObservedCookie {
+    name: string;
+    domain: string;
+    path?: string;
+    category?: CookieCategory;
+    firstParty: boolean;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None" | "Unspecified";
+    lifespanSeconds?: number;
+    droppedAtMs: number;
+    initiatorUrl?: string;
+}
+export interface ConsentSessionState {
+    bannerDisplayed: boolean;
+    bannerTimestampMs?: number;
+    consentGiven: boolean;
+    consentTimestampMs?: number;
+    acceptedCategories: CookieCategory[];
+    jurisdiction?: "GDPR" | "CCPA" | "LGPD" | "OTHER";
+}
+export type ConsentViolationSeverity = "critical" | "high" | "medium" | "low";
+export interface ConsentViolation {
+    code: "PRE_CONSENT_TRACKING" | "UNAUTHORIZED_CATEGORY" | "UNCLASSIFIED_COOKIE" | "EXCESSIVE_LIFESPAN" | "INSECURE_COOKIE" | "THIRD_PARTY_WITHOUT_CONSENT";
+    severity: ConsentViolationSeverity;
+    cookieName: string;
+    domain: string;
+    category: CookieCategory;
+    message: string;
+    remediation: string;
+}
+export interface CategorySummary {
+    category: CookieCategory;
+    totalCookies: number;
+    preConsentCount: number;
+    authorizedCount: number;
+    unauthorizedCount: number;
+}
+export interface CookieConsentAuditReport {
+    sessionId?: string;
+    jurisdiction: string;
+    totalCookiesObserved: number;
+    compliantCount: number;
+    violationsCount: number;
+    preConsentViolationsCount: number;
+    complianceScore: number;
+    complianceGrade: "A" | "B" | "C" | "D" | "F";
+    status: "compliant" | "warning" | "non_compliant";
+    categories: Record<CookieCategory, CategorySummary>;
+    violations: ConsentViolation[];
+    recommendations: string[];
+}
+export declare class CookieConsentComplianceAuditor {
+    /**
+     * Analyzes observed cookies against session consent states to identify
+     * regulatory compliance violations under GDPR/ePrivacy.
+     */
+    auditConsentCompliance(cookies: ObservedCookie[], session: ConsentSessionState, options?: {
+        strictMode?: boolean;
+        customSignatures?: Record<string, CookieCategory>;
+        maxLifespanSeconds?: number;
+    }): CookieConsentAuditReport;
+}

package/dist/analytics/core-web-vitals-cumulative-tbt-trend-forecaster.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Core Web Vitals TBT Trend & Budget Forecaster (Batch 19 - Gap 1)
+ *
+ * Performance budget regression & Total Blocking Time (TBT) trend forecaster
+ * inspired by SpeedCurve Performance Budgets, Calibre Alerts & DebugBear.
+ *
+ * Tracks TBT across deployment releases, fits linear regression trendlines,
+ * computes budget burn rate, and predicts the exact deployment release
+ * where performance budgets will be breached.
+ */
+export interface ReleasePerformanceSnapshot {
+    releaseTag: string;
+    timestampMs: number;
+    tbtMs: number;
+    longTasksCount: number;
+    maxLongTaskDurationMs: number;
+}
+export interface PerformanceBudgetConfig {
+    warningTbtThresholdMs?: number;
+    criticalTbtBudgetMs?: number;
+}
+export interface TbtTrendReport {
+    totalSnapshotsAnalyzed: number;
+    latestReleaseTag: string;
+    latestTbtMs: number;
+    baselineTbtMs: number;
+    tbtDeltaMs: number;
+    slopeTbtMsPerRelease: number;
+    currentStatus: "healthy" | "approaching_budget" | "budget_breached";
+    projectedReleasesUntilBudgetBreach: number | null;
+    averageLongTasksPerRelease: number;
+    recommendations: string[];
+}
+export declare class CoreWebVitalsCumulativeTbtTrendForecaster {
+    /**
+     * Forecasts TBT trajectory across historical deployment releases.
+     */
+    static forecastTbtTrend(snapshots: ReleasePerformanceSnapshot[], budget?: PerformanceBudgetConfig): TbtTrendReport;
+}

package/dist/analytics/core-web-vitals-interaction-event-debouncer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Core Web Vitals Interaction Event Debouncer (Batch 17 - Gap 1)
+ *
+ * High-frequency RUM telemetry reducer & interaction debouncer inspired by
+ * Datadog RUM Event Pipeline, PostHog Session Recording & LogRocket Event Batcher.
+ *
+ * Implements adaptive trailing-edge throttling, preserves high-fidelity rage click bursts,
+ * and compresses high-frequency DOM telemetry (scroll, pointermove, keypress) by > 85%
+ * before network egress without losing UX anomaly signals.
+ */
+export type TelemetryEventType = "scroll" | "pointermove" | "resize" | "keypress" | "click" | "pointerdown" | "input";
+export interface RawTelemetryEvent {
+    eventId: string;
+    type: TelemetryEventType;
+    timestampMs: number;
+    targetSelector?: string;
+    data?: Record<string, unknown>;
+}
+export interface DebouncedTelemetryBatch {
+    totalInputEvents: number;
+    emittedEventsCount: number;
+    compressionRatioPercent: number;
+    emittedEvents: RawTelemetryEvent[];
+    rageBurstDetected: boolean;
+    maxScrollDepthDetectedPercent?: number;
+}
+export interface DebouncerOptions {
+    scrollThrottleWindowMs?: number;
+    pointermoveThrottleWindowMs?: number;
+    keypressDebounceWindowMs?: number;
+    rageClickBurstThreshold?: number;
+}
+export declare class CoreWebVitalsInteractionEventDebouncer {
+    /**
+     * Reduces raw high-frequency telemetry events into an efficient batch.
+     */
+    static debounceEventStream(events: RawTelemetryEvent[], options?: DebouncerOptions): DebouncedTelemetryBatch;
+}

package/dist/analytics/core-web-vitals-interaction-input-delay-breakdown-profiler.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CoreWebVitalsInteractionInputDelayBreakdownProfiler
+ * Decomposes the Input Delay phase of Core Web Vitals INP (Interaction to Next Paint),
+ * pinpointing prior long tasks, hydration freezes, and main-thread queuing bottlenecks.
+ */
+export interface OverlappingLongTask {
+    name: string;
+    durationMs: number;
+    sourceScript?: string;
+}
+export interface InpInteractionProfileInput {
+    interactionId: string;
+    eventType: "pointerdown" | "click" | "keydown" | "keyup" | string;
+    targetElementSelector?: string;
+    inputDelayMs: number;
+    processingDurationMs: number;
+    presentationDelayMs: number;
+    overlappingLongTasks?: OverlappingLongTask[];
+}
+export type InputDelayPrimaryCause = "prior_long_task_blocking" | "hydration_render_freeze" | "third_party_script_competition" | "dom_listener_starvation" | "healthy_responsive_input";
+export interface InputDelayBreakdownReport {
+    interactionId: string;
+    eventType: string;
+    totalInpDurationMs: number;
+    inputDelayMs: number;
+    inputDelayPercentage: number;
+    isInputDelayDominant: boolean;
+    primaryCause: InputDelayPrimaryCause;
+    blockingTasksCount: number;
+    longestBlockingTaskMs: number;
+    prescribedRemediation: string;
+}
+export declare class CoreWebVitalsInteractionInputDelayBreakdownProfiler {
+    private static readonly CRITICAL_INPUT_DELAY_MS;
+    /**
+     * Profiles the input delay phase of an INP interaction.
+     */
+    profile(input: InpInteractionProfileInput): InputDelayBreakdownReport;
+}

package/dist/analytics/core-web-vitals-interaction-target-dom-element-pinpointer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CoreWebVitalsInteractionTargetDomElementPinpointer
+ * Pinpoints high-INP DOM target elements, isolating root causes across long JavaScript
+ * execution, synchronous reflow layout thrashing, and excessive DOM child node depth.
+ */
+export interface InteractionTraceEntryInput {
+    targetSelector: string;
+    eventType: "click" | "pointerdown" | "keydown" | "input";
+    durationMs: number;
+    inputDelayMs: number;
+    processingDurationMs: number;
+    presentationDelayMs: number;
+    domSubtreeNodeCount?: number;
+    forcedReflowDetected?: boolean;
+}
+export type InpBottleneckType = "synchronous_layout_thrashing" | "heavy_event_listener_execution" | "high_input_delay_main_thread_busy" | "complex_dom_subtree_rendering" | "optimal_fast_interaction";
+export interface TargetElementInpSummary {
+    targetSelector: string;
+    totalInteractions: number;
+    p75DurationMs: number;
+    p95DurationMs: number;
+    primaryBottleneck: InpBottleneckType;
+    forcedReflowCount: number;
+    averageSubtreeNodes: number;
+    developerRemediationSnippet: string;
+}
+export interface InpTargetAuditReport {
+    totalInteractionsAudited: number;
+    frustratingInteractionsCount: number;
+    uniqueSlowTargetsCount: number;
+    targetRankings: TargetElementInpSummary[];
+    siteWideRecommendations: string[];
+}
+export declare class CoreWebVitalsInteractionTargetDomElementPinpointer {
+    /**
+     * Aggregates interaction traces by DOM target and diagnoses INP root causes.
+     */
+    analyze(traces: InteractionTraceEntryInput[]): InpTargetAuditReport;
+    private percentile;
+}

package/dist/analytics/core-web-vitals-interaction-timeline-tracer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CoreWebVitalsInteractionTimelineTracer
+ * Reconstructs the chronological timeline of Core Web Vitals and user interactions in a session,
+ * correlating layout shifts with user inputs and identifying interaction delay bottlenecks.
+ */
+export type TimelineEventType = "navigation_start" | "ttfb" | "fcp" | "lcp" | "layout_shift" | "user_interaction" | "page_hide";
+export interface TimelineRawEventInput {
+    type: TimelineEventType;
+    timestampMs: number;
+    durationMs?: number;
+    score?: number;
+    targetSelector?: string;
+    interactionType?: "click" | "keydown" | "pointerdown";
+    hadRecentInput?: boolean;
+}
+export interface ReconstructedTimelineEvent {
+    orderIndex: number;
+    type: TimelineEventType;
+    timestampMs: number;
+    durationMs: number;
+    details: string;
+    isAnomaly: boolean;
+    anomalyReason?: string;
+}
+export interface SessionTimelineSummaryReport {
+    totalSessionDurationMs: number;
+    eventCount: number;
+    lcpTimestampMs: number | null;
+    peakInpDurationMs: number;
+    cumulativeClsScore: number;
+    unattributedClsScore: number;
+    interactionCorrelatedClsCount: number;
+    events: ReconstructedTimelineEvent[];
+    timelineDiagnosis: string[];
+}
+export declare class CoreWebVitalsInteractionTimelineTracer {
+    /**
+     * Traces and reconstructs the chronological timeline of CWV and interactions.
+     */
+    traceSession(events: TimelineRawEventInput[]): SessionTimelineSummaryReport;
+}

package/dist/analytics/core-web-vitals-lcp-sub-part-waterfall-profiler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CoreWebVitalsLcpSubPartWaterfallProfiler
+ * Decomposes Core Web Vitals Largest Contentful Paint (LCP) into the 4 official W3C sub-parts:
+ * TTFB, Resource Load Delay, Resource Load Duration, and Element Render Delay.
+ */
+export interface LcpSubPartsTimingInput {
+    lcpTotalMs: number;
+    ttfbMs: number;
+    loadDelayMs: number;
+    loadDurationMs: number;
+    renderDelayMs: number;
+    isImageLcp: boolean;
+    lcpElementSelector?: string;
+    lcpResourceUrl?: string;
+}
+export type LcpDominantSubPart = "ttfb" | "resource_load_delay" | "resource_load_duration" | "element_render_delay";
+export interface LcpSubPartBreakdown {
+    name: LcpDominantSubPart;
+    durationMs: number;
+    percentageOfLcp: number;
+    isOverBudget: boolean;
+    budgetTargetMs: number;
+}
+export interface LcpWaterfallAuditReport {
+    lcpTotalMs: number;
+    lcpRating: "good" | "needs_improvement" | "poor";
+    dominantBottleneck: LcpDominantSubPart;
+    subParts: LcpSubPartBreakdown[];
+    targetedPrescriptions: string[];
+}
+export declare class CoreWebVitalsLcpSubPartWaterfallProfiler {
+    /**
+     * Official Chrome/W3C recommended allocations for a 2.5s (2500ms) "Good" LCP:
+     * - TTFB: <= 800ms (40%)
+     * - Load Delay: <= 200ms (10%)
+     * - Load Duration: <= 1000ms (40%)
+     * - Render Delay: <= 200ms (10%)
+     */
+    private static readonly BUDGETS;
+    /**
+     * Decomposes LCP into sub-part waterfall with targeted optimization advice.
+     */
+    profile(input: LcpSubPartsTimingInput): LcpWaterfallAuditReport;
+}

package/dist/analytics/core-web-vitals-presentation-delay-breakdown-profiler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - CoreWebVitalsPresentationDelayBreakdownProfiler
+ * Decomposes the Presentation Delay phase of Core Web Vitals INP (Interaction to Next Paint),
+ * diagnosing style recalculation thrashing, forced reflows, and GPU compositing delays.
+ */
+export interface PresentationDelayInput {
+    interactionId: string;
+    presentationDelayMs: number;
+    totalInpDurationMs?: number;
+    styleRecalcDurationMs?: number;
+    layoutDurationMs?: number;
+    compositingDurationMs?: number;
+    modifiedDomNodesCount?: number;
+    targetElementSelector?: string;
+}
+export type PresentationBottleneckType = "forced_reflow_layout_thrashing" | "massive_style_recalculation" | "gpu_compositing_layer_overhead" | "raf_queue_starvation" | "optimal_fast_paint";
+export interface PresentationDelayReport {
+    interactionId: string;
+    presentationDelayMs: number;
+    isExcessive: boolean;
+    dominantBottleneck: PresentationBottleneckType;
+    styleRecalcMs: number;
+    layoutMs: number;
+    compositingMs: number;
+    prescribedRemediation: string;
+}
+export declare class CoreWebVitalsPresentationDelayBreakdownProfiler {
+    private static readonly CRITICAL_PRESENTATION_DELAY_MS;
+    /**
+     * Profiles the presentation delay phase of an INP interaction.
+     */
+    profile(input: PresentationDelayInput): PresentationDelayReport;
+}

package/dist/analytics/core-web-vitals-ttfb-diagnostic-auditor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Core Web Vitals TTFB Diagnostic Auditor (Batch 18 - Gap 1)
+ *
+ * Time To First Byte (TTFB) & Server-Timing diagnostic profiler inspired by
+ * SpeedCurve Server Timing Profiler, Cloudflare Observability & Catchpoint CDN Monitor.
+ *
+ * Deconstructs TTFB into DNS lookup, TCP/TLS handshake, server processing wait,
+ * and content download time. Parses W3C Server-Timing headers and detects
+ * CDN edge cache misses to isolate backend bottlenecks.
+ */
+export type TtfbRating = "good" | "needs_improvement" | "poor";
+export interface TtfbNavigationTimingBreakdown {
+    dnsLookupMs: number;
+    tcpHandshakeMs: number;
+    tlsNegotiationMs: number;
+    requestSendMs: number;
+    serverWaitTimeMs: number;
+    contentDownloadMs: number;
+    totalTtfbMs: number;
+}
+export interface ServerTimingMetric {
+    name: string;
+    durationMs: number;
+    description?: string;
+}
+export interface TtfbMeasurementInput {
+    url: string;
+    timing: {
+        domainLookupStart?: number;
+        domainLookupEnd?: number;
+        connectStart?: number;
+        secureConnectionStart?: number;
+        connectEnd?: number;
+        requestStart?: number;
+        responseStart: number;
+        responseEnd?: number;
+        navigationStart?: number;
+        fetchStart?: number;
+    };
+    serverTimingHeader?: string;
+    cacheStatusHeader?: string;
+}
+export interface TtfbAuditReport {
+    url: string;
+    totalTtfbMs: number;
+    rating: TtfbRating;
+    breakdown: TtfbNavigationTimingBreakdown;
+    parsedServerTiming: ServerTimingMetric[];
+    cacheStatus: "hit" | "miss" | "bypass" | "unknown";
+    primaryBottleneck: "dns" | "tls_connection" | "backend_compute" | "network_latency" | "none";
+    recommendations: string[];
+}
+export declare class CoreWebVitalsTtfbDiagnosticAuditor {
+    /**
+     * Audits Navigation Timing API parameters and headers to diagnose TTFB performance.
+     */
+    static auditTtfb(input: TtfbMeasurementInput): TtfbAuditReport;
+    private static parseServerTiming;
+}

package/dist/analytics/correlation-analyzer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * CorrelationAnalyzer — Moteur d'analyse statistique de corrélation (PostHog Correlation Analysis).
+ *
+ * Calcule automatiquement les corrélations (lift, odds ratio, corrélation phi de Pearson)
+ * entre les événements/actions effectués par les visiteurs et un objectif de conversion.
+ * Permet de répondre à : « Quels comportements multiplient les chances de conversion ? »
+ */
+export interface CorrelationCandidate {
+    eventName: string;
+    convertedWithEvent: number;
+    convertedWithoutEvent: number;
+    totalWithEvent: number;
+    totalWithoutEvent: number;
+    conversionRateWithEvent: number;
+    conversionRateWithoutEvent: number;
+    oddsRatio: number;
+    correlationScore: number;
+    significance: "positive_high" | "positive_moderate" | "neutral" | "negative";
+}
+export interface UserEventHistory {
+    userId: string;
+    converted: boolean;
+    events: string[];
+}
+export declare class CorrelationAnalyzer {
+    /**
+     * Analyse un ensemble d'historiques utilisateurs et retourne les facteurs corrélés triés par impact.
+     */
+    static analyze(histories: UserEventHistory[]): CorrelationCandidate[];
+}