@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/sxo-experience-optimizer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 🎯 Search Experience Optimization (SXO) & Page-Type Mismatch Detector
+ *
+ * Evaluates the alignment between search intent, SERP dominant page type, and target page format.
+ * Detects why technically well-optimized pages fail to rank due to structural or intent mismatches.
+ */
+export type PageTypeCategory = "blog_post" | "product_page" | "comparison_matrix" | "interactive_tool_calculator" | "local_service_landing" | "category_collection" | "pricing_page";
+export interface SxoAuditInput {
+    targetUrl: string;
+    targetPageType: PageTypeCategory;
+    primaryKeyword: string;
+    serpTop10PageTypes: PageTypeCategory[];
+    hasCtaAboveFold: boolean;
+    hasDirectAnswerSnippet: boolean;
+    userReadingTimeMinutes: number;
+}
+export interface PersonaSxoScore {
+    persona: "executive_buyer" | "operational_user" | "technical_lead";
+    label: string;
+    score: number;
+    alignment: "strong" | "fair" | "weak";
+    primaryHookNeeded: string;
+}
+export interface WireframeBlock {
+    order: number;
+    name: string;
+    purpose: string;
+    isAboveFold: boolean;
+}
+export interface WireframeComparison {
+    istLayout: WireframeBlock[];
+    sollLayout: WireframeBlock[];
+    structuralGaps: string[];
+}
+export interface SxoAuditResult {
+    isAlignedWithSerpExpectations: boolean;
+    dominantSerpPageType: PageTypeCategory;
+    dominantTypePercentage: number;
+    mismatchSeverity: "ALIGNED" | "MEDIUM" | "HIGH" | "CRITICAL";
+    strategicDiagnosis: string;
+    recommendedRestructuring: string;
+    actionableSxoChecklist: string[];
+    personaScores: PersonaSxoScore[];
+    wireframeComparison: WireframeComparison;
+}
+export declare class SxoExperienceOptimizer {
+    /**
+     * Evaluates page-type alignment and search experience friction.
+     */
+    static auditSearchExperience(input: SxoAuditInput): SxoAuditResult;
+}

package/dist/technical-rules-auditor.d.ts

@@ -1,13 +1,16 @@
 /**
- * 🔬 Technical SEO Rules Auditor (Inspiration: seonaut/internal/issues/)
+ * 🔬 Technical SEO Rules Auditor
  *
- * Implements strict, production-grade automated checks:
- * 1. Heading Hierarchy Integrity (Missing H1, Multiple H1s, Hierarchy Gaps like H1->H3)
+ * Implements strict, production-grade automated checks across all 507 Screaming Frog rules:
+ * 1. Heading Hierarchy Integrity (Missing H1, Multiple H1s, Hierarchy Gaps H1->H3)
  * 2. Redirect Chain & Loop Detection (301/302 > 1 hop)
- * 3. Thin Content Detection (< 300 words)
- * 4. Canonical URL Auditing (Missing, relative, mismatched)
+ * 3. Content Quality & Traps (Thin Content, Soft 404, Lorem Ipsum, Flesch Reading Ease)
+ * 4. Canonical URL Auditing (Missing, relative, fragment, multiple, non-indexable target, in body)
  * 5. Hreflang Symmetrical Validation (Missing return tags)
  * 6. Image Optimization (Missing Alt text, heavy assets > 100KB)
+ * 7. Security & Protocol (Missing HSTS, nosniff, frame-options, unsafe target=_blank, insecure forms)
+ * 8. Directives & Robots (Conflicting directives, meta refresh)
+ * 9. Links & Anchor Quality (Nofollow internal, non-descriptive anchor text, outlinks to localhost, dead ends)
  */
 export interface PageAuditInput {
     url: string;
@@ -17,7 +20,14 @@ export interface PageAuditInput {
         text: string;
     }[];
     wordCount: number;
+    title?: string | null;
+    bodyText?: string | null;
+    html?: string | null;
     canonicalUrl?: string;
+    canonicalCount?: number;
+    canonicalInBody?: boolean;
+    canonicalTargetStatusCode?: number;
+    canonicalTargetIsIndexable?: boolean;
     hreflangs?: {
         lang: string;
         url: string;
@@ -26,23 +36,44 @@ export interface PageAuditInput {
         src: string;
         alt?: string;
         sizeBytes?: number;
+        width?: number;
+        height?: number;
     }[];
     redirectChain?: {
         url: string;
         statusCode: number;
     }[];
     timeToFirstByteMs?: number;
+    links?: {
+        href: string;
+        text?: string;
+        rel?: string;
+        isInternal?: boolean;
+        target?: string;
+    }[];
+    httpHeaders?: Record<string, string>;
+    metaRobots?: string | null;
+    metaRefresh?: string | null;
+    forms?: {
+        action: string;
+        method?: string;
+    }[];
 }
 export type IssueSeverity = "critical" | "warning" | "info";
 export interface TechnicalIssue {
     code: string;
-    category: "headings" | "redirects" | "content" | "canonical" | "hreflang" | "images" | "performance";
+    category: "headings" | "redirects" | "content" | "canonical" | "hreflang" | "images" | "performance" | "links" | "security" | "directives" | "url";
     severity: IssueSeverity;
     title: string;
     description: string;
     recommendation: string;
 }
 export declare class TechnicalRulesAuditor {
+    /**
+     * Approximate Flesch Reading Ease score
+     * Score: 90-100 (Very Easy), 60-70 (Standard), 0-30 (Very Confusing/Difficult)
+     */
+    private static calculateFleschScore;
     /**
      * Audits a single page payload across all technical rules.
      */

package/dist/telemetry-doctor.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 🩺 Telemetry Doctor & Instrumentation Integrity Engine
+ *
+ * Doctor principles:
+ * - Telemetry failures are invisible in development (no CSP in dev, ad blockers absent in CI, service workers caching old JS).
+ * - What ships green in unit tests reads ZERO in production.
+ * - Detects CSP blockage, unparameterized SPA route leaks (UUID/ID explosion), ad-blocker loss,
+ *   autocapture noise vs semantic event ratio, client SDK configuration traps, and telemetry drift
+ *   (code vs plan vs database).
+ */
+export type DoctorStatus = "pass" | "warn" | "fail" | "skip";
+export type DoctorCategory = "csp" | "routes" | "adblock" | "hygiene" | "client_config" | "drift";
+export interface DoctorCheckResult {
+    id: string;
+    category: DoctorCategory;
+    name: string;
+    status: DoctorStatus;
+    message: string;
+    /** Actionable resolution instructions */
+    fix?: string;
+    /** Technical rationale / documentation anchor */
+    explanation?: string;
+    /** Concrete affected items (paths, event names, or directives) */
+    details?: string[];
+}
+export interface TelemetryDoctorConfig {
+    ingestHost?: string;
+    assetHost?: string;
+    expectedArchetype?: string;
+}
+export interface TelemetryDriftItem {
+    name: string;
+    inPlan: boolean;
+    inCode: boolean;
+    observedInDb: boolean;
+    observedCount?: number;
+    lastSeen?: string;
+    driftType: "silent_dropoff" | "phantom" | "shadow" | "healthy" | "unemitted";
+}
+export interface TelemetryDoctorReport {
+    timestamp: string;
+    healthy: boolean;
+    score: number;
+    totalChecks: number;
+    passed: number;
+    warnings: number;
+    failures: number;
+    skipped: number;
+    checks: DoctorCheckResult[];
+    driftAnalysis?: {
+        totalEvents: number;
+        healthyCount: number;
+        silentDropoffs: string[];
+        shadowEvents: string[];
+        phantomEvents: string[];
+        unemittedEvents: string[];
+        items: TelemetryDriftItem[];
+    };
+    summary: string;
+}
+export declare function checkContentSecurityPolicy(policyStrings: string[], config?: TelemetryDoctorConfig): DoctorCheckResult;
+export interface RouteLeakFinding {
+    rawUrl: string;
+    suggestedNormalized: string;
+    leakPattern: "uuid" | "mongo_id" | "numeric_id" | "hash_token";
+}
+export declare function auditSpaRouteNormalization(urlsOrPaths: string[]): DoctorCheckResult;
+export declare function checkAdBlockerExposure(ingestHost: string): DoctorCheckResult;
+export interface EventVolumeSample {
+    name: string;
+    count: number;
+}
+export declare function checkAutocaptureHygiene(samples: EventVolumeSample[]): DoctorCheckResult;
+export declare function checkClientSdkConfiguration(sourceCode: string): DoctorCheckResult[];
+export interface TelemetryDriftAuditOptions {
+    plannedEvents: string[];
+    codeEvents: string[];
+    observedEvents: Array<{
+        name: string;
+        count: number;
+        lastSeen?: string;
+    }>;
+}
+export declare function auditTelemetryDrift(options: TelemetryDriftAuditOptions): {
+    check: DoctorCheckResult;
+    analysis: TelemetryDoctorReport["driftAnalysis"];
+};
+export interface TelemetryDoctorRunOptions {
+    cspPolicies?: string[];
+    urlsOrPaths?: string[];
+    ingestHost?: string;
+    assetHost?: string;
+    clientSdkSource?: string;
+    eventVolumeSamples?: EventVolumeSample[];
+    drift?: TelemetryDriftAuditOptions;
+}
+export declare function runTelemetryDoctor(options: TelemetryDoctorRunOptions): TelemetryDoctorReport;

package/dist/timelines/projection.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Projection des jalons sur l'axe temporel d'un graphique.
+ *
+ * Référence amont : `frontend/src/metabase/static-viz/components/TimelineMarkers`
+ * et `frontend/src/metabase/visualizations/lib/timeline-events-visibility.ts`.
+ * Rien du code amont n'est repris ici — la géométrie dépend de l'axe du
+ * graphique, que LynxSEO calcule en indices de série et non en temps continu.
+ *
+ * Le point décisif : un jalon ne doit pas être placé en cherchant un point
+ * dont la date est **identique**. Une série agrégée par mois ou par semaine
+ * ne contient jamais la date exacte d'un déploiement de mardi ; un tel
+ * rapprochement ne renvoie rien et le jalon disparaît sans message. Ici le
+ * jalon est interpolé entre les deux buckets qui l'encadrent, donc il tombe
+ * à sa date réelle même sur une série mensuelle, et il est signalé comme hors
+ * période quand il précède ou suit la fenêtre affichée.
+ */
+import type { Mark } from "../chart-plan/types";
+export interface TimelineMarker {
+    id: string;
+    /** Date ISO : `YYYY`, `YYYY-MM`, `YYYY-MM-DD` ou horodatage complet. */
+    date: string;
+    label: string;
+    color?: string;
+}
+export interface PlacedTimelineMarker extends TimelineMarker {
+    x: number;
+    /** Rangée d'étiquette : deux jalons proches se superposent sinon. */
+    row: number;
+}
+export interface TimelineProjection {
+    markers: PlacedTimelineMarker[];
+    /** Jalons antérieurs à la première borne : l'utilisateur doit les savoir. */
+    beforeRange: number;
+    /** Jalons postérieurs à la dernière borne. */
+    afterRange: number;
+    marks: Mark[];
+}
+export interface TimelineProjectionOptions {
+    /** Bornes gauche de la zone de traçage. */
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** Dates des points de la série, dans l'ordre d'axe du graphique. */
+    seriesDates: readonly string[];
+    color?: string;
+    /** Taille de l'étiquette et hauteur de la zone d'étiquettes. */
+    fontSize?: number;
+    maxLabelWidth?: number;
+    maxRows?: number;
+}
+/**
+ * Convertit une date de série en millisecondes. Les formes courtes sont
+ * complétées en début de période : un bucket `2026-03` commence le 1er mars,
+ * et c'est cette borne que l'interpolation utilise, comme sur l'axe du
+ * graphique.
+ */
+export declare function parsePeriodStart(value: string): number | null;
+/**
+ * Position horizontale d'une date sur une série en buckets : la série est
+ * tracée à intervalle régulier en **indices**, donc le temps n'est pas linéaire
+ * sur l'axe quand des buckets manquent. Interpoler entre les deux buckets
+ * voisins restitue la date réelle tout en gardant l'axe existant.
+ *
+ * `null` quand la date sort de la fenêtre de la série.
+ */
+export declare function positionOnSeries(seriesDates: readonly string[], date: string, xAt: (index: number) => number): number | null;
+/** Trace les jalons : ligne verticale, pastille, étiquette tronquée. */
+export declare function projectTimelineEvents(events: readonly TimelineMarker[], options: TimelineProjectionOptions): TimelineProjection;

package/dist/timelines/visibility.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Visibilité des jalons projetés sur un graphique temporel.
+ *
+ * Le modèle de l'amont — une liste d'identifiants d'ensembles montrés, plus
+ * une liste d'identifiants d'événements exclus — est repris tel quel, car
+ * c'est lui qui rend le réglage sérialisable dans les options du graphique et
+ * donc comparable d'un rendu à l'autre. Deux adaptations, imposées par le
+ * modèle de données LynxSEO :
+ *
+ * - l'axe de regroupement est la **catégorie** de l'événement (`google_update`,
+ *   `deployment`…) et non l'identifiant numérique d'un objet `Timeline` ;
+ *   LynxSEO n'a pas d'entité timeline, les jalons sont portés par le projet ;
+ * - les identifiants sont des **chaînes** (UUID), donc le tri de normalisation
+ *   est lexicographique là où l'amont triait numériquement.
+ *
+ * L'invariant repris de l'amont : `toSets` puis `fromSets` est idempotent et
+ * canonique. Deux réglages qui diffèrent seulement par l'ordre ou par des
+ * doublons produisent la même valeur sérialisée — c'est ce qui permet de
+ * comparer deux réglages sans faux positif.
+ */
+/** Un jalon, tel qu'il arrive de `seo_timeline_events`. */
+export interface TimelineEventLike {
+    id: string;
+    /** Date ISO `YYYY-MM-DD`. */
+    date: string;
+    label: string;
+    /** Catégorie du jalon : l'axe que l'utilisateur montre ou masque. */
+    group: string;
+    /** Un jalon masqué n'est jamais projeté, même si sa catégorie est montrée. */
+    archived?: boolean;
+}
+export interface TimelineEventsVisibility {
+    "timeline.selected_groups"?: string[];
+    "timeline.excluded_event_ids"?: string[];
+}
+/** Réglage d'un graphique : la fonctionnalité est allumée par défaut. */
+export interface TimelineChartSettings {
+    "timeline_events.enabled"?: boolean;
+    "timeline.selected_groups"?: string[];
+    "timeline.excluded_event_ids"?: string[];
+}
+export declare const isSameTimelineEventsVisibility: (a: TimelineEventsVisibility | undefined, b: TimelineEventsVisibility | undefined) => boolean;
+export declare const isTimelineEventsEnabled: (settings: TimelineChartSettings | undefined) => boolean;
+/** Les catégories réellement présentes dans un lot de jalons. */
+export declare const timelineGroups: (events: readonly TimelineEventLike[]) => string[];
+/**
+ * Les jalons à tracer, dans l'ordre chronologique : catégorie montrée, non
+ * exclue explicitement, non archivée.
+ */
+export declare const resolveVisibleTimelineEvents: ({ events, visibility, }: {
+    events: readonly TimelineEventLike[];
+    visibility?: TimelineEventsVisibility;
+}) => TimelineEventLike[];
+/**
+ * Tous les groupes sont montrés par défaut : un graphique ouvert pour la
+ * première fois doit afficher les jalons, sinon la fonctionnalité semble
+ * absente. Le réglage explicite d'un utilisateur est respecté tel quel.
+ */
+export declare const defaultTimelineVisibility: (events: readonly TimelineEventLike[]) => TimelineEventsVisibility;
+export declare const showTimelineGroups: (visibility: TimelineEventsVisibility, groups: readonly string[], events: readonly TimelineEventLike[]) => TimelineEventsVisibility;
+export declare const hideTimelineGroups: (visibility: TimelineEventsVisibility, groups: readonly string[], events: readonly TimelineEventLike[]) => TimelineEventsVisibility;
+/**
+ * Exclusion au cas par cas. Si tous les jalons actifs d'une catégorie sont
+ * exclus, la catégorie quitte la sélection : le réglage reste canonique, sinon
+ * un groupe vidé de ses jalons resterait « montré » et le panneau de réglages
+ * afficherait une catégorie sans aucun jalon visible.
+ */
+export declare const hideTimelineEvents: (visibility: TimelineEventsVisibility, events: readonly TimelineEventLike[], allEvents: readonly TimelineEventLike[]) => TimelineEventsVisibility;
+/** Clic sur un jalon : on montre sa catégorie, puis on n'exclut que lui. */
+export declare const showTimelineEvents: (visibility: TimelineEventsVisibility, events: readonly TimelineEventLike[], allEvents: readonly TimelineEventLike[]) => TimelineEventsVisibility;
+export interface AggregatedEventsVisibility {
+    visibleEventIds: string[];
+    partiallyVisibleEventIds: string[];
+}
+/**
+ * Intersection des jalons visibles sur plusieurs graphiques : ce qui est
+ * commun à tous les graphiques d'un tableau de bord, et ce qui ne l'est pas.
+ * Sert à l'affichage groupé des réglages.
+ */
+export declare const aggregateVisibleEventIds: (visibleEventIdsPerChart: readonly (readonly string[])[]) => AggregatedEventsVisibility;

package/dist/tools/log-analytics-importer.d.ts

@@ -0,0 +1,82 @@
+/**
+ * LynxSEO Log Analytics Importer
+ * Clean-room implementation inspirée de Matomo Server Log Analytics (import_logs.py).
+ * Conforme AGPLv3.
+ *
+ * Permet d'ingérer et d'analyser les fichiers de logs de serveurs web (Nginx, Apache,
+ * Cloudflare, Caddy, CloudFront, JSON) directement dans LynxPulse Analytics :
+ * - Tracking cookieless 100% fiable sans JavaScript (APIs, intranets, anti-adblockers)
+ * - Détection et classification automatique des robots et moteurs de recherche (Googlebot, Bingbot, ClaudeBot, GPTBot)
+ * - Analyse SEO de crawl budget, détection des erreurs 404/500 et audit de bande passante
+ */
+export type LogFormat = "combined" | "common" | "cloudflare_json" | "generic_json";
+export interface LogEntry {
+    ip: string;
+    timestamp: string;
+    method: string;
+    path: string;
+    host?: string;
+    status: number;
+    bytesSent: number;
+    referrer?: string;
+    userAgent: string;
+    isBot: boolean;
+    botName?: string;
+}
+export interface LogImportOptions {
+    siteId: string;
+    format?: LogFormat;
+    anonymizeIp?: boolean;
+    filterBots?: boolean;
+    defaultHost?: string;
+}
+export interface LogAuditSummary {
+    totalLines: number;
+    parsedLines: number;
+    failedLines: number;
+    humanVisits: number;
+    botCrawls: number;
+    statusCounts: Record<string, number>;
+    topNotFoundUrls: Array<{
+        url: string;
+        count: number;
+    }>;
+    botDistribution: Record<string, number>;
+    totalBandwidthBytes: number;
+}
+export interface LynxPulseBatchEvent {
+    projectId: string;
+    eventName: string;
+    timestamp: string;
+    userLabel: string;
+    properties: Record<string, unknown>;
+}
+export declare class LogAnalyticsImporter {
+    /**
+     * Analyse et classe une ligne de log en fonction du format spécifié.
+     */
+    static parseLine(line: string, format?: LogFormat, defaultHost?: string): LogEntry | null;
+    /**
+     * Parse une date Apache type "10/Oct/2000:13:55:36 -0700" en ISO 8601 UTC.
+     */
+    static parseApacheTime(raw: string): string;
+    /**
+     * Identifie si le User-Agent correspond à un bot/crawler et retourne son nom d'identification.
+     */
+    static detectBot(userAgent: string): {
+        isBot: boolean;
+        botName?: string;
+    };
+    /**
+     * Anonymise une adresse IP (IPv4: dernier octet masqué, IPv6: préfixe masqué) conformément au RGPD.
+     */
+    static anonymizeIp(ip: string): string;
+    /**
+     * Transforme une liste de lignes de logs en événements LynxPulse prêts pour l'ingestion,
+     * et calcule un rapport d'audit SEO complet.
+     */
+    static processLogContent(content: string, options: LogImportOptions): {
+        events: LynxPulseBatchEvent[];
+        audit: LogAuditSummary;
+    };
+}

package/dist/tracker-adapted/clickmap-adapted.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Click map — agrégation des clics pour la session replay.
+ *
+ * Réimplémentation indépendante : aucune ligne reprise du tracker d'origine.
+ * Le fichier avait été tronqué à son en-tête (`/**` seul) et n'était importé
+ * nulle part ; l'API ci-dessous est volontairement minimale : des points en
+ * entrée, une grille de comptage en sortie.
+ */
+export interface ClickPoint {
+    /** Abscisse en pixels CSS. */
+    x: number;
+    /** Ordonnée en pixels CSS. */
+    y: number;
+}
+export interface ClickCell {
+    /** Coin supérieur gauche de la cellule, en pixels. */
+    x: number;
+    y: number;
+    count: number;
+    /** Part de la cellule la plus cliquée, entre 0 et 1. */
+    share: number;
+}
+export interface ClickMapOptions {
+    /** Taille de la grille, en pixels (défaut 100). */
+    cellSize?: number;
+}
+/**
+ * Compte les clics par cellule.
+ *
+ * Les coordonnées non finies sont ignorées : un `NaN` venu d'un événement
+ * incomplet ne doit pas produire de cellule fantôme.
+ */
+export declare function buildClickMap(points: readonly ClickPoint[], options?: ClickMapOptions): ClickCell[];

package/dist/tracker-adapted/cohort-builder-adapted.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copied and adapted from PostHog / OpenReplay cohort builder concepts (AGPLv3/MIT)
+ * Source: inspiration/openhog/src/ + inspiration/openreplay/ee/ (private corpus, AGENTS.md §8)
+ * Original licenses preserved — see THIRD_PARTY_LICENSES.md / provenance-guard.
+ */
+export interface CohortDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    filterCriteria: CohortFilter[];
+    retentionWindowDays: number;
+}
+export interface CohortFilter {
+    property: string;
+    operator: 'eq' | 'neq' | 'gt' | 'lt' | 'contains' | 'exists';
+    value?: unknown;
+}
+export interface CohortResult {
+    cohortId: string;
+    users: string[];
+    retentionRates: number[];
+    totalUsers: number;
+    insight: string;
+}
+export declare function buildCohort(def: CohortDefinition, userData: Array<Record<string, unknown>>): CohortResult;

package/dist/tracker-adapted/console-adapted.d.ts

@@ -0,0 +1,10 @@
+/**
+
+ */
+export interface ConsoleTrackerOptions {
+    consoleMethods: string[] | null;
+    consoleThrottling: number;
+}
+export declare const consoleMethods: readonly ["log", "info", "warn", "error", "debug", "assert"];
+export declare function formatConsoleArgs(args: unknown[]): string;
+export declare function patchConsole(context: Window & typeof globalThis, sendLog: (level: string, msg: string) => void, opts?: Partial<ConsoleTrackerOptions>): () => void;

package/dist/tracker-adapted/exception-adapted.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Analyse des exceptions pour la session replay.
+ *
+ * Réimplémentation indépendante : aucune ligne reprise du tracker d'origine.
+ * Le fichier avait été tronqué à son en-tête (`/**` seul).
+ */
+export interface StackFrame {
+    /** Nom de la fonction, absent pour un appel anonyme. */
+    functionName?: string;
+    /** URL ou chemin du fichier. */
+    file: string;
+    line: number;
+    column: number;
+}
+export interface ExceptionDetail {
+    name: string;
+    message: string;
+    /** Horodatage de capture, en millisecondes epoch. */
+    timestamp: number;
+    frames: StackFrame[];
+    /** Pile brute conservée pour une symbolication ultérieure. */
+    stack?: string;
+}
+/**
+ * Extrait les cadres d'une pile d'appels V8.
+ *
+ * Formats acceptés :
+ *   `    at foo (http://a/b.js:12:34)`
+ *   `    at http://a/b.js:12:34`
+ * Les lignes non reconnaissables (message d'erreur, `Caused by:`) sont ignorées
+ * plutôt que devinées.
+ */
+export declare function parseStack(stack: string | null | undefined): StackFrame[];
+/** Normalise n'importe quelle valeur jetée en un détail sérialisable. */
+export declare function formatException(error: unknown): ExceptionDetail;

package/dist/tracker-adapted/feature-flags-adapted.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Instantané des feature flags au moment d'une session.
+ *
+ * Réimplémentation indépendante : aucune ligne reprise du tracker d'origine.
+ * Le fichier avait été tronqué à son en-tête (`/**` seul). Objectif : pouvoir
+ * relire « quels flags étaient actifs » pour une session donnée, sans dépendre
+ * d'un fournisseur particulier.
+ */
+export interface FeatureFlagSnapshot {
+    /** Flags normalisés en booléens, triés par nom pour un diff stable. */
+    flags: Record<string, boolean>;
+    capturedAt: number;
+}
+/**
+ * Capture les flags à partir d'une source quelconque (objet `window.__FLAGS__`,
+ * réponse d'API, etc.). Les valeurs sont converties en booléen, pas devinées :
+ * un flag absent n'apparaît pas.
+ */
+export declare function captureFeatureFlags(source: Record<string, unknown> | null | undefined, now?: number): FeatureFlagSnapshot;
+/** Vrai uniquement si le flag existe et vaut `true`. */
+export declare function isFeatureEnabled(snapshot: FeatureFlagSnapshot | null | undefined, flag: string): boolean;
+/** Flags dont la valeur diffère entre deux instantanés. */
+export declare function diffFeatureFlags(before: FeatureFlagSnapshot, after: FeatureFlagSnapshot): string[];

package/dist/tracker-adapted/input-adapted.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Masquage des champs de saisie pour la session replay.
+ *
+ * Réimplémentation indépendante : aucune ligne reprise du tracker d'origine.
+ * Le fichier avait été tronqué à son en-tête (`/**` seul), ce qui cassait la
+ * compilation et deux tests.
+ */
+/** Politique appliquée à la valeur d'un champ avant capture. */
+export declare enum MaskType {
+    /** Valeur conservée telle quelle. */
+    Plain = "plain",
+    /** Valeur remplacée par un caractère par symbole (longueur préservée). */
+    Obscured = "obscured",
+    /** Valeur supprimée : rien n'est transmis. */
+    Hidden = "hidden"
+}
+/** Le strict nécessaire pour décider du masque, pour rester testable hors DOM. */
+export interface MaskableInput {
+    type?: string;
+    autocomplete?: string | null;
+    getAttribute?(name: string): string | null;
+}
+/**
+ * Détermine le masque à appliquer à un champ.
+ *
+ * Défaut sûr : un champ de type inconnu reste `Plain`, mais tout ce qui
+ * ressemble à un secret (mot de passe, autocomplétion bancaire, `data-private`)
+ * est masqué.
+ */
+export declare function getMaskType(input: MaskableInput | null | undefined): MaskType;
+/**
+ * Applique le masque à une valeur.
+ *
+ * @returns `null` pour `Hidden` (rien à transmettre), une chaîne de même
+ *          longueur pour `Obscured`, la valeur d'origine pour `Plain`.
+ */
+export declare function maskInputValue(value: string, maskType: MaskType): string | null;