【2025年最新】音声検索対応スキーママークアップの完全実装ガイド

// 音声検索クエリの特徴分析
const voiceSearchPatterns = {
    queryLength: {
        text: '平均2-3語',
        voice: '平均7-9語'
    },
    queryStyle: {
        text: 'SEO対策 方法',
        voice: 'SEO対策の効果的な方法を教えて'
    },
    intentDistribution: {
        informational: '65%', // 「〜とは」「〜について」
        navigational: '20%',  // 「〜を開いて」「〜のサイト」
        transactional: '15%'  // 「〜を注文」「〜を予約」
    },
    expectedResponseFormat: {
        directAnswer: '78%',  // 直接的な回答を期待
        conversational: '22%' // 会話的なやり取りを期待
    }
};

// 音声検索に最適化されたスキーママークアップ例
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "音声検索に最適化するにはどうすればよいですか",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "音声検索最適化には3つのポイントがあります。まず、会話的なキーワードの活用、次に構造化データの実装、最後にローカルSEOの強化です。特にスキーママークアップを使用することで、音声アシスタントが情報を理解しやすくなり、検索結果での表示率が向上します。",
        "speakable": {
          "@type": "SpeakableSpecification",
          "xpath": [
            "/html/head/title",
            "/html/body/main/article/section[1]/p[1]"
          ]
        }
      }
    }
  ]
}

const voiceSearchSchemaTypes = [
    {
        type: 'FAQPage',
        effectiveness: '95%',
        useCase: '質問回答型コンテンツ',
        voiceSearchCompatibility: '最高'
    },
    {
        type: 'HowTo',
        effectiveness: '89%', 
        useCase: '手順説明コンテンツ',
        voiceSearchCompatibility: '高'
    },
    {
        type: 'Recipe',
        effectiveness: '87%',
        useCase: '料理・レシピコンテンツ',
        voiceSearchCompatibility: '高'
    },
    {
        type: 'LocalBusiness',
        effectiveness: '85%',
        useCase: 'ローカルビジネス情報',
        voiceSearchCompatibility: '高'
    },
    {
        type: 'Product',
        effectiveness: '78%',
        useCase: '商品情報',
        voiceSearchCompatibility: '中'
    }
];

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question", 
      "name": "スマートスピーカーでウェブサイトの情報を聞くことはできますか",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "はい、可能です。適切なスキーママークアップを実装することで、Google Assistant、Amazon Alexa、Apple Siriなどの音声アシスタントがあなたのウェブサイトの情報を読み上げてくれます。特にFAQページやハウツーコンテンツは音声検索と相性が良く、実装により流入が大幅に増加する傾向があります。",
        "speakable": {
          "@type": "SpeakableSpecification",
          "xpath": ["/html/body/main/article/div[@class='faq-answer'][1]"],
          "cssSelector": ".faq-answer"
        },
        "dateModified": "2025-08-27",
        "author": {
          "@type": "Person",
          "name": "音声検索専門家",
          "jobTitle": "SEOコンサルタント"
        }
      }
    },
    {
      "@type": "Question",
      "name": "音声検索で上位表示されるコンテンツの特徴は何ですか",
      "acceptedAnswer": {
        "@type": "Answer", 
        "text": "音声検索で上位表示されるコンテンツには3つの共通点があります。1つ目は自然な会話形式での記述、2つ目は簡潔で明確な回答、3つ目は適切な構造化データの実装です。特に50文字以内の簡潔な回答と、その詳細説明を組み合わせた構成が効果的です。",
        "speakable": {
          "@type": "SpeakableSpecification",
          "xpath": ["/html/body/main/article/div[@class='faq-answer'][2]"]
        }
      }
    }
  ],
  "about": {
    "@type": "Thing",
    "name": "音声検索最適化"
  },
  "inLanguage": "ja-JP",
  "dateModified": "2025-08-27T10:00:00+09:00"
}

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "音声検索対応のスキーママークアップを実装する方法",
  "description": "ウェブサイトを音声検索に最適化するための構造化データ実装手順を詳しく解説します",
  "totalTime": "PT30M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "JPY",
    "value": "0"
  },
  "supply": [
    {
      "@type": "HowToSupply",
      "name": "HTMLファイル"
    },
    {
      "@type": "HowToSupply", 
      "name": "テキストエディタ"
    }
  ],
  "tool": [
    {
      "@type": "HowToTool",
      "name": "Google構造化データテストツール"
    }
  ],
  "step": [
    {
      "@type": "HowToStep",
      "name": "スキーママークアップの準備",
      "text": "まず、対象となるコンテンツの種類を特定し、最適なスキーマタイプを選択します",
      "url": "https://example.com/voice-search-schema#step1",
      "image": {
        "@type": "ImageObject",
        "url": "https://example.com/images/schema-prep.jpg"
      }
    },
    {
      "@type": "HowToStep", 
      "name": "JSON-LD形式での記述",
      "text": "選択したスキーマタイプをJSON-LD形式で記述し、HTMLのhead部分に挿入します",
      "url": "https://example.com/voice-search-schema#step2"
    },
    {
      "@type": "HowToStep",
      "name": "テストと検証",
      "text": "Google構造化データテストツールを使用して、マークアップが正しく認識されることを確認します",
      "url": "https://example.com/voice-search-schema#step3"
    }
  ],
  "video": {
    "@type": "VideoObject",
    "name": "音声検索スキーマ実装デモ",
    "description": "実際の実装プロセスを動画で解説",
    "thumbnailUrl": "https://example.com/video-thumb.jpg",
    "uploadDate": "2025-08-27",
    "duration": "PT10M30S"
  }
}

<!DOCTYPE html>
<html lang="ja">
<head>
    <script type="application/ld+json">
    {
        "@context": "https://schema.org",
        "@type": "Article",
        "headline": "2025年音声検索トレンドとSEO戦略",
        "speakable": {
            "@type": "SpeakableSpecification",
            "cssSelector": [".speakable-summary", ".key-points"],
            "xpath": [
                "/html/body/article/div[@class='summary']",
                "/html/body/article/section[@class='key-insights']/ul"
            ]
        },
        "author": {
            "@type": "Person", 
            "name": "SEO専門家"
        },
        "datePublished": "2025-08-27"
    }
    </script>
</head>
<body>
    <article>
        <div class="speakable-summary">
            音声検索は2025年に大きな転換点を迎え、従来のSEO戦略では対応できない新しい課題が浮上しています。
        </div>
        
        <section class="key-insights">
            <h2>重要なポイント</h2>
            <ul class="key-points">
                <li>会話型クエリの増加により、自然言語での最適化が必須</li>
                <li>構造化データの重要性が過去最高レベルに</li>
                <li>ローカル検索との統合が進展</li>
            </ul>
        </section>
        
        <div class="detailed-content">
            <!-- 詳細な解説内容（speakableに含めない） -->
        </div>
    </article>
</body>
</html>

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness", 
  "name": "音声検索対応SEOコンサルティング東京",
  "image": [
    "https://example.com/office-exterior.jpg",
    "https://example.com/team-photo.jpg"
  ],
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "渋谷区道玄坂2-10-12",
    "addressLocality": "渋谷区", 
    "addressRegion": "東京都",
    "postalCode": "150-0043",
    "addressCountry": "JP"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 35.6581,
    "longitude": 139.7013
  },
  "telephone": "+81-3-1234-5678",
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "09:00",
      "closes": "18:00"
    },
    {
      "@type": "OpeningHoursSpecification", 
      "dayOfWeek": "Saturday",
      "opens": "10:00",
      "closes": "15:00"
    }
  ],
  "priceRange": "¥¥¥",
  "servedCuisine": "SEOコンサルティング",
  "hasMenu": {
    "@type": "Menu",
    "name": "サービスメニュー",
    "hasMenuSection": [
      {
        "@type": "MenuSection",
        "name": "音声検索最適化",
        "hasMenuItem": {
          "@type": "MenuItem",
          "name": "基本プラン",
          "offers": {
            "@type": "Offer",
            "price": "50000",
            "priceCurrency": "JPY"
          }
        }
      }
    ]
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "127"
  }
}

// 多言語対応音声検索スキーマジェネレーター
class MultilingualVoiceSearchSchema {
    constructor() {
        this.supportedLanguages = {
            'ja': {locale: 'ja-JP', voice: 'ja-JP-Standard-A'},
            'en': {locale: 'en-US', voice: 'en-US-Standard-C'},
            'ko': {locale: 'ko-KR', voice: 'ko-KR-Standard-A'},
            'zh': {locale: 'zh-CN', voice: 'zh-CN-Standard-A'}
        };
    }
    
    generateMultilingualFAQ(faqData) {
        const schemas = {};
        
        Object.keys(this.supportedLanguages).forEach(lang => {
            const langConfig = this.supportedLanguages[lang];
            
            schemas[lang] = {
                "@context": "https://schema.org",
                "@type": "FAQPage",
                "inLanguage": langConfig.locale,
                "mainEntity": faqData[lang].map(qa => ({
                    "@type": "Question",
                    "name": qa.question,
                    "acceptedAnswer": {
                        "@type": "Answer",
                        "text": qa.answer,
                        "inLanguage": langConfig.locale,
                        "speakable": {
                            "@type": "SpeakableSpecification",
                            "cssSelector": `.faq-answer-${lang}`,
                            "voice": langConfig.voice
                        }
                    }
                }))
            };
        });
        
        return schemas;
    }
    
    // hreflangタグの自動生成
    generateHreflangTags(currentUrl) {
        const tags = [];
        
        Object.keys(this.supportedLanguages).forEach(lang => {
            const locale = this.supportedLanguages[lang].locale;
            tags.push(`<link rel="alternate" hreflang="${locale}" href="${currentUrl}${lang}/">`);
        });
        
        tags.push(`<link rel="alternate" hreflang="x-default" href="${currentUrl}">`);
        
        return tags.join('\n');
    }
}

// 使用例
const multilingualSchema = new MultilingualVoiceSearchSchema();
const faqData = {
    'ja': [
        {
            question: '音声検索の実装にはどのくらいの時間がかかりますか',
            answer: '基本的な実装であれば1-2日、高度な最適化を含む場合は1-2週間程度です'
        }
    ],
    'en': [
        {
            question: 'How long does it take to implement voice search optimization',
            answer: 'Basic implementation takes 1-2 days, advanced optimization takes 1-2 weeks'
        }
    ]
};

const generatedSchemas = multilingualSchema.generateMultilingualFAQ(faqData);

// 音声検索トラッキングシステム
class VoiceSearchAnalytics {
    constructor() {
        this.setupEventListeners();
        this.voiceSearchIndicators = [
            'voice search',
            'ok google',
            'hey siri', 
            'alexa',
            '音声検索',
            'voice command'
        ];
    }
    
    setupEventListeners() {
        // 音声検索からの流入を検知
        if (this.isVoiceSearchReferral()) {
            this.trackVoiceSearchVisit();
        }
        
        // ページ滞在時間による音声検索推定
        this.trackEngagementPatterns();
    }
    
    isVoiceSearchReferral() {
        const referrer = document.referrer.toLowerCase();
        const userAgent = navigator.userAgent.toLowerCase();
        const queryParams = new URLSearchParams(window.location.search);
        
        // Google Assistant からの流入検知
        if (referrer.includes('assistant.google.com')) {
            return true;
        }
        
        // 音声検索特有のパラメータ検知
        if (queryParams.has('voice') || queryParams.has('speech')) {
            return true;
        }
        
        // クエリ長による推定（7語以上は音声検索の可能性高）
        const searchQuery = queryParams.get('q') || '';
        const wordCount = searchQuery.split(' ').length;
        if (wordCount >= 7) {
            return true;
        }
        
        return false;
    }
    
    trackVoiceSearchVisit() {
        // Google Analytics 4 イベント送信
        if (typeof gtag !== 'undefined') {
            gtag('event', 'voice_search_visit', {
                'event_category': 'Voice Search',
                'event_label': 'Detected Voice Search Entry',
                'custom_parameter_1': this.getVoiceSearchType(),
                'engagement_time_msec': 1000
            });
        }
        
        // カスタムディメンションの設定
        gtag('config', 'GA_MEASUREMENT_ID', {
            'custom_map': {'custom_parameter_1': 'voice_search_type'}
        });
    }
    
    // 音声検索パフォーマンス分析
    async analyzeVoiceSearchPerformance() {
        const data = await this.fetchAnalyticsData();
        
        const analysis = {
            voiceSearchTraffic: this.calculateVoiceSearchTraffic(data),
            averageEngagementTime: this.calculateAverageEngagement(data), 
            conversionRate: this.calculateVoiceSearchConversions(data),
            topVoiceQueries: this.identifyVoiceQueries(data),
            deviceDistribution: this.analyzeDeviceTypes(data)
        };
        
        return this.generateVoiceSearchReport(analysis);
    }
    
    generateVoiceSearchReport(analysis) {
        return {
            summary: {
                totalVoiceSearchSessions: analysis.voiceSearchTraffic,
                conversionRate: `${analysis.conversionRate}%`,
                averageEngagement: `${analysis.averageEngagementTime}秒`,
                growth: this.calculateGrowthRate()
            },
            recommendations: this.generateOptimizationRecommendations(analysis),
            actionItems: this.prioritizeActionItems(analysis)
        };
    }
}

// スキーママークアップ効果測定システム
class SchemaPerformanceMonitor {
    constructor(searchConsoleAPI) {
        this.api = searchConsoleAPI;
        this.schemaTypes = ['FAQPage', 'HowTo', 'Recipe', 'LocalBusiness'];
    }
    
    async measureSchemaPerformance() {
        const results = {};
        
        for (const schemaType of this.schemaTypes) {
            results[schemaType] = await this.getSchemaMetrics(schemaType);
        }
        
        return this.analyzeOverallPerformance(results);
    }
    
    async getSchemaMetrics(schemaType) {
        const query = {
            startDate: '2025-01-01',
            endDate: '2025-08-27',
            dimensions: ['query', 'page'],
            searchType: 'web',
            dimensionFilterGroups: [{
                filters: [{
                    dimension: 'searchAppearance',
                    expression: schemaType.toLowerCase(),
                    operator: 'contains'
                }]
            }]
        };
        
        try {
            const response = await this.api.searchanalytics.query({
                siteUrl: 'https://example.com/',
                requestBody: query
            });
            
            return {
                impressions: response.data.rows?.reduce((sum, row) => sum + row.impressions, 0) || 0,
                clicks: response.data.rows?.reduce((sum, row) => sum + row.clicks, 0) || 0,
                ctr: response.data.rows?.length > 0 ? 
                    (response.data.rows.reduce((sum, row) => sum + row.clicks, 0) / 
                     response.data.rows.reduce((sum, row) => sum + row.impressions, 0)) * 100 : 0,
                averagePosition: response.data.rows?.length > 0 ? 
                    response.data.rows.reduce((sum, row) => sum + row.position, 0) / response.data.rows.length : 0
            };
        } catch (error) {
            console.error(`スキーマ ${schemaType} のメトリクス取得エラー:`, error);
            return { impressions: 0, clicks: 0, ctr: 0, averagePosition: 0 };
        }
    }
    
    // 自動最適化提案システム
    generateOptimizationSuggestions(performanceData) {
        const suggestions = [];
        
        Object.entries(performanceData).forEach(([schemaType, metrics]) => {
            if (metrics.ctr < 2.0) {
                suggestions.push({
                    type: 'CTR Improvement',
                    schema: schemaType,
                    priority: 'High',
                    suggestion: `${schemaType}のクリック率が低下しています。タイトルの最適化と説明文の改善を実施してください。`,
                    expectedImpact: `CTRを${(2.0 - metrics.ctr).toFixed(1)}%改善可能`
                });
            }
            
            if (metrics.averagePosition > 5.0) {
                suggestions.push({
                    type: 'Position Improvement',
                    schema: schemaType,
                    priority: 'Medium', 
                    suggestion: `${schemaType}の平均掲載順位が低下しています。コンテンツの質向上と内部リンクの強化を推奨します。`,
                    expectedImpact: `掲載順位を${(metrics.averagePosition - 3.0).toFixed(1)}位改善可能`
                });
            }
        });
        
        return suggestions.sort((a, b) => {
            const priorityOrder = { 'High': 3, 'Medium': 2, 'Low': 1 };
            return priorityOrder[b.priority] - priorityOrder[a.priority];
        });
    }
}

// C社で実装したRecipeスキーマ例
{
  "@context": "https://schema.org/",
  "@type": "Recipe",
  "name": "簡単チキンカレーの作り方",
  "image": [
    "https://example.com/curry-1x1.jpg",
    "https://example.com/curry-4x3.jpg"
  ],
  "description": "30分で作れる本格的なチキンカレーのレシピ。音声で手順を確認しながら調理できます",
  "keywords": "チキンカレー, 簡単レシピ, 30分料理, 音声レシピ",
  "author": {
    "@type": "Person",
    "name": "料理研究家 田中"
  },
  "datePublished": "2025-08-27",
  "prepTime": "PT10M",
  "cookTime": "PT20M",
  "totalTime": "PT30M",
  "recipeCategory": "メインディッシュ",
  "recipeCuisine": "インド料理",
  "recipeYield": "4人分",
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "320 kcal"
  },
  "recipeIngredient": [
    "鶏もも肉 400g",
    "玉ねぎ 2個",
    "カレー粉 大さじ2",
    "トマト缶 1缶"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "name": "野菜の下準備",
      "text": "玉ねぎを薄切りにします。鶏肉は一口大に切ります",
      "url": "https://example.com/curry-recipe#step1",
      "image": "https://example.com/curry-step1.jpg"
    },
    {
      "@type": "HowToStep", 
      "name": "炒める",
      "text": "フライパンに油を熱し、玉ねぎをきつね色になるまで炒めます",
      "url": "https://example.com/curry-recipe#step2"
    }
  ],
  "video": {
    "@type": "VideoObject",
    "name": "チキンカレー調理動画",
    "description": "音声ガイド付きの調理手順",
    "thumbnailUrl": "https://example.com/curry-video-thumb.jpg",
    "contentUrl": "https://example.com/curry-video.mp4",
    "uploadDate": "2025-08-27",
    "duration": "PT5M30S"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.9",
    "ratingCount": "312"
  }
}

// 技術文書向け音声検索最適化
class TechnicalContentVoiceOptimizer {
    constructor() {
        this.technicalTerms = new Map();
        this.pronunciationGuide = new Map();
        this.setupTechnicalGlossary();
    }
    
    setupTechnicalGlossary() {
        // 技術用語の読み上げ最適化
        this.technicalTerms.set('API', 'エーピーアイ');
        this.technicalTerms.set('SDK', 'エスディーケー');
        this.technicalTerms.set('REST', 'レスト');
        this.technicalTerms.set('GraphQL', 'グラフキューエル');
        
        // よくある音声検索クエリパターン
        this.voiceQueryPatterns = [
            'APIの使い方を教えて',
            'エラーが出た時の対処法は',
            '設定方法を説明して',
            'どうやって連携するの'
        ];
    }
    
    generateTechnicalFAQSchema(technicalContent) {
        const faqItems = technicalContent.map(item => ({
            "@type": "Question",
            "name": item.question,
            "acceptedAnswer": {
                "@type": "Answer",
                "text": this.optimizeForVoiceReading(item.answer),
                "speakable": {
                    "@type": "SpeakableSpecification",
                    "cssSelector": ".technical-answer",
                    "xpath": "//div[@class='technical-answer']"
                }
            }
        }));
        
        return {
            "@context": "https://schema.org",
            "@type": "FAQPage",
            "mainEntity": faqItems
        };
    }
    
    optimizeForVoiceReading(text) {
        // 技術用語を音声読み上げに適した形に変換
        let optimizedText = text;
        
        this.technicalTerms.forEach((pronunciation, term) => {
            const regex = new RegExp(term, 'gi');
            optimizedText = optimizedText.replace(regex, pronunciation);
        });
        
        // 長い文章を音声読み上げに適した長さに分割
        return this.splitForVoiceReading(optimizedText);
    }
    
    splitForVoiceReading(text) {
        const sentences = text.split('。');
        const voiceOptimizedSentences = sentences.map(sentence => {
            if (sentence.length > 100) {
                // 100文字超の文は適切な位置で区切る
                return this.insertVoicePauses(sentence);
            }
            return sentence;
        });
        
        return voiceOptimizedSentences.join('。');
    }
}

// 自動診断・修正システム
class VoiceSearchSchemaDiagnostic {
    constructor() {
        this.commonErrors = [
            'missing_required_properties',
            'invalid_date_format', 
            'speakable_xpath_error',
            'duplicate_questions',
            'excessive_text_length'
        ];
    }
    
    async diagnoseSchema(url) {
        const diagnosis = {
            errors: [],
            warnings: [], 
            suggestions: []
        };
        
        try {
            // Google Rich Results Testing API を使用
            const testResult = await this.testRichResults(url);
            
            // 音声検索特有のエラーチェック
            diagnosis.errors.push(...this.checkVoiceSearchErrors(testResult));
            diagnosis.warnings.push(...this.checkVoiceSearchWarnings(testResult));
            diagnosis.suggestions.push(...this.generateVoiceSearchSuggestions(testResult));
            
        } catch (error) {
            diagnosis.errors.push({
                type: 'api_error',
                message: `Rich Results APIエラー: ${error.message}`,
                severity: 'critical'
            });
        }
        
        return diagnosis;
    }
    
    checkVoiceSearchErrors(testResult) {
        const errors = [];
        
        // FAQPageの必須プロパティチェック
        if (testResult.richResultsItems) {
            testResult.richResultsItems.forEach(item => {
                if (item.richResultType === 'FAQPage') {
                    if (!item.items || item.items.length === 0) {
                        errors.push({
                            type: 'missing_faq_items',
                            message: 'FAQPageに質問が含まれていません',
                            severity: 'high',
                            fix: 'mainEntityプロパティに少なくとも1つの質問を追加してください'
                        });
                    }
                    
                    item.items?.forEach((faqItem, index) => {
                        if (!faqItem.name) {
                            errors.push({
                                type: 'missing_question_name',
                                message: `FAQ項目${index + 1}に質問文がありません`,
                                severity: 'high'
                            });
                        }
                        
                        if (!faqItem.acceptedAnswer?.text) {
                            errors.push({
                                type: 'missing_answer_text',
                                message: `FAQ項目${index + 1}に回答文がありません`,
                                severity: 'high'
                            });
                        }
                    });
                }
            });
        }
        
        return errors;
    }
    
    // 自動修正機能
    async autoFix(url, errors) {
        const fixes = [];
        
        for (const error of errors) {
            switch (error.type) {
                case 'invalid_date_format':
                    fixes.push(await this.fixDateFormat(error));
                    break;
                case 'speakable_xpath_error': 
                    fixes.push(await this.fixSpeakableXPath(error));
                    break;
                case 'excessive_text_length':
                    fixes.push(await this.optimizeTextLength(error));
                    break;
            }
        }
        
        return {
            totalFixed: fixes.filter(f => f.success).length,
            fixes: fixes,
            remainingIssues: errors.length - fixes.filter(f => f.success).length
        };
    }
    
    generateHealthReport() {
        return {
            summary: '音声検索スキーマ診断レポート',
            timestamp: new Date().toISOString(),
            overallScore: this.calculateOverallScore(),
            criticalIssues: this.criticalIssues.length,
            recommendations: this.generatePriorityRecommendations(),
            nextCheckDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString()
        };
    }
}

// 音声検索向けパフォーマンス最適化
class VoiceSearchPerformanceOptimizer {
    constructor() {
        this.cacheStrategies = new Map();
        this.setupOptimization();
    }
    
    setupOptimization() {
        // Service Worker による構造化データキャッシュ
        if ('serviceWorker' in navigator) {
            this.registerServiceWorker();
        }
        
        // スキーマの遅延読み込み設定
        this.setupLazySchemaLoading();
        
        // 音声検索用プリロード設定
        this.setupVoiceSearchPreload();
    }
    
    async registerServiceWorker() {
        try {
            const registration = await navigator.serviceWorker.register('/voice-search-sw.js');
            console.log('音声検索SW登録完了:', registration.scope);
        } catch (error) {
            console.error('SW登録エラー:', error);
        }
    }
    
    setupLazySchemaLoading() {
        // Intersection Observer による遅延読み込み
        const schemaElements = document.querySelectorAll('[data-schema-lazy]');
        
        const observer = new IntersectionObserver((entries) => {
            entries.forEach(entry => {
                if (entry.isIntersecting) {
                    this.loadSchema(entry.target);
                    observer.unobserve(entry.target);
                }
            });
        }, {
            threshold: 0.1,
            rootMargin: '100px'
        });
        
        schemaElements.forEach(element => observer.observe(element));
    }
    
    async loadSchema(element) {
        const schemaType = element.dataset.schemaType;
        const schemaData = element.dataset.schemaData;
        
        try {
            const schema = await this.fetchSchemaTemplate(schemaType);
            const populatedSchema = await this.populateSchemaData(schema, schemaData);
            
            const script = document.createElement('script');
            script.type = 'application/ld+json';
            script.textContent = JSON.stringify(populatedSchema);
            document.head.appendChild(script);
            
        } catch (error) {
            console.error('スキーマ読み込みエラー:', error);
        }
    }
    
    // Critical Resource Hints の最適化
    optimizeCriticalResourceHints() {
        const hints = [
            {
                rel: 'preconnect',
                href: 'https://www.google.com',
                crossorigin: 'anonymous'
            },
            {
                rel: 'dns-prefetch', 
                href: '//fonts.googleapis.com'
            },
            {
                rel: 'prefetch',
                href: '/voice-search-schemas.json'
            }
        ];
        
        hints.forEach(hint => {
            const link = document.createElement('link');
            Object.assign(link, hint);
            document.head.appendChild(link);
        });
    }
}

// 将来的な音声検索専用スキーマ例（予測）
{
  "@context": "https://schema.org",
  "@type": "VoiceOptimizedContent",
  "name": "音声最適化コンテンツ",
  "voiceReadingTime": "PT2M30S",
  "voiceComplexityLevel": "beginner",
  "supportedVoiceAssistants": ["Google Assistant", "Alexa", "Siri"],
  "conversationalFlow": {
    "@type": "ConversationFlow",
    "initialResponse": "こちらは音声検索に最適化されたコンテンツです",
    "followUpQuestions": [
      "詳しい説明をお聞きになりますか？",
      "関連する情報も必要でしょうか？"
    ]
  },
  "voicePersonalization": {
    "@type": "VoicePersonalization",
    "readingSpeed": "normal",
    "voiceEmphasis": ["重要ポイント", "数値データ"],
    "pausePoints": ["段落終了", "リスト項目間"]
  }
}