fix(landing): match microdata itemType and scope collection JSON-LD to visible posts

Address Greptile/Cursor review on PR #5638:
- itemType now always resolves to BlogPosting (matching Greptile's exact
  suggested fix), since the JSON-LD graph already carries the richer
  TechArticle type via a multi-type array and the microdata path doesn't
  need to duplicate that distinction
- buildCollectionPageJsonLd now receives the same tag-filtered/paginated
  post subset ContentIndexPage actually renders, instead of the full
  unfiltered catalog, via a new shared selectVisiblePosts/paginateContentPosts
  helper in lib/content/index-list.ts (also de-duplicates the pagination
  logic that previously lived only in ContentIndexPage)

Author: waleedlatif1

apps/sim/app/(landing)/blog/page.tsx

@@ -1,6 +1,7 @@
 import type { Metadata } from 'next'
 import { getAllPostMeta } from '@/lib/blog/registry'
 import { BLOG_SECTION, buildCollectionPageJsonLd, buildIndexMetadata } from '@/lib/blog/seo'
+import { selectVisiblePosts } from '@/lib/content/index-list'
 import { ContentIndexPage } from '@/app/(landing)/components'
 
 /**
@@ -35,7 +36,9 @@ export default async function BlogIndex({
       posts={posts}
       page={pageNum}
       tag={tag}
-      collectionJsonLd={buildCollectionPageJsonLd(posts)}
+      collectionJsonLd={buildCollectionPageJsonLd(
+        selectVisiblePosts(posts, { tag, page: pageNum })
+      )}
     />
   )
 }

apps/sim/app/(landing)/components/content-index-page/content-index-page.tsx

@@ -1,13 +1,11 @@
 import { ChipLink } from '@sim/emcn'
 import Image from 'next/image'
 import Link from 'next/link'
+import { paginateContentPosts } from '@/lib/content/index-list'
 import type { ContentMeta } from '@/lib/content/schema'
 import { Cta } from '@/app/(landing)/components/cta/cta'
 import { JsonLd } from '@/app/(landing)/components/json-ld'
 
-const POSTS_PER_PAGE = 20
-const FEATURED_COUNT = 3
-
 interface ContentIndexPageProps {
   /** Route base path, e.g. `/blog` or `/library`. */
   basePath: string
@@ -36,25 +34,7 @@ export function ContentIndexPage({
   tag,
   collectionJsonLd,
 }: ContentIndexPageProps) {
-  const filtered = tag ? posts.filter((p) => p.tags.includes(tag)) : posts
-  const dateSorted = [...filtered].sort(
-    (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
-  )
-
-  // Featured posts render once, in the page-1 featured row, regardless of
-  // where their date would otherwise place them — so they're carved out of
-  // the paginated pool up front rather than re-sorted to the front of page 1
-  // (which left them still reachable, and duplicated, on a later page).
-  const explicitlyFeatured = dateSorted.filter((p) => p.featured).slice(0, FEATURED_COUNT)
-  const featuredPosts =
-    explicitlyFeatured.length > 0 ? explicitlyFeatured : dateSorted.slice(0, FEATURED_COUNT)
-  const featuredSlugs = new Set(featuredPosts.map((p) => p.slug))
-  const paginated = dateSorted.filter((p) => !featuredSlugs.has(p.slug))
-
-  const totalPages = Math.max(1, Math.ceil(paginated.length / POSTS_PER_PAGE))
-  const start = (page - 1) * POSTS_PER_PAGE
-  const featured = page === 1 ? featuredPosts : []
-  const remaining = paginated.slice(start, start + POSTS_PER_PAGE)
+  const { featured, remaining, totalPages } = paginateContentPosts(posts, { tag, page })
 
   const pageHref = (targetPage: number) =>
     `${basePath}?page=${targetPage}${tag ? `&tag=${encodeURIComponent(tag)}` : ''}`

apps/sim/app/(landing)/components/content-post-page/content-post-page.tsx

@@ -34,11 +34,7 @@ export function ContentPostPage({
   const Article = post.Content
 
   return (
-    <article
-      className='w-full bg-[var(--bg)]'
-      itemScope
-      itemType={`https://schema.org/${post.technical ? 'TechArticle' : 'BlogPosting'}`}
-    >
+    <article className='w-full bg-[var(--bg)]' itemScope itemType='https://schema.org/BlogPosting'>
       <JsonLd data={graphJsonLd} />
       <header className='mx-auto w-full max-w-[1460px] px-20 pt-[112px] max-sm:px-5 max-sm:pt-20 max-lg:px-8'>
         <div className='mb-6'>

apps/sim/app/(landing)/library/page.tsx

@@ -1,4 +1,5 @@
 import type { Metadata } from 'next'
+import { selectVisiblePosts } from '@/lib/content/index-list'
 import { getAllPostMeta } from '@/lib/library/registry'
 import { buildCollectionPageJsonLd, buildIndexMetadata, LIBRARY_SECTION } from '@/lib/library/seo'
 import { ContentIndexPage } from '@/app/(landing)/components'
@@ -35,7 +36,9 @@ export default async function LibraryIndex({
       posts={posts}
       page={pageNum}
       tag={tag}
-      collectionJsonLd={buildCollectionPageJsonLd(posts)}
+      collectionJsonLd={buildCollectionPageJsonLd(
+        selectVisiblePosts(posts, { tag, page: pageNum })
+      )}
     />
   )
 }

apps/sim/lib/content/index-list.ts

@@ -0,0 +1,57 @@
+import type { ContentMeta } from '@/lib/content/schema'
+
+export const POSTS_PER_PAGE = 20
+export const FEATURED_COUNT = 3
+
+interface PaginatedContentPosts {
+  featured: ContentMeta[]
+  remaining: ContentMeta[]
+  totalPages: number
+}
+
+/**
+ * Reproduces `ContentIndexPage`'s render logic for a given `tag`/`page`
+ * combination: tag-filtered, date-sorted, with up to `FEATURED_COUNT`
+ * featured posts (explicit `post.featured` first, falling back to the most
+ * recent) carved out of the paginated pool and returned only on page 1.
+ * Shared by `ContentIndexPage` itself and `selectVisiblePosts` below, so
+ * every consumer stays in lockstep with what's actually rendered.
+ */
+export function paginateContentPosts(
+  posts: ContentMeta[],
+  { tag, page }: { tag?: string; page: number }
+): PaginatedContentPosts {
+  const filtered = tag ? posts.filter((p) => p.tags.includes(tag)) : posts
+  const dateSorted = [...filtered].sort(
+    (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+  )
+
+  const explicitlyFeatured = dateSorted.filter((p) => p.featured).slice(0, FEATURED_COUNT)
+  const featuredPosts =
+    explicitlyFeatured.length > 0 ? explicitlyFeatured : dateSorted.slice(0, FEATURED_COUNT)
+  const featuredSlugs = new Set(featuredPosts.map((p) => p.slug))
+  const paginated = dateSorted.filter((p) => !featuredSlugs.has(p.slug))
+
+  const totalPages = Math.max(1, Math.ceil(paginated.length / POSTS_PER_PAGE))
+  const start = (page - 1) * POSTS_PER_PAGE
+
+  return {
+    featured: page === 1 ? featuredPosts : [],
+    remaining: paginated.slice(start, start + POSTS_PER_PAGE),
+    totalPages,
+  }
+}
+
+/**
+ * Flat, render-order post list (featured then remaining) for a given
+ * `tag`/`page` combination - used to keep `buildCollectionPageJsonLd`'s
+ * `mainEntity` ItemList in sync with the posts actually visible on a
+ * filtered or paginated index URL, instead of the full unfiltered catalog.
+ */
+export function selectVisiblePosts(
+  posts: ContentMeta[],
+  options: { tag?: string; page: number }
+): ContentMeta[] {
+  const { featured, remaining } = paginateContentPosts(posts, options)
+  return [...featured, ...remaining]
+}