sovrium 0.0.2

package/src/domain/models/app/page/meta/open-graph.ts

@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { HttpUrlSchema } from '../common/url'
+
+/**
+ * Open Graph content type
+ *
+ * 6 standard Open Graph types for different content:
+ * - website: General websites, landing pages (most common, default)
+ * - article: Blog posts, news articles (adds publish date, author metadata)
+ * - book: Book pages, publications
+ * - profile: Personal or company profiles
+ * - video: Video content pages (enables video embeds in social feeds)
+ * - music: Music content, albums (enables audio players)
+ */
+export const OpenGraphTypeSchema = Schema.Literal(
+  'website',
+  'article',
+  'book',
+  'profile',
+  'video',
+  'music'
+).annotations({
+  description: 'Open Graph object type',
+})
+
+/**
+ * Open Graph locale format
+ *
+ * Language and territory format: [language]_[TERRITORY]
+ * - Pattern: ^[a-z]{2}_[A-Z]{2}$ (2 lowercase + underscore + 2 uppercase)
+ * - Examples: en_US (English, United States), fr_FR (French, France), es_ES (Spanish, Spain)
+ * - Helps platforms show content to the right audience based on language/region
+ */
+export const OpenGraphLocaleSchema = Schema.String.pipe(
+  Schema.pattern(/^[a-z]{2}_[A-Z]{2}$/, {
+    message: () =>
+      'Locale must be in format language_TERRITORY (e.g., en_US, fr_FR, es_ES, de_DE, ja_JP)',
+  })
+).annotations({
+  description: 'Locale in format language_TERRITORY',
+  examples: ['en_US', 'fr_FR', 'es_ES'],
+})
+
+/**
+ * Open Graph determiner
+ *
+ * Grammatical article that appears before the title in share messages.
+ * Used in: "John shared [determiner] [title]"
+ *
+ * 5 options:
+ * - 'a': "Share a Website Builder"
+ * - 'an': "Share an Amazing Product"
+ * - 'the': "Share the Ultimate Guide to SEO"
+ * - 'auto': Platform decides based on title (no article)
+ * - '': Empty string (no article)
+ *
+ * Improves grammar in social sharing messages for better user experience.
+ */
+export const OpenGraphDeterminerSchema = Schema.Literal('a', 'an', 'the', 'auto', '').annotations({
+  description: 'Word that appears before the title',
+})
+
+/**
+ * Open Graph protocol metadata for rich social media sharing
+ *
+ * Defines how pages appear when shared on Facebook, LinkedIn, and other platforms
+ * supporting the Open Graph protocol. Creates rich preview cards with images, titles,
+ * and descriptions to dramatically increase engagement and click-through rates.
+ *
+ * Required properties:
+ * - title: Page title for social sharing (max 90 chars, shorter than page <title>)
+ * - description: Page description (max 200 chars, concise value proposition)
+ * - type: Content type (website, article, book, profile, video, music)
+ * - url: Canonical URL for this page (absolute URL)
+ *
+ * Optional properties:
+ * - image: Social sharing image URL (recommended: 1200x630px, 1.91:1 aspect ratio)
+ * - imageAlt: Alternative text for the image (accessibility, screen readers)
+ * - siteName: Overall website/brand name (different from page title)
+ * - locale: Content language/territory (en_US, fr_FR, etc.)
+ * - determiner: Grammatical article before title (a, an, the, auto, "")
+ * - video: Video URL for video content (enables video embeds in feeds)
+ * - audio: Audio URL for audio content (enables audio players)
+ *
+ * Impact:
+ * - Rich cards get 2-3x more clicks than plain links
+ * - Image is most important element (grabs attention)
+ * - Without OG tags: generic unfurl with no image (low engagement)
+ * - Complete OG tags: professional social presence
+ *
+ * @example
+ * ```typescript
+ * const openGraph = {
+ *   title: 'Transform Your Business with AI-Powered Analytics',
+ *   description: 'Get real-time insights, automated reporting, and predictive analytics. Start free trial.',
+ *   type: 'website',
+ *   url: 'https://example.com/product',
+ *   image: 'https://example.com/og-image-1200x630.jpg',
+ *   imageAlt: 'Dashboard screenshot showing analytics graphs',
+ *   siteName: 'Acme Analytics',
+ *   locale: 'en_US'
+ * }
+ * ```
+ *
+ * @see specs/app/pages/meta/social/open-graph.schema.json
+ */
+export const OpenGraphSchema = Schema.Struct({
+  title: Schema.optional(
+    Schema.String.pipe(Schema.maxLength(90)).annotations({
+      description: 'Open Graph title (may differ from page title)',
+    })
+  ),
+  description: Schema.optional(
+    Schema.String.pipe(Schema.maxLength(200)).annotations({
+      description: 'Open Graph description',
+    })
+  ),
+  type: Schema.optional(OpenGraphTypeSchema),
+  url: Schema.optional(
+    HttpUrlSchema.annotations({
+      description: 'Canonical URL for this page',
+    })
+  ),
+  image: Schema.optional(
+    HttpUrlSchema.annotations({
+      description: 'Image URL for social sharing (recommended: 1200x630px)',
+    })
+  ),
+  imageAlt: Schema.optional(
+    Schema.String.annotations({
+      description: 'Alternative text for the Open Graph image',
+    })
+  ),
+  siteName: Schema.optional(
+    Schema.String.annotations({
+      description: 'Name of the overall website',
+    })
+  ),
+  locale: Schema.optional(OpenGraphLocaleSchema),
+  determiner: Schema.optional(OpenGraphDeterminerSchema),
+  video: Schema.optional(
+    HttpUrlSchema.annotations({
+      description: 'Video URL if sharing video content',
+    })
+  ),
+  audio: Schema.optional(
+    HttpUrlSchema.annotations({
+      description: 'Audio URL if sharing audio content',
+    })
+  ),
+}).annotations({
+  title: 'Open Graph Metadata',
+  description: 'Open Graph protocol metadata for rich social media sharing',
+})
+
+export type OpenGraphType = Schema.Schema.Type<typeof OpenGraphTypeSchema>
+export type OpenGraphLocale = Schema.Schema.Type<typeof OpenGraphLocaleSchema>
+export type OpenGraphDeterminer = Schema.Schema.Type<typeof OpenGraphDeterminerSchema>
+export type OpenGraph = Schema.Schema.Type<typeof OpenGraphSchema>

package/src/domain/models/app/page/meta/preload.ts

@@ -0,0 +1,190 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+
+/**
+ * Resource type hint for preloading
+ *
+ * 8 standard resource types for <link rel="preload" as="...">:
+ * - style: CSS stylesheets (critical CSS for above-the-fold content)
+ * - script: JavaScript files (critical scripts needed for initial render)
+ * - font: Web fonts (WOFF2, WOFF, TTF) - requires crossorigin attribute
+ * - image: Images (hero images, above-the-fold images)
+ * - video: Video files
+ * - audio: Audio files
+ * - document: HTML documents (iframes, embeds)
+ * - fetch: API data (XHR, Fetch API responses) - prefetch critical API data
+ */
+export const PreloadResourceTypeSchema = Schema.Literal(
+  'style',
+  'script',
+  'font',
+  'image',
+  'video',
+  'audio',
+  'document',
+  'fetch'
+).annotations({
+  description: 'Resource type hint',
+})
+
+/**
+ * CORS setting for preloaded resources
+ *
+ * 3 options:
+ * - true: Anonymous CORS (no credentials) - most common for fonts
+ * - false: No CORS (same-origin)
+ * - 'anonymous': Explicit anonymous CORS (same as true)
+ * - 'use-credentials': CORS with credentials (cookies, auth)
+ *
+ * Important for fonts:
+ * - Web fonts MUST have crossorigin attribute (even from same origin)
+ * - Without crossorigin: font downloads twice (preload + actual request)
+ * - With crossorigin: font downloads once (preload is reused)
+ */
+export const PreloadCrossOriginSchema = Schema.Union(
+  Schema.Boolean,
+  Schema.Literal('anonymous', 'use-credentials')
+).annotations({
+  description: 'CORS setting for the resource',
+})
+
+/**
+ * Preload resource configuration
+ *
+ * Defines a single resource to preload early in page load for performance optimization.
+ *
+ * Required properties:
+ * - href: Resource URL to preload (absolute or relative path)
+ * - as: Resource type hint (style, script, font, image, video, audio, document, fetch)
+ *
+ * Optional properties:
+ * - type: MIME type (font/woff2, image/webp, text/css, etc.) - helps browser prioritize
+ * - crossorigin: CORS setting (true/false/'anonymous'/'use-credentials') - required for fonts
+ * - media: Media query for conditional loading (e.g., "(min-width: 768px)")
+ *
+ * Common preload patterns:
+ * 1. **Critical CSS**: Preload main stylesheet for faster first paint
+ *    ```typescript
+ *    { href: './output.css', as: 'style' }
+ *    ```
+ *
+ * 2. **Web fonts**: Preload fonts used above-the-fold (crossorigin required!)
+ *    ```typescript
+ *    { href: './fonts/MyFont.woff2', as: 'font', type: 'font/woff2', crossorigin: true }
+ *    ```
+ *
+ * 3. **Hero images**: Preload above-the-fold images for faster LCP
+ *    ```typescript
+ *    { href: './hero.jpg', as: 'image', type: 'image/jpeg' }
+ *    ```
+ *
+ * 4. **Critical API data**: Prefetch data needed for initial render
+ *    ```typescript
+ *    { href: '/api/posts', as: 'fetch', crossorigin: 'use-credentials' }
+ *    ```
+ *
+ * 5. **Responsive images**: Preload images conditionally based on screen size
+ *    ```typescript
+ *    { href: './hero-mobile.jpg', as: 'image', media: '(max-width: 767px)' }
+ *    ```
+ *
+ * Performance impact:
+ * - Preload critical resources before parser discovers them
+ * - Reduces time to First Contentful Paint (FCP) by 200-500ms
+ * - Reduces Largest Contentful Paint (LCP) by 300-800ms (hero images, fonts)
+ * - Improves Core Web Vitals (FCP, LCP, CLS)
+ *
+ * @example
+ * ```typescript
+ * const preloadItem = {
+ *   href: './fonts/Inter.woff2',
+ *   as: 'font',
+ *   type: 'font/woff2',
+ *   crossorigin: true
+ * }
+ * ```
+ *
+ * @see specs/app/pages/meta/performance/preload.schema.json
+ */
+export const PreloadItemSchema = Schema.Struct({
+  href: Schema.String.annotations({
+    description: 'Resource URL to preload',
+  }),
+  as: PreloadResourceTypeSchema,
+  type: Schema.optional(
+    Schema.String.annotations({
+      description: 'MIME type for the resource',
+    })
+  ),
+  crossorigin: Schema.optional(PreloadCrossOriginSchema),
+  media: Schema.optional(
+    Schema.String.annotations({
+      description: 'Media query for conditional loading',
+    })
+  ),
+}).annotations({
+  description: 'Preload resource',
+})
+
+/**
+ * Resource preloading for performance optimization
+ *
+ * Array of critical resources to preload early in page load.
+ * Improves First Contentful Paint (FCP) and Largest Contentful Paint (LCP)
+ * by fetching resources before the browser parser discovers them.
+ *
+ * How preload works:
+ * 1. Browser receives <link rel="preload" ...> in <head>
+ * 2. Browser downloads resource immediately (high priority)
+ * 3. Resource is cached in browser
+ * 4. When parser discovers resource later, it's already downloaded (instant load)
+ *
+ * What to preload:
+ * - **Critical CSS**: Main stylesheet for above-the-fold content
+ * - **Web fonts**: Fonts used above-the-fold (prevent FOIT/FOUT)
+ * - **Hero images**: Largest Contentful Paint (LCP) images
+ * - **Critical scripts**: JavaScript needed for initial render
+ * - **API data**: Critical data needed for first render
+ *
+ * What NOT to preload:
+ * - Resources below the fold (defer or lazy load instead)
+ * - Non-critical resources (wasted bandwidth, slows critical resources)
+ * - Too many resources (limit to 3-5 items, prioritize most critical)
+ *
+ * Performance metrics improved:
+ * - First Contentful Paint (FCP): 200-500ms faster
+ * - Largest Contentful Paint (LCP): 300-800ms faster
+ * - Cumulative Layout Shift (CLS): Reduced by preventing font swaps
+ * - Time to Interactive (TTI): Faster by preloading critical scripts
+ *
+ * @example
+ * ```typescript
+ * const preload = [
+ *   // Critical CSS
+ *   { href: './output.css', as: 'style' },
+ *   // Web font (crossorigin required!)
+ *   { href: './fonts/Inter-Bold.woff2', as: 'font', type: 'font/woff2', crossorigin: true },
+ *   // Hero image (LCP)
+ *   { href: './hero.jpg', as: 'image', type: 'image/jpeg' },
+ *   // Critical API data
+ *   { href: '/api/posts', as: 'fetch', crossorigin: true }
+ * ]
+ * ```
+ *
+ * @see specs/app/pages/meta/performance/preload.schema.json
+ */
+export const PreloadSchema = Schema.Array(PreloadItemSchema).annotations({
+  title: 'Resource Preloading',
+  description: 'Preload critical resources for performance optimization',
+})
+
+export type PreloadResourceType = Schema.Schema.Type<typeof PreloadResourceTypeSchema>
+export type PreloadCrossOrigin = Schema.Schema.Type<typeof PreloadCrossOriginSchema>
+export type PreloadItem = Schema.Schema.Type<typeof PreloadItemSchema>
+export type Preload = Schema.Schema.Type<typeof PreloadSchema>

package/src/domain/models/app/page/meta/structured-data/article.ts

@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { SchemaOrgContext, schemaType } from './common-fields'
+
+/**
+ * Article type
+ *
+ * 3 article types for different content:
+ * - Article: General articles (default, most common)
+ * - NewsArticle: News articles (journalistic content, breaking news)
+ * - BlogPosting: Blog posts (personal/company blogs, opinion pieces)
+ */
+export const ArticleTypeSchema = Schema.Literal(
+  'Article',
+  'NewsArticle',
+  'BlogPosting'
+).annotations({
+  description: 'Article type',
+})
+
+/**
+ * Article author
+ *
+ * Author can be either a simple string name or a structured Person/Organization object.
+ * - String: Simple author name (e.g., "John Doe")
+ * - Object: Structured author with @type (Person/Organization), name, and optional URL
+ */
+export const ArticleAuthorSchema = Schema.Union(
+  Schema.String,
+  Schema.Struct({
+    '@type': Schema.Literal('Person', 'Organization').annotations({
+      description: 'Author type',
+    }),
+    name: Schema.optional(
+      Schema.String.annotations({
+        description: 'Author name',
+      })
+    ),
+    url: Schema.optional(
+      Schema.String.annotations({
+        description: 'Author profile URL',
+        format: 'uri',
+      })
+    ),
+  })
+).annotations({
+  description: 'Article author',
+})
+
+/**
+ * Publisher logo
+ *
+ * ImageObject with @type and url for publisher logo.
+ * Required for Article structured data to be eligible for rich results.
+ */
+export const PublisherLogoSchema = Schema.Struct({
+  '@type': schemaType('ImageObject'),
+  url: Schema.optional(
+    Schema.String.annotations({
+      description: 'Logo URL',
+      format: 'uri',
+    })
+  ),
+}).annotations({
+  description: 'Publisher logo',
+})
+
+/**
+ * Article publisher
+ *
+ * Organization object representing the content publisher.
+ * - @type: "Organization" (required)
+ * - name: Publisher name (e.g., "Acme Blog", "TechCrunch")
+ * - logo: ImageObject with publisher logo URL
+ */
+export const ArticlePublisherSchema = Schema.Struct({
+  '@type': schemaType('Organization'),
+  name: Schema.optional(
+    Schema.String.annotations({
+      description: 'Publisher name',
+    })
+  ),
+  logo: Schema.optional(PublisherLogoSchema),
+}).annotations({
+  description: 'Article publisher',
+})
+
+/**
+ * Schema.org Article structured data
+ *
+ * Represents articles, news articles, and blog posts for rich results in Google Search.
+ * Enables article cards with images, publication dates, and author attribution.
+ *
+ * Required properties:
+ * - @context: "https://schema.org" (Schema.org vocabulary)
+ * - @type: Article type (Article, NewsArticle, BlogPosting)
+ * - headline: Article title (shown in search results)
+ *
+ * Optional properties:
+ * - description: Article summary/excerpt
+ * - image: Article image URL (string) or array of image URLs (for carousel)
+ * - author: Author name (string) or structured Person/Organization object
+ * - datePublished: Publication date (ISO 8601 format)
+ * - dateModified: Last modification date (ISO 8601 format)
+ * - publisher: Publishing organization (Organization object with name and logo)
+ * - mainEntityOfPage: Canonical URL for the article
+ *
+ * Article types:
+ * - **Article**: General articles, how-to guides, tutorials
+ * - **NewsArticle**: Breaking news, journalism (adds publish date prominence)
+ * - **BlogPosting**: Personal/company blog posts, opinion pieces
+ *
+ * SEO impact:
+ * - **Rich results**: Article cards with image, headline, date, author in search
+ * - **Google News**: NewsArticle eligible for Google News (with additional requirements)
+ * - **Author attribution**: Links content to authors (E-E-A-T signals)
+ * - **Publisher branding**: Publisher logo and name shown in results
+ * - **Freshness signals**: datePublished and dateModified help ranking for time-sensitive queries
+ *
+ * @example
+ * ```typescript
+ * const article = {
+ *   "@context": "https://schema.org",
+ *   "@type": "BlogPosting",
+ *   headline: "10 Ways to Boost Productivity",
+ *   description: "Proven strategies to improve your daily productivity",
+ *   image: "https://example.com/article-image.jpg",
+ *   author: {
+ *     "@type": "Person",
+ *     name: "John Doe",
+ *     url: "https://example.com/author/johndoe"
+ *   },
+ *   datePublished: "2025-01-15T10:00:00Z",
+ *   dateModified: "2025-01-20T14:30:00Z",
+ *   publisher: {
+ *     "@type": "Organization",
+ *     name: "Acme Blog",
+ *     logo: {
+ *       "@type": "ImageObject",
+ *       url: "https://example.com/logo.png"
+ *     }
+ *   },
+ *   mainEntityOfPage: "https://example.com/blog/productivity-tips"
+ * }
+ * ```
+ *
+ * @see specs/app/pages/meta/structured-data/article.schema.json
+ */
+export const ArticleSchema = Schema.Struct({
+  '@context': SchemaOrgContext,
+  '@type': ArticleTypeSchema,
+  headline: Schema.String.annotations({
+    description: 'Article title',
+  }),
+  description: Schema.optional(
+    Schema.String.annotations({
+      description: 'Article summary',
+    })
+  ),
+  image: Schema.optional(
+    Schema.Union(
+      Schema.String.annotations({
+        description: 'Article image URL',
+        format: 'uri',
+      }),
+      Schema.Array(
+        Schema.String.annotations({
+          description: 'Article image URL',
+          format: 'uri',
+        })
+      )
+    ).annotations({
+      description: 'Article image(s)',
+    })
+  ),
+  author: Schema.optional(ArticleAuthorSchema),
+  datePublished: Schema.optional(
+    Schema.String.annotations({
+      description: 'Publication date',
+      format: 'date-time',
+    })
+  ),
+  dateModified: Schema.optional(
+    Schema.String.annotations({
+      description: 'Last modification date',
+      format: 'date-time',
+    })
+  ),
+  publisher: Schema.optional(ArticlePublisherSchema),
+  mainEntityOfPage: Schema.optional(
+    Schema.String.annotations({
+      description: "Article's canonical URL",
+      format: 'uri',
+    })
+  ),
+}).annotations({
+  title: 'Article Schema',
+  description: 'Schema.org Article structured data',
+})
+
+export type ArticleType = Schema.Schema.Type<typeof ArticleTypeSchema>
+export type ArticleAuthor = Schema.Schema.Type<typeof ArticleAuthorSchema>
+export type PublisherLogo = Schema.Schema.Type<typeof PublisherLogoSchema>
+export type ArticlePublisher = Schema.Schema.Type<typeof ArticlePublisherSchema>
+export type Article = Schema.Schema.Type<typeof ArticleSchema>

package/src/domain/models/app/page/meta/structured-data/breadcrumb.ts

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Schema } from 'effect'
+import { SchemaOrgContext, schemaType, positiveInt } from './common-fields'
+
+/**
+ * Breadcrumb list item
+ *
+ * Represents a single breadcrumb in the navigation trail.
+ *
+ * Required properties:
+ * - @type: "ListItem" (Schema.org type identifier)
+ * - position: Item position in breadcrumb trail (starts at 1)
+ * - name: Human-readable breadcrumb label (e.g., "Home", "Products", "Widget")
+ *
+ * Optional properties:
+ * - item: URL to the breadcrumb page (clickable link)
+ */
+export const BreadcrumbListItemSchema = Schema.Struct({
+  '@type': schemaType('ListItem'),
+  position: positiveInt('Item position in breadcrumb trail'),
+  name: Schema.String.annotations({
+    description: 'Breadcrumb label',
+  }),
+  item: Schema.optional(
+    Schema.String.annotations({
+      description: 'URL to the breadcrumb page',
+      format: 'uri',
+    })
+  ),
+}).annotations({
+  description: 'Breadcrumb list item',
+})
+
+/**
+ * Schema.org BreadcrumbList structured data
+ *
+ * Represents the navigation path (breadcrumb trail) showing the page's position
+ * in the site hierarchy. Displayed in Google search results as a breadcrumb trail
+ * instead of the full URL, improving click-through rates.
+ *
+ * Required properties:
+ * - @context: "https://schema.org" (Schema.org vocabulary)
+ * - @type: "BreadcrumbList" (Schema.org type identifier)
+ * - itemListElement: Array of breadcrumb items (ListItem objects)
+ *
+ * Breadcrumb structure:
+ * - Each item has @type "ListItem", position (integer starting at 1), name, and optional item URL
+ * - Position determines order: 1 = Home, 2 = Category, 3 = Subcategory, etc.
+ * - Name is the human-readable label shown in breadcrumb trail
+ * - Item URL is optional but recommended for clickable breadcrumbs
+ *
+ * Common patterns:
+ * - **Home > Category > Page**: 3-level hierarchy for content sites
+ * - **Home > Products > Category > Product**: 4-level for e-commerce
+ * - **Home > Docs > Section > Article**: 4-level for documentation
+ *
+ * SEO impact:
+ * - **Rich results**: Breadcrumb trail replaces URL in Google search results
+ * - **Site structure**: Helps search engines understand site architecture
+ * - **Navigation UX**: Users see page context in search results (higher CTR)
+ * - **Mobile optimization**: Breadcrumbs save space vs full URL on mobile
+ *
+ * Google display example:
+ * - Without breadcrumbs: "https://example.com/products/electronics/laptop"
+ * - With breadcrumbs: "Home › Products › Electronics › Laptop"
+ *
+ * @example
+ * ```typescript
+ * const breadcrumb = {
+ *   "@context": "https://schema.org",
+ *   "@type": "BreadcrumbList",
+ *   itemListElement: [
+ *     {
+ *       "@type": "ListItem",
+ *       position: 1,
+ *       name: "Home",
+ *       item: "https://example.com"
+ *     },
+ *     {
+ *       "@type": "ListItem",
+ *       position: 2,
+ *       name: "Products",
+ *       item: "https://example.com/products"
+ *     },
+ *     {
+ *       "@type": "ListItem",
+ *       position: 3,
+ *       name: "Widget",
+ *       item: "https://example.com/products/widget"
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * @see specs/app/pages/meta/structured-data/breadcrumb.schema.json
+ */
+export const BreadcrumbSchema = Schema.Struct({
+  '@context': SchemaOrgContext,
+  '@type': schemaType('BreadcrumbList'),
+  itemListElement: Schema.Array(BreadcrumbListItemSchema).annotations({
+    description: 'Array of breadcrumb items',
+  }),
+}).annotations({
+  title: 'Breadcrumb Schema',
+  description: 'Schema.org BreadcrumbList structured data',
+})
+
+export type BreadcrumbListItem = Schema.Schema.Type<typeof BreadcrumbListItemSchema>
+export type Breadcrumb = Schema.Schema.Type<typeof BreadcrumbSchema>