@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/lql/types.d.ts

@@ -0,0 +1,54 @@
+export type LqlDialect = "sqlite" | "postgres" | "clickhouse";
+export type LqlFieldRef = ["field", string, ...(string | number)[]] | {
+    field: string;
+    type?: string;
+};
+export type LqlFilterClause = any;
+export type LqlAggregationClause = any[];
+export type LqlBreakoutClause = any;
+export type LqlExpressionClause = Record<string, any>;
+export type LqlOrderByClause = any;
+export type LqlJoinClause = {
+    source: string | LqlQuery;
+    type?: "inner" | "left" | "right" | "full";
+    on: any;
+};
+export type LqlPivotClause = {
+    rowFields: string[];
+    columnFields: string[];
+    valueField: string;
+};
+export interface LqlStage {
+    source?: string | LqlQuery;
+    filter?: LqlFilterClause;
+    aggregation?: LqlAggregationClause[];
+    breakout?: LqlBreakoutClause[];
+    expressions?: LqlExpressionClause;
+    "order-by"?: LqlOrderByClause[];
+    limit?: number;
+    joins?: LqlJoinClause[];
+    pivot?: LqlPivotClause;
+    parameters?: Record<string, unknown>;
+}
+export interface LqlQuery {
+    "source-table"?: string;
+    source?: string | LqlQuery;
+    stages?: LqlStage[];
+    filter?: LqlFilterClause;
+    aggregation?: LqlAggregationClause[];
+    breakout?: LqlBreakoutClause[];
+    expressions?: LqlExpressionClause;
+    "order-by"?: LqlOrderByClause[];
+    limit?: number;
+    joins?: LqlJoinClause[];
+    pivot?: LqlPivotClause;
+    parameters?: Record<string, unknown>;
+}
+export interface LqlValidationError {
+    path: string;
+    message: string;
+}
+export interface CompiledSql {
+    sql: string;
+    params: unknown[];
+}

package/dist/lql/validator.d.ts

@@ -0,0 +1,2 @@
+import type { LqlQuery, LqlValidationError } from "./types";
+export declare function validateLql(query: LqlQuery): LqlValidationError[];

package/dist/lylql/compiler.d.ts

@@ -0,0 +1,2 @@
+export { compileQuery, compileExpression, compileWindowFunction, compileOffset, compileRank, compileWindowAggregate, compileCte, supportsCte, derivedTable, } from "../semantic/compiler";
+export type { CompiledSql } from "./lql-types";

package/dist/lylql/index.d.ts

@@ -0,0 +1,27 @@
+export * from "../semantic/types";
+export * from "../semantic/compiler";
+export * from "../semantic/schema-validator";
+export * from "../semantic/streaming";
+export * from "../semantic/pivot-powerset";
+export * as SqlAst from "../semantic/sql-ast";
+export * from "../semantic/sql-ast-builder";
+export * from "../semantic/sql-formatter";
+export * from "../semantic/schema-registry";
+export * from "../semantic/dialects/registry";
+export * as Dialects from "../semantic/dialects";
+export * from "../semantic/pipeline";
+export * from "../semantic/registry";
+export * from "../semantic/vocabulary";
+export * from "../semantic/primitives";
+export * from "../semantic/expr";
+export * from "../semantic/question";
+export * from "../semantic/metadata";
+export * from "../semantic/serialization";
+export * from "../semantic/diagnostics";
+export * from "../semantic/agent-schema";
+export * from "../semantic/cache";
+export * from "../semantic/chart-suggestion";
+export * from "../semantic/expr-json";
+export * from "../semantic/sandbox";
+export * from "../semantic/timezone";
+export * from "../semantic/eval-memory";

package/dist/lylql/lql-types.d.ts

@@ -0,0 +1,43 @@
+export type LqlDialect = "sqlite" | "postgres" | "clickhouse";
+export interface CompiledSql {
+    sql: string;
+    params: unknown[];
+}
+export interface LqlStage {
+    source?: string | LqlQuery;
+    filter?: unknown;
+    aggregation?: unknown[];
+    breakout?: unknown[];
+    expressions?: Record<string, unknown>;
+    "order-by"?: unknown[];
+    limit?: number;
+    joins?: unknown[];
+    pivot?: {
+        rowFields: string[];
+        columnFields: string[];
+        valueField: string;
+    };
+    parameters?: Record<string, unknown>;
+}
+export interface LqlQuery {
+    "source-table"?: string;
+    source?: string | LqlQuery;
+    stages?: LqlStage[];
+    filter?: unknown;
+    aggregation?: unknown[];
+    breakout?: unknown[];
+    expressions?: Record<string, unknown>;
+    "order-by"?: unknown[];
+    limit?: number;
+    joins?: unknown[];
+    pivot?: {
+        rowFields: string[];
+        columnFields: string[];
+        valueField: string;
+    };
+    parameters?: Record<string, unknown>;
+}
+export interface LqlValidationError {
+    path: string;
+    message: string;
+}

package/dist/lylql/streaming.d.ts

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

package/dist/lylql/types.d.ts

@@ -0,0 +1,3 @@
+export type { SemanticQuery, SemanticModel, SemanticDimension, SemanticMetric, SemanticSource, SemanticJoin, SemanticSegment, CompiledQuery, CompiledColumn, SemanticFieldType, PivotResult, WindowSpec, CteSpec, } from "../semantic/types";
+export type { SqlDialect, SqlDialectId, SqlParamType, SqlValueType, DateTruncUnit } from "../semantic/dialects/types";
+export type { LqlQuery, LqlStage, LqlDialect } from "./lql-types";

package/dist/lylql/validator.d.ts

@@ -0,0 +1,4 @@
+export { validate, validateSchema, explain, } from "../semantic/schema-validator";
+export type { ValidationResult, ValidationError, } from "../semantic/schema-validator";
+export type { Schema, SchemaDef } from "../semantic/schema-registry";
+export { schemaRegistry } from "../semantic/schema-registry";

package/dist/lynx-agent-readiness-auditor.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 🦁 LynxAgentReadinessAuditor — Autonomous AI Agent Crawl & Action Readiness
+ *
+ * Proprietary LynxSEO Auditor that evaluates how effectively autonomous AI agents
+ * (e.g., Claude, Cursor, ChatGPT Operator, Perplexity, OpenCode) can parse, navigate,
+ * self-throttle, and interact with a website or API without hallucination or failure.
+ *
+ * Implements 11 advanced inspection vectors:
+ * 1.  AGENT-RAW-CONTENT: Raw HTML text content ratio & SSR/SSG baseline (anti-empty-shell)
+ * 2.  AGENT-STATUS-INTEGRITY: True HTTP 404/410 status codes vs Soft-200 traps
+ * 3.  AGENT-LLMS-STANDARD: Machine-readable documentation (/llms.txt, /llms-full.txt)
+ * 4.  AGENT-RATELIMIT-HEADERS: Standard RFC/IETF rate-limiting & Retry-After headers
+ * 5.  AGENT-MCP-INTERFACE: Model Context Protocol (MCP) & WebMCP endpoint discovery
+ * 6.  AGENT-SCOPED-PERMISSIONS: Granular OAuth/API scopes & least-privilege schemas
+ * 7.  AGENT-ONBOARDING-FRICTION: Frictionless machine onboarding & zero-auth read paths
+ * 8.  AGENT-FORM-SEMANTICS: Structured input semantics, autocomplete, and explicit labels
+ * 9.  AGENT-STRUCTURED-ACTIONS: Schema.org potentialAction executable definitions
+ * 10. AGENT-INJECTION-DEFENSE: Prompt injection resistance & hidden-text traps
+ * 11. AGENT-BOT-GOVERNANCE: AI crawler policy & transparent robots.txt rules
+ */
+export type AgentReadinessTier = "essential" | "recommended" | "bonus";
+export type AgentCheckStatus = "pass" | "partial" | "fail";
+export type AgentReadinessGrade = "A+" | "A" | "B" | "C" | "D" | "F";
+export interface AgentReadinessCheck {
+    id: string;
+    name: string;
+    tier: AgentReadinessTier;
+    status: AgentCheckStatus;
+    score: number;
+    maxScore: number;
+    evidence: string;
+    recommendation: string;
+}
+export interface TierScoreBreakdown {
+    score: number;
+    maxScore: number;
+    passed: number;
+    total: number;
+}
+export interface AgentReadinessInput {
+    url: string;
+    finalUrl?: string;
+    httpStatus?: number;
+    html: string;
+    headers?: Record<string, string>;
+    robotsTxt?: string;
+    llmsTxt?: string;
+    openApiSpec?: Record<string, unknown>;
+    mcpManifest?: Record<string, unknown>;
+    jsonLdSchemas?: Array<Record<string, unknown>>;
+    probedErrorStatus?: number;
+    probedErrorHtml?: string;
+}
+export interface AgentReadinessReport {
+    target: string;
+    score: number;
+    grade: AgentReadinessGrade;
+    scoreLabel: string;
+    scoreBreakdown: {
+        essential: TierScoreBreakdown;
+        recommended: TierScoreBreakdown;
+        bonus: TierScoreBreakdown;
+    };
+    checks: AgentReadinessCheck[];
+    failures: AgentReadinessCheck[];
+    partials: AgentReadinessCheck[];
+    passes: AgentReadinessCheck[];
+    summary: string;
+    scannedAt: string;
+}
+export declare class LynxAgentReadinessAuditor {
+    /**
+     * Run a comprehensive autonomous agent readiness audit.
+     */
+    static audit(input: AgentReadinessInput): AgentReadinessReport;
+    private static checkRawContent;
+    private static checkStatusIntegrity;
+    private static checkLlmsStandard;
+    private static checkRateLimitHeaders;
+    private static checkMcpInterface;
+    private static checkScopedPermissions;
+    private static checkOnboardingFriction;
+    private static checkFormSemantics;
+    private static checkStructuredActions;
+    private static checkInjectionDefense;
+    private static checkBotGovernance;
+    private static computeGrade;
+    private static computeScoreLabel;
+}

package/dist/lynx-pulse-prism-engine.d.ts

@@ -0,0 +1,70 @@
+export interface VariantPerformance {
+    variantId: string;
+    impressions: number;
+    conversions: number;
+    totalRevenueCents: number;
+}
+export interface PrismArmAllocation {
+    variantId: string;
+    probBest: number;
+    allocatedTrafficRatio: number;
+    expectedConversionRate: number;
+    expectedRpvCents: number;
+}
+export interface PrismOptimizationResult {
+    allocations: PrismArmAllocation[];
+    winningVariantId: string;
+    statisticalConfidence: number;
+    estimatedIncrementalRevenueCents: number;
+}
+export interface TargetingContext {
+    cartSubtotalCents?: number;
+    cartItemCount?: number;
+    utmSource?: string;
+    utmCampaign?: string;
+    isFirstVisit?: boolean;
+    countryCode?: string;
+    deviceType?: "mobile" | "desktop" | "tablet";
+    pageUrl?: string;
+}
+export interface TargetingRules {
+    minCartSubtotalCents?: number;
+    maxCartSubtotalCents?: number;
+    allowedUtmSources?: string[];
+    onlyFirstVisit?: boolean;
+    onlyReturning?: boolean;
+    allowedCountries?: string[];
+    allowedDeviceTypes?: ("mobile" | "desktop" | "tablet")[];
+    urlPattern?: string;
+}
+/**
+ * Lynx Pulse Prism Engine
+ * Moteur d'optimisation prédictif inspiré de Prism AI (Multi-Armed Bandit Thompson Sampling & Smart Targeting Rules)
+ */
+export declare class LynxPulsePrismEngine {
+    /**
+     * Évalue si les règles de ciblage sont satisfaites pour le visiteur courant.
+     */
+    static evaluateTargetingRules(rules: TargetingRules, context: TargetingContext): boolean;
+    /**
+     * Calcule l'allocation optimale de trafic entre les variantes via Thompson Sampling (Simulations Monte-Carlo).
+     * Intègre le taux de conversion et le Revenue Per Visitor (RPV).
+     */
+    static calculatePrismOptimization(variants: VariantPerformance[], numSimulations?: number): PrismOptimizationResult;
+    /**
+     * Sélectionne dynamiquement une variante pour une nouvelle impression selon l'allocation Prism
+     */
+    static selectVariant(allocations: PrismArmAllocation[]): string;
+    /**
+     * Échantillonnage de la distribution Bêta via deux distributions Gamma.
+     */
+    private static sampleBeta;
+    /**
+     * Approximation de Marsaglia et Tsang pour la distribution Gamma.
+     */
+    private static sampleGamma;
+    /**
+     * Box-Muller transform pour loi normale N(0, 1).
+     */
+    private static sampleNormal;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * 🐒 `mailchimp-sync-engine.ts` — Synchronisation native Mailchimp Marketing API v3.
+ *
+ * Implémente :
+ * - Upsert de membre de liste via PUT `/3.0/lists/{list_id}/members/{subscriber_hash}` (MD5 de l'email).
+ * - Envoi des merge fields (FNAME, LNAME, PHONE, etc.).
+ * - Tagging automatique basé sur les réponses aux quiz Zero-Party Data.
+ * - Détection automatique du data center Mailchimp à partir de l'API Key (ex: `us19`, `us21`).
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+export interface MailchimpSyncPayload {
+    email: string;
+    phone?: string;
+    firstName?: string;
+    lastName?: string;
+    tags?: string[];
+    zeroPartyAnswers?: Record<string, unknown>;
+    couponCode?: string;
+}
+export interface MailchimpConfig {
+    apiKey: string;
+    listId: string;
+    serverPrefix?: string;
+}
+export interface MailchimpSyncResult {
+    ok: boolean;
+    memberId?: string;
+    status?: string;
+    tagsApplied?: string[];
+    error?: string;
+}
+export declare class MailchimpSyncEngine {
+    /**
+     * Extrait le datacenter Mailchimp à partir de la clé API (format `key-dc`, ex: `abc123xyz-us19`).
+     */
+    static extractServerPrefix(apiKey: string): string;
+    /**
+     * Calcule le hash MD5 d'une chaîne en pur JavaScript/TypeScript (sans dépendance crypto externe).
+     */
+    static md5(input: string): string;
+    /**
+     * Construit les tags dérivés des réponses aux questions du quiz.
+     */
+    static buildTags(answers?: Record<string, unknown>, extraTags?: string[]): string[];
+    /**
+     * Synchronise ou crée un abonné sur une liste Mailchimp.
+     */
+    static syncSubscriber(config: MailchimpConfig, payload: MailchimpSyncPayload, customFetch?: typeof fetch): Promise<MailchimpSyncResult>;
+}

package/dist/marketing-council-engine.d.ts

@@ -0,0 +1,94 @@
+/**
+ * 👥 Marketing Council Engine (Multi-Agent Deliberation)
+ * Implements structured debate among 4 marketing personas:
+ * Growth Hacker, Product Marketer, Brand Strategist, RevOps
+ * to evaluate and synthesize marketing strategies.
+ */
+export type MarketingPersona = "growth_hacker" | "product_marketer" | "brand_strategist" | "revops";
+export type MarketingCouncilVote = "STRONG_YES" | "YES" | "NO" | "STRONG_NO";
+export interface MarketingCouncilPerspective {
+    persona: MarketingPersona;
+    vote: MarketingCouncilVote;
+    reasoning: string[];
+    concerns: string[];
+    suggestions: string[];
+}
+export interface MarketingCouncilInput {
+    /** The marketing strategy, campaign, or proposal to evaluate */
+    proposal: string;
+    /** Context about the business/product */
+    context?: {
+        businessType?: "saas" | "ecommerce" | "content" | "leadgen" | "other";
+        stage?: "early" | "growth" | "mature";
+        goal?: "acquisition" | "activation" | "retention" | "referral" | "revenue";
+        targetAudience?: string;
+        budgetLevel?: "low" | "medium" | "high";
+    };
+    /** Specific aspects to focus on (optional) */
+    focusAreas?: ("copy" | "design" | "targeting" | "channels" | "funnel" | "metrics")[];
+}
+export interface MarketingCouncilResult {
+    /** Individual perspectives from each persona */
+    perspectives: MarketingCouncilPerspective[];
+    /** Consensus vote (if any) */
+    consensusVote?: MarketingCouncilVote;
+    /** Synthesis of the debate */
+    synthesis: string;
+    /** Actionable recommendations */
+    recommendations: string[];
+    /** Areas requiring further investigation */
+    openQuestions: string[];
+    /** Confidence in the recommendation (0-100) */
+    confidenceScore: number;
+}
+export declare class MarketingCouncilEngine {
+    /**
+     * Conduct structured debate among the four marketing personas
+     */
+    static deliberate(input: MarketingCouncilInput): MarketingCouncilResult;
+    /**
+     * Get perspective from Growth Hacker persona
+     * Focus: rapid experimentation, viral loops, metric-driven growth
+     */
+    private static getGrowthHackerPerspective;
+    /**
+     * Get perspective from Product Marketer persona
+     * Focus: positioning, messaging, product-market fit
+     */
+    private static getProductMarketerPerspective;
+    /**
+     * Obtenir la perspective du persona Stratège de marque
+     * Focus: équité de marque, cohérence à long terme, narration
+     */
+    private static getBrandStrategistPerspective;
+    /**
+     * Obtenir la perspective du persona RevOps
+     * Focus: métriques, responsabilité, alignement des processus
+     */
+    private static getRevOpsPerspective;
+    /**
+     * Calculer le vote de consensus basé sur les perspectives individuelles
+     */
+    private static calculateConsensus;
+    /**
+     * Générer une synthèse du débat
+     */
+    private static generateSynthesis;
+    /**
+     * Générer des recommandations pratiques
+     */
+    private static generateRecommendations;
+    /**
+     * Identifier les questions ouvertes nécessitant une enquête plus approfondie
+     */
+    private static identifyOpenQuestions;
+    /**
+     * Calculer un score de confiance basé sur l'alignement des perspectives
+     */
+    private static calculateConfidence;
+    /**
+     * Obtenir le nom d'affichage pour une persona
+     */
+    private static getPersonaDisplayName;
+}
+export default MarketingCouncilEngine;

package/dist/marketing-skills-engine.d.ts

@@ -1,7 +1,7 @@
 /**
  * 🎯 Marketing Skills & Growth Engine (ASO, NAP Citations, E-E-A-T, Lead Magnets)
  *
- * Implements algorithms inspired by marketingskills, claude-seo, and local business builders:
+ * Implements the growth algorithms below:
  * 1. AsoOptimizer: App Store Optimization (iOS / Google Play) & MobileApplication Schema
  * 2. NapConsistencyEngine: Name, Address, Phone concordance auditor across 50+ local directories
  * 3. EeatAuthorEngine: Author Authority & Credibility Scorer with sameAs Knowledge Graph validation
@@ -54,6 +54,47 @@ export interface LeadMagnetConfig {
     inputLabels: string[];
     embeddableHtml: string;
 }
+export interface AdsMathInput {
+    targetBudgetMonthly: number;
+    averageCpc: number;
+    landingConversionRate: number;
+    leadToCustomerRate: number;
+    customerLtv: number;
+    grossMarginPct: number;
+}
+export interface AdsMathResult {
+    projectedClicks: number;
+    projectedLeads: number;
+    projectedCustomers: number;
+    projectedCpa: number;
+    breakEvenRoas: number;
+    targetRoas: number;
+    projectedRevenue: number;
+    contributionMargin: number;
+    isViable: boolean;
+    diagnostics: string[];
+}
+export interface AiCitationFormatRiskResult {
+    format: "LISTICLE" | "COMPARISON_VS" | "OWNED_DOCUMENTATION" | "ORIGINAL_RESEARCH_DATA" | "HOW_TO_GUIDE";
+    riskLevel: "HIGH" | "MEDIUM" | "LOW";
+    chatGptPost56RiskPct: number;
+    recommendations: string[];
+    strategicPivotAdvice: string;
+}
+export interface CroFrictionAuditInput {
+    formFieldCount: number;
+    hasSocialAuth: boolean;
+    requiresCreditCardForTrial: boolean;
+    hasClearValuePropAboveFold: boolean;
+    hasSocialProofAboveFold: boolean;
+    hasExitIntentRecovery: boolean;
+}
+export interface CroFrictionAuditResult {
+    frictionScore: number;
+    estimatedDropoffRatePct: number;
+    criticalBlockers: string[];
+    highImpactFixes: string[];
+}
 export declare class MarketingSkillsEngine {
     /**
      * 1. 📱 ASO (App Store Optimization) Engine
@@ -71,4 +112,18 @@ export declare class MarketingSkillsEngine {
      * 4. 🧲 Lead Magnet & Embeddable ROI Calculator Generator
      */
     static generateLeadMagnet(type: "ROI_CALCULATOR" | "SEO_CHECKLIST" | "PRICE_ESTIMATOR" | "AUDIT_WIDGET", title: string, brandName?: string): LeadMagnetConfig;
+    /**
+     * 5. 💰 Paid Media & Ads Financial Modeling
+     * Calculates CPA, break-even ROAS, contribution margin, and financial viability
+     */
+    static calculateAdsMath(input: AdsMathInput): AdsMathResult;
+    /**
+     * 6. 🤖 AI Search Citation Format Volatility Auditor
+     * Evaluates citation stability across ChatGPT 5.6, Perplexity, and Gemini
+     */
+    static auditCitationFormatRisk(format: "LISTICLE" | "COMPARISON_VS" | "OWNED_DOCUMENTATION" | "ORIGINAL_RESEARCH_DATA" | "HOW_TO_GUIDE"): AiCitationFormatRiskResult;
+    /**
+     * 7. 🎯 CRO Friction & Tunnel Auditor
+     */
+    static auditCroFriction(input: CroFrictionAuditInput): CroFrictionAuditResult;
 }

package/dist/marketplace-price-intelligence.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 🛍️ Marketplaces Price Intelligence (Google Shopping / Amazon)
+ *
+ * Models competitive price landscapes on Google Shopping and Amazon so e-commerce
+ * audits can recommend pricing strategy: median positioning, price-ratio vs
+ * rating/value, top-seller share, and the organic-vs-shopping keyword gap.
+ */
+export interface PricePoint {
+    marketplace: "google_shopping" | "amazon";
+    listingTitle: string;
+    price: number;
+    currency: string;
+    seller?: string;
+    rating?: number | null;
+    reviewCount?: number | null;
+    inStock: boolean;
+}
+export interface PriceLandscape {
+    marketplace: "google_shopping" | "amazon";
+    count: number;
+    min: number;
+    max: number;
+    median: number;
+    p25: number;
+    p75: number;
+    mean: number;
+    outOfStockCount: number;
+}
+export interface MarketplaceKeywordGap {
+    keyword: string;
+    organicOnly: boolean;
+    shoppingOnly: boolean;
+    both: boolean;
+    neither: boolean;
+    recommendation: string;
+}
+export interface MarketplaceIntelligenceResult {
+    landscape: Record<"google_shopping" | "amazon", PriceLandscape | null>;
+    crossMarketplaceSummary: {
+        cheapest: {
+            marketplace: "google_shopping" | "amazon" | "tie";
+            price: number | null;
+        };
+        bestValue: {
+            marketplace: "google_shopping" | "amazon" | "tie";
+            reason: string;
+        };
+        priceRangeAcross: string;
+    };
+    outliers: PricePoint[];
+    recommendations: string[];
+}
+/**
+ * Computes a robust price distribution (percentiles, median, mean, range) from a
+ * set of listings. Returns null when there is no usable price data.
+ */
+export declare class MarketplacePriceIntelligence {
+    static analyzeLandscape(listings: PricePoint[]): PriceLandscape | null;
+    /**
+     * Full cross-marketplace intelligence from Google Shopping + Amazon listings.
+     */
+    static analyze(input: {
+        googleShopping: PricePoint[];
+        amazon: PricePoint[];
+    }): MarketplaceIntelligenceResult;
+    /**
+     * Classifies each keyword's presence across organic vs shopping surfaces and
+     * returns a targeted recommendation (the marketplace keyword-gap pattern).
+     */
+    static mapKeywordGap(input: {
+        keywords: string[];
+        organicRanked: string[];
+        shoppingListed: string[];
+    }): MarketplaceKeywordGap[];
+}