@h-ai/ui 0.1.0-alpha.60 → 0.1.0-alpha.62

package/dist/guide-storage.d.ts

@@ -0,0 +1,6 @@
+import type { GuideOptions, GuideProgress } from './guide-types.js';
+/** 存储受限时使用会话内存；只保存非敏感的引导偏好。 */
+export declare function createGuideStorage(options: GuideOptions): {
+    get(key: string): GuideProgress | null;
+    set(key: string, progress: GuideProgress | null): void;
+};

package/dist/guide-storage.js

@@ -0,0 +1,67 @@
+import { readStoredValue, writeStoredValue } from './internal/browser-safety.js';
+/** 存储受限时使用会话内存；只保存非敏感的引导偏好。 */
+export function createGuideStorage(options) {
+    const memory = new Map();
+    const persistence = options.persistence ?? 'cookie';
+    function read(key) {
+        if (memory.has(key))
+            return memory.get(key) ?? null;
+        try {
+            if (persistence === 'localStorage')
+                return readStoredValue(key) ?? memory.get(key) ?? null;
+            if (persistence === 'cookie' && typeof document !== 'undefined') {
+                const prefix = `${encodeURIComponent(key)}=`;
+                const value = document.cookie.split('; ').find(item => item.startsWith(prefix));
+                return value ? decodeURIComponent(value.slice(prefix.length)) : memory.get(key) ?? null;
+            }
+        }
+        catch {
+            // Cookie 禁用或内容损坏时不影响正常使用。
+        }
+        return memory.get(key) ?? null;
+    }
+    function write(key, value) {
+        memory.set(key, value);
+        try {
+            if (persistence === 'localStorage') {
+                if (value === null) {
+                    if (typeof localStorage !== 'undefined')
+                        localStorage.removeItem(key);
+                }
+                else {
+                    writeStoredValue(key, value);
+                }
+            }
+            else if (persistence === 'cookie' && typeof document !== 'undefined') {
+                const secure = globalThis.location?.protocol === 'https:' ? '; Secure' : '';
+                document.cookie = `${encodeURIComponent(key)}=${encodeURIComponent(value ?? '')}; Path=/; SameSite=Lax; Max-Age=${value === null ? '0' : '31536000'}${secure}`;
+            }
+        }
+        catch {
+            // WebView 或隐私模式下保留内存态。
+        }
+    }
+    return {
+        get(key) {
+            try {
+                const raw = read(key);
+                if (!raw)
+                    return null;
+                const value = JSON.parse(raw);
+                if (value && typeof value === 'object'
+                    && 'version' in value && typeof value.version === 'number' && Number.isFinite(value.version)
+                    && 'updatedAt' in value && typeof value.updatedAt === 'number' && Number.isFinite(value.updatedAt)
+                    && 'status' in value && (value.status === 'completed' || value.status === 'dismissed' || value.status === 'deferred')) {
+                    return { version: value.version, updatedAt: value.updatedAt, status: value.status };
+                }
+            }
+            catch {
+                // 损坏的偏好作为未看过处理。
+            }
+            return null;
+        },
+        set(key, progress) {
+            write(key, progress ? JSON.stringify(progress) : null);
+        },
+    };
+}

package/dist/guide-types.d.ts

@@ -0,0 +1,78 @@
+import type { NavAdapter } from './components/scenes/crud/nav-adapter.js';
+/** 业务文案使用函数延迟求值，切换语言时重新读取应用翻译。 */
+export type GuideText = string | (() => string);
+export interface GuideStep {
+    /** data-guide 的值；复杂定位可传入返回元素的函数。 */
+    target: string | (() => Element | null);
+    title: GuideText;
+    description: GuideText;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** 只准备页面交互状态，例如展开页签；可通过 signal 取消异步等待。 */
+    before?: (signal: AbortSignal) => void | Promise<void>;
+    /** 可选元素缺失时跳过，必要元素缺失时停止并显示提示。 */
+    optional?: boolean;
+}
+export interface GuideTour {
+    id: string;
+    title: GuideText;
+    description?: GuideText;
+    version?: number;
+    /** 目标页面路径；导航由宿主的 NavAdapter 提供。 */
+    route?: string;
+    steps: readonly GuideStep[];
+    /** 按当前权限或功能开关决定是否提供此导览。 */
+    enabled?: () => boolean;
+}
+export interface GuideArticle {
+    id: string;
+    title: GuideText;
+    description?: GuideText;
+    category?: GuideText;
+    /** Markdown 正文；原始 HTML 默认关闭。 */
+    content: GuideText;
+    tourId?: string;
+    enabled?: () => boolean;
+}
+export interface GuideProgress {
+    version: number;
+    status: 'completed' | 'dismissed' | 'deferred';
+    updatedAt: number;
+}
+export interface GuideOptions {
+    tours: readonly GuideTour[];
+    articles?: readonly GuideArticle[];
+    persistence?: 'cookie' | 'localStorage' | 'memory';
+    /** 同源多个应用应使用不同前缀。 */
+    persistKey?: string;
+    nav?: NavAdapter;
+    /** 每个目标元素的等待上限，默认 3000 毫秒。 */
+    waitTimeout?: number;
+}
+/** 浏览器 UI 控制器，操作失败返回 false 并设置 error，不抛业务异常。 */
+export interface GuideController {
+    readonly tours: readonly GuideTour[];
+    readonly articles: readonly GuideArticle[];
+    readonly offeredTour: GuideTour | undefined;
+    readonly activeTourId: string | null;
+    readonly busy: boolean;
+    readonly error: string;
+    readonly locale: string;
+    readonly pathname: string;
+    readonly helpOpen: boolean;
+    readonly articleId: string | null;
+    start: (id: string) => Promise<boolean>;
+    startIfNeeded: (id: string) => boolean;
+    defer: () => void;
+    dismiss: () => void;
+    stop: () => void;
+    reset: (id: string) => void;
+    getProgress: (id: string) => GuideProgress | null;
+    openHelp: (articleId?: string) => void;
+    closeHelp: () => void;
+    clearError: () => void;
+    /** GuideHost 负责同步以下宿主状态，应用通常不需要手动调用。 */
+    setLocale: (locale: string) => void;
+    setScope: (scope: string) => void;
+    handleNavigation: (pathname: string) => void;
+    resume: () => Promise<boolean>;
+}

package/dist/guide-types.js

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

package/dist/guide.d.ts

@@ -0,0 +1,3 @@
+export * from './components/scenes/guide/index.js';
+export * from './guide-types.js';
+export * from './guide.svelte.js';

package/dist/guide.js

@@ -0,0 +1,3 @@
+export * from './components/scenes/guide/index.js';
+export * from './guide-types.js';
+export * from './guide.svelte.js';

package/dist/guide.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { GuideController, GuideOptions, GuideText } from './guide-types.js';
+/** 解析业务文案；既支持普通字符串，也支持应用 i18n 函数。 */
+export declare function resolveGuideText(text?: GuideText): string;
+/**
+ * 创建应用独享的新手引导控制器。SSR 可创建，DOM 操作只在客户端启动时发生。
+ * 配置和控制器应在布局组件内创建，避免在 SSR 模块级共享用户状态。
+ */
+export declare function createGuide(options: GuideOptions): GuideController;

package/dist/guide.svelte.js

@@ -0,0 +1,450 @@
+import { tick } from 'svelte';
+import { SvelteSet } from 'svelte/reactivity';
+import { createBrowserNavAdapter } from './components/scenes/crud/nav-adapter.js';
+import { createGuideStorage } from './guide-storage.js';
+import { getUILocale, uiM } from './messages.js';
+/** 同一浏览器页面只允许一个导览拥有遮罩和键盘监听。 */
+let stopActiveGuide;
+/** 解析业务文案；既支持普通字符串，也支持应用 i18n 函数。 */
+export function resolveGuideText(text) {
+    return typeof text === 'function' ? text() : text ?? '';
+}
+function escapeGuideText(text) {
+    return resolveGuideText(text).replace(/[&<>"']/g, character => ({
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        '\'': '&#39;',
+    })[character]);
+}
+function findTarget(step) {
+    const element = typeof step.target === 'function'
+        ? step.target()
+        : [...document.querySelectorAll('[data-guide]')].find(item => item.getAttribute('data-guide') === step.target);
+    if (!element?.isConnected || !element.getClientRects().length || element.closest('[hidden], [aria-hidden="true"]'))
+        return null;
+    const style = getComputedStyle(element);
+    return style.visibility === 'hidden' || style.display === 'none' ? null : element;
+}
+/** 等待异步渲染、页签展开或布局变化，所有退出路径均清理监听和计时器。 */
+function waitForTarget(step, signal, timeout, ready) {
+    return new Promise((resolve) => {
+        let observer;
+        let timer;
+        let poll;
+        const finish = (element) => {
+            observer?.disconnect();
+            clearTimeout(timer);
+            clearInterval(poll);
+            signal.removeEventListener('abort', aborted);
+            resolve(element);
+        };
+        function aborted() {
+            finish(null);
+        }
+        const check = () => {
+            if (signal.aborted) {
+                finish(null);
+                return;
+            }
+            const element = ready() ? findTarget(step) : null;
+            if (element)
+                finish(element);
+        };
+        if (signal.aborted) {
+            finish(null);
+            return;
+        }
+        const initial = ready() ? findTarget(step) : null;
+        if (initial) {
+            finish(initial);
+            return;
+        }
+        observer = new MutationObserver(check);
+        observer.observe(document.documentElement, { childList: true, subtree: true, attributes: true });
+        signal.addEventListener('abort', aborted, { once: true });
+        timer = setTimeout(finish, timeout, null);
+        poll = setInterval(check, 50);
+    });
+}
+/**
+ * 创建应用独享的新手引导控制器。SSR 可创建，DOM 操作只在客户端启动时发生。
+ * 配置和控制器应在布局组件内创建，避免在 SSR 模块级共享用户状态。
+ */
+export function createGuide(options) {
+    const storage = createGuideStorage(options);
+    const nav = options.nav ?? createBrowserNavAdapter();
+    const persistKey = options.persistKey ?? 'hai-guide';
+    const pendingKey = `${persistKey}-pending`;
+    let scope = 'anonymous';
+    let locale = $state(getUILocale());
+    let offeredId = $state(null);
+    let activeTourId = $state(null);
+    let busy = $state(false);
+    let error = $state('');
+    let helpOpen = $state(false);
+    let articleId = $state(null);
+    let driver;
+    let abort;
+    let generation = 0;
+    let expectedPath;
+    let navigating = false;
+    let focusBefore = null;
+    let activeElement = null;
+    let targetObserver;
+    const msg = (key) => uiM(key, undefined, locale);
+    const progressKey = (id) => `${persistKey}:${scope}:${id}`;
+    const tourFor = (id) => options.tours.find(tour => tour.id === id && (!tour.enabled || tour.enabled()));
+    function clearPending() {
+        try {
+            sessionStorage.removeItem(pendingKey);
+        }
+        catch {
+            // 存储受限时仅支持宿主客户端导航。
+        }
+    }
+    function stop() {
+        generation++;
+        abort?.abort();
+        abort = undefined;
+        targetObserver?.disconnect();
+        targetObserver = undefined;
+        const previousDriver = driver;
+        driver = undefined;
+        previousDriver?.destroy();
+        activeTourId = null;
+        activeElement = null;
+        busy = false;
+        expectedPath = undefined;
+        if (!navigating)
+            clearPending();
+        if (stopActiveGuide === stop)
+            stopActiveGuide = undefined;
+        if (focusBefore?.isConnected)
+            focusBefore.focus();
+        focusBefore = null;
+    }
+    function mark(tour, status) {
+        storage.set(progressKey(tour.id), { version: tour.version ?? 1, status, updatedAt: Date.now() });
+    }
+    function getProgress(id) {
+        return storage.get(progressKey(id));
+    }
+    function driverSteps(tour) {
+        return tour.steps.map(step => ({
+            element: () => findTarget(step) ?? document.body,
+            popover: {
+                title: escapeGuideText(step.title),
+                description: escapeGuideText(step.description),
+                side: step.side ?? 'bottom',
+            },
+        }));
+    }
+    function translatedConfig(tour) {
+        return {
+            steps: driverSteps(tour),
+            nextBtnText: msg('guide_next'),
+            prevBtnText: msg('guide_previous'),
+            doneBtnText: msg('guide_done'),
+            closeBtnLabel: msg('guide_close'),
+            progressText: uiM('guide_progress', { current: '{{current}}', total: '{{total}}' }, locale),
+        };
+    }
+    async function start(id) {
+        if (typeof document === 'undefined')
+            return false;
+        stopActiveGuide?.();
+        stop();
+        navigating = false;
+        error = '';
+        offeredId = null;
+        helpOpen = false;
+        const tour = tourFor(id);
+        if (!tour?.steps.length) {
+            error = 'guide_unavailable';
+            return false;
+        }
+        const run = generation;
+        const signal = new AbortController();
+        abort = signal;
+        activeTourId = id;
+        busy = true;
+        stopActiveGuide = stop;
+        focusBefore = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+        const requiredSeen = new SvelteSet();
+        let finishHighlight;
+        function hasPreviousStep(index = driver?.getActiveIndex() ?? 0) {
+            return [...requiredSeen].some(stepIndex => stepIndex < index);
+        }
+        function disableNavigation(disabled) {
+            const popover = driver?.getState().popover;
+            if (popover) {
+                popover.nextButton.disabled = disabled;
+                popover.previousButton.disabled = disabled || !hasPreviousStep();
+            }
+        }
+        async function showStep(index, direction = 1) {
+            if (signal.signal.aborted || run !== generation)
+                return false;
+            busy = true;
+            disableNavigation(true);
+            try {
+                while (index >= 0 && index < tour.steps.length) {
+                    const step = tour.steps[index];
+                    await step.before?.(signal.signal);
+                    await tick();
+                    if (signal.signal.aborted || run !== generation)
+                        return false;
+                    const element = await waitForTarget(step, signal.signal, options.waitTimeout ?? 3000, () => !expectedPath || nav.pathname === expectedPath);
+                    if (signal.signal.aborted || run !== generation)
+                        return false;
+                    if (!element) {
+                        if (step.optional) {
+                            index += direction;
+                            continue;
+                        }
+                        error = 'guide_targetMissing';
+                        stop();
+                        return false;
+                    }
+                    requiredSeen.add(index);
+                    activeElement = element;
+                    driver?.setConfig({ ...driver.getConfig(), ...translatedConfig(tour) });
+                    // 等到引擎完成首帧定位后再报告启动成功，键盘此时已可操作。
+                    await new Promise((resolve) => {
+                        const finished = () => {
+                            signal.signal.removeEventListener('abort', finished);
+                            if (finishHighlight === finished)
+                                finishHighlight = undefined;
+                            resolve();
+                        };
+                        finishHighlight = finished;
+                        signal.signal.addEventListener('abort', finished, { once: true });
+                        driver?.drive(index);
+                    });
+                    if (!signal.signal.aborted && run === generation && !findTarget(step)) {
+                        error = 'guide_targetMissing';
+                        stop();
+                        return false;
+                    }
+                    return !signal.signal.aborted && run === generation;
+                }
+                if (direction > 0 && tour.steps.every((step, stepIndex) => step.optional || requiredSeen.has(stepIndex)) && requiredSeen.size) {
+                    // 完成点击与 DOM 卸载可能发生在同一帧，不能把已消失的目标误记为完成。
+                    const currentStep = tour.steps[driver?.getActiveIndex() ?? 0];
+                    if (!currentStep || !findTarget(currentStep)) {
+                        error = 'guide_targetMissing';
+                        stop();
+                        return false;
+                    }
+                    mark(tour, 'completed');
+                    stop();
+                    return true;
+                }
+                error = 'guide_targetMissing';
+                stop();
+                return false;
+            }
+            catch {
+                if (!signal.signal.aborted && run === generation) {
+                    error = 'guide_startFailed';
+                    stop();
+                }
+                return false;
+            }
+            finally {
+                if (run === generation) {
+                    busy = false;
+                    disableNavigation(false);
+                }
+            }
+        }
+        try {
+            // 动态导入引擎，只有开始导览时才加载定位和遮罩实现。
+            const { driver: createDriver } = await import('driver.js');
+            if (signal.signal.aborted || run !== generation)
+                return false;
+            if (tour.route && nav.pathname !== tour.route.split('?')[0]) {
+                expectedPath = tour.route.split('?')[0];
+                navigating = true;
+                try {
+                    sessionStorage.setItem(pendingKey, JSON.stringify({ id, scope, route: expectedPath, createdAt: Date.now() }));
+                }
+                catch {
+                    // Cookie 或 WebView 存储限制不阻止客户端导航。
+                }
+                await nav.navigate(tour.route);
+                if (signal.signal.aborted || run !== generation)
+                    return false;
+                if (!options.nav) {
+                    // 默认导航会完整加载新页面；保留待启动记录，由目标页宿主恢复。
+                    stop();
+                    return true;
+                }
+                navigating = false;
+            }
+            expectedPath ??= nav.pathname;
+            driver = createDriver({
+                ...translatedConfig(tour),
+                popoverClass: 'hai-guide-popover',
+                showProgress: true,
+                animate: !globalThis.matchMedia?.('(prefers-reduced-motion: reduce)').matches,
+                duration: 200,
+                stageRadius: 10,
+                stagePadding: 8,
+                overlayOpacity: 0.45,
+                allowKeyboardControl: true,
+                overlayClickBehavior: 'close',
+                onNextClick: () => {
+                    if (!busy)
+                        void showStep((driver?.getActiveIndex() ?? 0) + 1);
+                },
+                onPrevClick: () => {
+                    if (!busy && hasPreviousStep())
+                        void showStep((driver?.getActiveIndex() ?? 0) - 1, -1);
+                },
+                onDoneClick: () => {
+                    if (!busy)
+                        void showStep(tour.steps.length);
+                },
+                onHighlighted: () => finishHighlight?.(),
+                // 引擎首帧未完成时不会触发 onDestroyed；从关闭开始时统一取消等待。
+                onDestroyStarted: stop,
+                onDestroyed: () => {
+                    if (driver) {
+                        driver = undefined;
+                        stop();
+                    }
+                },
+                onPopoverRender: (popover) => {
+                    // 第三方默认支持 HTML；业务翻译和插值统一按纯文本写入。
+                    const index = driver?.getActiveIndex() ?? 0;
+                    const step = tour.steps[index];
+                    popover.title.textContent = resolveGuideText(step?.title);
+                    popover.description.textContent = resolveGuideText(step?.description);
+                    popover.nextButton.textContent = msg(index === tour.steps.length - 1 ? 'guide_done' : 'guide_next');
+                    popover.previousButton.textContent = msg('guide_previous');
+                    popover.progress.textContent = uiM('guide_progress', { current: index + 1, total: tour.steps.length }, locale);
+                    popover.nextButton.disabled = busy;
+                    popover.previousButton.disabled = busy || !hasPreviousStep(index);
+                },
+            });
+            const started = await showStep(0);
+            if (started && !signal.signal.aborted) {
+                clearPending();
+                targetObserver = new MutationObserver(() => {
+                    if (!busy && activeElement && !findTarget(tour.steps[driver?.getActiveIndex() ?? 0])) {
+                        error = 'guide_targetMissing';
+                        stop();
+                    }
+                });
+                targetObserver.observe(document.documentElement, { subtree: true, childList: true, attributes: true });
+            }
+            return started;
+        }
+        catch {
+            if (!signal.signal.aborted && run === generation) {
+                navigating = false;
+                error = 'guide_startFailed';
+                stop();
+            }
+            return false;
+        }
+    }
+    return {
+        get tours() { return options.tours.filter(tour => !tour.enabled || tour.enabled()); },
+        get articles() { return (options.articles ?? []).filter(article => !article.enabled || article.enabled()); },
+        get offeredTour() { return offeredId ? tourFor(offeredId) : undefined; },
+        get activeTourId() { return activeTourId; },
+        get busy() { return busy; },
+        get error() { return error ? msg(error) : ''; },
+        get locale() { return locale; },
+        get pathname() { return nav.pathname; },
+        get helpOpen() { return helpOpen; },
+        get articleId() { return articleId; },
+        start,
+        startIfNeeded(id) {
+            const tour = tourFor(id);
+            if (!tour || activeTourId || offeredId || typeof document === 'undefined')
+                return false;
+            const progress = getProgress(id);
+            if (progress?.version === (tour.version ?? 1)
+                && (progress.status !== 'deferred' || Date.now() - progress.updatedAt < 86400000)) {
+                return false;
+            }
+            offeredId = id;
+            return true;
+        },
+        defer() {
+            const tour = offeredId ? tourFor(offeredId) : undefined;
+            if (tour)
+                mark(tour, 'deferred');
+            offeredId = null;
+        },
+        dismiss() {
+            const tour = offeredId ? tourFor(offeredId) : undefined;
+            if (tour)
+                mark(tour, 'dismissed');
+            offeredId = null;
+        },
+        stop,
+        reset(id) { storage.set(progressKey(id), null); },
+        getProgress,
+        openHelp(id) {
+            stop();
+            offeredId = null;
+            error = '';
+            articleId = id ?? null;
+            helpOpen = true;
+        },
+        closeHelp() { helpOpen = false; },
+        clearError() { error = ''; },
+        setLocale(value) {
+            locale = value;
+            const tour = activeTourId ? tourFor(activeTourId) : undefined;
+            if (driver && tour) {
+                driver.setConfig({ ...driver.getConfig(), ...translatedConfig(tour) });
+                driver.drive(driver.getActiveIndex() ?? 0);
+            }
+        },
+        setScope(value) {
+            if (scope !== value) {
+                // 首次装配 scope 时保留上一页面的待启动记录，账号切换才取消当前交互。
+                if (activeTourId || offeredId || helpOpen) {
+                    navigating = false;
+                    stop();
+                }
+                scope = value;
+                offeredId = null;
+                helpOpen = false;
+                error = '';
+            }
+        },
+        handleNavigation(pathname) {
+            if (!navigating && activeTourId && expectedPath && pathname !== expectedPath)
+                stop();
+        },
+        async resume() {
+            try {
+                const raw = sessionStorage.getItem(pendingKey);
+                if (!raw)
+                    return false;
+                clearPending();
+                const pending = JSON.parse(raw);
+                if (pending && typeof pending === 'object'
+                    && 'id' in pending && typeof pending.id === 'string'
+                    && 'scope' in pending && pending.scope === scope
+                    && 'route' in pending && pending.route === nav.pathname
+                    && 'createdAt' in pending && typeof pending.createdAt === 'number'
+                    && Date.now() - pending.createdAt < 300000) {
+                    return await start(pending.id);
+                }
+            }
+            catch {
+                // 过期或损坏的导航记录不阻止页面使用。
+            }
+            return false;
+        },
+    };
+}

package/dist/index.d.ts

@@ -5,6 +5,8 @@
  * @module index
  */
 export * from './components/index.js';
+export * from './guide-types.js';
+export * from './guide.svelte.js';
 export * from './i18n.svelte.js';
 export * from './internal/browser-safety.js';
 export * from './message.svelte.js';

package/dist/index.js

@@ -6,6 +6,8 @@
  */
 // ─── 组件导出（从 components/ 统一导出所有三层组件及其类型） ───
 export * from './components/index.js';
+export * from './guide-types.js';
+export * from './guide.svelte.js';
 // ─── i18n 国际化（Paraglide 辅助工具） ───
 export * from './i18n.svelte.js';
 // ─── 浏览器能力安全辅助（剪贴板、localStorage 等降级方案） ───

package/dist/messages/en-US.json

@@ -351,5 +351,22 @@
   "password_policy_uppercase": "Include uppercase letters",
   "password_policy_lowercase": "Include lowercase letters",
   "password_policy_number": "Include numbers",
-  "password_policy_special": "Include special characters"
+  "password_policy_special": "Include special characters",
+  "guide_welcome": "Welcome",
+  "guide_start": "Start tour",
+  "guide_later": "Remind me later",
+  "guide_dismiss": "Do not remind me",
+  "guide_help": "Help center",
+  "guide_close": "Close",
+  "guide_loading": "Preparing your tour…",
+  "guide_next": "Next",
+  "guide_previous": "Previous",
+  "guide_done": "Done",
+  "guide_progress": "Step {current} of {total}",
+  "guide_search": "Search help",
+  "guide_empty": "No matching help content",
+  "guide_tours": "Product tours",
+  "guide_unavailable": "This tour is unavailable. Choose another topic in the help center.",
+  "guide_targetMissing": "This action is not available on the current page. Try again later or read the help content.",
+  "guide_startFailed": "Unable to start the tour. Please try again later."
 }