From 1e9cc3ba48f28a5c3ed4c5199f2994277ce8fe33 Mon Sep 17 00:00:00 2001
From: kevin <kevin@webstackbuilders.com>
Date: Tue, 4 Aug 2026 16:46:37 +0300
Subject: [PATCH] Fix Sentry error in switcher script

---
 .../Switcher/client/__tests__/index.spec.ts   | 128 +++++++++++++++++-
 .../Content/Switcher/client/index.ts          |  85 +++++++++---
 src/components/Content/Switcher/index.astro   |  20 ++-
 .../Switcher/server/__tests__/index.spec.ts   |  46 ++++++-
 .../Content/Switcher/server/index.ts          |  29 ++++
 .../scripts/sentry/__tests__/helpers.spec.ts  | 127 +++++++++++++++++
 src/components/scripts/sentry/helpers.ts      |  62 +++++++++
 src/content/clients/digest-engine.mdx         |  43 ++++++
 8 files changed, 514 insertions(+), 26 deletions(-)
 create mode 100644 src/content/clients/digest-engine.mdx

diff --git a/src/components/Content/Switcher/client/__tests__/index.spec.ts b/src/components/Content/Switcher/client/__tests__/index.spec.ts
index 3a2af4c0..88a5206e 100644
--- a/src/components/Content/Switcher/client/__tests__/index.spec.ts
+++ b/src/components/Content/Switcher/client/__tests__/index.spec.ts
@@ -5,7 +5,7 @@ import { experimental_AstroContainer as AstroContainer } from 'astro/container'
 import SwitcherAstro from '@components/Content/Switcher/index.astro'
 import type { ContentSwitcherElement } from '@components/Content/Switcher/client'
 import type { WebComponentModule } from '@components/scripts/@types/webComponentModule'
-import { executeRender } from '@test/unit/helpers/litRuntime'
+import { executeRender, type RenderResult } from '@test/unit/helpers/litRuntime'
 
 type SwitcherModule = WebComponentModule<ContentSwitcherElement>
 
@@ -18,7 +18,10 @@ describe('ContentSwitcherElement', () => {
 
   const runComponentRender = async (
     args: Parameters<AstroContainer['renderToString']>[1],
-    assertion: (_context: { element: ContentSwitcherElement }) => Promise<void> | void
+    assertion: (_context: {
+      element: ContentSwitcherElement
+      renderResult: RenderResult
+    }) => Promise<void> | void
   ): Promise<void> => {
     await executeRender<SwitcherModule>({
       container,
@@ -30,7 +33,7 @@ describe('ContentSwitcherElement', () => {
       },
       assert: async ({ element, module, renderResult }) => {
         expect(renderResult).toContain(`<${module.registeredName}`)
-        await assertion({ element })
+        await assertion({ element, renderResult })
       },
     })
   }
@@ -118,4 +121,123 @@ describe('ContentSwitcherElement', () => {
       }
     )
   })
+
+  test('disables the deep-dive label and toggle when the alternate variant is missing', async () => {
+    await runComponentRender(
+      {
+        props: {
+          currentVariant: 'overview',
+          slug: 'article-without-deep-dive',
+          hasAlternate: false,
+        },
+      },
+      async ({ element }) => {
+        const overviewLink = element.querySelector('#overview-label') as HTMLAnchorElement | null
+        const deepDiveLink = element.querySelector('#deep-dive-label') as HTMLAnchorElement | null
+        const switchLink = element.querySelector(
+          '[data-switcher-toggle]'
+        ) as HTMLAnchorElement | null
+
+        expect(overviewLink?.getAttribute('href')).toBe('/articles/article-without-deep-dive')
+        expect(overviewLink?.getAttribute('aria-disabled')).toBe('false')
+        expect(deepDiveLink?.getAttribute('href')).toBeNull()
+        expect(deepDiveLink?.getAttribute('aria-disabled')).toBe('true')
+        expect(switchLink?.getAttribute('href')).toBeNull()
+        expect(switchLink?.getAttribute('aria-disabled')).toBe('true')
+      }
+    )
+  })
+
+  test('disables the overview label when the alternate variant is missing on deep-dive pages', async () => {
+    await runComponentRender(
+      {
+        props: {
+          currentVariant: 'deep-dive',
+          slug: 'deep-dive-without-overview',
+          hasAlternate: false,
+        },
+      },
+      async ({ element }) => {
+        const overviewLink = element.querySelector('#overview-label') as HTMLAnchorElement | null
+        const deepDiveLink = element.querySelector('#deep-dive-label') as HTMLAnchorElement | null
+        const switchLink = element.querySelector(
+          '[data-switcher-toggle]'
+        ) as HTMLAnchorElement | null
+
+        expect(deepDiveLink?.getAttribute('href')).toBe('/deep-dive/deep-dive-without-overview')
+        expect(deepDiveLink?.getAttribute('aria-disabled')).toBe('false')
+        expect(overviewLink?.getAttribute('href')).toBeNull()
+        expect(overviewLink?.getAttribute('aria-disabled')).toBe('true')
+        expect(switchLink?.getAttribute('href')).toBeNull()
+        expect(switchLink?.getAttribute('aria-disabled')).toBe('true')
+      }
+    )
+  })
+
+  test('does not prefetch the alternate variant href when it is missing', async () => {
+    await runComponentRender(
+      {
+        props: {
+          currentVariant: 'overview',
+          slug: 'article-without-deep-dive',
+          hasAlternate: false,
+        },
+      },
+      async () => {
+        await new Promise(resolve => setTimeout(resolve, 200))
+
+        const prefetchLink = document.head.querySelector(
+          'link[rel="prefetch"][href="/deep-dive/article-without-deep-dive"]'
+        ) as HTMLLinkElement | null
+
+        expect(prefetchLink).toBeNull()
+      }
+    )
+  })
+
+  test('renders has-alternate="false" for articles without a deep-dive entry', async () => {
+    await runComponentRender(
+      {
+        props: {
+          path: '/articles/kubernetes-pod-disruption-budget-autoscaler-node-rotation',
+        },
+      },
+      async ({ element, renderResult }) => {
+        expect(renderResult).toContain('has-alternate="false"')
+
+        const deepDiveLink = element.querySelector('#deep-dive-label') as HTMLAnchorElement | null
+        const switchLink = element.querySelector(
+          '[data-switcher-toggle]'
+        ) as HTMLAnchorElement | null
+
+        expect(deepDiveLink?.getAttribute('href')).toBeNull()
+        expect(switchLink?.getAttribute('href')).toBeNull()
+      }
+    )
+  })
+
+  test('renders the has-alternate attribute for articles with a deep-dive entry', async () => {
+    await runComponentRender(
+      {
+        props: {
+          path: '/articles/reverse-engineering-documentation-legacy-systems',
+        },
+      },
+      async ({ element, renderResult }) => {
+        expect(renderResult).toContain('has-alternate="true"')
+
+        const deepDiveLink = element.querySelector('#deep-dive-label') as HTMLAnchorElement | null
+        const switchLink = element.querySelector(
+          '[data-switcher-toggle]'
+        ) as HTMLAnchorElement | null
+
+        expect(deepDiveLink?.getAttribute('href')).toBe(
+          '/deep-dive/reverse-engineering-documentation-legacy-systems'
+        )
+        expect(switchLink?.getAttribute('href')).toBe(
+          '/deep-dive/reverse-engineering-documentation-legacy-systems'
+        )
+      }
+    )
+  })
 })
diff --git a/src/components/Content/Switcher/client/index.ts b/src/components/Content/Switcher/client/index.ts
index 8ca1074d..c78888d2 100644
--- a/src/components/Content/Switcher/client/index.ts
+++ b/src/components/Content/Switcher/client/index.ts
@@ -1,4 +1,5 @@
 import { LitElement, html } from 'lit'
+import { ifDefined } from 'lit/directives/if-defined.js'
 import { defineCustomElement } from '@components/scripts/utils'
 import type { WebComponentModule } from '@components/scripts/@types/webComponentModule'
 import { queryPrefetchLink } from './selectors'
@@ -7,6 +8,8 @@ export type ContentVariant = 'overview' | 'deep-dive'
 
 const prefetchedHrefs = new Set<string>()
 
+const disabledLinkClasses = 'pointer-events-none cursor-not-allowed opacity-50'
+
 const normalizeSlug = (slug: string): string => slug.replace(/^\/+|\/+$/g, '')
 
 const queueIdlePrefetch = (work: () => void): void => {
@@ -82,15 +85,29 @@ export class ContentSwitcherElement extends LitElement {
   static override properties = {
     currentVariant: { type: String, attribute: 'current-variant' },
     slug: { type: String },
+    hasAlternate: {
+      type: Boolean,
+      attribute: 'has-alternate',
+      /**
+       * Astro renders boolean attributes as has-alternate="true" or
+       * has-alternate="false", so the default Lit converter (attribute
+       * presence) is not sufficient on its own.
+       */
+      converter: {
+        fromAttribute: (value: string | null) => value !== null && value !== 'false',
+      },
+    },
   }
 
   declare currentVariant: ContentVariant
   declare slug: string
+  declare hasAlternate: boolean
 
   constructor() {
     super()
     this.currentVariant = 'overview'
     this.slug = ''
+    this.hasAlternate = false
   }
 
   protected override createRenderRoot() {
@@ -109,6 +126,10 @@ export class ContentSwitcherElement extends LitElement {
   }
 
   private prefetchAlternateVariant(): void {
+    if (!this.hasAlternate) {
+      return
+    }
+
     const alternateVariant = this.currentVariant === 'deep-dive' ? 'overview' : 'deep-dive'
     const href = buildVariantHref(alternateVariant, this.slug)
 
@@ -123,34 +144,54 @@ export class ContentSwitcherElement extends LitElement {
     const deepDiveHref = buildVariantHref('deep-dive', this.slug)
     const switchHref = isDeepDive ? overviewHref : deepDiveHref
 
+    /**
+     * When the alternate variant route does not exist, its label link and the
+     * toggle are rendered inert so visitors cannot navigate to a 404 page.
+     */
+    const overviewLinkDisabled = !this.hasAlternate && isDeepDive
+    const deepDiveLinkDisabled = !this.hasAlternate && !isDeepDive
+
     const commonLabelClasses = 'text-xs no-underline hover:no-underline focus-visible:no-underline'
 
-    const overviewLabelClass = isDeepDive
-      ? 'content-switcher-label content-switcher-label--overview text-content-offset hover:text-content' +
-        ' ' +
-        commonLabelClasses
-      : 'content-switcher-label content-switcher-label--overview text-page-inverse' +
-        ' ' +
-        commonLabelClasses
-
-    const deepDiveLabelClass = isDeepDive
-      ? 'content-switcher-label content-switcher-label--deep-dive text-page-inverse' +
-        ' ' +
-        commonLabelClasses
-      : 'content-switcher-label content-switcher-label--deep-dive text-content-offset hover:text-content' +
-        ' ' +
-        commonLabelClasses
+    const overviewLabelClass =
+      (isDeepDive
+        ? 'content-switcher-label content-switcher-label--overview text-content-offset hover:text-content' +
+          ' ' +
+          commonLabelClasses
+        : 'content-switcher-label content-switcher-label--overview text-page-inverse' +
+          ' ' +
+          commonLabelClasses) + (overviewLinkDisabled ? ' ' + disabledLinkClasses : '')
+
+    const deepDiveLabelClass =
+      (isDeepDive
+        ? 'content-switcher-label content-switcher-label--deep-dive text-page-inverse' +
+          ' ' +
+          commonLabelClasses
+        : 'content-switcher-label content-switcher-label--deep-dive text-content-offset hover:text-content' +
+          ' ' +
+          commonLabelClasses) + (deepDiveLinkDisabled ? ' ' + disabledLinkClasses : '')
+
+    const switchTrackClass =
+      'content-switcher-track group relative inline-flex h-4 w-7 shrink-0 cursor-pointer items-center rounded-full border border-transparent bg-page-inverse transition-colors focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-secondary' +
+      (this.hasAlternate ? '' : ' ' + disabledLinkClasses)
 
     return html`
       <div class="flex items-center gap-3" role="radiogroup" aria-label="Content Variant">
-        <a class="${overviewLabelClass}" id="overview-label" href="${overviewHref}">Overview</a>
+        <a
+          class="${overviewLabelClass}"
+          id="overview-label"
+          href="${ifDefined(overviewLinkDisabled ? undefined : overviewHref)}"
+          aria-disabled="${overviewLinkDisabled ? 'true' : 'false'}"
+          >Overview</a
+        >
 
         <a
-          href="${switchHref}"
+          href="${ifDefined(this.hasAlternate ? switchHref : undefined)}"
           role="switch"
           aria-checked="${isDeepDive ? 'true' : 'false'}"
+          aria-disabled="${this.hasAlternate ? 'false' : 'true'}"
           aria-label="Toggle between Overview and Deep Dive"
-          class="content-switcher-track group relative inline-flex h-4 w-7 shrink-0 cursor-pointer items-center rounded-full border border-transparent bg-page-inverse transition-colors focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-secondary"
+          class="${switchTrackClass}"
           data-switcher-toggle
         >
           <span
@@ -158,7 +199,13 @@ export class ContentSwitcherElement extends LitElement {
           ></span>
         </a>
 
-        <a class="${deepDiveLabelClass}" id="deep-dive-label" href="${deepDiveHref}">Deep Dive</a>
+        <a
+          class="${deepDiveLabelClass}"
+          id="deep-dive-label"
+          href="${ifDefined(deepDiveLinkDisabled ? undefined : deepDiveHref)}"
+          aria-disabled="${deepDiveLinkDisabled ? 'true' : 'false'}"
+          >Deep Dive</a
+        >
       </div>
     `
   }
diff --git a/src/components/Content/Switcher/index.astro b/src/components/Content/Switcher/index.astro
index e183d229..40d97960 100644
--- a/src/components/Content/Switcher/index.astro
+++ b/src/components/Content/Switcher/index.astro
@@ -1,5 +1,5 @@
 ---
-import { parseContentPath } from './server'
+import { contentPathHasAlternateVariant, parseContentPath } from './server'
 import { BuildError } from '@lib/errors/BuildError'
 import './index.css'
 
@@ -10,20 +10,30 @@ export type Props = {
   currentVariant?: 'overview' | 'deep-dive'
   /** Legacy slug for client rendering */
   slug?: string
+  /** Legacy override for whether the alternate variant route exists */
+  hasAlternate?: boolean
 }
 
-const { path, currentVariant: legacyCurrentVariant, slug: legacySlug = '' } = Astro.props
+const {
+  path,
+  currentVariant: legacyCurrentVariant,
+  slug: legacySlug = '',
+  hasAlternate: legacyHasAlternate,
+} = Astro.props
 
 let currentVariant: 'overview' | 'deep-dive'
 let slug: string
+let hasAlternateVariant: boolean
 
 if (path) {
   const parsed = parseContentPath(path)
   currentVariant = parsed.currentVariant === 'articles' ? 'overview' : 'deep-dive'
   slug = parsed.slug
+  hasAlternateVariant = await contentPathHasAlternateVariant(path)
 } else if (legacyCurrentVariant) {
   currentVariant = legacyCurrentVariant
   slug = legacySlug
+  hasAlternateVariant = legacyHasAlternate ?? true
 } else {
   throw new BuildError('Content/Switcher: expected either `path` or `currentVariant` prop.', {
     phase: 'compilation',
@@ -33,7 +43,11 @@ if (path) {
 }
 ---
 
-<content-switcher class="print:hidden!" current-variant={currentVariant} slug={slug}
+<content-switcher
+  class="print:hidden!"
+  current-variant={currentVariant}
+  slug={slug}
+  has-alternate={hasAlternateVariant}
 ></content-switcher>
 
 <script>
diff --git a/src/components/Content/Switcher/server/__tests__/index.spec.ts b/src/components/Content/Switcher/server/__tests__/index.spec.ts
index c3f94132..5040c405 100644
--- a/src/components/Content/Switcher/server/__tests__/index.spec.ts
+++ b/src/components/Content/Switcher/server/__tests__/index.spec.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { BuildError } from '@lib/errors/BuildError'
-import { parseContentPath } from '../index'
+import { contentPathHasAlternateVariant, parseContentPath } from '../index'
 
 describe('parseContentPath', () => {
   it('parses an articles path into currentVariant and slug', () => {
@@ -79,3 +79,47 @@ describe('parseContentPath', () => {
     }
   })
 })
+
+/**
+ * These tests run against the real content collections (the same pattern used
+ * by the CallToAction/Download tests). The slugs below are stable fixtures:
+ * `reverse-engineering-documentation-legacy-systems` ships both an `index.mdx`
+ * and a `pdf.mdx`, while
+ * `kubernetes-pod-disruption-budget-autoscaler-node-rotation` has no `pdf.mdx`
+ * and therefore no deep-dive route.
+ */
+describe('contentPathHasAlternateVariant', () => {
+  it('returns true for an article that has a deep-dive entry', async () => {
+    await expect(
+      contentPathHasAlternateVariant('/articles/reverse-engineering-documentation-legacy-systems')
+    ).resolves.toBe(true)
+  })
+
+  it('returns false for an article without a deep-dive entry', async () => {
+    await expect(
+      contentPathHasAlternateVariant(
+        '/articles/kubernetes-pod-disruption-budget-autoscaler-node-rotation'
+      )
+    ).resolves.toBe(false)
+  })
+
+  it('returns true for a deep-dive path whose overview article exists', async () => {
+    await expect(
+      contentPathHasAlternateVariant('/deep-dive/reverse-engineering-documentation-legacy-systems')
+    ).resolves.toBe(true)
+  })
+
+  it('returns false when the slug does not exist in either collection', async () => {
+    await expect(contentPathHasAlternateVariant('/articles/no-such-article-slug')).resolves.toBe(
+      false
+    )
+    await expect(contentPathHasAlternateVariant('/deep-dive/no-such-article-slug')).resolves.toBe(
+      false
+    )
+  })
+
+  it('returns false when the path has no slug', async () => {
+    await expect(contentPathHasAlternateVariant('articles')).resolves.toBe(false)
+    await expect(contentPathHasAlternateVariant('deep-dive')).resolves.toBe(false)
+  })
+})
diff --git a/src/components/Content/Switcher/server/index.ts b/src/components/Content/Switcher/server/index.ts
index 8528267e..d2a96c89 100644
--- a/src/components/Content/Switcher/server/index.ts
+++ b/src/components/Content/Switcher/server/index.ts
@@ -1,4 +1,6 @@
+import { getCollection } from 'astro:content'
 import { BuildError } from '@lib/errors/BuildError'
+import { isDev } from '@lib/config/environmentServer'
 type ContentVariant = 'articles' | 'deep-dive'
 
 export const parseContentPath = (path: string) => {
@@ -33,3 +35,30 @@ export const parseContentPath = (path: string) => {
     slug: slugParts.join('/'),
   }
 }
+
+/**
+ * Determines whether the alternate content variant route exists for the given
+ * content path. Deep-dive pages are only generated for articles that ship a
+ * `pdf.mdx` entry, so the switcher must not link to or prefetch variants that
+ * would resolve to a 404. Draft filtering mirrors the article and deep-dive
+ * page `getStaticPaths` queries.
+ */
+export const contentPathHasAlternateVariant = async (path: string): Promise<boolean> => {
+  const { currentVariant, slug } = parseContentPath(path)
+
+  if (!slug) {
+    return false
+  }
+
+  /**
+   * getCollection with an id filter is used instead of getEntry so missing
+   * entries do not emit "not found" warnings during the build.
+   */
+  const alternateCollection = currentVariant === 'articles' ? 'deepDives' : 'articles'
+  const alternateEntries = await getCollection(
+    alternateCollection,
+    ({ id, data }) => id === slug && (isDev() || data.isDraft !== true)
+  )
+
+  return alternateEntries.length > 0
+}
diff --git a/src/components/scripts/sentry/__tests__/helpers.spec.ts b/src/components/scripts/sentry/__tests__/helpers.spec.ts
index 441c6ca1..b138ebe9 100644
--- a/src/components/scripts/sentry/__tests__/helpers.spec.ts
+++ b/src/components/scripts/sentry/__tests__/helpers.spec.ts
@@ -268,6 +268,89 @@ const createAbortedViewTransitionErrorEvent = (): Parameters<typeof beforeSendHa
     },
   }) as unknown as Parameters<typeof beforeSendHandler>[0]
 
+const createContentPageNotFoundHttpErrorEvent = (): Parameters<typeof beforeSendHandler>[0] =>
+  ({
+    type: 'error',
+    request: {
+      url: 'https://www.webstackbuilders.com/deep-dive/kubernetes-pod-disruption-budget-autoscaler-node-rotation',
+    },
+    exception: {
+      values: [
+        {
+          value: 'HTTP Client Error with status code: 404',
+          mechanism: {
+            type: 'auto.http.client.fetch',
+            handled: false,
+          },
+        },
+      ],
+    },
+  }) as unknown as Parameters<typeof beforeSendHandler>[0]
+
+const createContentPageServerErrorHttpErrorEvent = (): Parameters<typeof beforeSendHandler>[0] =>
+  ({
+    type: 'error',
+    request: {
+      url: 'https://www.webstackbuilders.com/articles/some-article',
+    },
+    exception: {
+      values: [
+        {
+          value: 'HTTP Client Error with status code: 500',
+          mechanism: {
+            type: 'auto.http.client.fetch',
+            handled: false,
+          },
+        },
+      ],
+    },
+  }) as unknown as Parameters<typeof beforeSendHandler>[0]
+
+const createNonContentPageNotFoundHttpErrorEvent = (): Parameters<typeof beforeSendHandler>[0] =>
+  ({
+    type: 'error',
+    request: {
+      url: 'https://www.webstackbuilders.com/downloads/some-guide',
+    },
+    exception: {
+      values: [
+        {
+          value: 'HTTP Client Error with status code: 404',
+          mechanism: {
+            type: 'auto.http.client.fetch',
+            handled: false,
+          },
+        },
+      ],
+    },
+  }) as unknown as Parameters<typeof beforeSendHandler>[0]
+
+const createPlaywrightBindingErrorEvent = (): Parameters<typeof beforeSendHandler>[0] =>
+  ({
+    type: 'error',
+    message: 'Function "autoconsentSendMessage" is not exposed',
+    exception: {
+      values: [
+        {
+          value: 'Function "autoconsentSendMessage" is not exposed',
+          mechanism: {
+            type: 'auto.browser.global_handlers.onunhandledrejection',
+            handled: false,
+          },
+          stacktrace: {
+            frames: [
+              {
+                filename:
+                  '/home/ang/coder/projects/crawl/.venv/lib/python3.12/site-packages/playwright/driver/package/lib/server/page.js',
+                function: 'PageBinding.dispatch',
+              },
+            ],
+          },
+        },
+      ],
+    },
+  }) as unknown as Parameters<typeof beforeSendHandler>[0]
+
 const createHint = (): Parameters<typeof beforeSendHandler>[1] =>
   ({}) as Parameters<typeof beforeSendHandler>[1]
 
@@ -449,6 +532,50 @@ describe('sentry helpers', () => {
       expect(result).toBeNull()
     })
 
+    it('drops 404 http client failures for content page fetches', () => {
+      isProdMock.mockReturnValue(true)
+      getConsentSnapshotMock.mockReturnValue({ analytics: true })
+
+      const event = createContentPageNotFoundHttpErrorEvent()
+
+      const result = beforeSendHandler(event, createHint())
+
+      expect(result).toBeNull()
+    })
+
+    it('keeps non-404 http client failures for content page fetches', () => {
+      isProdMock.mockReturnValue(true)
+      getConsentSnapshotMock.mockReturnValue({ analytics: true })
+
+      const event = createContentPageServerErrorHttpErrorEvent()
+
+      const result = beforeSendHandler(event, createHint())
+
+      expect(result).toBe(event)
+    })
+
+    it('keeps 404 http client failures for non-content page fetches', () => {
+      isProdMock.mockReturnValue(true)
+      getConsentSnapshotMock.mockReturnValue({ analytics: true })
+
+      const event = createNonContentPageNotFoundHttpErrorEvent()
+
+      const result = beforeSendHandler(event, createHint())
+
+      expect(result).toBe(event)
+    })
+
+    it('drops automation framework binding errors from bot traffic', () => {
+      isProdMock.mockReturnValue(true)
+      getConsentSnapshotMock.mockReturnValue({ analytics: true })
+
+      const event = createPlaywrightBindingErrorEvent()
+
+      const result = beforeSendHandler(event, createHint())
+
+      expect(result).toBeNull()
+    })
+
     it('scrubs PII when analytics consent is missing and preserves safe breadcrumbs', () => {
       isProdMock.mockReturnValue(true)
       getConsentSnapshotMock.mockReturnValue({ analytics: false })
diff --git a/src/components/scripts/sentry/helpers.ts b/src/components/scripts/sentry/helpers.ts
index 59ca62ba..e8fe1503 100644
--- a/src/components/scripts/sentry/helpers.ts
+++ b/src/components/scripts/sentry/helpers.ts
@@ -198,6 +198,55 @@ const isHandledConsentCheckpointClientError = (
   )
 }
 
+/**
+ * Matches same-origin content page fetches. The Content Switcher prefetches the
+ * alternate article variant as a best-effort warmup, and crawlers can trigger
+ * fetches for content URLs that do not exist. A 404 from one of these GET
+ * requests is expected noise rather than an application error.
+ */
+const CONTENT_PAGE_REQUEST_PATTERN = /^https?:\/\/[^/]+\/(?:articles|deep-dive)\//
+
+const isContentPageNotFoundHttpError = (event: Parameters<BeforeSendHandler>[0]): boolean => {
+  const requestUrl = event.request?.url
+  const exception = event.exception?.values?.[0]
+  const mechanismType = exception?.mechanism?.type
+  const errorMessage = exception?.value ?? event.message ?? ''
+  const statusCodeMatch =
+    typeof errorMessage === 'string' ? errorMessage.match(/status code:\s*(\d{3})/i) : null
+  const statusCode = statusCodeMatch?.[1] ? Number(statusCodeMatch[1]) : undefined
+
+  return (
+    typeof requestUrl === 'string' &&
+    CONTENT_PAGE_REQUEST_PATTERN.test(requestUrl) &&
+    mechanismType === 'auto.http.client.fetch' &&
+    statusCode === 404
+  )
+}
+
+/**
+ * Matches errors produced by automation frameworks driving the page. Playwright
+ * rejects calls to page bindings that were never exposed (for example
+ * "autoconsentSendMessage" from crawler consent tooling), and those rejections
+ * surface as unhandled promise rejections in the page. Real visitors never have
+ * automation bindings or driver stack frames, so these events are bot noise.
+ */
+const PLAYWRIGHT_BINDING_ERROR_PATTERN = /Function ".*" is not exposed/
+
+const isAutomationFrameworkError = (event: Parameters<BeforeSendHandler>[0]): boolean => {
+  const exception = event.exception?.values?.[0]
+  const errorMessage = exception?.value ?? event.message ?? ''
+
+  if (typeof errorMessage === 'string' && PLAYWRIGHT_BINDING_ERROR_PATTERN.test(errorMessage)) {
+    return true
+  }
+
+  const frames = exception?.stacktrace?.frames ?? []
+
+  return frames.some(
+    frame => typeof frame.filename === 'string' && frame.filename.includes('playwright')
+  )
+}
+
 const isHandledAbortedViewTransitionError = (
   event: Parameters<BeforeSendHandler>[0]
 ): boolean => {
@@ -310,6 +359,19 @@ export const beforeSendHandler: BeforeSendHandler = (event, _hint) => {
     return null
   }
 
+  // The Content Switcher prefetches the alternate article variant as a
+  // best-effort warmup and crawlers fetch content URLs that may not exist.
+  // A 404 from a content page fetch is expected noise, not an app error.
+  if (isContentPageNotFoundHttpError(event)) {
+    return null
+  }
+
+  // Errors raised by automation frameworks (e.g. Playwright page bindings
+  // injected by crawler consent tooling) come from bots, not real visitors.
+  if (isAutomationFrameworkError(event)) {
+    return null
+  }
+
   // Astro view transitions can abort an in-flight navigation when a newer
   // navigation supersedes it. The browser surfaces that as an unhandled
   // DOMException rejection with no user-visible failure, so drop it as noise.
diff --git a/src/content/clients/digest-engine.mdx b/src/content/clients/digest-engine.mdx
new file mode 100644
index 00000000..1b4a0616
--- /dev/null
+++ b/src/content/clients/digest-engine.mdx
@@ -0,0 +1,43 @@
+---
+id: "digest-engine"
+displayName: "Digest Engine"
+role: "Systems Analyst"
+industry: "Pharmaceuticals / Life Sciences"
+businessType: "Global Pharmaceutical Company"
+workModel: "On-Site"
+location: "Indianapolis, Indiana"
+startDate: 2011-06-01
+endDate: 2013-08-01
+website: "https://www.lilly.com/"
+linkedinUrl: "https://www.linkedin.com/company/eli-lilly-and-company/"
+published: true
+---
+
+Fortune 100 pharmaceutical company with global R&D and manufacturing operations, requiring business process analysis, systems documentation, and technology procurement support across multiple internal teams.
+
+<List
+  variant="experience-list"
+  classes={{ wrapper: '-mt-3 mb-0' }}
+  items={[
+    {
+      lead: 'Worked with users, observing business processes, ',
+      text: 'interviewing staff, and documenting practices. Conducted research, analyzed business operations, and problem solved operating inefficiencies.',
+    },
+    {
+      lead: 'Created and analyzed users requirements ',
+      text: 'for technology systems using use cases, mock ups, and interviewing stakeholders.',
+    },
+    {
+      lead: 'Prepared bid documents ',
+      text: 'and functional specifications for new application implementations.',
+    },
+    {
+      lead: 'Led sprint planning ',
+      text: 'and daily scrum meetings.',
+    },
+    {
+      lead: 'Created and maintained a company-wide inventory ',
+      text: 'and descriptions of major systems, and a new employee guide to using them.',
+    },
+  ]}
+/>