@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/plugins/tag-manager/container.d.ts

@@ -0,0 +1,98 @@
+/**
+ * LynxSEO - Tag Manager : conteneurs, versions et environnements.
+ * Modèle inspiré de Matomo Tag Manager (GPLv3 / AGPLv3 compatible) — TypeScript original.
+ *
+ * Invariant de déterminisme : aucune horloge ni aléa dans ce module. Les horodatages
+ * (`now`) sont toujours fournis par l'appelant ; la même version figée produit toujours
+ * le même export octet pour octet (l'horodatage appartient à la version, pas à l'export).
+ */
+import { type ConsentCategory, type ParameterValue, type TagTemplateId, type TriggerTemplateId, type VariableTemplateId } from "./templates";
+export type ConditionOperator = "equals" | "not_equals" | "contains" | "starts_with" | "ends_with" | "regex" | "lt" | "gt" | "exists";
+export declare const CONDITION_OPERATORS: readonly ConditionOperator[];
+export interface TriggerCondition {
+    /** Identifiant d'une variable du conteneur (ou pseudo-variable `context.*`). */
+    variable: string;
+    operator: ConditionOperator;
+    value?: string;
+}
+export interface ContainerTag {
+    id: string;
+    name: string;
+    template: TagTemplateId;
+    parameters: Readonly<Record<string, ParameterValue>>;
+    /** Identifiants des déclencheurs qui activent ce tag. */
+    triggers: readonly string[];
+    consentRequired: readonly ConsentCategory[];
+    /** Priorité d'exécution : les valeurs élevées partent en premier (ordre stable). */
+    priority: number;
+    fireOnce: boolean;
+    active: boolean;
+}
+export interface ContainerTrigger {
+    id: string;
+    name: string;
+    template: TriggerTemplateId;
+    parameters: Readonly<Record<string, ParameterValue>>;
+    conditions: readonly TriggerCondition[];
+    active: boolean;
+}
+export interface ContainerVariable {
+    id: string;
+    name: string;
+    template: VariableTemplateId;
+    parameters: Readonly<Record<string, ParameterValue>>;
+}
+export interface ContainerVersionContent {
+    tags: readonly ContainerTag[];
+    triggers: readonly ContainerTrigger[];
+    variables: readonly ContainerVariable[];
+}
+export type VersionStatus = "draft" | "committed";
+export interface ContainerVersion extends ContainerVersionContent {
+    id: string;
+    status: VersionStatus;
+    /** Fourni par l'appelant à la création — jamais lu depuis l'horloge interne. */
+    createdAt: string;
+}
+export type EnvironmentName = "preview" | "live";
+export declare const ENVIRONMENT_PREVIEW: EnvironmentName;
+export declare const ENVIRONMENT_LIVE: EnvironmentName;
+export interface ContainerEnvironment {
+    name: EnvironmentName;
+    publishedVersionId: string | null;
+    /** Historique des versions publiées, de la plus ancienne à la plus récente (file de rollback). */
+    history: string[];
+}
+export interface TagContainer {
+    id: string;
+    siteId: string;
+    name: string;
+    draftVersionId: string;
+    versions: Record<string, ContainerVersion>;
+    environments: Record<EnvironmentName, ContainerEnvironment>;
+}
+export declare class TagContainerError extends Error {
+    readonly name = "TagContainerError";
+}
+export declare function createContainer(input: {
+    id: string;
+    siteId: string;
+    name: string;
+    now: string;
+    content?: ContainerVersionContent;
+}): TagContainer;
+export declare function getDraft(container: TagContainer): ContainerVersion;
+/** Remplace le contenu de la version de travail. Refuse une version committée. */
+export declare function setDraftContent(container: TagContainer, content: ContainerVersionContent): void;
+/**
+ * Gèle la version de travail courante (commit implicite : elle devient publiable
+ * et immuable) et ouvre une nouvelle version de travail clonée. `now` est fourni
+ * par l'appelant — jamais lu d'une horloge interne.
+ */
+export declare function createVersion(container: TagContainer, now: string): ContainerVersion;
+/** Marque une version comme committee donc immuable : condition sine qua non pour publier. */
+export declare function commitVersion(container: TagContainer, versionId: string): ContainerVersion;
+export declare function publish(container: TagContainer, environment: EnvironmentName, versionId: string): ContainerEnvironment;
+/** Republie la version antérieure de l'environnement ; renvoie null si l'historique est vide. */
+export declare function rollback(container: TagContainer, environment: EnvironmentName): ContainerVersion | null;
+export declare function resolveVersion(container: TagContainer, environment: EnvironmentName): ContainerVersion | null;

package/dist/plugins/tag-manager/evaluate.d.ts

@@ -0,0 +1,63 @@
+/**
+ * LynxSEO - Tag Manager : évaluateur de conteneur (plan d'exécution).
+ * Correction des trois bugs du stub :
+ *  1. la correspondance d'un déclencheur = (type d'événement compatible ET toutes les
+ *     conditions satisfaites) — des conditions vides ne rendent plus un déclencheur
+ *     universel ;
+ *  2. les motifs `regex` sont bornés et pré-compilés (garde anti-ReDoS) ;
+ *  3. les opérateurs sont une liste fermée : tout opérateur inconnu REFUSE.
+ * L'évaluateur ne mute jamais l'événement reçu : il retourne un plan d'exécution.
+ */
+import type { ContainerTag, ContainerTrigger, ContainerVariable, TriggerCondition } from "./container";
+import { type ConsentCategory, type ParameterValue } from "./templates";
+export interface ConsentState {
+    granted: Readonly<Partial<Record<ConsentCategory, boolean>>>;
+}
+export interface EvaluationContext {
+    /** Type d'événement brut (`tracker.*` côté bus, `rt.*` côté runtime). */
+    eventType: string;
+    /** Payload en lecture seule : l'évaluateur s'interdit de le muter. */
+    payload: Readonly<Record<string, unknown>>;
+    /** État du dataLayer côté runtime ; à défaut le payload du bus sert de dataLayer. */
+    dataLayer?: Readonly<Record<string, unknown>>;
+    url?: string;
+    referrer?: string;
+    readCookie?: (name: string) => string | null;
+    /** Absence de consentement ⇒ refus pour tout tag exigeant une catégorie. */
+    consent?: ConsentState;
+    /**
+     * Suivi `fire_once` : l'appelant crée et conserve ce jeu ; l'évaluateur y ajoute
+     * les identifiants planifiés. C'est l'état du moteur, pas celui de l'événement.
+     */
+    firedTagIds?: Set<string>;
+}
+export interface PlannedTag {
+    id: string;
+    name: string;
+    template: ContainerTag["template"];
+    parameters: Readonly<Record<string, ParameterValue>>;
+    priority: number;
+}
+/** Toute source disposant des trois collections (version interne ou export). */
+export interface EvaluableVersion {
+    tags: readonly ContainerTag[];
+    triggers: readonly ContainerTrigger[];
+    variables: readonly ContainerVariable[];
+}
+export declare const MAX_REGEX_PATTERN_LENGTH = 256;
+export declare const MAX_REGEX_INPUT_LENGTH = 4096;
+/** Compile un motif utilisateur après garde ; null = refus (motif invalide ou pathogène). */
+export declare function compileGuardedRegex(pattern: string): RegExp | null;
+/** Lit un chemin pointé (`a.b.c`) dans une source d'objets imbriqués. */
+export declare function readPath(path: string, source: Readonly<Record<string, unknown>>): unknown;
+export declare function pickUrlComponent(href: string, component: string): string;
+export declare function resolveVariableValue(variable: ContainerVariable, ctx: EvaluationContext): unknown;
+export declare function evaluateCondition(condition: TriggerCondition, resolvedVariables: ReadonlyMap<string, unknown>): boolean;
+export declare function matchesTrigger(trigger: ContainerTrigger, ctx: EvaluationContext, resolvedVariables: ReadonlyMap<string, unknown>): boolean;
+export declare function consentSatisfied(required: readonly ConsentCategory[], consent?: ConsentState): boolean;
+/**
+ * Retourne les tags à exécuter pour un événement, triés par priorité décroissante
+ * puis identifiant croissant (ordre stable et déterministe). Ne mute ni la version
+ * ni le contexte, hormis `ctx.firedTagIds` (état du moteur pour `fire_once`).
+ */
+export declare function planExecution(version: EvaluableVersion, ctx: EvaluationContext): PlannedTag[];

package/dist/plugins/tag-manager/export.d.ts

@@ -0,0 +1,62 @@
+/**
+ * LynxSEO - Tag Manager : export déterministe d'une version de conteneur.
+ * Inspiré du modèle export/import de Matomo Tag Manager (GPLv3 / AGPLv3 compatible).
+ *
+ * Déterminisme obligatoire : aucune horloge ni aléa dans le chemin de génération.
+ * La même version (contenu + `createdAt` figés) produit le même octet pour le même
+ * octet, quel que soit l'ordre d'insertion d'origine ou le moment de la sérialisation.
+ */
+import type { TagContainer } from "./container";
+import type { ConsentCategory, ParameterValue, TagTemplateId, TriggerTemplateId, VariableTemplateId } from "./templates";
+export interface ExportedTag {
+    id: string;
+    name: string;
+    template: TagTemplateId;
+    parameters: Readonly<Record<string, ParameterValue>>;
+    triggers: readonly string[];
+    consentRequired: readonly ConsentCategory[];
+    priority: number;
+    fireOnce: boolean;
+    active: boolean;
+}
+export interface ExportedTrigger {
+    id: string;
+    name: string;
+    template: TriggerTemplateId;
+    parameters: Readonly<Record<string, ParameterValue>>;
+    conditions: readonly ExportedTriggerCondition[];
+    active: boolean;
+}
+export interface ExportedTriggerCondition {
+    variable: string;
+    operator: string;
+    value?: string;
+}
+export interface ExportedVariable {
+    id: string;
+    name: string;
+    template: VariableTemplateId;
+    parameters: Readonly<Record<string, ParameterValue>>;
+}
+export interface ExportedContainerVersion {
+    kind: "lynxseo-tmv1";
+    containerId: string;
+    siteId: string;
+    versionId: string;
+    /** Hérité de la version : l'horodatage appartient à la version, jamais à l'export. */
+    createdAt: string;
+    tags: readonly ExportedTag[];
+    triggers: readonly ExportedTrigger[];
+    variables: readonly ExportedVariable[];
+}
+/** Construit l'objet exporté, trié par identifiant pour un octet-stable canonique. */
+export declare function exportContainerVersion(container: TagContainer, versionId: string): ExportedContainerVersion;
+/**
+ * JSON canonique : clés d'objet triées lexicographiquement, tableaux dans l'ordre
+ * de destination, valeurs `undefined` omises (sémantique JSON.stringify).
+ */
+export declare function stableStringify(value: unknown): string;
+/** Sérialisation déterministe de l'export d'une version. */
+export declare function serializeContainerVersion(container: TagContainer, versionId: string): string;
+/** SHA-256 hexadécimal de la charge exportée (WebCrypto, dispo edge/node/browser). */
+export declare function sha256Hex(text: string): Promise<string>;

package/dist/plugins/tag-manager/index.d.ts

@@ -0,0 +1,104 @@
+/**
+ * LynxSEO - Tag Manager Plugin
+ * Inspiré de Matomo Tag Manager (GPLv3 / AGPLv3 compatible).
+ *
+ * Façade publique : elle conserve les signatures historiques (registerTrigger,
+ * registerVariable, registerTag, getContainer, getStats) et les branche désormais
+ * sur le noyau templates/conteneur/évaluateur. L'événement reçu n'est JAMAIS muté :
+ * l'évaluation retourne un plan d'exécution (`planEvent` / `getLastPlan`).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+import { type ContainerTag, type ContainerTrigger, type ContainerVariable, type EnvironmentName, type TagContainer } from "./container";
+import { type ConsentState, type PlannedTag } from "./evaluate";
+export interface Tag {
+    id: string;
+    name: string;
+    type: string;
+    config: Record<string, unknown>;
+    triggers: string[];
+    active: boolean;
+}
+export interface Trigger {
+    id: string;
+    name: string;
+    type: string;
+    conditions: Array<{
+        variable: string;
+        operator: string;
+        value: string;
+    }>;
+    active: boolean;
+}
+export interface Variable {
+    id: string;
+    name: string;
+    type: string;
+    config: Record<string, unknown>;
+}
+export declare class TagManagerPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    private tags;
+    private triggers;
+    private variables;
+    private container;
+    private lastPlan;
+    private firedTagIds;
+    private registrationErrors;
+    constructor();
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** Évalue un événement du bus contre la version de travail et retourne le plan. */
+    planEvent(event: PluginEvent): PlannedTag[];
+    getLastPlan(): readonly PlannedTag[];
+    getTagContainer(): TagContainer;
+    /** Erreurs de mappage legacy→noyau (types/opérateurs hors catalogue). */
+    getRegistrationErrors(): readonly string[];
+    /** Enregistre un déclencheur (forme historique, type libre mappé vers le catalogue). */
+    registerTrigger(trigger: Trigger): void;
+    registerVariable(variable: Variable): void;
+    /**
+     * Enregistre un tag. Si `type` est un template du catalogue, les paramètres sont
+     * validés contre le schéma du template — refus explicite (throw) si un paramètre
+     * est inconnu ou invalide. Les types hors catalogue restent dans le registre
+     * historique (getContainer/getStats) mais ne sont jamais planifiés.
+     */
+    registerTag(tag: Tag): void;
+    /** Cycle de vie du conteneur, exposé brut pour la tranche persistance/UI. */
+    commitCurrentVersion(): string;
+    branchNewVersion(now: string): string;
+    publishVersion(environment: EnvironmentName, versionId: string): void;
+    rollbackEnvironment(environment: EnvironmentName): void;
+    resolvePublishedVersion(environment: EnvironmentName): import("./container").ContainerVersion | null;
+    /** Réinitialise le suivi `fire_once` (nouvelle page de vie du conteneur). */
+    resetExecutionState(): void;
+    getContainer(): {
+        tags: Tag[];
+        triggers: Trigger[];
+        variables: Variable[];
+        generatedAt: string;
+    };
+    /** Volumétrie du conteneur, y compris les entités désactivées. */
+    getStats(): {
+        tags: {
+            total: number;
+            active: number;
+        };
+        triggers: {
+            total: number;
+            active: number;
+        };
+        variables: {
+            total: number;
+        };
+    };
+    private extractConsent;
+    /** Reconstruit la version de travail depuis les registres legacy + catalogue. */
+    private syncDraft;
+    disable(): Promise<void>;
+}
+export default TagManagerPlugin;
+export type { ContainerTag, ContainerTrigger, ContainerVariable, TagContainer, ConsentState, PlannedTag };
+export type { ExportedContainerVersion, ExportedTag, ExportedTrigger, ExportedVariable } from "./export";
+export { exportContainerVersion, serializeContainerVersion } from "./export";
+export { loadContainerRuntime, versionFromExport } from "./runtime";

package/dist/plugins/tag-manager/runtime.d.ts

@@ -0,0 +1,75 @@
+/**
+ * LynxSEO - Tag Manager : runtime client (navigateur) d'un conteneur exporté.
+ * Modèle inspiré des `*.web.js` de Matomo Tag Manager (GPLv3 / AGPLv3 compatible) —
+ * TypeScript original.
+ *
+ * Small-safe par construction : aucun innerHTML, aucun eval, aucun new Function sur
+ * du contenu distant. La validation des templates est faite À L'EXPORT (côté serveur) ;
+ * ici on ne fait qu'exécuter des plans fermés. Tout accès au DOM réel passe par les
+ * interfaces injectables DocumentLike / WindowLike / ScriptLoader / TransportLike,
+ * ce qui permet de tester sans DOM.
+ */
+import { type ContainerTag, type ContainerTrigger, type ContainerVariable } from "./container";
+import type { ExportedContainerVersion } from "./export";
+import { type ConsentState, type EvaluationContext, type PlannedTag } from "./evaluate";
+export interface ScriptLoader {
+    loadScript(url: string, options?: {
+        async: boolean;
+        position: string;
+    }): void;
+}
+export interface TransportLike {
+    post(url: string, body: string): void;
+}
+export interface DocumentLike {
+    /**
+     * Injection de snippet HTML (template `custom_html`). L'implémentation réelle est
+     * la responsabilité de l'hôte (sandbox, CSP) ; le runtime, lui, ne touche jamais
+     * innerHTML directement.
+     */
+    insertSnippet(targetSelector: string, html: string): void;
+}
+export type RuntimeEventName = "page_view" | "dom_ready" | "click" | "custom_event" | "error";
+export interface WindowLike {
+    readonly location: {
+        readonly href: string;
+    };
+    readonly referrer: string;
+    readCookie(name: string): string | null;
+    on(event: RuntimeEventName, handler: (payload: Record<string, unknown>) => void): void;
+}
+export interface DataLayer {
+    push(item: Record<string, unknown>): void;
+    set(key: string, value: unknown): void;
+    get(key: string): unknown;
+    /** Instantané plat pour la résolution des variables `data_layer`. */
+    snapshot(): Record<string, unknown>;
+}
+export interface RuntimeDeps {
+    window: WindowLike;
+    document: DocumentLike;
+    scriptLoader: ScriptLoader;
+    transport: TransportLike;
+}
+export interface TagManagerRuntime {
+    readonly dataLayer: DataLayer;
+    setConsent(state: ConsentState): void;
+    /** Planifie ET exécute ; retourne le plan appliqué. */
+    handleEvent(name: RuntimeEventName, payload?: Record<string, unknown>): PlannedTag[];
+    /** Abonne le runtime aux événements de la fenêtre hôte. */
+    start(): void;
+}
+export interface RuntimeVersion {
+    tags: ContainerTag[];
+    triggers: ContainerTrigger[];
+    variables: ContainerVariable[];
+}
+export declare function versionFromExport(exported: ExportedContainerVersion): RuntimeVersion;
+/** Corps `tagGatewayHitSchema`-compatible pour un tag `lynx_collect` planifié. */
+export declare function buildTagGatewayHitBody(tag: PlannedTag, ctx: EvaluationContext): Record<string, unknown>;
+/**
+ * Charge un conteneur exporté et retourne un runtime. La résolution des variables
+ * réutilise `evaluate.ts` (mêmes garde-fous que le serveur) ; le dataLayer sert de
+ * payload aux variables `data_layer`.
+ */
+export declare function loadContainerRuntime(exported: ExportedContainerVersion, deps: RuntimeDeps): TagManagerRuntime;

package/dist/plugins/tag-manager/templates.d.ts

@@ -0,0 +1,87 @@
+/**
+ * LynxSEO - Tag Manager : descripteurs de templates (tags, déclencheurs, variables).
+ * Modèle inspiré de Matomo Tag Manager (GPLv3 / AGPLv3 compatible) — TypeScript original,
+ * aucune ligne de PHP traduite.
+ *
+ * Chaque template déclare des paramètres typés (type de valeur, contrôle UI, requis,
+ * validateurs, normalisation). L'évaluation est totiale : un opérateur/paramètre inconnu
+ * est refusé explicitement, jamais toléré silencieusement.
+ */
+export type ParameterValueType = "string" | "number" | "boolean" | "string_list" | "url";
+export type UiControl = "text" | "textarea" | "number" | "checkbox" | "select" | "url";
+export type TagTemplateId = "custom_html" | "loader" | "lynx_collect" | "capi_conversion";
+export type TriggerTemplateId = "page_view" | "dom_ready" | "element_click" | "custom_event" | "all_errors";
+export type VariableTemplateId = "constant" | "data_layer" | "url" | "referrer" | "cookie";
+export type ConsentCategory = "analytics" | "ads" | "functional" | "performance";
+export type TemplateCategory = "ads" | "analytics" | "conversion" | "custom" | "privacy";
+export type ParameterValue = string | number | boolean | readonly string[];
+/** Retourne null si la valeur est acceptable, sinon le message d'erreur. */
+export type ParameterValidator = (value: ParameterValue) => string | null;
+export interface ParameterSchema {
+    name: string;
+    label: string;
+    type: ParameterValueType;
+    uiControl: UiControl;
+    required: boolean;
+    options?: readonly string[];
+    defaultValue?: ParameterValue;
+    validators?: readonly ParameterValidator[];
+}
+export interface TagTemplate {
+    kind: "tag";
+    id: TagTemplateId;
+    name: string;
+    description: string;
+    category: TemplateCategory;
+    /** Catégories de consentement exigées par défaut ; un tag peut les affiner. */
+    consentRequired: readonly ConsentCategory[];
+    parameters: readonly ParameterSchema[];
+}
+export interface TriggerTemplate {
+    kind: "trigger";
+    id: TriggerTemplateId;
+    name: string;
+    description: string;
+    /** Types d'événement (bus `tracker.*` et runtime client `rt.*`) compatibles. */
+    eventTypes: readonly string[];
+    parameters: readonly ParameterSchema[];
+}
+export interface VariableTemplate {
+    kind: "variable";
+    id: VariableTemplateId;
+    name: string;
+    description: string;
+    parameters: readonly ParameterSchema[];
+}
+export type Template = TagTemplate | TriggerTemplate | VariableTemplate;
+export interface ParametersResult {
+    ok: boolean;
+    values: Record<string, ParameterValue>;
+    errors: string[];
+}
+export declare const notEmpty: ParameterValidator;
+export declare const httpOrRelativePath: ParameterValidator;
+export declare const positiveNumber: ParameterValidator;
+/**
+ * Unicité statique des identifiants de template : un id ne peut exister qu'une fois
+ * par catalogue, ce qui rend les lookups sûrs sans garde supplémentaire.
+ */
+export declare function isTagTemplateId(value: string): value is TagTemplateId;
+export declare function isTriggerTemplateId(value: string): value is TriggerTemplateId;
+export declare function isVariableTemplateId(value: string): value is VariableTemplateId;
+export declare function getTagTemplate(id: string): TagTemplate | undefined;
+export declare function getTriggerTemplate(id: string): TriggerTemplate | undefined;
+export declare function getVariableTemplate(id: string): VariableTemplate | undefined;
+export declare function listTagTemplates(): readonly TagTemplate[];
+export declare function listTriggerTemplates(): readonly TriggerTemplate[];
+export declare function listVariableTemplates(): readonly VariableTemplate[];
+export declare function listConsentCategories(): readonly ConsentCategory[];
+/**
+ * Valide et normalise un jeu de paramètres bruts contre un template.
+ * Refus explicite : paramètre inconnu, paramètre requis absent, type invalide,
+ * valeur hors `options`, validateur personnalisé. Aucun default permissif.
+ */
+export declare function validateTemplateParameters(template: {
+    id: string;
+    parameters: readonly ParameterSchema[];
+}, raw: Record<string, unknown>): ParametersResult;

package/dist/plugins/tasks-timetable/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * LynxSEO - Tasks Timetable & Scheduled Jobs Plugin
+ * Surveillance des tâches planifiées d'arrière-plan, des crons et des verrous
+ * distribués (KV / Redis) — Parité Matomo TasksTimetable & PostHog Tasks.
+ *
+ * @license AGPL-3.0-or-later
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin/types";
+export type TaskScheduleType = "minutely" | "hourly" | "daily" | "weekly" | "monthly";
+export type TaskExecutionStatus = "success" | "failed" | "skipped" | "running";
+export interface ScheduledTaskInfo {
+    taskName: string;
+    category: "analytics" | "retention" | "integration" | "security" | "maintenance";
+    scheduleType: TaskScheduleType;
+    cronExpression: string;
+    description: string;
+    lastExecution?: string;
+    lastDurationMs?: number;
+    lastStatus?: TaskExecutionStatus;
+    lastError?: string;
+    nextScheduledExecution: string;
+    isLocked: boolean;
+    lockHeldUntil?: string;
+}
+export interface TasksTimetableReport {
+    totalTasks: number;
+    activeLocksCount: number;
+    failedTasksCount: number;
+    systemHealth: "healthy" | "degraded" | "critical";
+    tasks: ScheduledTaskInfo[];
+}
+export declare class TasksTimetablePlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private readonly tasks;
+    constructor();
+    private initDefaultTasks;
+    private calculateNextExecution;
+    enable(_ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    recordExecution(taskName: string, status: TaskExecutionStatus, durationMs: number, error?: string): void;
+    setLockStatus(taskName: string, isLocked: boolean, ttlSeconds?: number): void;
+    registerCustomTask(info: ScheduledTaskInfo): void;
+    getTimetable(): TasksTimetableReport;
+    reset(): void;
+}
+export default TasksTimetablePlugin;

package/dist/plugins/taxonomy-dictionary/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * LynxSEO - Taxonomy Dictionary & Data Governance Plugin
+ * Inspiré de PostHog Event Taxonomy & Matomo Custom Dimensions Catalog.
+ * AGPL-3.0-or-later.
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin/types";
+export type PropertyDataType = "string" | "numeric" | "boolean" | "datetime" | "json";
+export type SensitivityLevel = "public" | "internal" | "pii";
+export type VerificationStatus = "verified" | "unverified" | "deprecated";
+export interface PropertyDefinition {
+    name: string;
+    dataType: PropertyDataType;
+    description: string;
+    sensitivity: SensitivityLevel;
+    required: boolean;
+    exampleValue?: string | number | boolean;
+}
+export interface EventDefinition {
+    name: string;
+    description: string;
+    owner?: string;
+    tags: string[];
+    status: VerificationStatus;
+    properties: PropertyDefinition[];
+    firstSeenIso: string;
+    lastSeenIso: string;
+    observedCount: number;
+}
+export interface TaxonomyHealthAudit {
+    totalEvents: number;
+    verifiedEvents: number;
+    deprecatedEvents: number;
+    unverifiedEvents: number;
+    documentedPropertiesCount: number;
+    piiPropertiesCount: number;
+    healthScorePercent: number;
+    recommendations: string[];
+}
+export declare class TaxonomyDictionaryPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private readonly events;
+    enable(_ctx: PluginContext): Promise<void>;
+    private getSiteEvents;
+    private seedStandardDefinitions;
+    upsertEventDefinition(siteId: string, event: {
+        name: string;
+        description?: string;
+        owner?: string;
+        tags?: string[];
+        status?: VerificationStatus;
+        properties?: PropertyDefinition[];
+    }): EventDefinition;
+    addPropertyDefinition(siteId: string, eventName: string, property: PropertyDefinition): EventDefinition;
+    deleteEventDefinition(siteId: string, eventName: string): boolean;
+    recordObservedEvent(siteId: string, eventName: string, payloadProperties?: Record<string, unknown>): void;
+    getAuditReport(siteId: string): TaxonomyHealthAudit;
+    getEventDefinitions(siteId: string): EventDefinition[];
+    onEvent(event: PluginEvent): Promise<void>;
+    disable(): Promise<void>;
+}