SEO Architect
Run ID: 69cd33ad3e7fb09ff16a8f1d2026-04-01SEO & Growth
PantheraHive BOS
BOS Dashboard

SEO Site Architecture Design: Comprehensive Strategy

Project: SEO Architect Workflow - Step 2 of 3

This document outlines the comprehensive SEO site architecture design, providing a strategic blueprint for optimizing a website for search engine visibility and user experience. This architecture is designed for scalability, topical authority, and efficient crawlability, suitable for new sites or major redesigns.


1. Project Overview & Objectives

Goal: To establish a robust, search engine-friendly site architecture that facilitates optimal crawling, indexing, and ranking for target keywords while providing an intuitive and engaging user experience.

Key Objectives:


2. Core Principles of SEO Site Architecture

The proposed architecture is built upon the following foundational principles:


3. Proposed Site Architecture Model: Combined Silos & Hub-and-Spoke

We recommend a hybrid model that combines Content Siloing with a Hub-and-Spoke approach. This strategy allows for strong topical segmentation while also creating powerful internal linking structures around pillar content.

High-Level Structure:

  1. Homepage: The central authority, linking to main categories/pillar pages.
  2. Main Categories (Silos): Broad topics, each acting as a top-level content silo.
  3. Sub-Categories/Pillar Pages (Hubs): More specific topics within a main category, serving as the "hub" for related content.
  4. Supporting Content (Spokes): Detailed articles, product pages, or resources that elaborate on sub-category topics and link back to their respective hubs.

Visual Representation (Conceptual):

text • 659 chars
Homepage
  ├── Main Category 1 (Silo)
  │     ├── Sub-Category A / Pillar Page 1 (Hub)
  │     │     ├── Supporting Article 1.1 (Spoke)
  │     │     ├── Supporting Article 1.2 (Spoke)
  │     │     └── Supporting Article 1.3 (Spoke)
  │     ├── Sub-Category B / Pillar Page 2 (Hub)
  │     │     ├── Supporting Article 2.1 (Spoke)
  │     │     └── Supporting Article 2.2 (Spoke)
  │     └── ...
  ├── Main Category 2 (Silo)
  │     ├── Sub-Category C / Pillar Page 3 (Hub)
  │     │     ├── Supporting Article 3.1 (Spoke)
  │     │     └── Supporting Article 3.2 (Spoke)
  │     └── ...
  └── Other Important Pages (e.g., About Us, Contact, Privacy Policy)
Sandboxed live preview

SEO Site Architecture Design: Comprehensive Strategy

This document outlines a comprehensive SEO site architecture designed to maximize organic visibility, improve user experience, and establish strong topical authority for your website. This strategy encompasses URL structure, internal linking, content siloing, hub-and-spoke models, and critical technical SEO specifications.


1. URL Structure Strategy

A well-designed URL structure is fundamental for both search engine crawlability and user comprehension. Our strategy focuses on creating logical, clean, and keyword-rich URLs.

1.1 Core Principles:

  • Hierarchical & Logical: URLs will reflect the site's information architecture, making the user's and search engine's journey clear.
  • User-Friendly: Easy to read, understand, and remember.
  • Keyword-Rich: Include primary keywords where appropriate, without keyword stuffing.
  • Concise: Shorter URLs are generally preferred.
  • Static: Avoid dynamic parameters where possible.
  • Lowercase: All URLs will use lowercase characters to prevent duplicate content issues.
  • Hyphens as Separators: Use hyphens (-) for word separation, not underscores (_).
  • No Special Characters: Avoid special characters, spaces, or unnecessary punctuation.
  • Trailing Slashes: Ensure consistency (e.g., always include or always omit, typically include for directories).

1.2 Proposed URL Patterns:

| Content Type | Example Pattern | Rationale |

| :------------------ | :-------------------------------------------------- | :------------------------------------------------------------------------------- |

| Homepage | https://www.yourdomain.com/ | Root domain. |

| Primary Category| https://www.yourdomain.com/category-name/ | Clear, broad topic identifier. |

| Sub-Category | https://www.yourdomain.com/category-name/sub-category-name/ | Reflects hierarchy, allows for deeper keyword targeting. |

| Product Page | https://www.yourdomain.com/category-name/product-name/ or https://www.yourdomain.com/products/product-name/ | Direct and descriptive. |

| Service Page | https://www.yourdomain.com/services/service-name/ | Clear identification for service offerings. |

| Blog Post | https://www.yourdomain.com/blog/post-title-keyword/ | Standard blog structure, allows for keyword-rich titles. |

| Pillar Page | https://www.yourdomain.com/pillar-topic-name/ | Often at a higher level, acting as a hub for a broad topic. |

| About Us/Contact| https://www.yourdomain.com/about-us/ | Standard, easily recognizable informational pages. |

1.3 Implementation Notes:

  • 301 Redirects: For any existing URLs that will change, implement permanent (301) redirects to preserve SEO value.
  • Canonicalization: Use canonical tags (<link rel="canonical" href="...">) on pages with identical or very similar content to specify the preferred URL.
  • URL Parameter Handling: Minimize the use of URL parameters. If unavoidable (e.g., for filtering/sorting), use rel="canonical" and configure Google Search Console to handle them appropriately.

2. Internal Linking Strategy

A robust internal linking strategy is crucial for distributing "link equity" (PageRank), defining site hierarchy, and guiding both users and search engine crawlers through your content.

2.1 Key Objectives:

  • Improve Crawlability & Indexing: Ensure all important pages are discoverable by search engines.
  • Distribute PageRank: Pass authority from stronger pages to weaker but important pages.
  • Enhance User Experience: Help users navigate the site and find related content easily.
  • Define Site Structure: Reinforce topical relationships between pages.
  • Boost Keyword Rankings: Use keyword-rich anchor text to signal relevance for target keywords.

2.2 Linking Mechanisms:

  • Global Navigation (Main Menu):

* Links to primary categories, pillar pages, and essential sections.

* Should be clear, concise, and consistent across the site.

* Utilize drop-down menus for sub-categories where appropriate, ensuring they are crawlable.

  • Breadcrumbs:

* Provide a clear path from the homepage to the current page.

* Enhance user navigation and reinforce site hierarchy for search engines.

* Implement with Schema.org BreadcrumbList markup.

  • Contextual Links (In-Content):

* Most powerful form of internal linking.

* Integrate links naturally within the body text of articles, product descriptions, and service pages.

* Use descriptive, varied, and keyword-rich anchor text that accurately reflects the linked page's content.

* Prioritize linking to deeper, relevant content within the same silo or to related hub pages.

  • Footer Navigation:

* Links to less prominent but important pages (e.g., privacy policy, terms of service, contact, sitemap).

* Can also include links to key category or service pages.

  • Related Content Widgets/Sections:

* "Related Posts," "You Might Also Like," or "Customers Also Viewed" sections.

* Programmatically link to other relevant content based on tags, categories, or content similarity.

  • Sitemaps (HTML & XML):

* HTML Sitemap: A user-facing page listing all major pages, aiding navigation for both users and crawlers.

* XML Sitemap: Submitted to search engines to help them discover and prioritize pages for crawling.

2.3 Anchor Text Best Practices:

  • Descriptive: Clearly indicate what the linked page is about.
  • Keyword-Rich: Incorporate relevant keywords, but avoid exact match keyword stuffing.
  • Varied: Use a range of anchor texts for the same target page to avoid over-optimization penalties.
  • Concise: Keep anchor text brief and to the point.
  • Natural: Links should flow naturally within the content.

2.4 Link Depth & Orphan Pages:

  • Link Depth: Aim to keep all important pages within 3-4 clicks from the homepage.
  • Orphan Pages: Regularly audit for pages with no internal links pointing to them. These pages are difficult for users and search engines to find and should be integrated into the internal linking structure.

3. Content Silos

Content siloing is the strategic grouping of related content into distinct, thematically strong categories. This establishes topical authority, improves crawlability, and enhances the relevance of your pages for specific keywords.

3.1 Definition & Benefits:

  • Definition: A content silo is a logical grouping of interlinked web pages that are all related to a specific topic or theme, forming a distinct "column" of authority within your website.
  • Benefits:

* Topical Authority: Signals to search engines that your site is an expert on a specific subject.

* Improved Relevancy: Concentrates link equity and contextual relevance within a topic.

* Better Rankings: Helps individual pages and the entire silo rank higher for target keywords.

* Enhanced User Experience: Makes it easier for users to find comprehensive information on a topic.

* Streamlined Crawling: Guides search engine bots through related content efficiently.

3.2 Structure & Implementation:

  • Identify Core Themes: Begin by identifying 3-7 broad, overarching topics relevant to your business. These will form your main silos.
  • Map Sub-Topics: For each core theme, brainstorm and map out all related sub-topics, articles, and pages.
  • Hierarchical Linking:

* Vertical Linking: Strong links from the main category page (the "pillar" or "hub") down to sub-category pages and individual articles.

Horizontal Linking: Strong internal links between* pages within the same silo (e.g., related blog posts within the same category).

* Limited Cross-Silo Linking: Minimize direct links between different silos, except for very high-level, relevant connections (e.g., from a blog post in one silo to a service page in another, if genuinely relevant).

  • URL Structure Reinforcement: Your URL structure should visually reinforce your silos (e.g., /category/subcategory/article).

3.3 Example Silo Structure: "Digital Marketing Services"

  • Main Silo Page (Category): /digital-marketing-services/

* Sub-Silo Page 1: /digital-marketing-services/seo-services/

* Article 1: /digital-marketing-services/seo-services/local-seo-guide/

* Article 2: /digital-marketing-services/seo-services/technical-seo-checklist/

* Article 3: /digital-marketing-services/seo-services/keyword-research-tactics/

* Internal Links: SEO Services page links to all 3 articles. Articles link back to SEO Services page and to each other where relevant.

* Sub-Silo Page 2: /digital-marketing-services/ppc-management/

* Article 1: /digital-marketing-services/ppc-management/google-ads-setup/

* Article 2: /digital-marketing-services/ppc-management/facebook-ads-roi/

* Internal Links: PPC Management page links to both articles. Articles link back to PPC Management page and to each other where relevant.


4. Hub-and-Spoke Models (Pillar Content Strategy)

The Hub-and-Spoke model is an advanced form of content siloing that designates a central, comprehensive "Hub" page (often called a Pillar page) and surrounds it with detailed "Spoke" pages (supporting content).

4.1 Definition & Benefits:

  • Hub Page (Pillar Content): A comprehensive, high-level overview of a broad topic. It targets a broad keyword and provides a general understanding, linking out to all related Spoke pages. It does not go into deep detail on any single sub-topic.
  • Spoke Pages (Cluster Content): Detailed articles, guides, or resources that dive deep into specific sub-topics related to the Hub. Each Spoke page targets a more specific, long-tail keyword.
  • Benefits:

* Establishes Authority: Clearly demonstrates expertise on a broad topic by linking to many related, in-depth resources.

* Improved Rankings: Helps the Hub page rank for broad keywords and the Spoke pages rank for long-tail keywords.

* Strong Internal Linking: Creates a highly efficient link structure, passing authority effectively.

* Enhanced User Journey: Provides users with a clear path from general information to specific details.

4.2 Structure & Linking Rules:

  • Hub Page:

Links to every* Spoke page within its cluster.

Does not* link directly to other Hub pages (unless absolutely necessary and highly relevant, with careful consideration).

Does not* link out to external sites for core content.

  • Spoke Pages:

* Link back to their parent Hub page.

Can link to other relevant Spoke pages within the same cluster* where appropriate.

* Can link to relevant external resources.

4.3 Example Hub-and-Spoke Model: "Content Marketing"

  • Hub Page (Pillar): /content-marketing-strategy/

* Content: High-level overview of content marketing, its importance, key components (planning, creation, distribution, measurement).

* Keywords: "Content Marketing Strategy," "What is Content Marketing."

* Internal Links (to Spokes):

* "How to Conduct Keyword Research for Content"

* "Developing a Content Calendar"

* "Content Promotion Strategies"

* "Measuring Content Marketing ROI"

* "Types of Content: Blog Posts, Videos, Infographics"

  • Spoke Page 1: /content-marketing-strategy/keyword-research-for-content/

* Content: Detailed guide on keyword research tools, techniques, and strategies specifically for content creation.

* Keywords: "Keyword research tools," "long-tail keywords content," "SEO keyword strategy."

* Internal Link (back to Hub): "Learn more about overall content marketing strategy."

  • Spoke Page 2: /content-marketing-strategy/content-calendar-development/

* Content: Step-by-step guide to creating an effective content calendar, including templates and best practices.

* Keywords: "Content calendar template," "how to plan content," "editorial calendar."

* Internal Link (back to Hub): "Return to the comprehensive content marketing strategy guide."

  • (Additional Spoke Pages follow the same pattern)

5. Technical SEO Specifications

Technical SEO ensures that search engines can efficiently crawl, index, and understand your website's content. These specifications are critical for foundational SEO success.

5.1 Crawlability & Indexability:

  • XML Sitemaps:

* Generate and submit an XML sitemap to Google Search Console and Bing Webmaster Tools.

* Ensure the sitemap includes all canonical, indexable URLs and is kept up-to-date automatically.

* Exclude non-indexable pages (e.g., login pages, duplicate content, filtered results) from the sitemap.

  • Robots.txt:

* Correctly configure robots.txt to guide search engine crawlers.

* Disallow pages or sections that should not be crawled (e.g., admin areas, internal search results).


4. Detailed Architectural Components

4.1. URL Structure Design

The URL structure will be clean, semantic, human-readable, and keyword-rich, reflecting the site's hierarchical organization.

Specifications:

  • HTTPS: All URLs must use HTTPS for security and SEO benefits.
  • Hyphens: Use hyphens (-) as word separators, not underscores (_).
  • Lowercase: All URLs should be lowercase to prevent duplicate content issues.
  • Conciseness: Keep URLs as short as possible while remaining descriptive.
  • Keyword Inclusion: Integrate primary keywords where natural and relevant.
  • Avoid IDs & Parameters: Minimize the use of numerical IDs or dynamic parameters unless absolutely necessary (e.g., filtered results, pagination). If parameters are used, implement proper canonicalization and robots.txt directives.
  • Trailing Slashes: Standardize on one convention (e.g., always use trailing slashes for directories, never for files) and enforce with redirects.

Proposed Structure Examples:

  • Homepage: https://www.yourdomain.com/
  • Main Category Page: https://www.yourdomain.com/category-name/
  • Sub-Category/Pillar Page: https://www.yourdomain.com/category-name/sub-category-name/
  • Product/Service Page: https://www.yourdomain.com/category-name/sub-category-name/product-service-keyword/
  • Blog/Article Page: https://www.yourdomain.com/blog/topic-name/article-title-keyword/ (or https://www.yourdomain.com/topic-name/article-title-keyword/ if blog is integrated into main hierarchy)
  • Author Pages: https://www.yourdomain.com/author/author-name/
  • Static Pages: https://www.yourdomain.com/about-us/, https://www.yourdomain.com/contact/

Actionable Steps:

  • Map out the complete URL path for all existing and planned content.
  • Implement 301 redirects for any legacy URLs during a redesign.
  • Ensure the CMS automatically generates SEO-friendly URLs based on page titles, with manual override capabilities.

4.2. Content Siloing & Topic Clusters

Content siloing is crucial for establishing topical authority and directing PageRank efficiently.

Strategy:

  • Physical Silos: Create distinct directory structures on the server that physically separate related content.

* Example: All content related to "Digital Marketing" resides under /digital-marketing/, with sub-directories for /digital-marketing/seo/, /digital-marketing/ppc/, etc.

  • Logical Silos: Reinforce physical silos with internal linking, ensuring that pages within a silo primarily link to other pages within the same silo. Cross-silo linking should be minimal and highly strategic.
  • Topic Clusters: Each silo will contain multiple topic clusters, with a "pillar page" acting as the central hub for each cluster.

Actionable Steps:

  • Conduct thorough keyword research to identify core topics and sub-topics.
  • Group related keywords into content clusters.
  • Design the directory structure to mirror these clusters.
  • Audit existing content to fit into the new silo structure, identifying gaps or redundant content.

4.3. Internal Linking Strategy

A robust internal linking strategy is vital for distributing PageRank, improving crawlability, and guiding users through the site.

Specifications:

  • Contextual Links: Include relevant, descriptive, and keyword-rich anchor text in the body of content.

Example:* "Learn more about our [advanced SEO techniques](/digital-marketing/seo/advanced-seo/)."

  • Navigational Links:

* Main Navigation: Clear, concise links to main categories and pillar pages.

* Breadcrumbs: Implement breadcrumbs on all sub-pages to show users their location within the hierarchy and provide additional internal links.

Example:* Home > Category > Sub-Category > Current Page

* Footer Navigation: Include links to important static pages (e.g., About Us, Contact, Privacy Policy, Terms of Service).

  • Silo-Specific Linking: Pages within a silo should heavily link to other pages within that same silo, especially to the pillar page.
  • Hub-and-Spoke Linking:

* The Hub (Pillar Page) links out to all Spoke (Supporting) Pages within its cluster.

* All Spoke Pages link back to their respective Hub Page.

Spoke pages can also link to other highly relevant spoke pages within the same* cluster.

  • Link Depth: Aim for important pages to be no more than 3-4 clicks from the homepage.
  • Anchor Text Optimization: Use descriptive and varied anchor text, incorporating relevant keywords naturally. Avoid generic "click here."
  • Image Links: Use alt text for images used as links, as alt text functions as anchor text for image links.

Actionable Steps:

  • Develop an internal linking matrix for each content cluster.
  • Train content creators on best practices for internal linking.
  • Regularly audit internal links for broken links, orphaned pages, and optimization opportunities.

4.4. Hub-and-Spoke Model Implementation

The Hub-and-Spoke model (also known as the Topic Cluster model) is a powerful way to organize content around central themes.

Implementation Details:

  • Hub Pages (Pillar Content):

* Comprehensive, high-quality content covering a broad topic in depth.

* Targets broad, high-volume keywords.

* Links to all supporting "spoke" content.

* Often longer-form content (2000+ words).

* Examples: "The Ultimate Guide to SEO," "Complete Beginner's Guide to Digital Marketing."

  • Spoke Pages (Cluster Content):

* Detailed articles, guides, or product pages that dive deep into specific sub-topics derived from the hub page.

* Targets long-tail keywords related to the hub.

* Links back to the hub page using relevant anchor text.

* Can link to other relevant spoke pages within the same cluster.

* Examples: "How to Conduct Keyword Research," "On-Page SEO Checklist," "Link Building Strategies for Small Businesses" (all linking back to "The Ultimate Guide to SEO").

Actionable Steps:

  • Identify core broad topics that can serve as pillar pages.
  • Map out all related long-tail keywords and content ideas that will become spoke pages.
  • Create a content calendar that prioritizes pillar page creation and subsequent spoke content development.

4.5. Navigation & User Experience (UX) Considerations

A well-designed navigation system is critical for both users and search engines.

Specifications:

  • Primary Navigation: Clear, concise, and consistent across the entire site. Use logical grouping for main categories.
  • Secondary/Footer Navigation: For less critical but important pages (e.g., legal, contact, careers).
  • Breadcrumbs: Implement on all pages below the homepage. They provide context and additional internal links.
  • Search Functionality: Implement a robust internal search engine to help users find specific content quickly. Optimize internal search results for SEO.
  • Sitemaps (HTML): Create an HTML sitemap for users, providing an organized overview of the site's structure.
  • Mobile-First Design: Ensure the navigation is fully responsive and user-friendly on all device types.
  • Clickable Elements: Ensure all navigation elements are easily clickable and accessible.

Actionable Steps:

  • Conduct user testing on navigation paths.
  • Regularly review internal search queries to identify content gaps or navigation issues.
  • Prioritize mobile responsiveness in design and development.

5. Technical SEO Specifications

Solid technical SEO forms the foundation for any successful site architecture.

Key Specifications:

  • XML Sitemaps:

* Generate and maintain accurate XML sitemaps (e.g., sitemap.xml, sitemap_images.xml, sitemap_videos.xml).

* Include only canonical, indexable URLs.

* Submit sitemaps to Google Search Console and Bing Webmaster Tools.

* Update sitemaps automatically with new content.

  • Robots.txt:

* Use robots.txt to control crawler access to specific areas (e.g., /wp-admin/, /temp-pages/, /thank-you-pages/).

* Ensure no valuable, indexable content is blocked.

* Reference the XML sitemap location within robots.txt.

  • Canonical Tags (rel="canonical"):

* Implement canonical tags on all pages to prevent duplicate content issues (e.g., for pagination, filtered results, or HTTP/HTTPS versions).

* Self-referencing canonicals should be used on all unique pages.

  • Schema Markup (Structured Data):

* Implement relevant Schema.org markup (e.g., Organization, Website, BreadcrumbList, Article, Product, FAQPage, LocalBusiness, Review).

* Use JSON-LD format.

* Test implementation using Google's Rich Results Test tool.

  • Mobile-Friendliness:

* Ensure responsive design for all content and layouts.

* Prioritize Core Web Vitals (LCP, FID, CLS) for mobile users.

* Test using Google's Mobile-Friendly Test tool.

  • Site Speed & Performance (Core Web Vitals):

* Optimize image sizes and formats (e.g., WebP).

* Minify CSS, JavaScript, and HTML.

* Leverage browser caching.

* Implement server-side rendering (SSR) or static site generation (SSG) where appropriate.

* Use a Content Delivery Network (CDN).

* Regularly monitor performance with Google PageSpeed Insights and Lighthouse.

  • HTTPS (SSL/TLS):

* Ensure all pages are served over HTTPS.

* Implement HSTS (HTTP Strict Transport Security) header.

  • Hreflang Tags (for International SEO):

* If targeting multiple languages or regions, implement hreflang tags correctly to signal language and geographical targeting to search engines.

  • Error Pages (404):

* Create custom, user-friendly 404 pages that include navigation options and a search bar.

* Ensure 404 pages return the correct HTTP status code.

  • Redirects:

* Use 301 (Permanent) redirects for any changed URLs or merged content.

* Avoid redirect chains (multiple redirects).

  • Crawl Budget Optimization:

* Minimize low-value pages and ensure only important content is easily discoverable.

* Use noindex for pages not intended for search engines (e.g., thank you pages, internal search results).

  • Accessibility (A11Y):

* Adhere to WCAG guidelines for web accessibility, benefiting both users and SEO.

* Use proper semantic HTML.

* Provide alt text for all images.

Actionable Steps:

  • Conduct a full technical SEO audit
gemini Output

SEO Site Architecture Design: Comprehensive Strategy

Project: SEO Architect Design

Date: October 26, 2023

Deliverable: Complete SEO Site Architecture Strategy

Prepared For: [Client Name/Organization]


1. Executive Summary

This document outlines a comprehensive SEO site architecture design, meticulously crafted to maximize organic search visibility, improve user experience, and ensure long-term scalability. It covers critical aspects including URL structure, internal linking strategies (including content silos and hub-and-spoke models), and essential technical SEO specifications. This architecture is designed to be robust, intuitive for both users and search engines, and future-proof, serving as a foundational blueprint for new sites or significant redesigns.

2. Core Principles of SEO Architecture

Our architectural design is built upon the following fundamental principles:

  • Clarity & Simplicity: Easy for users to navigate and for search engines to crawl and understand.
  • Topical Authority: Grouping related content to establish deep expertise in specific areas, boosting relevance and rankings.
  • Crawlability & Indexability: Ensuring search engines can efficiently discover, crawl, and index all valuable content.
  • User Experience (UX): Optimizing for fast loading times, mobile responsiveness, and intuitive navigation.
  • Scalability: Designing a structure that can easily accommodate future content expansion without compromising SEO performance.
  • Keyword Integration: Strategically incorporating target keywords into URLs, headings, and content for enhanced relevance.

3. URL Structure Design

A well-defined URL structure is hierarchical, descriptive, and consistent. It acts as a breadcrumb for both users and search engines, indicating the location and relevance of a page within the site.

3.1. General Principles

  • Readability: URLs should be human-readable and convey the page's content at a glance.
  • Keyword Inclusion: Integrate primary keywords naturally where appropriate, but avoid keyword stuffing.
  • Hierarchy: Reflect the site's logical structure, moving from broader categories to more specific pages.
  • Consistency: Maintain a uniform structure across the entire site.
  • Conciseness: Keep URLs as short as possible while retaining descriptiveness.
  • Static & Clean: Avoid dynamic parameters (e.g., ?id=123) where possible; use hyphens (-) for word separation.
  • Lowercase: All URLs should be lowercase to prevent duplicate content issues.
  • HTTPS: All URLs must use HTTPS for security and SEO benefits.

3.2. Recommended URL Structure Examples

Let's assume a hypothetical e-commerce site selling "Outdoor Gear":

  • Homepage: https://www.example.com/
  • Primary Categories (Silos):

* https://www.example.com/camping/

* https://www.example.com/hiking/

* https://www.example.com/climbing/

  • Subcategories (within a Silo):

* https://www.example.com/camping/tents/

* https://www.example.com/camping/sleeping-bags/

* https://www.example.com/hiking/backpacks/

  • Product/Article Pages (Leaf Nodes):

* https://www.example.com/camping/tents/lightweight-2-person-tent/

* https://www.example.com/hiking/backpacks/adventure-trek-60l-backpack/

* https://www.example.com/blog/best-camping-tents-for-beginners/ (Blog articles typically reside under a /blog/ or /resources/ segment)

3.3. Canonicalization

  • Implement rel="canonical" tags on all pages to specify the preferred version of a URL, preventing duplicate content issues (e.g., for pages accessible via multiple paths, filtered results, or print versions).
  • Ensure the canonical URL points to the self-referencing preferred version for unique pages.

4. Content Siloing Strategy

Content siloing is a method of organizing a website's content into distinct, thematically related groups. This strengthens topical authority, improves relevance for specific keywords, and enhances internal linking power.

4.1. Benefits of Content Siloing

  • Enhanced Topical Authority: Signals to search engines that the site is a comprehensive resource on specific subjects.
  • Improved Keyword Relevance: Concentrates keyword themes, helping pages rank for more specific and competitive terms.
  • Stronger Internal Linking: Facilitates a logical flow of link equity within a silo, boosting the authority of key pages.
  • Better User Experience: Helps users find related content more easily.

4.2. Identifying Core Topics/Silos

  1. Keyword Research: Identify broad, high-volume keywords that represent major categories of your business/content.
  2. Competitor Analysis: Analyze how successful competitors structure their content.
  3. User Intent: Group content based on distinct user needs or problem areas.
  4. Business Objectives: Align silos with primary products, services, or knowledge areas.

4.3. Silo Structure (Conceptual Example)

Let's continue with the "Outdoor Gear" example:

  • Homepage (Root Authority)

* Silo 1: Camping Gear

* Sub-category 1: Tents

* Sub-category 2: Sleeping Bags

* Sub-category 3: Cooking Equipment

* Blog Posts: "Best Tents for Backpacking," "Camping Checklist," "How to Choose a Sleeping Bag"

* Silo 2: Hiking & Backpacking

* Sub-category 1: Backpacks

* Sub-category 2: Hiking Boots

* Sub-category 3: Navigation Tools

* Blog Posts: "Top 10 Hiking Trails," "Guide to Choosing a Backpack," "Hiking Safety Tips"

* Silo 3: Climbing Equipment

* Sub-category 1: Ropes

* Sub-category 2: Harnesses

* Sub-category 3: Helmets

* Blog Posts: "Beginner's Guide to Rock Climbing," "Essential Climbing Gear," "Climbing Safety"

4.4. Implementation

  • Directory Structure: Use a clear URL directory structure (as described in Section 3) to physically separate silos.
  • Internal Linking: Confine most internal links to within the same silo, only linking to other silos when absolutely necessary and contextually relevant.

5. Internal Linking Strategy: Hub-and-Spoke Model

The hub-and-spoke model is a powerful internal linking strategy that leverages content silos to distribute link equity and establish topical authority effectively.

5.1. Definition & Benefits

  • Hub Page: A high-level, comprehensive page (often a category page, pillar page, or ultimate guide) that covers a broad topic within a silo. It serves as the central "hub" of information.
  • Spoke Pages: Detailed, specific pages (e.g., product pages, sub-category pages, blog posts, FAQs) that dive deeper into sub-topics related to the hub. They "spoke out" from the hub.
  • Benefits:

* Concentrates Link Equity: Directs internal link juice from spokes back to the hub, boosting its authority.

* Establishes Topical Relevance: Clearly signals to search engines the relationship between content.

* Improved Crawlability: Ensures all related content is easily discovered by crawlers.

* Enhanced User Journey: Guides users through related content, improving engagement.

5.2. Hub Page Characteristics

  • Comprehensive: Offers a broad overview of the silo's main topic.
  • High-Quality Content: Well-researched, detailed, and authoritative.
  • Strategic Internal Links: Links out to all relevant spoke pages within its silo.
  • Receives Links: Receives internal links from its spoke pages and often from the homepage or global navigation.
  • Target Keywords: Ranks for broad, high-volume keywords.
  • Example: https://www.example.com/camping/ (The main "Camping" category page).

5.3. Spoke Page Characteristics

  • Specific: Focuses on a niche sub-topic related to the hub.
  • Detailed: Provides in-depth information, answers specific questions, or describes a particular product/service.
  • Contextual Internal Links: Links back to its hub page and potentially to other relevant spoke pages within the same silo.
  • Target Keywords: Ranks for long-tail keywords or more specific phrases.
  • Example: https://www.example.com/camping/tents/lightweight-2-person-tent/ or https://www.example.com/blog/best-tents-for-backpacking/

5.4. Linking Patterns

  1. Hub to Spoke: The hub page should link to all relevant spoke pages within its silo. These links should be natural and contextually relevant (e.g., "For more details on lightweight tents, see our [lightweight 2-person tent product page](link to spoke).").
  2. Spoke to Hub: Each spoke page should link back to its primary hub page. This is crucial for passing link equity up to the hub. Anchor text should be relevant to the hub's main topic (e.g., "Return to our comprehensive [Camping Gear Guide](link to hub).").
  3. Spoke to Spoke (within same silo): Spoke pages can link to other highly relevant spoke pages within the same silo to create a dense network of related content. Avoid linking to spokes in other silos unless absolutely necessary and highly contextual.
  4. Global Navigation: The main navigation should reflect the primary silos (hub pages). Breadcrumbs should clearly show the path from the homepage to the current page.

5.5. Anchor Text Strategy

  • Descriptive & Keyword-Rich: Use anchor text that accurately describes the linked page's content and includes relevant keywords (e.g., "lightweight hiking backpacks" instead of "click here").
  • Vary Anchor Text: While keyword-rich, vary anchor text naturally to avoid over-optimization penalties. Use synonyms and related phrases.
  • Contextual: Anchor text should flow naturally within the surrounding text.

6. Technical SEO Specifications

Technical SEO ensures that search engines can efficiently crawl, index, and understand your site's content.

6.1. Crawlability & Indexability

  • Robots.txt:

* Create and maintain a robots.txt file at the root of the domain.

* Use it to block search engine crawlers from accessing irrelevant or duplicate content (e.g., internal search results, admin pages, staging environments).

* Include a link to your XML sitemap.

  • XML Sitemaps:

* Generate and submit a comprehensive XML sitemap (or multiple sitemaps for large sites) to Google Search Console and Bing Webmaster Tools.

* Include all canonical URLs of pages you want indexed.

* Exclude noindex pages, duplicate content, and blocked URLs.

* Update sitemaps regularly as content changes.

  • HTML Sitemaps:

* Consider creating an HTML sitemap for very large sites to aid user navigation and provide an additional crawl path for search engines.

  • Noindex/Nofollow Directives:

* Use meta name="robots" content="noindex, follow" for pages that should not appear in search results but whose links should still be followed (e.g., thank-you pages, login pages).

* Use meta name="robots" content="noindex, nofollow" for pages that should not be indexed and whose links should not pass equity (e.g., deprecated content).

* Use rel="nofollow" on individual links to prevent link equity transfer, typically for user-generated content, sponsored links, or untrusted external links.

  • Parameter Handling:

* Use Google Search Console's URL Parameters tool to instruct Google on how to handle dynamic URL parameters (e.g., ?color=red, ?sort=price).

  • Crawl Budget Optimization:

* Minimize redirect chains.

* Clean up broken links (404s).

* Reduce reliance on JavaScript for core content and navigation (or ensure it's crawlable).

* Optimize internal linking to prioritize important pages.

6.2. Performance & User Experience (UX)

  • Page Speed (Core Web Vitals):

* Largest Contentful Paint (LCP): Optimize image sizes, lazy load offscreen images, use efficient server responses.

* First Input Delay (FID): Minimize JavaScript execution time, optimize third-party scripts.

* Cumulative Layout Shift (CLS): Specify image dimensions, ensure ads and embeds have reserved space, avoid injecting content above existing content.

* Implement image optimization (compression, WebP format).

* Leverage browser caching.

* Minify CSS, JavaScript, and HTML.

* Utilize Content Delivery Networks (CDNs).

  • Mobile-First Indexing:

* Ensure the mobile version of the site contains all critical content and functionality present on the desktop version.

* Use responsive design for a consistent experience across devices.

* Ensure mobile pages load quickly.

  • Structured Data (Schema Markup):

* Implement relevant Schema.org markup (e.g., Organization, Product, Article, FAQPage, BreadcrumbList, LocalBusiness, Review) to provide context to search engines and enable rich results.

* Validate all schema markup using Google's Rich Results Test.

  • Accessibility (A11y):

* Ensure all images have descriptive alt text.

* Use semantic HTML.

* Provide keyboard navigation.

* Ensure sufficient color contrast.

6.3. Security

  • HTTPS Enforcement:

* Ensure all pages load securely via HTTPS.

* Implement 301 redirects from HTTP to HTTPS for all legacy HTTP URLs.

* Renew SSL certificates promptly.

6.4. Internationalization (If Applicable)

  • Hreflang Tags:

* For sites serving multiple languages or regions, implement hreflang tags to indicate language and geographical targeting to search engines.

* Ensure bidirectional linking between equivalent pages.

  • Domain Strategy:

* Choose a clear domain strategy: ccTLDs (.de, .fr), subdirectories (example.com/fr/), or subdomains (fr.example.com). Subdirectories are generally preferred for consolidating domain authority.

6.5. Error Handling &

seo_architect.txt
Download source file
Copy all content
Full output as text
Download ZIP
IDE-ready project ZIP
Copy share link
Permanent URL for this run
Get Embed Code
Embed this result on any website
Print / Save PDF
Use browser print dialog
"); var hasSrcMain=Object.keys(extracted).some(function(k){return k.indexOf("src/main")>=0;}); if(!hasSrcMain) zip.file(folder+"src/main."+ext,"import React from 'react' import ReactDOM from 'react-dom/client' import App from './App' import './index.css' ReactDOM.createRoot(document.getElementById('root')!).render( ) "); var hasSrcApp=Object.keys(extracted).some(function(k){return k==="src/App."+ext||k==="App."+ext;}); if(!hasSrcApp) zip.file(folder+"src/App."+ext,"import React from 'react' import './App.css' function App(){ return(

"+slugTitle(pn)+"

Built with PantheraHive BOS

) } export default App "); zip.file(folder+"src/index.css","*{margin:0;padding:0;box-sizing:border-box} body{font-family:system-ui,-apple-system,sans-serif;background:#f0f2f5;color:#1a1a2e} .app{min-height:100vh;display:flex;flex-direction:column} .app-header{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px;padding:40px} h1{font-size:2.5rem;font-weight:700} "); zip.file(folder+"src/App.css",""); zip.file(folder+"src/components/.gitkeep",""); zip.file(folder+"src/pages/.gitkeep",""); zip.file(folder+"src/hooks/.gitkeep",""); Object.keys(extracted).forEach(function(p){ var fp=p.startsWith("src/")?p:"src/"+p; zip.file(folder+fp,extracted[p]); }); zip.file(folder+"README.md","# "+slugTitle(pn)+" Generated by PantheraHive BOS. ## Setup ```bash npm install npm run dev ``` ## Build ```bash npm run build ``` ## Open in IDE Open the project folder in VS Code or WebStorm. "); zip.file(folder+".gitignore","node_modules/ dist/ .env .DS_Store *.local "); } /* --- Vue (Vite + Composition API + TypeScript) --- */ function buildVue(zip,folder,app,code,panelTxt){ var pn=pkgName(app); var C=cc(pn); var extracted=extractCode(panelTxt); zip.file(folder+"package.json",'{ "name": "'+pn+'", "version": "0.0.0", "type": "module", "scripts": { "dev": "vite", "build": "vue-tsc -b && vite build", "preview": "vite preview" }, "dependencies": { "vue": "^3.5.13", "vue-router": "^4.4.5", "pinia": "^2.3.0", "axios": "^1.7.9" }, "devDependencies": { "@vitejs/plugin-vue": "^5.2.1", "typescript": "~5.7.3", "vite": "^6.0.5", "vue-tsc": "^2.2.0" } } '); zip.file(folder+"vite.config.ts","import { defineConfig } from 'vite' import vue from '@vitejs/plugin-vue' import { resolve } from 'path' export default defineConfig({ plugins: [vue()], resolve: { alias: { '@': resolve(__dirname,'src') } } }) "); zip.file(folder+"tsconfig.json",'{"files":[],"references":[{"path":"./tsconfig.app.json"},{"path":"./tsconfig.node.json"}]} '); zip.file(folder+"tsconfig.app.json",'{ "compilerOptions":{ "target":"ES2020","useDefineForClassFields":true,"module":"ESNext","lib":["ES2020","DOM","DOM.Iterable"], "skipLibCheck":true,"moduleResolution":"bundler","allowImportingTsExtensions":true, "isolatedModules":true,"moduleDetection":"force","noEmit":true,"jsxImportSource":"vue", "strict":true,"paths":{"@/*":["./src/*"]} }, "include":["src/**/*.ts","src/**/*.d.ts","src/**/*.tsx","src/**/*.vue"] } '); zip.file(folder+"env.d.ts","/// "); zip.file(folder+"index.html"," "+slugTitle(pn)+"
"); var hasMain=Object.keys(extracted).some(function(k){return k==="src/main.ts"||k==="main.ts";}); if(!hasMain) zip.file(folder+"src/main.ts","import { createApp } from 'vue' import { createPinia } from 'pinia' import App from './App.vue' import './assets/main.css' const app = createApp(App) app.use(createPinia()) app.mount('#app') "); var hasApp=Object.keys(extracted).some(function(k){return k.indexOf("App.vue")>=0;}); if(!hasApp) zip.file(folder+"src/App.vue"," "); zip.file(folder+"src/assets/main.css","*{margin:0;padding:0;box-sizing:border-box}body{font-family:system-ui,sans-serif;background:#fff;color:#213547} "); zip.file(folder+"src/components/.gitkeep",""); zip.file(folder+"src/views/.gitkeep",""); zip.file(folder+"src/stores/.gitkeep",""); Object.keys(extracted).forEach(function(p){ var fp=p.startsWith("src/")?p:"src/"+p; zip.file(folder+fp,extracted[p]); }); zip.file(folder+"README.md","# "+slugTitle(pn)+" Generated by PantheraHive BOS. ## Setup ```bash npm install npm run dev ``` ## Build ```bash npm run build ``` Open in VS Code or WebStorm. "); zip.file(folder+".gitignore","node_modules/ dist/ .env .DS_Store *.local "); } /* --- Angular (v19 standalone) --- */ function buildAngular(zip,folder,app,code,panelTxt){ var pn=pkgName(app); var C=cc(pn); var sel=pn.replace(/_/g,"-"); var extracted=extractCode(panelTxt); zip.file(folder+"package.json",'{ "name": "'+pn+'", "version": "0.0.0", "scripts": { "ng": "ng", "start": "ng serve", "build": "ng build", "test": "ng test" }, "dependencies": { "@angular/animations": "^19.0.0", "@angular/common": "^19.0.0", "@angular/compiler": "^19.0.0", "@angular/core": "^19.0.0", "@angular/forms": "^19.0.0", "@angular/platform-browser": "^19.0.0", "@angular/platform-browser-dynamic": "^19.0.0", "@angular/router": "^19.0.0", "rxjs": "~7.8.0", "tslib": "^2.3.0", "zone.js": "~0.15.0" }, "devDependencies": { "@angular-devkit/build-angular": "^19.0.0", "@angular/cli": "^19.0.0", "@angular/compiler-cli": "^19.0.0", "typescript": "~5.6.0" } } '); zip.file(folder+"angular.json",'{ "$schema": "./node_modules/@angular/cli/lib/config/schema.json", "version": 1, "newProjectRoot": "projects", "projects": { "'+pn+'": { "projectType": "application", "root": "", "sourceRoot": "src", "prefix": "app", "architect": { "build": { "builder": "@angular-devkit/build-angular:application", "options": { "outputPath": "dist/'+pn+'", "index": "src/index.html", "browser": "src/main.ts", "tsConfig": "tsconfig.app.json", "styles": ["src/styles.css"], "scripts": [] } }, "serve": {"builder":"@angular-devkit/build-angular:dev-server","configurations":{"production":{"buildTarget":"'+pn+':build:production"},"development":{"buildTarget":"'+pn+':build:development"}},"defaultConfiguration":"development"} } } } } '); zip.file(folder+"tsconfig.json",'{ "compileOnSave": false, "compilerOptions": {"baseUrl":"./","outDir":"./dist/out-tsc","forceConsistentCasingInFileNames":true,"strict":true,"noImplicitOverride":true,"noPropertyAccessFromIndexSignature":true,"noImplicitReturns":true,"noFallthroughCasesInSwitch":true,"paths":{"@/*":["src/*"]},"skipLibCheck":true,"esModuleInterop":true,"sourceMap":true,"declaration":false,"experimentalDecorators":true,"moduleResolution":"bundler","importHelpers":true,"target":"ES2022","module":"ES2022","useDefineForClassFields":false,"lib":["ES2022","dom"]}, "references":[{"path":"./tsconfig.app.json"}] } '); zip.file(folder+"tsconfig.app.json",'{ "extends":"./tsconfig.json", "compilerOptions":{"outDir":"./dist/out-tsc","types":[]}, "files":["src/main.ts"], "include":["src/**/*.d.ts"] } '); zip.file(folder+"src/index.html"," "+slugTitle(pn)+" "); zip.file(folder+"src/main.ts","import { bootstrapApplication } from '@angular/platform-browser'; import { appConfig } from './app/app.config'; import { AppComponent } from './app/app.component'; bootstrapApplication(AppComponent, appConfig) .catch(err => console.error(err)); "); zip.file(folder+"src/styles.css","* { margin: 0; padding: 0; box-sizing: border-box; } body { font-family: system-ui, -apple-system, sans-serif; background: #f9fafb; color: #111827; } "); var hasComp=Object.keys(extracted).some(function(k){return k.indexOf("app.component")>=0;}); if(!hasComp){ zip.file(folder+"src/app/app.component.ts","import { Component } from '@angular/core'; import { RouterOutlet } from '@angular/router'; @Component({ selector: 'app-root', standalone: true, imports: [RouterOutlet], templateUrl: './app.component.html', styleUrl: './app.component.css' }) export class AppComponent { title = '"+pn+"'; } "); zip.file(folder+"src/app/app.component.html","

"+slugTitle(pn)+"

Built with PantheraHive BOS

"); zip.file(folder+"src/app/app.component.css",".app-header{display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:60vh;gap:16px}h1{font-size:2.5rem;font-weight:700;color:#6366f1} "); } zip.file(folder+"src/app/app.config.ts","import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core'; import { provideRouter } from '@angular/router'; import { routes } from './app.routes'; export const appConfig: ApplicationConfig = { providers: [ provideZoneChangeDetection({ eventCoalescing: true }), provideRouter(routes) ] }; "); zip.file(folder+"src/app/app.routes.ts","import { Routes } from '@angular/router'; export const routes: Routes = []; "); Object.keys(extracted).forEach(function(p){ var fp=p.startsWith("src/")?p:"src/"+p; zip.file(folder+fp,extracted[p]); }); zip.file(folder+"README.md","# "+slugTitle(pn)+" Generated by PantheraHive BOS. ## Setup ```bash npm install ng serve # or: npm start ``` ## Build ```bash ng build ``` Open in VS Code with Angular Language Service extension. "); zip.file(folder+".gitignore","node_modules/ dist/ .env .DS_Store *.local .angular/ "); } /* --- Python --- */ function buildPython(zip,folder,app,code){ var title=slugTitle(app); var pn=pkgName(app); var src=code.replace(/^```[w]* ?/m,"").replace(/ ?```$/m,"").trim(); var reqMap={"numpy":"numpy","pandas":"pandas","sklearn":"scikit-learn","tensorflow":"tensorflow","torch":"torch","flask":"flask","fastapi":"fastapi","uvicorn":"uvicorn","requests":"requests","sqlalchemy":"sqlalchemy","pydantic":"pydantic","dotenv":"python-dotenv","PIL":"Pillow","cv2":"opencv-python","matplotlib":"matplotlib","seaborn":"seaborn","scipy":"scipy"}; var reqs=[]; Object.keys(reqMap).forEach(function(k){if(src.indexOf("import "+k)>=0||src.indexOf("from "+k)>=0)reqs.push(reqMap[k]);}); var reqsTxt=reqs.length?reqs.join(" "):"# add dependencies here "; zip.file(folder+"main.py",src||"# "+title+" # Generated by PantheraHive BOS print(title+" loaded") "); zip.file(folder+"requirements.txt",reqsTxt); zip.file(folder+".env.example","# Environment variables "); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. ## Setup ```bash python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt ``` ## Run ```bash python main.py ``` "); zip.file(folder+".gitignore",".venv/ __pycache__/ *.pyc .env .DS_Store "); } /* --- Node.js --- */ function buildNode(zip,folder,app,code){ var title=slugTitle(app); var pn=pkgName(app); var src=code.replace(/^```[w]* ?/m,"").replace(/ ?```$/m,"").trim(); var depMap={"mongoose":"^8.0.0","dotenv":"^16.4.5","axios":"^1.7.9","cors":"^2.8.5","bcryptjs":"^2.4.3","jsonwebtoken":"^9.0.2","socket.io":"^4.7.4","uuid":"^9.0.1","zod":"^3.22.4","express":"^4.18.2"}; var deps={}; Object.keys(depMap).forEach(function(k){if(src.indexOf(k)>=0)deps[k]=depMap[k];}); if(!deps["express"])deps["express"]="^4.18.2"; var pkgJson=JSON.stringify({"name":pn,"version":"1.0.0","main":"src/index.js","scripts":{"start":"node src/index.js","dev":"nodemon src/index.js"},"dependencies":deps,"devDependencies":{"nodemon":"^3.0.3"}},null,2)+" "; zip.file(folder+"package.json",pkgJson); var fallback="const express=require("express"); const app=express(); app.use(express.json()); app.get("/",(req,res)=>{ res.json({message:""+title+" API"}); }); const PORT=process.env.PORT||3000; app.listen(PORT,()=>console.log("Server on port "+PORT)); "; zip.file(folder+"src/index.js",src||fallback); zip.file(folder+".env.example","PORT=3000 "); zip.file(folder+".gitignore","node_modules/ .env .DS_Store "); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. ## Setup ```bash npm install ``` ## Run ```bash npm run dev ``` "); } /* --- Vanilla HTML --- */ function buildVanillaHtml(zip,folder,app,code){ var title=slugTitle(app); var isFullDoc=code.trim().toLowerCase().indexOf("=0||code.trim().toLowerCase().indexOf("=0; var indexHtml=isFullDoc?code:" "+title+" "+code+" "; zip.file(folder+"index.html",indexHtml); zip.file(folder+"style.css","/* "+title+" — styles */ *{margin:0;padding:0;box-sizing:border-box} body{font-family:system-ui,-apple-system,sans-serif;background:#fff;color:#1a1a2e} "); zip.file(folder+"script.js","/* "+title+" — scripts */ "); zip.file(folder+"assets/.gitkeep",""); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. ## Open Double-click `index.html` in your browser. Or serve locally: ```bash npx serve . # or python3 -m http.server 3000 ``` "); zip.file(folder+".gitignore",".DS_Store node_modules/ .env "); } /* ===== MAIN ===== */ var sc=document.createElement("script"); sc.src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"; sc.onerror=function(){ if(lbl)lbl.textContent="Download ZIP"; alert("JSZip load failed — check connection."); }; sc.onload=function(){ var zip=new JSZip(); var base=(_phFname||"output").replace(/.[^.]+$/,""); var app=base.toLowerCase().replace(/[^a-z0-9]+/g,"_").replace(/^_+|_+$/g,"")||"my_app"; var folder=app+"/"; var vc=document.getElementById("panel-content"); var panelTxt=vc?(vc.innerText||vc.textContent||""):""; var lang=detectLang(_phCode,panelTxt); if(_phIsHtml){ buildVanillaHtml(zip,folder,app,_phCode); } else if(lang==="flutter"){ buildFlutter(zip,folder,app,_phCode,panelTxt); } else if(lang==="react-native"){ buildReactNative(zip,folder,app,_phCode,panelTxt); } else if(lang==="swift"){ buildSwift(zip,folder,app,_phCode,panelTxt); } else if(lang==="kotlin"){ buildKotlin(zip,folder,app,_phCode,panelTxt); } else if(lang==="react"){ buildReact(zip,folder,app,_phCode,panelTxt); } else if(lang==="vue"){ buildVue(zip,folder,app,_phCode,panelTxt); } else if(lang==="angular"){ buildAngular(zip,folder,app,_phCode,panelTxt); } else if(lang==="python"){ buildPython(zip,folder,app,_phCode); } else if(lang==="node"){ buildNode(zip,folder,app,_phCode); } else { /* Document/content workflow */ var title=app.replace(/_/g," "); var md=_phAll||_phCode||panelTxt||"No content"; zip.file(folder+app+".md",md); var h=""+title+""; h+="

"+title+"

"; var hc=md.replace(/&/g,"&").replace(//g,">"); hc=hc.replace(/^### (.+)$/gm,"

$1

"); hc=hc.replace(/^## (.+)$/gm,"

$1

"); hc=hc.replace(/^# (.+)$/gm,"

$1

"); hc=hc.replace(/**(.+?)**/g,"$1"); hc=hc.replace(/ {2,}/g,"

"); h+="

"+hc+"

Generated by PantheraHive BOS
"; zip.file(folder+app+".html",h); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. Files: - "+app+".md (Markdown) - "+app+".html (styled HTML) "); } zip.generateAsync({type:"blob"}).then(function(blob){ var a=document.createElement("a"); a.href=URL.createObjectURL(blob); a.download=app+".zip"; a.click(); URL.revokeObjectURL(a.href); if(lbl)lbl.textContent="Download ZIP"; }); }; document.head.appendChild(sc); }function phShare(){navigator.clipboard.writeText(window.location.href).then(function(){var el=document.getElementById("ph-share-lbl");if(el){el.textContent="Link copied!";setTimeout(function(){el.textContent="Copy share link";},2500);}});}function phEmbed(){var runId=window.location.pathname.split("/").pop().replace(".html","");var embedUrl="https://pantherahive.com/embed/"+runId;var code='';navigator.clipboard.writeText(code).then(function(){var el=document.getElementById("ph-embed-lbl");if(el){el.textContent="Embed code copied!";setTimeout(function(){el.textContent="Get Embed Code";},2500);}});}