@syntrologie/adapt-overlays 2.4.0 → 2.5.1

package/dist/celebrations/effects/fireworks.js

@@ -0,0 +1,69 @@
+const PARTICLES_PER_BURST = { light: 20, medium: 40, heavy: 80 };
+const BURST_COUNTS = { light: 3, medium: 4, heavy: 5 };
+export const fireworksEffect = {
+    init(width, height, config) {
+        const perBurst = PARTICLES_PER_BURST[config.intensity];
+        const burstCount = BURST_COUNTS[config.intensity];
+        const colors = config.colors.length > 0 ? config.colors : ['#ff4444', '#44ff44', '#4444ff'];
+        const particles = [];
+        for (let b = 0; b < burstCount; b++) {
+            const cx = Math.random() * width * 0.8 + width * 0.1;
+            const cy = Math.random() * height * 0.6;
+            const burstColor = colors[Math.floor(Math.random() * colors.length)];
+            for (let i = 0; i < perBurst; i++) {
+                const angle = (Math.PI * 2 * i) / perBurst + (Math.random() - 0.5) * 0.3;
+                const speed = Math.random() * 3 + 2;
+                particles.push({
+                    x: cx,
+                    y: cy,
+                    vx: Math.cos(angle) * speed,
+                    vy: Math.sin(angle) * speed,
+                    rotation: 0,
+                    rotationSpeed: 0,
+                    size: Math.random() * 3 + 2,
+                    color: burstColor,
+                    opacity: 1,
+                    shape: 'circle',
+                    data: { centerX: cx, centerY: cy },
+                });
+            }
+        }
+        return particles;
+    },
+    update(particles, _dt, _elapsed) {
+        let anyVisible = false;
+        for (const p of particles) {
+            // Deceleration
+            p.vx *= 0.97;
+            p.vy *= 0.97;
+            // Slight gravity
+            p.vy += 0.03;
+            // Movement
+            p.x += p.vx;
+            p.y += p.vy;
+            // Fade over time
+            p.opacity -= 0.008;
+            if (p.opacity < 0)
+                p.opacity = 0;
+            if (p.opacity > 0.01) {
+                anyVisible = true;
+            }
+        }
+        return anyVisible;
+    },
+    render(ctx, particles) {
+        for (const p of particles) {
+            if (p.opacity < 0.01)
+                continue;
+            ctx.save();
+            ctx.globalAlpha = p.opacity;
+            ctx.fillStyle = p.color;
+            ctx.shadowBlur = 12;
+            ctx.shadowColor = p.color;
+            ctx.beginPath();
+            ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+            ctx.fill();
+            ctx.restore();
+        }
+    },
+};

package/dist/celebrations/effects/sparkles.d.ts

@@ -0,0 +1,3 @@
+import type { CelebrationEffect } from '../types';
+export declare const sparklesEffect: CelebrationEffect;
+//# sourceMappingURL=sparkles.d.ts.map

package/dist/celebrations/effects/sparkles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkles.d.ts","sourceRoot":"","sources":["../../../src/celebrations/effects/sparkles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,iBAAiB,EAAY,MAAM,UAAU,CAAC;AAI/E,eAAO,MAAM,cAAc,EAAE,iBA0F5B,CAAC"}

package/dist/celebrations/effects/sparkles.js

@@ -0,0 +1,83 @@
+const INTENSITY_COUNTS = { light: 30, medium: 60, heavy: 120 };
+export const sparklesEffect = {
+    init(width, height, config) {
+        const count = INTENSITY_COUNTS[config.intensity];
+        const colors = config.colors.length > 0 ? config.colors : ['#ffd700', '#ffffff', '#fffacd'];
+        const particles = [];
+        for (let i = 0; i < count; i++) {
+            particles.push({
+                x: Math.random() * width,
+                y: Math.random() * height,
+                vx: (Math.random() - 0.5) * 0.3,
+                vy: -(Math.random() * 0.5 + 0.2),
+                rotation: Math.random() * Math.PI * 2,
+                rotationSpeed: (Math.random() - 0.5) * 0.1,
+                size: Math.random() * 4 + 2,
+                color: colors[Math.floor(Math.random() * colors.length)],
+                opacity: Math.random() * 0.5 + 0.5,
+                shape: 'circle',
+                data: {
+                    /** Phase offset for sine-wave twinkle */
+                    phase: Math.random() * Math.PI * 2,
+                    /** Base opacity before twinkle modulation */
+                    baseOpacity: Math.random() * 0.5 + 0.5,
+                },
+            });
+        }
+        return particles;
+    },
+    update(particles, _dt, elapsed) {
+        let anyVisible = false;
+        for (const p of particles) {
+            // Gentle upward float
+            p.x += p.vx;
+            p.y += p.vy;
+            p.rotation += p.rotationSpeed;
+            // Gradually fade out over lifetime
+            if (p.data) {
+                p.data.baseOpacity = (p.data.baseOpacity ?? 1) - 0.001;
+                if (p.data.baseOpacity < 0)
+                    p.data.baseOpacity = 0;
+            }
+            // Twinkle — oscillate opacity with sine wave
+            const phase = p.data?.phase ?? 0;
+            const baseOpacity = p.data?.baseOpacity ?? 1;
+            if (baseOpacity <= 0.01) {
+                p.opacity = 0;
+            }
+            else {
+                const twinkle = Math.sin(elapsed * 0.005 + phase) * 0.4 + 0.6;
+                p.opacity = baseOpacity * twinkle;
+            }
+            if (p.opacity > 0.01) {
+                anyVisible = true;
+            }
+        }
+        return anyVisible;
+    },
+    render(ctx, particles) {
+        for (const p of particles) {
+            if (p.opacity < 0.01)
+                continue;
+            ctx.save();
+            ctx.globalAlpha = p.opacity;
+            ctx.fillStyle = p.color;
+            ctx.translate(p.x, p.y);
+            ctx.rotate(p.rotation);
+            // Draw a 4-point diamond/star shape
+            const s = p.size;
+            ctx.beginPath();
+            ctx.moveTo(0, -s);
+            ctx.lineTo(s * 0.3, -s * 0.3);
+            ctx.lineTo(s, 0);
+            ctx.lineTo(s * 0.3, s * 0.3);
+            ctx.lineTo(0, s);
+            ctx.lineTo(-s * 0.3, s * 0.3);
+            ctx.lineTo(-s, 0);
+            ctx.lineTo(-s * 0.3, -s * 0.3);
+            ctx.closePath();
+            ctx.fill();
+            ctx.restore();
+        }
+    },
+};

package/dist/celebrations/engine.d.ts

@@ -0,0 +1,16 @@
+import type { CelebrationConfig, CelebrationEffect } from './types';
+export declare class CelebrationEngine {
+    private canvas;
+    private ctx;
+    private rafId;
+    private particles;
+    private startTime;
+    private lastFrame;
+    private duration;
+    private effect;
+    private container;
+    start(container: HTMLElement, effect: CelebrationEffect, config: CelebrationConfig): void;
+    stop(): void;
+    private tick;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/celebrations/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/celebrations/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAY,MAAM,SAAS,CAAC;AAE9E,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,GAAG,CAAyC;IACpD,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,SAAS,CAA4B;IAE7C,KAAK,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI;IA2CzF,IAAI,IAAI,IAAI;IAeZ,OAAO,CAAC,IAAI;CA+Bb"}

package/dist/celebrations/engine.js

@@ -0,0 +1,89 @@
+export class CelebrationEngine {
+    constructor() {
+        this.canvas = null;
+        this.ctx = null;
+        this.rafId = null;
+        this.particles = [];
+        this.startTime = 0;
+        this.lastFrame = 0;
+        this.duration = 0;
+        this.effect = null;
+        this.container = null;
+    }
+    start(container, effect, config) {
+        this.container = container;
+        this.effect = effect;
+        this.duration = config.duration;
+        // Create fullscreen canvas
+        const canvas = document.createElement('canvas');
+        canvas.setAttribute('data-syntro-celebrate', '');
+        Object.assign(canvas.style, {
+            position: 'fixed',
+            inset: '0',
+            pointerEvents: 'none',
+            zIndex: '2147483646',
+        });
+        const dpr = window.devicePixelRatio || 1;
+        const width = window.innerWidth;
+        const height = window.innerHeight;
+        canvas.width = width * dpr;
+        canvas.height = height * dpr;
+        canvas.style.width = `${width}px`;
+        canvas.style.height = `${height}px`;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            return;
+        }
+        ctx.scale(dpr, dpr);
+        this.canvas = canvas;
+        this.ctx = ctx;
+        container.appendChild(canvas);
+        // Initialize particles
+        this.particles = effect.init(width, height, config);
+        this.startTime = performance.now();
+        this.lastFrame = this.startTime;
+        // Start animation loop
+        this.tick = this.tick.bind(this);
+        this.rafId = requestAnimationFrame(this.tick);
+    }
+    stop() {
+        if (this.rafId !== null) {
+            cancelAnimationFrame(this.rafId);
+            this.rafId = null;
+        }
+        if (this.canvas && this.container) {
+            this.canvas.remove();
+            this.canvas = null;
+        }
+        this.ctx = null;
+        this.effect = null;
+        this.container = null;
+        this.particles = [];
+    }
+    tick(now) {
+        if (!this.ctx || !this.canvas || !this.effect)
+            return;
+        const elapsed = now - this.startTime;
+        const dt = now - this.lastFrame;
+        this.lastFrame = now;
+        // Auto-stop after duration
+        if (elapsed >= this.duration) {
+            this.stop();
+            return;
+        }
+        // Clear canvas
+        const width = this.canvas.width / (window.devicePixelRatio || 1);
+        const height = this.canvas.height / (window.devicePixelRatio || 1);
+        this.ctx.clearRect(0, 0, width, height);
+        // Update physics — stop if all particles are done
+        const alive = this.effect.update(this.particles, dt, elapsed);
+        if (!alive) {
+            this.stop();
+            return;
+        }
+        // Render
+        this.effect.render(this.ctx, this.particles);
+        // Next frame
+        this.rafId = requestAnimationFrame(this.tick);
+    }
+}

package/dist/celebrations/index.d.ts

@@ -0,0 +1,3 @@
+import type { ActionExecutor, CelebrateAction } from '../types';
+export declare const executeCelebrate: ActionExecutor<CelebrateAction>;
+//# sourceMappingURL=index.d.ts.map

package/dist/celebrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/celebrations/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAkB,MAAM,UAAU,CAAC;AAoDhF,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,eAAe,CAoC5D,CAAC"}

package/dist/celebrations/index.js

@@ -0,0 +1,73 @@
+import { confettiEffect } from './effects/confetti';
+import { emojiRainEffect } from './effects/emoji-rain';
+import { fireworksEffect } from './effects/fireworks';
+import { sparklesEffect } from './effects/sparkles';
+import { CelebrationEngine } from './engine';
+const FALLBACK_COLORS = [
+    '#ff0000',
+    '#00ff00',
+    '#0000ff',
+    '#ffff00',
+    '#ff00ff',
+    '#00ffff',
+    '#ff8800',
+    '#8800ff',
+];
+/**
+ * Build a celebration palette from the theme's primary/hover colors.
+ * Returns 6 color variants (solid, transparent, white accent) for visual variety.
+ */
+function buildThemePalette(primary, hover) {
+    return [primary, hover, `${primary}cc`, `${hover}cc`, '#ffffff', `${primary}80`];
+}
+/**
+ * Read --sc-color-primary and --sc-color-primary-hover from the overlay root.
+ * Returns a theme palette if both are available, otherwise null.
+ */
+function readThemeColors(overlayRoot) {
+    try {
+        const styles = getComputedStyle(overlayRoot);
+        const primary = styles.getPropertyValue('--sc-color-primary')?.trim();
+        const hover = styles.getPropertyValue('--sc-color-primary-hover')?.trim();
+        if (primary?.startsWith('#') && primary.length >= 7) {
+            return buildThemePalette(primary, hover || primary);
+        }
+    }
+    catch {
+        /* fallback */
+    }
+    return null;
+}
+const effectRegistry = new Map([
+    ['confetti', confettiEffect],
+    ['fireworks', fireworksEffect],
+    ['sparkles', sparklesEffect],
+    ['emoji-rain', emojiRainEffect],
+]);
+export const executeCelebrate = async (action, context) => {
+    const effect = effectRegistry.get(action.effect);
+    if (!effect) {
+        console.warn(`[adaptive-overlays] Unknown celebration effect: "${action.effect}". Available: ${[...effectRegistry.keys()].join(', ')}`);
+        return { cleanup: () => { } };
+    }
+    // Colors priority: action.colors > theme palette > hardcoded fallback
+    const colors = action.colors ?? readThemeColors(context.overlayRoot) ?? FALLBACK_COLORS;
+    const config = {
+        duration: action.duration ?? 3000,
+        intensity: action.intensity ?? 'medium',
+        colors,
+        props: action.props,
+    };
+    const engine = new CelebrationEngine();
+    engine.start(context.overlayRoot, effect, config);
+    context.publishEvent('action.applied', {
+        id: context.generateId(),
+        kind: 'overlays:celebrate',
+        effect: action.effect,
+    });
+    return {
+        cleanup: () => {
+            engine.stop();
+        },
+    };
+};

package/dist/celebrations/types.d.ts

@@ -0,0 +1,34 @@
+/** A single particle in the animation */
+export interface Particle {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    rotation: number;
+    rotationSpeed: number;
+    size: number;
+    color: string;
+    opacity: number;
+    shape?: 'rect' | 'circle' | 'emoji';
+    emoji?: string;
+    /** Effect-specific extra data */
+    data?: Record<string, number>;
+}
+/** Shared config props passed to all effects */
+export interface CelebrationConfig {
+    duration: number;
+    intensity: 'light' | 'medium' | 'heavy';
+    colors: string[];
+    /** Effect-specific props (emoji string, burst point, etc.) */
+    props?: Record<string, unknown>;
+}
+/** The pluggable effect interface — init/update/render */
+export interface CelebrationEffect {
+    /** Create initial particles */
+    init(width: number, height: number, config: CelebrationConfig): Particle[];
+    /** Update particle physics each frame. Return false when all particles are done. */
+    update(particles: Particle[], dt: number, elapsed: number): boolean;
+    /** Draw particles to canvas */
+    render(ctx: CanvasRenderingContext2D, particles: Particle[]): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/celebrations/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/celebrations/types.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,gDAAgD;AAChD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IACxC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,0DAA0D;AAC1D,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,QAAQ,EAAE,CAAC;IAC3E,oFAAoF;IACpF,MAAM,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACpE,+BAA+B;IAC/B,MAAM,CAAC,GAAG,EAAE,wBAAwB,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;CACpE"}

package/dist/celebrations/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../src/editor.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAqBH,OAAO,KAAK,EAAE,gBAAgB,EAAY,MAAM,SAAS,CAAC;AA0L1D,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,gBAAgB,2CA2d5E;AAED;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;CAAe,CAAC;AAExC,eAAe,cAAc,CAAC"}
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../src/editor.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAqBH,OAAO,KAAK,EAAE,gBAAgB,EAAY,MAAM,SAAS,CAAC;AA4N1D,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,gBAAgB,2CAif5E;AAED;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;CAAe,CAAC;AAExC,eAAe,cAAc,CAAC"}

package/dist/editor.js

@@ -10,6 +10,39 @@ import { DetectionBadge, DismissedSection, EditorBody, EditorCard, EditorFooter,
 import { MessageSquare, Route, Sparkles, Square, Tag, Zap } from 'lucide-react';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { summarizeOverlayItem } from './summarize';
+/** Extract the CSS selector string from an anchorId (object or legacy string). */
+function resolveAnchorSelector(anchorId) {
+    if (!anchorId)
+        return '';
+    if (typeof anchorId === 'string')
+        return anchorId;
+    if (typeof anchorId === 'object' && 'selector' in anchorId) {
+        return anchorId.selector;
+    }
+    return '';
+}
+/** Extract the target route from an AnchorId object, ignoring wildcard '**'. */
+function resolveAnchorRoute(anchorId) {
+    if (!anchorId || typeof anchorId !== 'object')
+        return null;
+    const route = anchorId.route;
+    if (typeof route === 'string' && route !== '**')
+        return route;
+    if (Array.isArray(route)) {
+        const first = route.find((r) => typeof r === 'string' && r !== '**');
+        return first ?? null;
+    }
+    return null;
+}
+/** Save a pending highlight selector to sessionStorage (inlined to avoid cross-package import). */
+function savePendingHighlight(selector) {
+    try {
+        sessionStorage.setItem('syntro:editor:pending-highlight', selector);
+    }
+    catch {
+        // Silently ignore
+    }
+}
 function itemKey(section, index) {
     return `${section}:${index}`;
 }
@@ -41,7 +74,8 @@ function flattenItems(config) {
                 section,
                 index: i,
                 summary: summarizeOverlayItem(section, rec),
-                anchorId: rec.anchorId || '',
+                anchorId: resolveAnchorSelector(rec.anchorId),
+                rawAnchorId: rec.anchorId,
                 isTour: false,
             });
         });
@@ -55,6 +89,7 @@ function flattenItems(config) {
             index: i,
             summary: summarizeOverlayItem('tours', tour),
             anchorId: '',
+            rawAnchorId: undefined,
             isTour: true,
         });
     });
@@ -89,7 +124,7 @@ function getStepIcon(step) {
 }
 function getStepLabel(step) {
     const action = step.action;
-    const anchor = action.anchorId;
+    const anchor = resolveAnchorSelector(action.anchorId);
     if (anchor)
         return anchor;
     const content = action.content;
@@ -117,7 +152,7 @@ function useAnchorDetection(items, config) {
                     if (tour && tour.steps.length > 0) {
                         const firstStep = tour.steps[0];
                         const action = firstStep.action;
-                        selectorToCheck = action?.anchorId || '';
+                        selectorToCheck = resolveAnchorSelector(action?.anchorId);
                     }
                 }
                 if (!selectorToCheck) {
@@ -274,6 +309,25 @@ export function OverlaysEditor({ config, onChange, editor }) {
         }
         editor.publish();
     }, [dismissedKeys, typedConfig, onChange, editor]);
+    const handleBadgeClick = useCallback(async (item) => {
+        const detection = detectionMap.get(item.key);
+        if (detection?.found && item.anchorId) {
+            editor.highlightElement(item.anchorId);
+        }
+        else {
+            const route = resolveAnchorRoute(item.rawAnchorId);
+            if (route) {
+                if (item.anchorId)
+                    savePendingHighlight(item.anchorId);
+                await editor.navigateTo(route);
+                if (item.anchorId)
+                    editor.highlightElement(item.anchorId);
+            }
+            else if (item.anchorId) {
+                editor.highlightElement(item.anchorId);
+            }
+        }
+    }, [editor, detectionMap]);
     const handleCardHover = useCallback((item) => {
         setHoveredKey(item.key);
         if (item.anchorId) {
@@ -290,7 +344,7 @@ export function OverlaysEditor({ config, onChange, editor }) {
         const item = arr[index];
         if (!item)
             return null;
-        const anchorId = item.anchorId || '';
+        const anchorId = resolveAnchorSelector(item.anchorId);
         switch (section) {
             case 'tooltips': {
                 const content = item.content || {};
@@ -343,7 +397,7 @@ export function OverlaysEditor({ config, onChange, editor }) {
     };
     const renderCard = (item) => {
         const detection = detectionMap.get(item.key);
-        return (_jsxs("div", { children: [_jsxs(EditorCard, { itemKey: item.key, onClick: () => handleCardClick(item), className: "se-flex se-items-center se-gap-2", onMouseEnter: () => handleCardHover(item), onMouseLeave: handleCardLeave, children: [_jsx(DetectionBadge, { found: detection?.found ?? false }), _jsx("span", { className: "se-shrink-0 se-flex se-items-center -se-ml-1", onClick: (e) => {
+        return (_jsxs("div", { children: [_jsxs(EditorCard, { itemKey: item.key, onClick: () => handleCardClick(item), className: "se-flex se-items-center se-gap-2", onMouseEnter: () => handleCardHover(item), onMouseLeave: handleCardLeave, children: [_jsx(DetectionBadge, { found: detection?.found ?? false, onClick: () => handleBadgeClick(item) }), _jsx("span", { className: "se-shrink-0 se-flex se-items-center -se-ml-1", onClick: (e) => {
                                 e.stopPropagation();
                                 handleCardClick(item);
                             }, children: _jsx(SectionIcon, { section: item.section }) }), _jsx("span", { className: "se-flex-1 se-overflow-hidden se-text-ellipsis se-whitespace-nowrap", onClick: () => handleCardClick(item), children: item.summary }), _jsx("button", { type: "button", className: "se-py-0.5 se-px-1.5 se-rounded se-border-none se-bg-transparent se-text-slate-grey-7 se-text-sm se-cursor-pointer se-shrink-0 se-leading-none", onClick: (e) => {

package/dist/executors/tour.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tour Executor
+ *
+ * Orchestrates sequential tour steps with cross-page state persistence.
+ * Tours can span multiple pages and resume after navigation.
+ *
+ * Each step contains an inner action (modal, tooltip) that gets executed.
+ * The tour listens for CTA click events to advance to the next step.
+ */
+import type { ActionExecutor } from '@syntrologie/sdk-contracts';
+import type { TourAction } from '../tour-types';
+/**
+ * Execute a tour action
+ *
+ * Tours orchestrate a sequence of steps, persisting state to localStorage
+ * to support cross-page navigation. Each step contains an action to execute
+ * and optionally defines transitions based on action events.
+ */
+export declare const executeTour: ActionExecutor<TourAction>;
+//# sourceMappingURL=tour.d.ts.map

package/dist/executors/tour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tour.d.ts","sourceRoot":"","sources":["../../src/executors/tour.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAmC,MAAM,4BAA4B,CAAC;AAClG,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;AAiG1D;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,UAAU,CAwSlD,CAAC"}