@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/expired-domain-valuator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 🏛️ Expired Domain Valuator
+ *
+ * Implements the signature expired domain assessment:
+ * - Computes Residual Authority Score (0-100) based on Majestic TF/CF and referring domains
+ * - Evaluates Spam & Historical Penalty Risk (unbalanced TF/CF ratio, toxic anchor texts, de-indexation)
+ * - Estimates Fair Market Value in Euros (€)
+ * - Prescribes the optimal action: 301 Redirection, PBN satellite, Site Rebuild, or Toxic Avoidance
+ */
+export interface ExpiredDomainMetrics {
+    domain: string;
+    domainAgeYears?: number;
+    trustFlow: number;
+    citationFlow: number;
+    referringDomainsCount: number;
+    totalBacklinksCount: number;
+    topicalTrustFlowCategory?: string;
+    residualRankedKeywordsTop100: number;
+    isIndexedInGoogle: boolean;
+    topAnchors: Array<{
+        anchor: string;
+        percentage: number;
+    }>;
+}
+export type ExpiredDomainRecommendation = "ACQUIRE_FOR_301" | "ACQUIRE_FOR_PBN" | "REBUILD_SITE" | "AVOID_TOXIC";
+export interface ExpiredDomainAuditResult {
+    domain: string;
+    authorityScore: number;
+    spamRiskScore: number;
+    tfCfRatio: number;
+    isPenalizedRisk: boolean;
+    recommendation: ExpiredDomainRecommendation;
+    recommendationLabel: string;
+    estimatedFairMarketValueEur: number;
+    strategicActionPlan: string;
+    warningFlags: string[];
+}
+export declare class ExpiredDomainValuator {
+    private static readonly TOXIC_PATTERNS;
+    /**
+     * Evaluates an expired domain and computes its market value and strategic recommendation.
+     */
+    static evaluateDomain(metrics: ExpiredDomainMetrics): ExpiredDomainAuditResult;
+}

package/dist/exporters/branded-analytics-report.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 🖼️ Branded Analytics Report — G11
+ *
+ * Exports étendus et marque blanche : produit un rapport HTML autonome
+ * (imprimable en PDF haute qualité) et une carte SVG vectorielle, tous deux
+ * portant le logo et le nom de l'agence.
+ *
+ * Le principe est celui de `white-label.ts` (côté app) et
+ * `exporters/html-pdf-report.ts` (rapport d'audit) : la marque est un
+ * paramètre, jamais une valeur codée en dur, et `hideBranding` supprime toute
+ * mention de la plateforme LynxSEO du rendu.
+ *
+ * Adapté (réécrit, sans import) des conventions de rapport white-label de
+ * l'écosystème (Matomo/Metabase) : en-tête logo + pied de page agence, palette
+ * paramétrable, tableaux et KPI paginés pour l'impression A4.
+ */
+export interface AnalyticsReportBrand {
+    /** Nom affiché de l'agence ; « LynxSEO » si absent. */
+    brandName?: string;
+    /** Logo absolu (URL ou data-URI) affiché dans l'en-tête. */
+    logoUrl?: string;
+    /** Couleur d'accent de la marque (`#rrggbb`). */
+    primaryColor?: string;
+    secondaryColor?: string;
+    supportEmail?: string;
+    /** Supprime les mentions « LynxSEO » quand l'agence marque en blanc. */
+    hideBranding?: boolean;
+}
+export interface AnalyticsReportSection {
+    title: string;
+    description?: string;
+    columns: string[];
+    rows: Array<Array<string | number | null>>;
+}
+export interface AnalyticsKpi {
+    label: string;
+    value: string;
+    hint?: string;
+}
+export interface BrandedAnalyticsReportInput {
+    title: string;
+    siteName: string;
+    generatedAt: string;
+    brand?: AnalyticsReportBrand;
+    kpis?: AnalyticsKpi[];
+    sections: AnalyticsReportSection[];
+    footerNote?: string;
+    /** Inline SVG charts rendered right after the KPI block. */
+    charts?: AnalyticsReportChart[];
+}
+export interface AnalyticsReportChart {
+    title: string;
+    svg: string;
+}
+export interface BarChartPoint {
+    label: string;
+    value: number;
+}
+export interface BrandedSvgCardInput {
+    title: string;
+    subtitle?: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+    brand?: AnalyticsReportBrand;
+    width?: number;
+}
+/** Échappe les valeurs interpolées : ce rapport est du HTML, pas du texte brut. */
+export declare function escapeReportHtml(value: string): string;
+/**
+ * Histogramme SVG autonome (aucune dépendance) pour les rapports imprimables.
+ * Les libellés sont échappés ; seules les couleurs hexadécimales sont admises.
+ */
+export declare function renderBarChartSvg(points: BarChartPoint[], options?: {
+    color?: string;
+    width?: number;
+    height?: number;
+}): string;
+/**
+ * Rapport HTML autonome, prêt pour l'impression (Chromium `print-to-pdf`) ou
+ * pour l'export `.html`. Les couleurs et le logo proviennent de la marque.
+ */
+export declare function renderBrandedAnalyticsReport(input: BrandedAnalyticsReportInput): string;
+/**
+ * Carte vectorielle autonome (SVG) réutilisable hors navigateur : convient
+ * comme source d'export PNG/JPEG (rasterisée côté client) ou comme image
+ * intégrée dans un email/webhook. `hideBranding` retire la signature.
+ */
+export declare function renderBrandedSvgCard(input: BrandedSvgCardInput): string;

package/dist/exporters/excel-action-tracker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Interactive Excel Action Tracker & Multi-Sheet Exporter
+ *
+ * Generates an authoritative .xlsx workbook with:
+ * - Summary sheet with dynamic COUNTIF/COUNTIFS formulas linking to Actions
+ * - Actions sheet with status dropdown validation and conditional styling
+ * - Pages sheet with full crawl & semantic quality inventory
+ */
+import { type AuditScoreResult } from "../audit-scoring-engine";
+import { Translator } from "../i18n/translator";
+export interface CrawledPageInventoryItem {
+    url: string;
+    statusCode: number | null;
+    indexable: boolean;
+    title?: string;
+    h1?: string;
+    wordCount?: number;
+    depth?: number;
+    helpfulness?: number;
+    specificity?: number;
+    trust?: number;
+    citability?: number;
+}
+export interface ExcelWorkbookInput {
+    domain: string;
+    auditDate: string;
+    scoreResult: AuditScoreResult;
+    pages?: CrawledPageInventoryItem[];
+    translator?: Translator;
+    lang?: string;
+}
+export declare function generateAuditExcelWorkbook(input: ExcelWorkbookInput): Promise<Buffer>;

package/dist/exporters/html-pdf-report.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Executive HTML & Vector PDF Audit Report Generator
+ *
+ * Emits self-contained, print-ready HTML with inline SVG vector charts,
+ * dark executive cover band, circular gauge, quadrant matrix,
+ * category bars, and prioritized action inventory.
+ */
+import { type AuditScoreResult, type PrioritizedAction } from "../audit-scoring-engine";
+import { type AuditNarrative } from "../narrative-validator";
+import { Translator } from "../i18n/translator";
+export interface WhiteLabelConfig {
+    agencyName?: string;
+    agencyLogoUrl?: string;
+    agencyWebsite?: string;
+    auditorName?: string;
+    auditorContact?: string;
+    reportSubtitle?: string;
+    theme?: "jev-warm" | "lynx-cyber" | "corporate-blue";
+}
+export interface AuditReportInput {
+    domain: string;
+    auditDate: string;
+    scoreResult: AuditScoreResult;
+    totalPagesCrawled: number;
+    narrative?: Partial<AuditNarrative>;
+    whiteLabel?: WhiteLabelConfig;
+    translator?: Translator;
+    lang?: string;
+}
+export declare function generateFixCodeSnippet(action: PrioritizedAction, domain: string): string | null;
+export declare function generateSvgScoreGauge(score: number, grade: string, partial?: boolean): string;
+export declare function generateSvgCategoryBars(categories: Record<string, number | null>): string;
+export declare function generateSvgImpactEffortMatrix(actions: PrioritizedAction[]): string;
+export declare function renderAuditHtmlReport(input: AuditReportInput): string;
+export declare const generateHtmlAuditReport: typeof renderAuditHtmlReport;

package/dist/exporters/markdown-report.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Full Markdown Report & Digest Generator
+ */
+import { Translator } from "../i18n/translator";
+/**
+ * Generate full Markdown audit report
+ */
+export declare function generateMarkdownReport(auditData: any, narrativeInput?: any, translatorOrLang?: Translator | string): string;
+/**
+ * Generate compact evidence-only digest for LLM agents or prompt context.
+ */
+export declare function generateAuditDigest(auditData: any): string;
+export declare const renderAuditMarkdownReport: typeof generateMarkdownReport;

package/dist/extended-schemas.d.ts

@@ -35,7 +35,18 @@ export interface SchemaOrgLocalBusinessOpts {
     country: string;
     latitude?: number;
     longitude?: number;
+    /**
+     * Legacy `"09:00-18:00"` entries. They are published as Monday-Friday, so
+     * prefer `openingHoursSpecification` when the real days differ (e.g. a shop
+     * open on Saturday).
+     */
     openingHours?: string[];
+    /** Explicit, day-aware opening hours. Takes precedence over `openingHours`. */
+    openingHoursSpecification?: Array<{
+        dayOfWeek: string[];
+        opens: string;
+        closes: string;
+    }>;
     priceRange?: string;
 }
 export interface SchemaOrgProductOpts {
@@ -47,6 +58,12 @@ export interface SchemaOrgProductOpts {
     currency: string;
     image?: string;
 }
+export interface SchemaOrgArticleImage {
+    url: string;
+    width?: number;
+    height?: number;
+    caption?: string;
+}
 export interface SchemaOrgArticleOpts {
     headline: string;
     description: string;
@@ -55,6 +72,20 @@ export interface SchemaOrgArticleOpts {
     dateModified?: string;
     authorName: string;
     publisherName: string;
+    /** Article subtype. Defaults to "Article". */
+    type?: "Article" | "NewsArticle" | "BlogPosting" | "TechArticle" | "Report";
+    authorUrl?: string;
+    authorType?: "Person" | "Organization";
+    publisherUrl?: string;
+    publisherLogoUrl?: string;
+    image?: string | SchemaOrgArticleImage | Array<string | SchemaOrgArticleImage>;
+    isAccessibleForFree?: boolean;
+    mainEntityOfPage?: string;
+    inLanguage?: string;
+    articleSection?: string;
+    keywords?: string[];
+    wordCount?: number;
+    speakableSelectors?: string[];
 }
 export declare class ExtendedSchemaGraphBuilder {
     /**
@@ -103,6 +134,31 @@ export declare class ExtendedSchemaGraphBuilder {
         name: string;
         url: string;
     }[]): Record<string, unknown>;
+    /**
+     * 6b. Article / NewsArticle / BlogPosting
+     *
+     * Google requires headline, author, publisher and at least one of the image
+     * fields to be present; optional props are only emitted when supplied so the
+     * node never carries invented values.
+     */
+    static buildArticle(opts: SchemaOrgArticleOpts): Record<string, unknown>;
+    /**
+     * 6c. Article graph wiring WebPage, Article and optional BreadcrumbList
+     * through permanent @id references.
+     */
+    static buildArticleGraph(opts: SchemaOrgArticleOpts & {
+        breadcrumbs?: {
+            name: string;
+            url: string;
+        }[];
+    }): Record<string, unknown>;
+    /**
+     * 6d. Multiple breadcrumb trails on one page.
+     */
+    static buildBreadcrumbTrails(trails: {
+        name: string;
+        url: string;
+    }[][]): Record<string, unknown>[];
     /**
      * 7. AggregateRating (Google Gold Stars in SERPs) - Strictly Dynamic (No Fake Defaults)
      */
@@ -114,7 +170,41 @@ export declare class ExtendedSchemaGraphBuilder {
         itemReviewedName: string;
     }): Record<string, unknown> | null;
     /**
-     * 8. AggregateOffer (Price Ranges & Tiers) - Inspired by santifer-irepair
+     * 7b. Individual Review Schema (Trustpilot / G2 Verified Review Pattern)
+     */
+    static buildReview(opts: {
+        itemReviewedName: string;
+        authorName: string;
+        reviewRating: number;
+        reviewBody: string;
+        datePublished?: string;
+        publisherName?: string;
+    }): Record<string, unknown>;
+    /**
+     * 7c. Recipe Schema (Google Gold Rich Snippets for Food, Ingredients, Nutrition)
+     */
+    static buildRecipe(opts: {
+        name: string;
+        description: string;
+        image?: string;
+        authorName?: string;
+        prepTimeMinutes?: number;
+        cookTimeMinutes?: number;
+        totalTimeMinutes?: number;
+        recipeYield?: string;
+        recipeCategory?: string;
+        recipeCuisine?: string;
+        keywords?: string[];
+        recipeIngredients: string[];
+        recipeInstructions: string[];
+        calories?: number;
+        aggregateRating?: {
+            ratingValue: number;
+            reviewCount: number;
+        };
+    }): Record<string, unknown>;
+    /**
+     * 8. AggregateOffer (Price Ranges & Tiers)
      */
     static buildAggregateOffer(opts: {
         lowPrice: number;
@@ -142,7 +232,7 @@ export declare class ExtendedSchemaGraphBuilder {
         searchUrlTemplate?: string;
     }): Record<string, unknown>;
     /**
-     * 11. Speakable Schema (Google Assistant & Voice Search) - Rank Math Pro Parity
+     * 11. Speakable Schema (Google Assistant & Voice Search)
      */
     static buildSpeakable(opts: {
         cssSelectors?: string[];

package/dist/flag-decision.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Décision de feature flag pour un visiteur donné : ciblage par propriétés,
+ * pourcentage de déploiement puis attribution d'une variante.
+ *
+ * Le calcul est pur (aucune horloge, aucun aléa, aucune entrée/sortie) et repose
+ * sur le même hachage que `experiment-assignment` : un visiteur obtient toujours
+ * la même réponse pour un même drapeau, quel que soit le runtime et même après un
+ * rechargement. C'est ce qui rend une décision stable enough pour être prise
+ * côté serveur et consommée par un script embarqué.
+ */
+export type FlagOperator = "is" | "is_not" | "contains" | "not_contains" | "is_one_of" | "not_one_of" | "is_set" | "not_set" | "gt" | "lt";
+/** Comparaison d'une propriété du visiteur à une valeur de référence. */
+export interface FlagCondition {
+    property: string;
+    operator: FlagOperator;
+    /** Ignoré par `is_set` / `not_set`. */
+    value?: string | number | boolean | Array<string | number>;
+}
+/**
+ * Groupe de conditions évaluées en ET. Plusieurs groupes sont évalués en OU :
+ * c'est ce qui permet « visiteurs de France EN Chrome, OU visiteurs en
+ * localhost quelle que soit la langue ».
+ */
+export interface FlagConditionGroup {
+    conditions: FlagCondition[];
+}
+export interface FlagVariantRule {
+    key: string;
+    /** Poids d'allocation ; 0 sort la variante de la répartition. */
+    weight: number;
+}
+export interface FlagDecisionInput {
+    key: string;
+    /** `false` = drapeau arrêté : personne ne le voit, quel que soit le ciblage. */
+    enabled: boolean;
+    rolloutPercentage: number;
+    variants?: FlagVariantRule[];
+    /** Absence de groupe = pas de restriction de ciblage. */
+    conditions?: FlagConditionGroup[];
+    /** Payload par clé de variante ; sert au rendu sans redéploiement. */
+    payloads?: Record<string, unknown>;
+    /** Valeur renvoyée quand le visiteur est dans le rollout mais hors variante. */
+    defaultPayload?: unknown;
+}
+export interface FlagVisitorContext {
+    /** Identifiant stable du visiteur (id distinct du tracker, ou id utilisateur). */
+    identifier: string;
+    properties?: Record<string, unknown>;
+}
+export type FlagDecisionReason = "active" | "flag_disabled" | "no_identifier" | "rollout" | "targeting";
+export interface FlagDecision {
+    key: string;
+    enabled: boolean;
+    variant: string | null;
+    payload: unknown;
+    reason: FlagDecisionReason;
+}
+/**
+ * Évalue les groupes de ciblage. Un groupe sans condition n'exclut personne ;
+ * des groupes absents signifient « tous les visiteurs ».
+ */
+export declare function matchesFlagConditions(groups: FlagConditionGroup[] | undefined, properties: Record<string, unknown> | undefined): boolean;
+/**
+ * Bucket de déploiement : 100 est toujours vrai, 0 toujours faux, sinon le
+ * drapeau sert de graine pour que deux drapeaux à 50 % ne recrutent pas les
+ * mêmes visiteurs.
+ */
+export declare function isInRollout(flagKey: string, identifier: string, rolloutPercentage: number): boolean;
+/** Décision complète pour un drapeau et un visiteur. */
+export declare function decideFlag(flag: FlagDecisionInput, context: FlagVisitorContext): FlagDecision;
+/** Décision groupée pour une liste de drapeaux, dans l'ordre d'entrée. */
+export declare function decideFlags(flags: FlagDecisionInput[], context: FlagVisitorContext): Record<string, FlagDecision>;

package/dist/flag-dependency.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license AGPL-3.0-or-later
+ *
+ * Dependances entre feature flags (a la PostHog).
+ *
+ * Un drapeau peut dependre d'un autre : il n'est servi que si le drapeau
+ * dependance affiche une variante precise. Utile pour :
+ * - gateuler une fonctionnalite sur une experience parente ;
+ * - evitar d'afficher un CTA si le layout auquel il appartient est desactive ;
+ * - chaîner des rollouts progresses.
+ */
+export interface FlagDependency {
+    /** Cle du drapeau qui depend d'un autre. */
+    flagKey: string;
+    /** Cle du drapeau dont il depend. */
+    dependsOnFlagKey: string;
+    /** Variante requise du drapeau dependance. Si absent, n'importe quelle variante active suffit. */
+    requiredVariantKey?: string;
+}
+/**
+ * Resout les dependances : retourne les clefs de drapeaux qui doivent etre
+ * excludes car une dependance n'est pas satisfaite.
+ *
+ * `decisions` est le resultat de `decideFlags` (cle = flagKey, valeur = decision).
+ */
+export declare function unresolvedDependencies(dependencies: FlagDependency[], decisions: Record<string, {
+    variant: string | null;
+    enabled: boolean;
+}>): string[];
+/**
+ * Filtre les decisions pour retirer les drapeaux dont une dependance n'est pas
+ * satisfaite. Retourne un nouvel objet sans les drapeau excludes.
+ */
+export declare function applyDependencies(decisions: Record<string, {
+    variant: string | null;
+    enabled: boolean;
+}>, dependencies: FlagDependency[]): Record<string, {
+    variant: string | null;
+    enabled: boolean;
+}>;

package/dist/flag-override.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license AGPL-3.0-or-later
+ *
+ * Overrides manuels de feature flags (à la PostHog).
+ *
+ * Un override force une variante pour un visiteur donné, indépendamment du
+ * pourcentage de déploiement et du ciblage. Utile pour :
+ * - activer un flag en interne avant un rollout public ;
+ * - exclure un visiteur d'un variant buggé ;
+ * - assigner manuellement un client bêta à une variante precise.
+ *
+ * Le calcul est pur : une liste d'overrides statiques est evaluatee avant la
+ * decision normale. Un override l'emporte sur tout le reste.
+ */
+export interface FlagOverride {
+    /** Cle du drapeau concerne. */
+    flagKey: string;
+    /** Visiteur (distinctId) cible par l'override. */
+    identifier: string;
+    /** Variante forcee (null pour desactiver le flag pour ce visiteur). */
+    variantKey: string | null;
+    /** Alias optionnel pour compatibilite. */
+    variant?: string | null;
+    /** Motif lisible, affiche dans l'UI d'administration. */
+    reason?: string;
+    /** Date a partir de laquelle l'override s'applique. Optionnel. */
+    activeFrom?: string;
+    /** Date a laquelle l'override expire. Optionnel. */
+    activeUntil?: string;
+}
+/**
+ * Teste si un override est actif a un instant donne.
+ */
+export declare function isOverrideActive(override: FlagOverride, nowMs?: number): boolean;
+/**
+ * Retourne l'override applicable pour un drapeau et un visiteur, ou undefined.
+ * Si plusieurs overrides correspondent, le plus recent (activeFrom) gagne.
+ */
+export declare function findOverride(overrides: FlagOverride[], flagKey: string, identifier: string, nowMs?: number): FlagOverride | undefined;
+/**
+ * Applique les overrides a une liste de decisions de drapeaux pour un visiteur
+ * donne. Les decisions deja prises sont remplacees quand un override existe
+ * pour ce visiteur et ce drapeau.
+ */
+export declare function applyOverrides(decisions: Record<string, {
+    enabled: boolean;
+    variant: string | null;
+}>, overrides: FlagOverride[], identifier: string, nowMs?: number): Record<string, {
+    enabled: boolean;
+    variant: string | null;
+    override?: FlagOverride;
+}>;

package/dist/flag-release-schedule.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license AGPL-3.0-or-later
+ *
+ * Planning de release/rollback pour feature flags (a la PostHog).
+ *
+ * Permet de programmer l'activation ou la desactivation d'un drapeau a une
+ * date donnee, sans redploiement. Utile pour :
+ * - lancer un flag a une date precise (campagne, saisonnalite) ;
+ * - desactiver automatiquement un flag après une periode d'essai ;
+ * - preparer un rollout futur qui se declenche seul.
+ */
+export interface FlagReleaseSchedule {
+    /** Cle du drapeau concerne. */
+    flagKey: string;
+    /** Date de debut d'activation (inclus). Optionnel : actif des le debut si absent. */
+    startAt?: string;
+    /** Date de fin d'activation (exclus). Optionnel : actif sans fin si absent. */
+    expireAt?: string;
+    /** Fuseau horaire pour l'interpretation des dates (IANA). Optionnel. */
+    timezone?: string;
+    /** Motif du planning. */
+    reason?: string;
+}
+/**
+ * Teste si un planning est actif a un instant donne.
+ *
+ * Les dates ISO sont parsees en UTC. Si le fuseau est specifie, on pourrait
+ * ajuster, mais pour garder le calcul pur et deterministe on compare en UTC.
+ */
+export declare function isScheduleActive(schedule: FlagReleaseSchedule, nowMs?: number): boolean;
+/**
+ * Filtre une liste de plannings pour ne garder que ceux actifs maintenant.
+ */
+export declare function filterActiveSchedules(schedules: FlagReleaseSchedule[], nowMs?: number): FlagReleaseSchedule[];

package/dist/flow-framework-engine.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 🌊 FLOW Framework Operating Engine (Find · Leverage · Optimize · Win)
+ *
+ * Implements the evidence-led operating model for modern AI-search era SEO:
+ * - Stage 1 (Find): Keyword research, gap analysis, intent clustering, demand mining.
+ * - Stage 2 (Leverage): Off-site authority, backlink leverage, entity presence.
+ * - Stage 3 (Optimize): On-page architecture, Information Gain, schema, SXO, performance.
+ * - Stage 4 (Win): Conversion rate (CRO), BOFU capture, dual-surface scorecard (Google + AI Search).
+ * - Stage 5 (Local): GBP, NAP alignment, GeoMesh, local reviews.
+ */
+export type FlowStage = "find" | "leverage" | "optimize" | "win" | "local";
+export interface FlowStageDetail {
+    stage: FlowStage;
+    stageName: string;
+    objective: string;
+    corePrinciples: string[];
+    keyToolsInLynxSeo: string[];
+    recommendedPromptTemplate: string;
+}
+export declare class FlowFrameworkEngine {
+    /**
+     * Retrieves guidelines and execution parameters for a given FLOW framework stage.
+     */
+    static getStageGuidelines(stage: FlowStage, domain?: string): FlowStageDetail;
+}

package/dist/free-public-tools.d.ts

@@ -1,6 +1,6 @@
 /**
  * 🛠️ Free Public Interactive Tools & Lead Magnets Suite
- * Inspired by Ahrefs, Semrush, Moz, and WordStream free tool ecosystems.
+ * Free public tool ecosystem: SEO audit, keyword and traffic calculators.
  *
  * Provides 6 zero-dependency interactive calculators and simulators that can be embedded
  * on public programmatic pages to maximize dwell time, engagement, backlink acquisition, and user conversion.