diff --git a/packages/shared/src/components/Feed.spec.tsx b/packages/shared/src/components/Feed.spec.tsx
index 515c80bc929..37dbc8cb233 100644
--- a/packages/shared/src/components/Feed.spec.tsx
+++ b/packages/shared/src/components/Feed.spec.tsx
@@ -556,6 +556,68 @@ describe('Feed logged in', () => {
     ).toEqual(['postItem', 'postItem', 'highlightItem', 'postItem']);
   });
 
+  // `disableHighlightItems` is set by MainFeedLayout when it mounts the sponsor
+  // strip, which is what carries breaking news in the card's place.
+  it('should drop the Happening Now card when the layout says the strip carries it', async () => {
+    renderComponent(
+      [
+        {
+          request: {
+            query: FEED_V2_QUERY,
+            variables,
+          },
+          result: {
+            data: {
+              page: {
+                pageInfo: defaultFeedPage.pageInfo,
+                edges: [
+                  {
+                    node: {
+                      __typename: 'FeedHighlightsItem',
+                      feedMeta: null,
+                      highlights: [
+                        {
+                          id: 'highlight-1',
+                          channel: 'agents',
+                          headline: 'The first highlight',
+                          highlightedAt: '2026-04-05T09:00:00.000Z',
+                          post: {
+                            id: defaultFeedPage.edges[0].node.id,
+                            commentsPermalink:
+                              defaultFeedPage.edges[0].node.commentsPermalink,
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  {
+                    node: {
+                      __typename: 'FeedPostItem',
+                      post: defaultFeedPage.edges[0].node,
+                      feedMeta: defaultFeedPage.edges[0].node.feedMeta ?? null,
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
+      ],
+      defaultUser,
+      SharedFeedPage.MyFeed,
+      FEED_V2_QUERY,
+      { disableHighlightItems: true },
+    );
+
+    await waitForNock();
+
+    // The posts around it still render, so the card is dropped rather than the
+    // whole response being discarded.
+    expect(await screen.findAllByTestId('postItem')).not.toHaveLength(0);
+    expect(screen.queryByTestId('highlightItem')).not.toBeInTheDocument();
+    expect(screen.queryByText('Happening Now')).not.toBeInTheDocument();
+  });
+
   it('should send upvote mutation', async () => {
     let mutationCalled = false;
     renderComponent([
diff --git a/packages/shared/src/components/Feed.tsx b/packages/shared/src/components/Feed.tsx
index c4fe7262a42..b96a5c9774a 100644
--- a/packages/shared/src/components/Feed.tsx
+++ b/packages/shared/src/components/Feed.tsx
@@ -102,6 +102,12 @@ export interface FeedProps<T>
   showSearch?: boolean;
   actionButtons?: ReactNode;
   disableAds?: boolean;
+  /**
+   * Drop the Happening Now card. Owned by the layout that renders the sponsor
+   * strip, which is where breaking news goes while the strip is up — a feed
+   * with no strip above it must never lose the card.
+   */
+  disableHighlightItems?: boolean;
   staticAd?: { ad: Ad; index: number };
   disableAdRefresh?: boolean;
   allowFetchMore?: boolean;
@@ -211,6 +217,7 @@ export default function Feed<T>({
   shortcuts,
   actionButtons,
   disableAds,
+  disableHighlightItems,
   staticAd,
   disableAdRefresh = false,
   allowFetchMore,
@@ -374,6 +381,7 @@ export default function Feed<T>({
       disableTopHero: isV2,
       isHorizontal,
       excludePinnedPosts,
+      disableHighlightItems,
       settings: {
         disableAds,
         staticAd,
diff --git a/packages/shared/src/components/MainFeedLayout.tsx b/packages/shared/src/components/MainFeedLayout.tsx
index a5ab98f95bf..70c59547a9b 100644
--- a/packages/shared/src/components/MainFeedLayout.tsx
+++ b/packages/shared/src/components/MainFeedLayout.tsx
@@ -17,7 +17,13 @@ import classNames from 'classnames';
 import { useRouter } from 'next/router';
 import type { FeedProps } from './Feed';
 import Feed from './Feed';
-import { FeedPageLayoutMobile, feedGutter } from './utilities/common';
+import {
+  FeedPageLayoutMobile,
+  feedGutter,
+  feedWidth,
+} from './utilities/common';
+import { SponsorStrip } from '../features/monetization/sponsorStrip/SponsorStrip';
+import { useSponsorStripFeed } from '../features/monetization/sponsorStrip/useSponsorStripFeed';
 import { ExploreChipsBar } from './feeds/ExploreChipsBar';
 import { buildPersonalizedCategories } from './feeds/exploreCategories';
 import { useFeeds } from '../hooks/feed/useFeeds';
@@ -26,7 +32,6 @@ import { AskSearchBanner } from './marketing/banners/AskSearchBanner';
 import { FeedEngagementBanner } from './brand/FeedEngagementBanner';
 import { ExploreSignupStrip } from './auth/ExploreSignupStrip';
 import FeedContext from '../contexts/FeedContext';
-import feedStyles from './Feed.module.css';
 import AuthContext from '../contexts/AuthContext';
 import type { LoggedUser } from '../lib/user';
 import { SharedFeedPage } from './utilities';
@@ -215,10 +220,7 @@ const getQueryBasedOnLogin = (
 // The feed's own width: full width normally, and clamped + centered to the
 // same card-based max-width as the grid on wide screens (desktopL). The CSS
 // vars feed the `styles.container` max-width calc (grid gap is 2rem).
-const feedWidthClassName = classNames(
-  'relative flex w-full flex-col laptopL:mx-auto',
-  feedStyles.container,
-);
+const feedWidthClassName = classNames('relative flex flex-col', feedWidth);
 const commentClassName = {
   container: 'rounded-none border-0 border-b tablet:border-x',
   commentBox: {
@@ -791,6 +793,13 @@ export default function MainFeedLayout({
     }
     return '';
   }, [customFeedsData, feedName, router.query.slugOrId]);
+  // Read here rather than inside the feed or the strip: this is the one place
+  // that owns both, so the card can only ever go missing on a surface that is
+  // mounting the strip — with headlines in it — in the card's place.
+  const sponsorStrip = useSponsorStripFeed({
+    feedName,
+    disableAds: feedProps?.disableAds,
+  });
   const v2ActionButtons = feedProps?.actionButtons;
   const showFeedV2PageHeader =
     isV2 &&
@@ -858,6 +867,7 @@ export default function MainFeedLayout({
           feedProps && (
             <Feed
               {...feedProps}
+              disableHighlightItems={sponsorStrip.disableHighlightItems}
               shortcuts={shortcuts}
               topContent={
                 (isExploreTag || shouldUseListFeedLayout) && chipsNode ? (
@@ -877,6 +887,17 @@ export default function MainFeedLayout({
         )}
         {children}
       </FeedPageLayoutComponent>
+      {/* Docked outside the page container so it spans the feed column and
+          pins to the window, and mounted here rather than in each app's
+          MainFeedPage because this is the one component both the webapp and
+          the extension new tab render — and the only place the feed name is
+          already resolved from `default` to the reader's own feed. */}
+      {sponsorStrip.isEnabled && (
+        <SponsorStrip
+          headlines={sponsorStrip.headlines}
+          headlinesSettled={sponsorStrip.headlinesSettled}
+        />
+      )}
     </>
   );
 }
diff --git a/packages/shared/src/components/MainLayout.tsx b/packages/shared/src/components/MainLayout.tsx
index 4c672a717bd..8bb757fed9e 100644
--- a/packages/shared/src/components/MainLayout.tsx
+++ b/packages/shared/src/components/MainLayout.tsx
@@ -417,7 +417,20 @@ function MainLayoutComponent({
           />
         )}
         {sidebarOwnsHeader ? (
-          <div className="flex min-h-0 flex-1 flex-col laptop:my-3 laptop:ml-1 laptop:mr-3">
+          <div
+            className={classNames(
+              'flex min-h-0 flex-1 flex-col laptop:my-3 laptop:ml-1 laptop:mr-3',
+              // A dock pins to the window, so the frame gives up its bottom
+              // gutter for the one case that holds one. Otherwise the frame
+              // stops 14px short of the viewport and a `sticky bottom-0` dock
+              // inside it cannot reach the bottom, resting there on first
+              // paint and at the end of the feed while pinning flush in
+              // between — a dock that jumps as the feed loads.
+              // Literal, not built from `DOCK_CLASS`: Tailwind scans source
+              // text and generates nothing for an interpolated class name.
+              'laptop:has-[.feed-dock]:mb-0',
+            )}
+          >
             {showHomepageTopBanners && (
               <HomepageTopBanners className="mx-4 mb-3 laptop:mx-0" />
             )}
@@ -432,12 +445,22 @@ function MainLayoutComponent({
                 // No drop shadow — the subtle border defines the floating card
                 // in both themes; shadow-2 cast a heavy bottom shadow.
                 'laptop:overflow-clip laptop:rounded-24 laptop:border laptop:border-border-subtlest-quaternary laptop:bg-background-default laptop:p-0.5',
+                // The dock becomes the frame's bottom edge, so the padding
+                // that would hold it up goes, and the corners it would be
+                // clipped into square off.
+                'laptop:has-[.feed-dock]:rounded-b-none laptop:has-[.feed-dock]:border-b-0 laptop:has-[.feed-dock]:pb-0',
                 LAYOUT_FRAME_CLASS,
+                // These subtract exactly the chrome above the frame plus its
+                // own margins, so the frame ends level with the window. With
+                // a dock the bottom margin is gone, so 0.75rem less comes off
+                // — a frame that stops short leaves a `sticky bottom-0` dock
+                // resting at its end, which is what happens for as long as
+                // the feed is too short to make the page scrollable.
                 !hasTopBanners &&
                   !topBanner &&
                   (isBannerAvailable
-                    ? 'laptop:min-h-[calc(100vh-3.5rem)]'
-                    : 'laptop:min-h-[calc(100vh-1.5rem)]'),
+                    ? 'laptop:min-h-[calc(100vh-3.5rem)] laptop:has-[.feed-dock]:min-h-[calc(100vh-2.75rem)]'
+                    : 'laptop:min-h-[calc(100vh-1.5rem)] laptop:has-[.feed-dock]:min-h-[calc(100vh-0.75rem)]'),
               )}
             >
               <RouteProgressBar />
diff --git a/packages/shared/src/components/ScrollToTopButton.tsx b/packages/shared/src/components/ScrollToTopButton.tsx
index 989fb8ca8c7..01066831926 100644
--- a/packages/shared/src/components/ScrollToTopButton.tsx
+++ b/packages/shared/src/components/ScrollToTopButton.tsx
@@ -63,7 +63,9 @@ export default function ScrollToTopButton(): ReactElement | null {
       tabIndex={show ? 0 : -1}
       {...props}
       className={classNames(
-        'absolute right-4 z-2',
+        // Lifts over the sponsor strip when one is docked; the property is
+        // unset otherwise, so the margin collapses to zero.
+        'absolute right-4 z-2 mt-[calc(-1_*_var(--sponsor-strip-height,0px))]',
         showFeedbackButton
           ? '-top-26 tablet:-top-32'
           : '-top-12 tablet:-top-18 laptop:-top-24',
diff --git a/packages/shared/src/components/feedback/FeedbackWidget.tsx b/packages/shared/src/components/feedback/FeedbackWidget.tsx
index 3f548adf7a6..98a79dcab82 100644
--- a/packages/shared/src/components/feedback/FeedbackWidget.tsx
+++ b/packages/shared/src/components/feedback/FeedbackWidget.tsx
@@ -182,7 +182,9 @@ export function FeedbackWidget({
     <Button
       variant={ButtonVariant.Primary}
       size={ButtonSize.Medium}
-      className="group fixed bottom-4 right-4 z-max !h-auto !gap-0 !px-3 py-1.5 shadow-2"
+      // `--sponsor-strip-height` is set only while the sponsor strip is docked
+      // (see `sponsorStripOffset`), so this is the usual 1rem everywhere else.
+      className="group fixed bottom-[calc(1rem_+_var(--sponsor-strip-height,0px))] right-4 z-max !h-auto !gap-0 !px-3 py-1.5 shadow-2"
       onClick={() => openModal({ type: LazyModal.Feedback })}
       aria-label="Send feedback. Real people reply."
       aria-keyshortcuts="Control+Shift+F Meta+Shift+F"
diff --git a/packages/shared/src/components/utilities/common.tsx b/packages/shared/src/components/utilities/common.tsx
index b1a14fed99f..91476307ff9 100644
--- a/packages/shared/src/components/utilities/common.tsx
+++ b/packages/shared/src/components/utilities/common.tsx
@@ -3,6 +3,7 @@ import React from 'react';
 import classNames from 'classnames';
 import classed from '../../lib/classed';
 import styles from './utilities.module.css';
+import feedStyles from '../Feed.module.css';
 import { ArrowIcon } from '../icons';
 import { SourceMemberRole } from '../../graphql/sources';
 import type { OrganizationMemberRole } from '../../features/organizations/types';
@@ -136,6 +137,38 @@ export const BaseFeedPage = classed(
 export const feedGutter =
   'tablet:px-6 laptop:px-10 laptop:[.layout-frame_&]:px-0';
 
+/**
+ * The feed grid's own width: full width normally, and clamped and centred to
+ * the same card-based max-width as the grid on wide screens (desktopL). Needs
+ * `--num-cards` and `--feed-gap` set on the element for that calc.
+ *
+ * Chrome that has to line up with the cards pairs this with `feedGutter`:
+ * together they are where the feed's left and right edges actually are, which
+ * neither one is on its own.
+ */
+export const feedWidth = classNames(
+  'w-full laptopL:mx-auto',
+  feedStyles.container,
+);
+
+/**
+ * The last step in to the cards, and the one `feedGutter` cannot describe.
+ *
+ * Inside the v2 floating card the gutter is zero — the card is already the
+ * frame — but the grid then takes an inset of its own so the cards sit off
+ * the frame's rounded corners (`laptop:p-6` in FeedContainer). So in v2 the
+ * cards' left and right edges are 24px inside the gutter's, and chrome that
+ * lines up with them by gutter alone lands a full inset short.
+ *
+ * Horizontal only: the grid's vertical half is the frame's own breathing
+ * room, and chrome outside the grid sets its own height.
+ *
+ * Keyed to the frame's class rather than to `isV2` for the same reason
+ * `feedGutter` is: the flag resolves after mount, and this inset has to
+ * appear at exactly the moment the frame it insets from does.
+ */
+export const feedFrameInsetX = 'laptop:[.layout-frame_&]:px-6';
+
 // Vertical padding only. The horizontal inset moved to FeedContainer
 // (see `feedGutter`) because this component is not in the tree on
 // every feed route — FeedPageLayoutList is used instead on some — and
diff --git a/packages/shared/src/features/monetization/sponsorStrip/SponsorLogo.tsx b/packages/shared/src/features/monetization/sponsorStrip/SponsorLogo.tsx
new file mode 100644
index 00000000000..051c75d9922
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/SponsorLogo.tsx
@@ -0,0 +1,134 @@
+import type { CSSProperties, ReactElement } from 'react';
+import React, { useMemo } from 'react';
+import classNames from 'classnames';
+import { AdPixel } from '../../../components/cards/ad/common/AdPixel';
+import { getViewedPixels } from '../../../components/cards/ad/common/getViewedPixels';
+import { anchorSponsoredRel } from '../../../lib/strings';
+import { boxedLogoHeight } from './sponsorLogoSizing';
+import type { ResolvedSponsor } from './sponsorStripCreative';
+import { useSponsorSlotLog } from './useSponsorSlotLog';
+
+interface SponsorLogoProps {
+  sponsor: ResolvedSponsor;
+  slotIndex: number;
+  /**
+   * Cap height for the optical sizing that keeps a wall of unrelated marks
+   * looking like one row. Omitted by the slot that sets `exactHeight`.
+   */
+  cap?: number;
+  /**
+   * Draw the mark at exactly this height and let the width follow the ratio.
+   * The gold slot's shape is known and it is meant to dominate, so trading
+   * its height away for width the way the wall does only makes it smaller.
+   */
+  exactHeight?: number;
+  /**
+   * Fixed box the mark is drawn into. Wall slots use one so the row's width
+   * cannot jump every time a rotation swaps a square mark for a long lockup;
+   * the gold slot takes its natural width instead.
+   */
+  boxWidth?: number;
+  /**
+   * Draw the mark as a single-colour silhouette that takes the surrounding
+   * text colour, instead of the file's own inks. This is what makes a wall of
+   * marks from a dozen advertisers read as one row in both themes — full
+   * colour there is a patchwork, and half the marks die against one ground.
+   * The gold slot is the exception: its brand colour is what was sold.
+   */
+  monochrome?: boolean;
+  /** Height ceiling in px, so a mark cannot outgrow the row it sits in. */
+  maxHeight?: number;
+  className?: string;
+}
+
+export const SponsorLogo = ({
+  sponsor,
+  slotIndex,
+  cap,
+  exactHeight,
+  boxWidth,
+  monochrome = false,
+  maxHeight,
+  className,
+}: SponsorLogoProps): ReactElement => {
+  const { ref, isViewable, onClick } = useSponsorSlotLog<HTMLAnchorElement>({
+    sponsor,
+    slotIndex,
+  });
+  const viewedPixels = useMemo(
+    () => getViewedPixels(sponsor.pixel),
+    [sponsor.pixel],
+  );
+  let height: number;
+
+  if (exactHeight !== undefined) {
+    height = exactHeight;
+  } else if (cap !== undefined) {
+    height = boxedLogoHeight(
+      sponsor.ratio,
+      cap,
+      boxWidth ?? Number.POSITIVE_INFINITY,
+      maxHeight,
+    );
+  } else {
+    throw new Error('SponsorLogo needs either a cap or an exactHeight');
+  }
+
+  const size: CSSProperties = {
+    height: `${height}px`,
+    width: `${Math.round(height * sponsor.ratio)}px`,
+  };
+
+  return (
+    <a
+      ref={ref}
+      href={sponsor.link}
+      target="_blank"
+      rel={anchorSponsoredRel}
+      title={sponsor.company}
+      onClick={onClick}
+      className={classNames(
+        'relative flex shrink-0 items-center justify-center',
+        className,
+      )}
+      style={boxWidth ? { width: `${boxWidth}px` } : undefined}
+    >
+      {monochrome ? (
+        <span
+          role="img"
+          aria-label={sponsor.company}
+          className="block"
+          style={{
+            ...size,
+            // `bg-current` is not in this palette — the design tokens replace
+            // the default colours — so the ink is painted directly and the
+            // logo file is what shapes it.
+            backgroundColor: 'currentColor',
+            maskImage: `url(${sponsor.logo})`,
+            maskRepeat: 'no-repeat',
+            maskPosition: 'center',
+            maskSize: 'contain',
+            WebkitMaskImage: `url(${sponsor.logo})`,
+            WebkitMaskRepeat: 'no-repeat',
+            WebkitMaskPosition: 'center',
+            WebkitMaskSize: 'contain',
+          }}
+        />
+      ) : (
+        <img
+          src={sponsor.logo}
+          alt={sponsor.company}
+          className="object-contain"
+          style={size}
+        />
+      )}
+      {/* No `fireOnMount`: the ad server should count the impression when the
+          mark reaches the viewport, which is how every other placement counts
+          it. Only the viewable re-fire below is already gated by then. */}
+      <AdPixel pixel={sponsor.pixel} />
+      {isViewable && !!viewedPixels.length && (
+        <AdPixel pixel={viewedPixels} fireOnMount />
+      )}
+    </a>
+  );
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/SponsorStrip.spec.tsx b/packages/shared/src/features/monetization/sponsorStrip/SponsorStrip.spec.tsx
new file mode 100644
index 00000000000..b2a697275b8
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/SponsorStrip.spec.tsx
@@ -0,0 +1,376 @@
+import React from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, fireEvent, render, screen, within } from '@testing-library/react';
+import type { AuthContextData } from '../../../contexts/AuthContext';
+import AuthContext from '../../../contexts/AuthContext';
+import { getLogContextStatic } from '../../../contexts/LogContext';
+import type { LogContextData } from '../../../hooks/log/useLogContextData';
+import type { PostHighlight } from '../../../graphql/highlights';
+import { AdActions } from '../../../lib/ads';
+import { LogEvent } from '../../../lib/log';
+import { SponsorStrip } from './SponsorStrip';
+import { fetchSponsorStripAds } from './mockSponsorStripAds';
+import { SponsorTier } from './sponsorStripCreative';
+
+jest.mock('./mockSponsorStripAds', () => ({
+  fetchSponsorStripAds: jest.fn(),
+}));
+
+jest.mock('../../../hooks/utils/useThemedAsset', () => ({
+  useIsLightTheme: () => false,
+}));
+
+const mockFetch = jest.mocked(fetchSponsorStripAds);
+let headlines: PostHighlight[] = [];
+let headlinesSettled = true;
+
+const creative = (
+  company: string,
+  tier: SponsorTier,
+  pixel: string[] = [],
+) => ({
+  gen_id: `gen-${company}`,
+  company,
+  logo_img: { light: `light-${company}`, dark: `dark-${company}` },
+  logo_ratio: 3,
+  link: `https://daily.dev/${company}`,
+  pixel,
+  tier,
+});
+
+const headline = (id: string): PostHighlight => ({
+  id,
+  channel: 'agents',
+  headline: `Headline ${id}`,
+  highlightedAt: new Date().toISOString(),
+  post: { id: `post-${id}`, commentsPermalink: `https://daily.dev/p/${id}` },
+});
+
+const PREMIUM = ['p1', 'p2', 'p3', 'p4', 'p5', 'p6'];
+const COMMUNITY = ['c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'c10'];
+
+// Wide enough for eight wall slots — four premium, four community — which
+// leaves the community deck bigger than the row it fills, the only state in
+// which a rotation has anywhere to go.
+const WALL_WIDTH = 900;
+const COMMUNITY_SLOTS = 4;
+
+const ads = [
+  creative('gold', SponsorTier.Gold, ['https://api.daily.dev/px?id=gold']),
+  ...PREMIUM.map((company) => creative(company, SponsorTier.Premium)),
+  ...COMMUNITY.map((company) => creative(company, SponsorTier.Community)),
+];
+
+const logEvent = jest.fn();
+const logEventStart = jest.fn();
+const logEventEnd = jest.fn();
+
+const LogContext = getLogContextStatic();
+
+const renderStrip = () => {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+
+  return render(
+    <QueryClientProvider client={client}>
+      <AuthContext.Provider
+        value={
+          {
+            isAuthReady: true,
+            user: { id: 'u1' },
+          } as unknown as AuthContextData
+        }
+      >
+        <LogContext.Provider
+          value={
+            {
+              logEvent,
+              logEventStart,
+              logEventEnd,
+              sendBeacon: jest.fn(),
+            } as unknown as LogContextData
+          }
+        >
+          <SponsorStrip
+            headlines={headlines}
+            headlinesSettled={headlinesSettled}
+          />
+        </LogContext.Provider>
+      </AuthContext.Provider>
+    </QueryClientProvider>,
+  );
+};
+
+/**
+ * Lets the ad query settle before the row is asserted on. The strip runs on
+ * fake timers for its rotation, so the query's promise has to be flushed by
+ * hand rather than waited on.
+ */
+const settle = async () => {
+  await act(async () => {
+    await Promise.resolve();
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+  });
+};
+
+const shownLogos = (): string[] =>
+  within(screen.getByTestId('sponsorStripRow'))
+    .getAllByRole('link')
+    .map((link) => link.getAttribute('title') as string);
+
+const extraOf = (call: unknown[]): Record<string, unknown> =>
+  JSON.parse((call[0] as { extra: string }).extra);
+
+const callsFor = (action: AdActions) =>
+  logEvent.mock.calls.filter(
+    ([event]) => (event as { event_name: string }).event_name === action,
+  );
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  jest.useFakeTimers();
+  mockFetch.mockResolvedValue(ads);
+  headlines = [];
+  headlinesSettled = true;
+  jest
+    .spyOn(Element.prototype, 'getBoundingClientRect')
+    .mockReturnValue({ width: WALL_WIDTH } as DOMRect);
+});
+
+afterEach(() => {
+  jest.useRealTimers();
+  document.documentElement.style.removeProperty('--sponsor-strip-height');
+});
+
+const setHeadlines = (next: PostHighlight[]) => {
+  headlines = next;
+};
+
+const publishedHeight = (): string =>
+  document.documentElement.style.getPropertyValue('--sponsor-strip-height');
+
+it('should render the gold sponsor, four premium slots and the community row', async () => {
+  renderStrip();
+  await settle();
+
+  const logos = shownLogos();
+
+  expect(logos[0]).toEqual('gold');
+  expect(logos.filter((company) => PREMIUM.includes(company))).toHaveLength(4);
+  expect(logos.filter((company) => COMMUNITY.includes(company))).toHaveLength(
+    COMMUNITY_SLOTS,
+  );
+});
+
+it('should log an impression per logo with its tier and slot', async () => {
+  renderStrip();
+  await settle();
+
+  const impressions = callsFor(AdActions.Impression);
+
+  // Exactly one per mark on the row, and none for a mark the row trimmed: the
+  // wall waits to be measured precisely so a creative it is about to drop
+  // never bills an impression on its way through.
+  expect(impressions).toHaveLength(shownLogos().length);
+  expect(extraOf(impressions[0])).toEqual(
+    expect.objectContaining({
+      placement: 'footer_logo',
+      tier: SponsorTier.Gold,
+      slot_index: 0,
+      gen_id: 'gen-gold',
+    }),
+  );
+});
+
+it('should open air time for every logo on the row', async () => {
+  renderStrip();
+  await settle();
+
+  expect(logEventStart).toHaveBeenCalledTimes(shownLogos().length);
+  expect(logEventStart.mock.calls[0][1]).toEqual(
+    expect.objectContaining({ event_name: AdActions.AirTime }),
+  );
+  expect(logEventStart.mock.calls[0][0]).toMatch(/^ss-0-gen-gold$/);
+});
+
+it('should hold the same row for the life of the page', async () => {
+  renderStrip();
+  await settle();
+
+  const before = shownLogos();
+
+  // Turnover is per page load now, so nothing may swap under the reader —
+  // and nothing may log a second impression for a slot that never changed.
+  await act(async () => {
+    jest.advanceTimersByTime(5 * 60_000);
+  });
+
+  expect(shownLogos()).toEqual(before);
+  expect(callsFor(AdActions.Impression)).toHaveLength(before.length);
+});
+
+it('should log a click with the logo that was clicked', async () => {
+  renderStrip();
+  await settle();
+
+  fireEvent.click(screen.getByTitle('gold'));
+
+  const clicks = callsFor(AdActions.Click);
+
+  expect(clicks).toHaveLength(1);
+  expect(extraOf(clicks[0])).toEqual(
+    expect.objectContaining({ gen_id: 'gen-gold', slot_index: 0 }),
+  );
+});
+
+it("should fire the ad server's impression pixel for a logo that carries one", async () => {
+  renderStrip();
+  await settle();
+
+  const pixels = screen.getAllByTestId('pixel');
+
+  expect(pixels).toHaveLength(1);
+  expect(pixels[0]).toHaveAttribute('src', 'https://api.daily.dev/px?id=gold');
+});
+
+it('should carry the breaking news the feed no longer shows', async () => {
+  setHeadlines([headline('h1'), headline('h2')]);
+  renderStrip();
+  await settle();
+
+  const ticker = within(screen.getByTestId('sponsorStripHeadlines'));
+
+  expect(ticker.getByText('Breaking news')).toBeInTheDocument();
+  expect(ticker.getByText('Headline h1')).toBeInTheDocument();
+  expect(ticker.getByText('Headline h2')).toBeInTheDocument();
+});
+
+it('should still carry the ticker when the ad server has no fill', async () => {
+  mockFetch.mockResolvedValue([]);
+  setHeadlines([headline('h1')]);
+  renderStrip();
+  await settle();
+
+  // The feed's card is suppressed on the strip's behalf, so a strip with no
+  // sponsors must not also drop the headlines.
+  expect(screen.getByTestId('sponsorStripHeadlines')).toBeInTheDocument();
+  expect(screen.queryByTestId('sponsorStripRow')).not.toBeInTheDocument();
+});
+
+it('should render nothing when it has neither sponsors nor headlines', async () => {
+  mockFetch.mockResolvedValue([]);
+  renderStrip();
+  await settle();
+
+  expect(screen.queryByTestId('sponsorStrip')).not.toBeInTheDocument();
+});
+
+it('should log a click on a headline with the headline that was clicked', async () => {
+  setHeadlines([headline('h1'), headline('h2')]);
+  renderStrip();
+  await settle();
+
+  fireEvent.click(screen.getByText('Headline h2'));
+
+  const clicks = logEvent.mock.calls.filter(
+    ([event]) =>
+      (event as { event_name: string }).event_name === LogEvent.Click,
+  );
+
+  expect(extraOf(clicks[0])).toEqual(
+    expect.objectContaining({ clicked_highlight_id: 'h2', position: 1 }),
+  );
+});
+
+it('should publish its height so the floating controls can clear it', async () => {
+  setHeadlines([headline('h1')]);
+  renderStrip();
+  await settle();
+
+  // The sponsor row plus the ticker: the feedback pill and the scroll-to-top
+  // button read this to lift out of the dock's way.
+  expect(publishedHeight()).toEqual('72px');
+});
+
+it('should publish only the height of the row it actually renders', async () => {
+  mockFetch.mockResolvedValue([]);
+  setHeadlines([headline('h1')]);
+  renderStrip();
+  await settle();
+
+  expect(publishedHeight()).toEqual('32px');
+});
+
+it('should take the offset back when it has nothing to show', async () => {
+  mockFetch.mockResolvedValue([]);
+  renderStrip();
+  await settle();
+
+  expect(publishedHeight()).toEqual('');
+});
+
+it('should take the offset back when it unmounts', async () => {
+  setHeadlines([headline('h1')]);
+  const { unmount } = renderStrip();
+  await settle();
+  unmount();
+
+  expect(publishedHeight()).toEqual('');
+});
+
+// Two independent round trips into a dock pinned to the viewport bottom: a row
+// appearing underneath shoves the logos up, so both are held open until their
+// query answers.
+it('should hold the ticker row open before the headlines arrive', async () => {
+  setHeadlines([]);
+  headlinesSettled = false;
+  renderStrip();
+  await settle();
+
+  expect(screen.getByTestId('sponsorStripHeadlines')).toBeInTheDocument();
+  expect(publishedHeight()).toEqual('72px');
+});
+
+it('should hold the sponsor row open before the ad query answers', () => {
+  setHeadlines([headline('h1')]);
+  renderStrip();
+
+  expect(screen.getByTestId('sponsorStripRow')).toBeInTheDocument();
+  expect(publishedHeight()).toEqual('72px');
+});
+
+const tickerImpressions = () =>
+  logEvent.mock.calls.filter(
+    (call) =>
+      (call[0] as { event_name: string }).event_name === LogEvent.Impression &&
+      extraOf(call).feed === 'sponsor-strip-headlines',
+  );
+
+it('should log the ticker impression once the headlines arrive', async () => {
+  setHeadlines([headline('h1'), headline('h2')]);
+  renderStrip();
+  await settle();
+
+  expect(tickerImpressions()).toHaveLength(1);
+  expect(extraOf(tickerImpressions()[0]).count).toEqual(2);
+});
+
+it('should not log a ticker impression while the row is still empty', async () => {
+  setHeadlines([]);
+  headlinesSettled = false;
+  renderStrip();
+  await settle();
+
+  expect(tickerImpressions()).toHaveLength(0);
+});
+
+it('should collapse the reserved row once the query answers empty', async () => {
+  setHeadlines([]);
+  renderStrip();
+  await settle();
+
+  expect(screen.queryByTestId('sponsorStripHeadlines')).not.toBeInTheDocument();
+  expect(publishedHeight()).toEqual('40px');
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/SponsorStrip.tsx b/packages/shared/src/features/monetization/sponsorStrip/SponsorStrip.tsx
new file mode 100644
index 00000000000..3bb31a19074
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/SponsorStrip.tsx
@@ -0,0 +1,222 @@
+import type { CSSProperties, ReactElement } from 'react';
+import React, { useContext } from 'react';
+import classNames from 'classnames';
+import {
+  COMMUNITY_CAP,
+  GOLD_HEIGHT,
+  PREMIUM_CAP,
+  SLOT_WIDTH,
+  WALL_MAX_HEIGHT,
+} from './sponsorLogoSizing';
+import { SponsorLogo } from './SponsorLogo';
+import { SponsorStripHeadlines } from './SponsorStripHeadlines';
+import type { PostHighlight } from '../../../graphql/highlights';
+import type { ResolvedSponsor } from './sponsorStripCreative';
+import {
+  DOCK_CLASS,
+  HEADLINES_ROW_HEIGHT,
+  SPONSOR_ROW_HEIGHT,
+  usePublishStripHeight,
+} from './sponsorStripOffset';
+import {
+  feedFrameInsetX,
+  feedGutter,
+  feedWidth,
+} from '../../../components/utilities/common';
+import { PREMIUM_SLOT_COUNT } from './sponsorStripSlots';
+import { useSponsorStripAds } from './useSponsorStripAds';
+import FeedContext from '../../../contexts/FeedContext';
+
+interface SponsorStripProps {
+  /**
+   * Passed in rather than queried here: the feed layout needs the same list to
+   * decide whether it can give up its Happening Now card, and one query
+   * cannot be allowed to answer that question two different ways.
+   */
+  headlines: PostHighlight[];
+  /** Whether that query has answered; see the row reservation below. */
+  headlinesSettled: boolean;
+}
+
+interface SponsorRowProps {
+  gold: ResolvedSponsor | null;
+  premium: ResolvedSponsor[];
+  community: ResolvedSponsor[];
+  wallRef: (node: HTMLElement | null) => void;
+  widthStyle: CSSProperties;
+}
+
+const SponsorRow = ({
+  gold,
+  premium,
+  community,
+  wallRef,
+  widthStyle,
+}: SponsorRowProps): ReactElement => (
+  // The border and the ground span the dock; only the content is held to the
+  // feed's own edges, so the row reads as one bar under a column of cards.
+  <div
+    data-testid="sponsorStripRow"
+    className="w-full border-t border-border-subtlest-tertiary"
+  >
+    <div className={classNames(feedGutter, feedWidth)} style={widthStyle}>
+      {/* The frame inset rides its own element rather than joining the two
+        above: all three set horizontal padding, and stacking them on one
+        element leaves which wins to the order Tailwind happens to emit
+        them in. Nested, they compose — the gutter finds the frame, and this
+        finds the cards inside it. */}
+      <div
+        className={classNames('flex h-10 items-center gap-5', feedFrameInsetX)}
+      >
+        {gold && (
+          <div className="flex shrink-0 items-center gap-x-2.5">
+            <span className="whitespace-nowrap text-text-quaternary typo-caption2">
+              Made possible by
+            </span>
+            {/* The gold mark is the one slot that keeps its own inks and its
+              own size: one coloured mark at full height against a silhouetted
+              wall is the whole hierarchy of the row, without a hover effect
+              on top. */}
+            <SponsorLogo
+              sponsor={gold}
+              slotIndex={0}
+              exactHeight={GOLD_HEIGHT}
+              className="text-text-primary"
+            />
+          </div>
+        )}
+        {gold && !!(premium.length || community.length) && (
+          <span
+            aria-hidden
+            className="h-5 w-px shrink-0 bg-border-subtlest-tertiary"
+          />
+        )}
+        {/* One run for both wall tiers, spread with `justify-between` the way
+          the broadcast bar this borrows from distributes its credits: the row
+          breathes on a wide window and tightens before it clips. Premium sits
+          left and carries a hair more ink; the slots are a fixed width, so a
+          rotation swapping a square mark for a long lockup cannot make the
+          whole row shuffle sideways. */}
+        <div
+          ref={wallRef}
+          className="flex min-w-0 flex-1 items-center justify-between gap-4 overflow-hidden"
+        >
+          {premium.map((sponsor, index) => (
+            <SponsorLogo
+              key={sponsor.genId}
+              sponsor={sponsor}
+              slotIndex={index + 1}
+              cap={PREMIUM_CAP}
+              boxWidth={SLOT_WIDTH}
+              maxHeight={WALL_MAX_HEIGHT}
+              monochrome
+              className="text-text-secondary transition-colors hover:text-text-primary"
+            />
+          ))}
+          {community.map((sponsor, index) => (
+            <SponsorLogo
+              key={sponsor.genId}
+              sponsor={sponsor}
+              // Offset by the full premium row rather than by how many premium
+              // creatives happened to fill it, so a slot index means the same
+              // position from one session to the next.
+              slotIndex={index + 1 + PREMIUM_SLOT_COUNT}
+              cap={COMMUNITY_CAP}
+              boxWidth={SLOT_WIDTH}
+              maxHeight={WALL_MAX_HEIGHT}
+              monochrome
+              className="text-text-tertiary transition-colors hover:text-text-primary"
+            />
+          ))}
+        </div>
+      </div>
+    </div>
+  </div>
+);
+
+/**
+ * The dock: the paid row with the breaking-news ticker stacked under it.
+ *
+ * Two rows rather than one, and the reason is not decoration. Browsers draw
+ * their link-status bubble in the bottom corner over whatever the page
+ * renders, and on a feed of links it is up most of the time. Stacking puts
+ * something expendable in its path — a label on ambient data — and lifts the
+ * row an advertiser paid for clear of it. It also earns the space: a permanent
+ * bar carrying only advertising is rent, while one carrying the headlines the
+ * reader came for is a feature that happens to be sponsored.
+ *
+ * Either row can be missing — no fill from the ad server, or no headlines at
+ * all — and the dock still holds the other one. What it must never do is show
+ * neither while the feed's Happening Now card is suppressed on its behalf,
+ * which is why an empty dock renders nothing at all and the suppression is
+ * keyed to the same gate.
+ *
+ * Both rows are held open at their own height until their query answers. They
+ * are two independent round trips into a dock pinned to the bottom of the
+ * viewport, so a row appearing under the logos shoves the logos upward — and
+ * the reader watches the paid row jump on every load. Reserving costs an empty
+ * bar for as long as the queries take; collapsing happens only once a query
+ * has answered and there is genuinely nothing to show.
+ */
+export const SponsorStrip = ({
+  headlines,
+  headlinesSettled,
+}: SponsorStripProps): ReactElement | null => {
+  const {
+    gold,
+    premium,
+    community,
+    wallRef,
+    isSettled: adsSettled,
+  } = useSponsorStripAds({
+    enabled: true,
+  });
+  // Read here rather than passed down: the dock is mounted inside the same
+  // providers as the feed, and the calc behind `feedWidth` needs these.
+  const { numCards } = useContext(FeedContext);
+  const widthStyle = {
+    '--num-cards': numCards.eco,
+    '--feed-gap': '2rem',
+  } as CSSProperties;
+  const hasSponsors = !!gold || !!premium.length || !!community.length;
+  const showSponsorRow = hasSponsors || !adsSettled;
+  const showHeadlines = !!headlines.length || !headlinesSettled;
+  // Published before the early return so the controls that lift for the dock
+  // also settle back when it has nothing to show.
+  usePublishStripHeight(
+    (showSponsorRow ? SPONSOR_ROW_HEIGHT : 0) +
+      (showHeadlines ? HEADLINES_ROW_HEIGHT : 0),
+  );
+
+  if (!showSponsorRow && !showHeadlines) {
+    return null;
+  }
+
+  return (
+    <div
+      data-testid="sponsorStrip"
+      className={classNames(
+        'sticky bottom-0 z-3 hidden w-full flex-col bg-background-default tablet:flex',
+        // `sticky bottom-0` reaches the viewport bottom only while its
+        // containing block extends past that line, so the dock needs the v2
+        // frame to run all the way down — see `DOCK_CLASS`, which is how the
+        // frame knows to drop its bottom inset. Without that the dock has two
+        // resting places and jumps between them.
+        DOCK_CLASS,
+      )}
+    >
+      {showSponsorRow && (
+        <SponsorRow
+          gold={gold}
+          premium={premium}
+          community={community}
+          wallRef={wallRef}
+          widthStyle={widthStyle}
+        />
+      )}
+      {showHeadlines && (
+        <SponsorStripHeadlines headlines={headlines} widthStyle={widthStyle} />
+      )}
+    </div>
+  );
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/SponsorStripHeadlines.tsx b/packages/shared/src/features/monetization/sponsorStrip/SponsorStripHeadlines.tsx
new file mode 100644
index 00000000000..6d3ce98e5d5
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/SponsorStripHeadlines.tsx
@@ -0,0 +1,116 @@
+import type { CSSProperties, ReactElement } from 'react';
+import React, { useCallback } from 'react';
+import classNames from 'classnames';
+import { getHighlightsUrl } from '../../../components/cards/highlight/common';
+import Link from '../../../components/utilities/Link';
+import { RelativeTime } from '../../../components/utilities/RelativeTime';
+import { useLogContext } from '../../../contexts/LogContext';
+import type { PostHighlight } from '../../../graphql/highlights';
+import useLogEventOnce from '../../../hooks/log/useLogEventOnce';
+import { feedHighlightsLogEvent } from '../../../lib/feed';
+import {
+  feedFrameInsetX,
+  feedGutter,
+  feedWidth,
+} from '../../../components/utilities/common';
+import { LogEvent, Origin } from '../../../lib/log';
+
+const HEADLINES_FEED_NAME = 'sponsor-strip-headlines';
+
+/**
+ * The row carries more than fits on purpose: it should read as a ticker
+ * continuing past the edge, not a list that happens to end. The fade is what
+ * makes that read as intentional — a hard clip chops a headline in half and
+ * looks like a bug.
+ */
+const fadeStyle: CSSProperties = {
+  maskImage:
+    'linear-gradient(to right, black calc(100% - 2.5rem), transparent)',
+  WebkitMaskImage:
+    'linear-gradient(to right, black calc(100% - 2.5rem), transparent)',
+};
+
+export const SponsorStripHeadlines = ({
+  headlines,
+  widthStyle,
+}: {
+  headlines: PostHighlight[];
+  widthStyle: CSSProperties;
+}): ReactElement => {
+  const { logEvent } = useLogContext();
+
+  // Conditional because the row is mounted empty to hold its height open
+  // while the query runs, and an impression logged then would report a ticker
+  // of nothing.
+  useLogEventOnce(
+    () =>
+      feedHighlightsLogEvent(LogEvent.Impression, {
+        feedName: HEADLINES_FEED_NAME,
+        action: 'impression',
+        count: headlines.length,
+        highlightIds: headlines.map(({ id }) => id),
+        origin: Origin.Feed,
+      }),
+    { condition: !!headlines.length },
+  );
+
+  const onHeadlineClick = useCallback(
+    (highlight: PostHighlight, position: number) =>
+      logEvent(
+        feedHighlightsLogEvent(LogEvent.Click, {
+          feedName: HEADLINES_FEED_NAME,
+          clickedHighlight: highlight,
+          position,
+          origin: Origin.Feed,
+        }),
+      ),
+    [logEvent],
+  );
+
+  return (
+    <div
+      data-testid="sponsorStripHeadlines"
+      className="w-full border-t border-border-subtlest-tertiary bg-background-default"
+    >
+      <div className={classNames(feedGutter, feedWidth)} style={widthStyle}>
+        {/* See the sponsor row: the frame inset is nested rather than stacked
+          so the three horizontal paddings compose instead of racing. */}
+        <div
+          className={classNames('flex h-8 items-center gap-4', feedFrameInsetX)}
+        >
+          {/* The sacrificial left zone, and the reason the strip has two rows
+            at all: the browser paints its link-status bubble over this corner,
+            and a label losing a word to it costs nothing, where the row above
+            it is the one somebody paid for. */}
+          <span className="shrink-0 whitespace-nowrap text-text-quaternary typo-caption2">
+            Breaking news
+          </span>
+          {/* Scrollable rather than merely clipped: the row carries more than
+            it can show, and a reader who wants the headline under the fade has
+            no other way to reach it. The bar is hidden because the fade
+            already says the row continues. */}
+          <div
+            className="no-scrollbar flex min-w-0 flex-1 items-center gap-5 overflow-x-auto"
+            style={fadeStyle}
+          >
+            {headlines.map((highlight, index) => (
+              <Link href={getHighlightsUrl(highlight.id)} key={highlight.id}>
+                <a
+                  href={getHighlightsUrl(highlight.id)}
+                  onClick={() => onHeadlineClick(highlight, index)}
+                  className="flex shrink-0 items-center gap-1.5 whitespace-nowrap text-text-secondary typo-caption1 hover:text-text-primary"
+                >
+                  {highlight.headline}
+                  <RelativeTime
+                    dateTime={highlight.highlightedAt}
+                    className="text-text-quaternary"
+                  />
+                </a>
+              </Link>
+            ))}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/mockSponsorStripAds.ts b/packages/shared/src/features/monetization/sponsorStrip/mockSponsorStripAds.ts
new file mode 100644
index 00000000000..1a297f901c7
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/mockSponsorStripAds.ts
@@ -0,0 +1,152 @@
+import { SponsorTier } from './sponsorStripCreative';
+
+/**
+ * Stand-in for the `footer_logo` placement while the ad server side is built.
+ * Swapping it for the real thing is one call:
+ *
+ *   GET /v1/a/footer_logo?count=<n>  (+ the consent params in `lib/ads.ts`)
+ *
+ * The payload below is the wire shape `sponsorStripCreativeSchema` parses, so
+ * the response drops in without touching anything downstream.
+ *
+ * PLACEHOLDER DATA — not a sponsorship and not an ad server. The wall marks
+ * are advertiser logos already published on business.daily.dev, borrowed so
+ * the row can be judged at the weight and spacing real assets give it. The
+ * gold slot carries Google Cloud, per the design mockup, drawn from the
+ * lockup their own site serves. It is still a fixture: nothing here says a
+ * gold slot has been sold, and the "Made possible by" label claims more than
+ * a display campaign does, so this stays behind the experiment flag until the
+ * slot is actually sold.
+ *
+ * One mark is deliberately absent: business.daily.dev serves GitLab's logo as
+ * a base64 WebP wrapped in an `<svg>`, and a raster has no alpha shape to mask
+ * — it silhouettes into a solid block. It is the clearest example of why real
+ * inventory needs an asset spec, and it is left out rather than papered over.
+ *
+ * `pixel` is empty throughout. A fixture that pinged the ad server with
+ * invented generation ids would put junk impressions in real reporting; the
+ * pixel path is covered by the specs instead.
+ */
+
+const LOGO_BASE = 'https://business.daily.dev/assets/company-logos';
+
+const wallSponsor = (
+  company: string,
+  file: string,
+  ratio: number,
+  tier: SponsorTier,
+) => ({
+  gen_id: `mock-${file}`,
+  company,
+  // The same file for both themes: the wall silhouettes its marks through a
+  // mask that takes the row's text colour, so one asset serves either ground.
+  // Real creatives are expected to carry a themed pair — see the gold slot,
+  // which cannot be masked because its colour is the point.
+  logo_img: {
+    light: `${LOGO_BASE}/${file}.svg`,
+    dark: `${LOGO_BASE}/${file}.svg`,
+  },
+  logo_ratio: ratio,
+  link: `https://daily.dev/?utm_source=sponsor_strip&sponsor=${file}`,
+  pixel: [] as string[],
+  tier,
+});
+
+/**
+ * The gold slot's artwork: Google Cloud's own lockup, taken from the file
+ * their site serves (gstatic.com/cgc/google-cloud-logo-fullcolor.svg) — the
+ * four-ink Google wordmark followed by "Cloud", and no cloud symbol. The
+ * symbol lockup is an older mark they no longer lead with, and the inks here
+ * are their refreshed palette, brighter than the classic four.
+ */
+const GOOGLE_WORDMARK = [
+  // G
+  {
+    ink: '#3186FF',
+    d: 'M7.666 15.529c-1.423-.014-2.721-.367-3.895-1.058a7.659 7.659 0 0 1-2.766-2.832C.335 10.449 0 9.142 0 7.718c0-1.446.335-2.756 1.005-3.932a7.292 7.292 0 0 1 2.766-2.77C4.945.34 6.25 0 7.687 0c1.119 0 2.144.187 3.077.56a6.008 6.008 0 0 1 2.382 1.722L11.644 3.86c-.587-.602-1.191-1.034-1.813-1.297-.614-.263-1.319-.394-2.113-.394-1.008 0-1.92.228-2.735.685a4.987 4.987 0 0 0-1.937 1.96c-.47.844-.705 1.822-.705 2.936 0 1.086.235 2.057.705 2.915a5.136 5.136 0 0 0 1.927 1.991c.815.478 1.73.716 2.745.716.905 0 1.713-.159 2.424-.477a4.146 4.146 0 0 0 1.74-1.452c.442-.643.708-1.425.798-2.345H7.635V6.95h7.19c.069.457.103.871.103 1.245 0 1.452-.3 2.739-.901 3.859a6.31 6.31 0 0 1-2.559 2.583c-1.098.608-2.365.906-3.802.892z',
+  },
+  // o
+  {
+    ink: '#FC413D',
+    d: 'M21.588 15.53c-1.064 0-2.02-.246-2.87-.737a5.249 5.249 0 0 1-1.978-2.023c-.47-.864-.705-1.836-.705-2.915 0-1.106.242-2.085.725-2.935a5.175 5.175 0 0 1 2-1.992c.842-.47 1.785-.705 2.828-.705 1.057 0 2.006.238 2.849.715a5.156 5.156 0 0 1 2 2.002c.483.858.724 1.83.724 2.915 0 1.08-.238 2.05-.715 2.915a5.208 5.208 0 0 1-1.989 2.033c-.842.484-1.799.726-2.87.726zm0-1.971c.656 0 1.236-.163 1.74-.488a3.308 3.308 0 0 0 1.181-1.338 4.144 4.144 0 0 0 .425-1.878c0-.677-.142-1.293-.425-1.846a3.235 3.235 0 0 0-1.18-1.328 3.174 3.174 0 0 0-1.741-.487c-.608 0-1.167.155-1.678.466a3.38 3.38 0 0 0-1.223 1.307c-.297.554-.445 1.183-.445 1.888 0 .678.138 1.3.414 1.868.283.56.677 1.006 1.181 1.338.511.332 1.095.498 1.75.498z',
+  },
+  // o
+  {
+    ink: '#FFBE00',
+    d: 'M33.637 15.53c-1.064 0-2.02-.246-2.87-.737a5.25 5.25 0 0 1-1.979-2.023c-.47-.864-.704-1.836-.704-2.915 0-1.106.242-2.085.725-2.935a5.173 5.173 0 0 1 2-1.992c.842-.47 1.785-.705 2.828-.705 1.056 0 2.006.238 2.849.715a5.155 5.155 0 0 1 1.999 2.002c.483.858.725 1.83.725 2.915 0 1.08-.238 2.05-.715 2.915a5.21 5.21 0 0 1-1.989 2.033c-.842.484-1.799.726-2.87.726zm0-1.971c.656 0 1.236-.163 1.74-.488a3.309 3.309 0 0 0 1.181-1.338 4.143 4.143 0 0 0 .425-1.878c0-.677-.142-1.293-.425-1.846a3.236 3.236 0 0 0-1.18-1.328 3.174 3.174 0 0 0-1.741-.487c-.608 0-1.168.155-1.678.466a3.381 3.381 0 0 0-1.223 1.307c-.297.554-.445 1.183-.445 1.888 0 .678.138 1.3.414 1.868.283.56.677 1.006 1.18 1.338.512.332 1.096.498 1.752.498z',
+  },
+  // g
+  {
+    ink: '#3186FF',
+    d: 'M45.376 20c-1.188 0-2.169-.25-2.942-.747-.767-.498-1.406-1.29-1.917-2.376l1.948-.86c.324.615.718 1.096 1.18 1.441.463.353 1.03.53 1.7.53 1.022 0 1.799-.298 2.33-.893.54-.595.809-1.424.809-2.49v-.964h-.073c-.166.249-.4.501-.704.757a4.33 4.33 0 0 1-1.12.643 3.95 3.95 0 0 1-1.45.26c-1.043 0-1.947-.232-2.714-.696a4.575 4.575 0 0 1-1.761-1.929c-.407-.83-.611-1.78-.611-2.852 0-1.059.203-2.006.611-2.843.407-.843.988-1.504 1.74-1.981.76-.477 1.644-.716 2.652-.716.719 0 1.378.142 1.98.425.6.284 1.07.689 1.408 1.214h.041V4.606h2.155v9.356c0 4.025-1.754 6.038-5.262 6.038zm0-6.753c.635 0 1.188-.149 1.657-.446.47-.298.829-.71 1.078-1.235.248-.532.373-1.137.373-1.815 0-.692-.125-1.297-.373-1.815a2.754 2.754 0 0 0-1.078-1.214c-.47-.284-1.019-.425-1.647-.425-.615 0-1.157.145-1.627.435-.47.284-.835.688-1.098 1.214-.262.526-.393 1.13-.393 1.815 0 .72.131 1.342.393 1.868.27.525.64.926 1.109 1.203.47.276 1.005.415 1.606.415z',
+  },
+  // l
+  { ink: '#00AF57', d: 'M52.307 15.187V.332h2.258v14.855h-2.258z' },
+  // e
+  {
+    ink: '#FC413D',
+    d: 'M61.233 15.508c-1.588 0-2.904-.512-3.947-1.535-1.035-1.024-1.554-2.372-1.554-4.046 0-1.639.501-2.987 1.503-4.045 1.008-1.065 2.324-1.598 3.947-1.598 1.063 0 1.982.273 2.755.82.78.546 1.395 1.4 1.844 2.562a4.488 4.488 0 0 1 .207.788l-8.494 3.61-.59-1.712 7.033-2.987-.197.944c-.262-.74-.628-1.276-1.098-1.608a2.587 2.587 0 0 0-1.543-.498c-.967 0-1.737.332-2.31.996-.574.657-.86 1.521-.86 2.593 0 1.01.331 1.871.994 2.583.663.713 1.468 1.069 2.414 1.069.566 0 1.095-.142 1.585-.426.49-.283.919-.68 1.285-1.193l1.678 1.1a5.4 5.4 0 0 1-1.927 1.878c-.815.47-1.723.705-2.725.705z',
+  },
+];
+
+/**
+ * "Cloud" ships as #212226 — near-black, and it all but disappears against
+ * the dark feed — so it is the one ink taken off their file and flipped with
+ * the ground instead. Nothing else about the artwork changes.
+ */
+const CLOUD_WORD =
+  'M78.58 15.545c-2.204 0-4.041-.74-5.512-2.22-1.471-1.487-2.207-3.347-2.207-5.58 0-2.241.74-4.091 2.217-5.55 1.478-1.46 3.308-2.19 5.49-2.19a7.57 7.57 0 0 1 2.062.28 6.652 6.652 0 0 1 1.803.8c.546.339 1.115.83 1.71 1.473L82.567 4.05c-.511-.546-.95-.933-1.316-1.161a4.272 4.272 0 0 0-1.202-.519 5.418 5.418 0 0 0-1.47-.187c-1.54 0-2.832.512-3.875 1.535-1.043 1.017-1.564 2.355-1.564 4.015 0 1.653.517 3.005 1.553 4.056 1.036 1.044 2.331 1.566 3.885 1.566.546 0 1.07-.076 1.575-.228a5.14 5.14 0 0 0 1.378-.643c.414-.277.863-.685 1.347-1.224l1.616 1.546c-.663.74-1.288 1.29-1.876 1.649-.58.36-1.208.63-1.885.809a8.07 8.07 0 0 1-2.155.28zm7.055-.342V.348h2.258v14.855h-2.258zm9.052.342c-1.61 0-2.939-.536-3.988-1.608-1.05-1.072-1.575-2.42-1.575-4.045 0-1.646.525-2.998 1.575-4.056 1.056-1.058 2.386-1.587 3.988-1.587 1.602 0 2.932.532 3.989 1.597 1.056 1.065 1.584 2.414 1.584 4.046 0 1.625-.524 2.973-1.574 4.045s-2.383 1.608-3.999 1.608zm0-1.97c.946 0 1.74-.343 2.383-1.028.642-.691.963-1.577.963-2.655 0-1.093-.324-1.978-.974-2.656-.642-.678-1.433-1.017-2.372-1.017-.946 0-1.74.34-2.383 1.017-.642.678-.963 1.563-.963 2.656 0 1.078.318 1.964.953 2.655.642.685 1.44 1.027 2.393 1.027zm10.639 1.97c-1.257 0-2.227-.363-2.911-1.09-.684-.732-1.025-1.766-1.025-3.1V4.59h2.258v6.42c0 .865.197 1.526.59 1.982.401.457.971.685 1.71.685.773 0 1.426-.298 1.958-.892.532-.602.797-1.321.797-2.158V4.591h2.259v10.612h-2.145v-2.521l1.026 1.027h-1.088c-.297.533-.759.972-1.388 1.317a4.165 4.165 0 0 1-2.041.52zm11.894 0c-1.443 0-2.642-.522-3.595-1.566-.946-1.051-1.419-2.41-1.419-4.077 0-1.653.48-3.005 1.44-4.056.967-1.051 2.176-1.577 3.626-1.577a4.18 4.18 0 0 1 2.02.498c.621.325 1.088.754 1.399 1.286h.072V.348h2.238v14.855h-2.155v-1.878l.238.415h-.3c-.332.546-.819.986-1.461 1.317a4.59 4.59 0 0 1-2.103.488zm.404-1.95c.905 0 1.664-.346 2.279-1.038.622-.698.933-1.587.933-2.665 0-1.08-.314-1.957-.943-2.635-.622-.678-1.378-1.017-2.269-1.017-.891 0-1.65.34-2.279 1.017-.622.678-.932 1.56-.932 2.645 0 1.072.307 1.957.922 2.655.621.692 1.384 1.038 2.289 1.038z';
+
+const GOLD_COMPANY = 'Google Cloud';
+/** The artwork's own box, so `logo_ratio` below is measured, not guessed. */
+const GOLD_BOX = { width: 123, height: 20 };
+
+/**
+ * A lockup rather than a word, so the paid slot reads as a logo at a glance
+ * the way the marks beside it do. Two inks: the wordmark holds its brand
+ * colours in both themes while "Cloud" flips, which is exactly the case a
+ * single flat file cannot serve and the reason the wire contract takes a
+ * pair.
+ */
+const goldLockup = (cloudInk: string): string => {
+  const wordmark = GOOGLE_WORDMARK.map(
+    ({ ink, d }) => `<path fill="${ink}" d="${d}"/>`,
+  ).join('');
+  const svg =
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${GOLD_BOX.width}" height="${GOLD_BOX.height}" viewBox="0 0 ${GOLD_BOX.width} ${GOLD_BOX.height}">` +
+    `${wordmark}<path fill="${cloudInk}" d="${CLOUD_WORD}"/></svg>`;
+
+  return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+};
+
+const MOCK_SPONSOR_STRIP_ADS = [
+  {
+    gen_id: 'mock-gold',
+    company: GOLD_COMPANY,
+    logo_img: {
+      light: goldLockup('#0E1217'),
+      dark: goldLockup('#FFFFFF'),
+    },
+    logo_ratio: GOLD_BOX.width / GOLD_BOX.height,
+    link: 'https://cloud.google.com/free?utm_source=sponsor_strip&sponsor=google-cloud',
+    pixel: [] as string[],
+    tier: SponsorTier.Gold,
+  },
+  // Ratios are the marks' own, read off each file's viewBox, so the optical
+  // sizing has the same numbers a real creative would carry.
+  wallSponsor('Datadog', 'datadog', 800.5 / 203.19, SponsorTier.Premium),
+  wallSponsor('PostHog', 'posthog', 512 / 90, SponsorTier.Premium),
+  wallSponsor('ClickHouse', 'clickhouse', 584.9 / 103.1, SponsorTier.Premium),
+  wallSponsor('Retool', 'retool', 87 / 17, SponsorTier.Premium),
+  wallSponsor('Snyk', 'snyk', 65 / 35, SponsorTier.Premium),
+  wallSponsor('Okta', 'okta', 512 / 169, SponsorTier.Community),
+  wallSponsor('Neo4j', 'neo4j', 512 / 170, SponsorTier.Community),
+  wallSponsor('Pulumi', 'pulumi', 512 / 128, SponsorTier.Community),
+  wallSponsor('LaunchDarkly', 'launchdarkly', 512 / 80, SponsorTier.Community),
+  wallSponsor('Sonar', 'sonar', 512 / 125, SponsorTier.Community),
+  wallSponsor('JetBrains', 'jetbrains', 298 / 64, SponsorTier.Community),
+  wallSponsor('Sentry', 'sentry', 512 / 113, SponsorTier.Community),
+];
+
+export const fetchSponsorStripAds = async (): Promise<unknown> =>
+  MOCK_SPONSOR_STRIP_ADS;
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorLogoSizing.spec.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorLogoSizing.spec.ts
new file mode 100644
index 00000000000..4160e92efe0
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorLogoSizing.spec.ts
@@ -0,0 +1,66 @@
+import {
+  COMMUNITY_CAP,
+  SLOT_GAP,
+  SLOT_WIDTH,
+  WALL_MAX_HEIGHT,
+  boxedLogoHeight,
+  fittedSlotCount,
+  opticalHeight,
+} from './sponsorLogoSizing';
+
+describe('opticalHeight', () => {
+  it('should give a square mark more height than a long lockup', () => {
+    expect(opticalHeight(1, COMMUNITY_CAP)).toBeGreaterThan(
+      opticalHeight(6, COMMUNITY_CAP),
+    );
+  });
+
+  it('should clamp both extremes so nothing blows out the row', () => {
+    expect(opticalHeight(0.1, COMMUNITY_CAP)).toEqual(
+      Math.round(COMMUNITY_CAP * 1.6),
+    );
+    expect(opticalHeight(20, COMMUNITY_CAP)).toEqual(
+      Math.round(COMMUNITY_CAP * 0.8),
+    );
+  });
+});
+
+describe('boxedLogoHeight', () => {
+  it('should hold a wide lockup down to what the box can show', () => {
+    const ratio = 12;
+
+    expect(
+      boxedLogoHeight(ratio, COMMUNITY_CAP, SLOT_WIDTH) * ratio,
+    ).toBeLessThanOrEqual(SLOT_WIDTH);
+  });
+
+  it('should leave a mark that already fits at its optical height', () => {
+    expect(boxedLogoHeight(2, COMMUNITY_CAP, SLOT_WIDTH)).toEqual(
+      opticalHeight(2, COMMUNITY_CAP),
+    );
+  });
+});
+
+describe('boxedLogoHeight, row ceiling', () => {
+  it('should hold a square mark down to the row it sits in', () => {
+    // A 1:1 mark takes the tallest optical height there is, which is what
+    // would otherwise push the row open.
+    expect(
+      boxedLogoHeight(1, COMMUNITY_CAP, SLOT_WIDTH, WALL_MAX_HEIGHT),
+    ).toEqual(WALL_MAX_HEIGHT);
+  });
+});
+
+describe('fittedSlotCount', () => {
+  it('should count the slots that fit with their gaps', () => {
+    const three = SLOT_WIDTH * 3 + SLOT_GAP * 2;
+
+    expect(fittedSlotCount(three)).toEqual(3);
+    expect(fittedSlotCount(three + SLOT_WIDTH - 1)).toEqual(3);
+  });
+
+  it('should treat an unmeasurably narrow row as unmeasured', () => {
+    expect(fittedSlotCount(SLOT_WIDTH - 1)).toBeNull();
+    expect(fittedSlotCount(0)).toBeNull();
+  });
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorLogoSizing.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorLogoSizing.ts
new file mode 100644
index 00000000000..14b702464af
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorLogoSizing.ts
@@ -0,0 +1,73 @@
+/**
+ * The gold mark is drawn at this height, full stop — no optical normalising.
+ * That normalising exists to stop a dozen unrelated wall marks fighting each
+ * other, and it works by trading height for width, so it punishes exactly the
+ * wide mark-plus-wordmark lockup a paid slot is most likely to supply: the
+ * lockup came out shorter than the tallest silhouette beside it, which is the
+ * opposite of what the slot is sold as. One known creative in one slot does
+ * not need normalising, it needs to be the biggest thing on the row.
+ *
+ * It is the box height, not the cap height, and a lockup that is all wordmark
+ * spends nearly all of that box on letterforms where a mark-plus-wordmark
+ * spends it on the mark. Sized for the former: matching the wall's ceiling in
+ * height, it still leads the row on width and on being the one slot in
+ * colour.
+ */
+export const GOLD_HEIGHT = 20;
+/** The wall's two tiers differ by a hair of ink, not by a wash of opacity. */
+export const PREMIUM_CAP = 17;
+export const COMMUNITY_CAP = 15;
+
+/**
+ * Ceiling for the wall, which the optical sizing knows nothing about: a
+ * near-square mark would otherwise take its full optical height and outgrow
+ * the 40px row.
+ */
+export const WALL_MAX_HEIGHT = 20;
+
+/** Fixed box every wall mark is drawn into, and the gap between boxes. */
+export const SLOT_WIDTH = 88;
+export const SLOT_GAP = 16;
+
+const REFERENCE_RATIO = 3.5;
+
+/**
+ * Logo files run from square marks to 6:1 lockups. Sizing them all to one cap
+ * height makes the square ones illegible and lets the long ones dominate, so
+ * height is normalised by area instead — every mark gets roughly the same ink
+ * — and clamped so nothing blows out the row.
+ */
+export const opticalHeight = (ratio: number, cap: number): number =>
+  Math.round(
+    Math.min(
+      cap * 1.6,
+      Math.max(cap * 0.8, cap * Math.sqrt(REFERENCE_RATIO / ratio)),
+    ),
+  );
+
+/** Optical height, held down to whatever fits the box and the row. */
+export const boxedLogoHeight = (
+  ratio: number,
+  cap: number,
+  maxWidth: number,
+  maxHeight: number = Number.POSITIVE_INFINITY,
+): number =>
+  Math.floor(Math.min(opticalHeight(ratio, cap), maxWidth / ratio, maxHeight));
+
+/**
+ * How many fixed-width slots the measured row holds. `null` means "not
+ * measured yet" rather than "nothing fits": a row narrower than a single slot
+ * cannot have been laid out, and treating that as zero would empty the row
+ * with nothing guaranteed to come along and correct it.
+ */
+export const fittedSlotCount = (
+  available: number,
+  slotWidth: number = SLOT_WIDTH,
+  gap: number = SLOT_GAP,
+): number | null => {
+  if (available < slotWidth) {
+    return null;
+  }
+
+  return Math.floor((available + gap) / (slotWidth + gap));
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorStripCreative.spec.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripCreative.spec.ts
new file mode 100644
index 00000000000..8a1ab63431d
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripCreative.spec.ts
@@ -0,0 +1,45 @@
+import {
+  SponsorTier,
+  parseSponsors,
+  resolveSponsor,
+} from './sponsorStripCreative';
+
+const raw = (overrides: Record<string, unknown> = {}) => ({
+  gen_id: 'gen-1',
+  company: 'Quantile',
+  logo_img: { light: 'light.svg', dark: 'dark.svg' },
+  logo_ratio: 3.5,
+  link: 'https://quantile.dev',
+  pixel: ['https://api.daily.dev/px'],
+  tier: SponsorTier.Premium,
+  ...overrides,
+});
+
+describe('parseSponsors', () => {
+  it('should keep a well formed creative', () => {
+    expect(parseSponsors([raw()])).toHaveLength(1);
+  });
+
+  it('should drop a creative the row could not link to', () => {
+    expect(parseSponsors([raw({ link: 'not a url' })])).toEqual([]);
+  });
+
+  it('should treat an unknown tier as community rather than dropping the sale', () => {
+    const [creative] = parseSponsors([raw({ tier: 'platinum' })]);
+
+    expect(creative.tier).toEqual(SponsorTier.Community);
+  });
+
+  it('should tolerate a payload that is not a list', () => {
+    expect(parseSponsors(undefined)).toEqual([]);
+  });
+});
+
+describe('resolveSponsor', () => {
+  it('should pick the logo for the current theme', () => {
+    const [creative] = parseSponsors([raw()]);
+
+    expect(resolveSponsor(creative, true).logo).toEqual('light.svg');
+    expect(resolveSponsor(creative, false).logo).toEqual('dark.svg');
+  });
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorStripCreative.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripCreative.ts
new file mode 100644
index 00000000000..c7e398d83f1
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripCreative.ts
@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { urlParseSchema } from '../../../lib/links';
+
+export enum SponsorTier {
+  /** One slot, static, always leftmost. Never enters a rotation deck. */
+  Gold = 'gold',
+  Premium = 'premium',
+  Community = 'community',
+}
+
+const themedStringSchema = z.object({
+  dark: z.string(),
+  light: z.string(),
+});
+
+/**
+ * Raw shape of a `footer_logo` creative from the ad server (snake_case JSON),
+ * matching how engagement-ad creatives arrive.
+ */
+export const sponsorStripCreativeSchema = z.object({
+  gen_id: z.string(),
+  company: z.string(),
+  logo_img: themedStringSchema,
+  /**
+   * Intrinsic width / height. Logo files run from square marks to 6:1
+   * lockups, so a row that fixes the height needs the ratio to size the
+   * mark optically rather than letting a long lockup dominate.
+   */
+  logo_ratio: z.number().positive(),
+  link: urlParseSchema,
+  pixel: z.array(z.string()).optional().default([]),
+  /**
+   * An unknown tier lands in community rather than dropping the creative: an
+   * unranked advertiser still earns its impression, an absent one does not.
+   */
+  tier: z.enum(SponsorTier).catch(SponsorTier.Community),
+});
+
+export type SponsorStripCreative = z.infer<typeof sponsorStripCreativeSchema>;
+export type ThemedValue = z.infer<typeof themedStringSchema>;
+
+/** A creative with its themed logo resolved to the current theme. */
+export interface ResolvedSponsor {
+  genId: string;
+  company: string;
+  logo: string;
+  ratio: number;
+  link: string;
+  pixel: string[];
+  tier: SponsorTier;
+}
+
+export const parseSponsors = (raw: unknown): SponsorStripCreative[] => {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+
+  return raw.flatMap((creative) => {
+    const result = sponsorStripCreativeSchema.safeParse(creative);
+    return result.success ? [result.data] : [];
+  });
+};
+
+export const resolveSponsor = (
+  creative: SponsorStripCreative,
+  isLight: boolean,
+): ResolvedSponsor => ({
+  genId: creative.gen_id,
+  company: creative.company,
+  logo: isLight ? creative.logo_img.light : creative.logo_img.dark,
+  ratio: creative.logo_ratio,
+  link: creative.link,
+  pixel: creative.pixel,
+  tier: creative.tier,
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorStripLog.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripLog.ts
new file mode 100644
index 00000000000..37e782a6554
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripLog.ts
@@ -0,0 +1,38 @@
+import type { LogEvent } from '../../../hooks/log/useLogQueue';
+import type { AdActions } from '../../../lib/ads';
+import { AdPlacement } from '../../../lib/ads';
+import type { ResolvedSponsor } from './sponsorStripCreative';
+
+/**
+ * Every sponsor-strip signal (impression, viewable impression, click, air
+ * time) reports through this one builder, so a logo's whole story can be cut
+ * by tier and slot in the warehouse. Shaped like `adLogEvent` in `lib/feed.ts`
+ * — same `target_type`, same url field — so the strip sits alongside the other
+ * placements rather than needing its own reporting.
+ */
+export const sponsorStripLogEvent = (
+  action: AdActions,
+  sponsor: ResolvedSponsor,
+  slotIndex: number,
+  extra?: Record<string, unknown>,
+): LogEvent => ({
+  event_name: action,
+  target_id: sponsor.company,
+  target_type: 'ad',
+  feed_item_target_url: sponsor.link,
+  extra: JSON.stringify({
+    placement: AdPlacement.SponsorStrip,
+    tier: sponsor.tier,
+    slot_index: slotIndex,
+    gen_id: sponsor.genId,
+    ...extra,
+  }),
+});
+
+/**
+ * Air time is a duration event, so its key has to survive a rotation: the
+ * outgoing logo's event ends under its own key while the incoming one starts
+ * under a new one, in the same render.
+ */
+export const airTimeKey = (slotIndex: number, genId: string): string =>
+  `ss-${slotIndex}-${genId}`;
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorStripOffset.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripOffset.ts
new file mode 100644
index 00000000000..e0d2fab4e38
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripOffset.ts
@@ -0,0 +1,52 @@
+import { useEffect } from 'react';
+
+/**
+ * The dock's height, published on the document root so the controls that float
+ * at the bottom of the viewport can lift clear of it.
+ *
+ * A custom property rather than a context because the consumers are in other
+ * trees entirely: the feedback pill renders from `MainLayout`, the
+ * scroll-to-top button from the webapp's footer wrapper and the extension's
+ * new-tab shell. None of them are below the strip, so nothing React hands
+ * down could reach them. The property only exists while the dock is mounted,
+ * which is what scopes the offset to the experiment.
+ */
+const SPONSOR_STRIP_HEIGHT_VAR = '--sponsor-strip-height';
+
+/**
+ * Marks the dock for the v2 frame to style around. The frame floats with a
+ * gutter on every side, and a dock is supposed to pin to the window, so the
+ * frame drops its bottom inset for the one case where it holds one. A class
+ * rather than the test id because this is layout, and rather than a prop
+ * because the frame is two components above the dock's mount point.
+ *
+ * `MainLayout` matches this with literal `has-[.feed-dock]` variants — Tailwind
+ * scans source text and generates nothing for an interpolated class name — so
+ * this value and those selectors have to be changed together.
+ */
+export const DOCK_CLASS = 'feed-dock';
+
+/**
+ * Row heights, derived rather than measured: both rows are a fixed height by
+ * design, and a number is testable where a ResizeObserver in a headless DOM is
+ * not. Keep these in step with the `h-10` and `h-8` on the rows themselves.
+ */
+export const SPONSOR_ROW_HEIGHT = 40;
+export const HEADLINES_ROW_HEIGHT = 32;
+
+export const usePublishStripHeight = (height: number): void => {
+  useEffect(() => {
+    const { style } = globalThis.document.documentElement;
+
+    if (!height) {
+      style.removeProperty(SPONSOR_STRIP_HEIGHT_VAR);
+      return undefined;
+    }
+
+    style.setProperty(SPONSOR_STRIP_HEIGHT_VAR, `${height}px`);
+
+    return () => {
+      style.removeProperty(SPONSOR_STRIP_HEIGHT_VAR);
+    };
+  }, [height]);
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorStripSlots.spec.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripSlots.spec.ts
new file mode 100644
index 00000000000..391cc6b072b
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripSlots.spec.ts
@@ -0,0 +1,35 @@
+import type { SponsorStripCreative } from './sponsorStripCreative';
+import { SponsorTier } from './sponsorStripCreative';
+import { partitionByTier } from './sponsorStripSlots';
+
+const creative = (
+  id: string,
+  tier = SponsorTier.Community,
+): SponsorStripCreative =>
+  ({
+    gen_id: id,
+    company: id,
+    tier,
+  } as SponsorStripCreative);
+
+const companies = (creatives: SponsorStripCreative[]) =>
+  creatives.map(({ company }) => company);
+
+describe('partitionByTier', () => {
+  it('should keep a single gold sponsor', () => {
+    const pools = partitionByTier([
+      creative('gold-1', SponsorTier.Gold),
+      creative('gold-2', SponsorTier.Gold),
+      creative('premium-1', SponsorTier.Premium),
+      creative('community-1'),
+    ]);
+
+    expect(pools.gold?.company).toEqual('gold-1');
+    expect(companies(pools.premium)).toEqual(['premium-1']);
+    expect(companies(pools.community)).toEqual(['community-1']);
+  });
+
+  it('should report no gold sponsor when none was sold', () => {
+    expect(partitionByTier([creative('c1'), creative('c2')]).gold).toBeNull();
+  });
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/sponsorStripSlots.ts b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripSlots.ts
new file mode 100644
index 00000000000..d65fb42e1f7
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/sponsorStripSlots.ts
@@ -0,0 +1,25 @@
+import type { SponsorStripCreative } from './sponsorStripCreative';
+import { SponsorTier } from './sponsorStripCreative';
+
+/**
+ * Premium is deliberately the scarcer tier: one gold, four premium, and
+ * community takes whatever the row has left, which is always more.
+ */
+export const PREMIUM_SLOT_COUNT = 4;
+
+interface SponsorPools {
+  gold: SponsorStripCreative | null;
+  premium: SponsorStripCreative[];
+  community: SponsorStripCreative[];
+}
+
+export const partitionByTier = (
+  sponsors: SponsorStripCreative[],
+): SponsorPools => ({
+  // A second gold creative is dropped rather than demoted. The tier is sold as
+  // the one slot that never shares, so two of them is not a degraded version
+  // of what was sold, it is a different thing.
+  gold: sponsors.find(({ tier }) => tier === SponsorTier.Gold) ?? null,
+  premium: sponsors.filter(({ tier }) => tier === SponsorTier.Premium),
+  community: sponsors.filter(({ tier }) => tier === SponsorTier.Community),
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useSponsorSlotLog.ts b/packages/shared/src/features/monetization/sponsorStrip/useSponsorSlotLog.ts
new file mode 100644
index 00000000000..6f3dbfab009
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useSponsorSlotLog.ts
@@ -0,0 +1,95 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useLogContext } from '../../../contexts/LogContext';
+import { AdActions } from '../../../lib/ads';
+import type { ViewabilityData } from '../viewability';
+import { viewabilityLogExtra } from '../viewability';
+import { useViewability } from '../useViewability';
+import type { ResolvedSponsor } from './sponsorStripCreative';
+import { airTimeKey, sponsorStripLogEvent } from './sponsorStripLog';
+
+interface UseSponsorSlotLogProps {
+  sponsor: ResolvedSponsor;
+  slotIndex: number;
+}
+
+interface UseSponsorSlotLog<T extends HTMLElement> {
+  ref: (node: T | null) => void;
+  isViewable: boolean;
+  onClick: () => void;
+}
+
+/**
+ * The four signals for one logo in one slot: an impression when it takes the
+ * slot, an IAB viewable impression when it has actually been seen, air time
+ * for as long as it holds the slot, and a click.
+ */
+export const useSponsorSlotLog = <T extends HTMLElement = HTMLElement>({
+  sponsor,
+  slotIndex,
+}: UseSponsorSlotLogProps): UseSponsorSlotLog<T> => {
+  const { logEvent, logEventStart, logEventEnd } = useLogContext();
+  const sponsorRef = useRef(sponsor);
+  sponsorRef.current = sponsor;
+  const { genId } = sponsor;
+
+  useEffect(() => {
+    const key = airTimeKey(slotIndex, genId);
+    const startAirTime = () =>
+      logEventStart(
+        key,
+        sponsorStripLogEvent(AdActions.AirTime, sponsorRef.current, slotIndex),
+      );
+
+    logEvent(
+      sponsorStripLogEvent(AdActions.Impression, sponsorRef.current, slotIndex),
+    );
+    startAirTime();
+
+    // Going inactive ends every open duration event and beacons it, so a logo
+    // still holding its slot when the reader comes back needs its air time
+    // reopened — `useLogPageView` reopens the page view for the same reason.
+    const onLifecycle = (event: Event) => {
+      const { newState } =
+        (event as CustomEvent<{ newState?: string }>).detail ?? {};
+
+      if (newState === 'active') {
+        startAirTime();
+      }
+    };
+
+    globalThis.addEventListener('statechange', onLifecycle);
+
+    return () => {
+      globalThis.removeEventListener('statechange', onLifecycle);
+      logEventEnd(key);
+    };
+  }, [genId, slotIndex, logEvent, logEventStart, logEventEnd]);
+
+  const onViewable = useCallback(
+    (data: ViewabilityData) =>
+      logEvent(
+        sponsorStripLogEvent(
+          AdActions.Viewable,
+          sponsorRef.current,
+          slotIndex,
+          viewabilityLogExtra(data),
+        ),
+      ),
+    [logEvent, slotIndex],
+  );
+
+  const { ref, isViewable } = useViewability<T>({
+    onViewable,
+    trackingKey: genId,
+  });
+
+  const onClick = useCallback(
+    () =>
+      logEvent(
+        sponsorStripLogEvent(AdActions.Click, sponsorRef.current, slotIndex),
+      ),
+    [logEvent, slotIndex],
+  );
+
+  return { ref, isViewable, onClick };
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useSponsorStrip.spec.tsx b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStrip.spec.tsx
new file mode 100644
index 00000000000..24b32dad749
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStrip.spec.tsx
@@ -0,0 +1,95 @@
+import React from 'react';
+import { renderHook } from '@testing-library/react';
+import type { AuthContextData } from '../../../contexts/AuthContext';
+import AuthContext from '../../../contexts/AuthContext';
+import { getLogContextStatic } from '../../../contexts/LogContext';
+import type { LogContextData } from '../../../hooks/log/useLogContextData';
+import { SharedFeedPage } from '../../../components/utilities/common';
+import { useConditionalFeature } from '../../../hooks/useConditionalFeature';
+import { useViewSizeClient } from '../../../hooks/useViewSize';
+import { useSponsorStrip } from './useSponsorStrip';
+
+jest.mock('../../../hooks/useConditionalFeature', () => ({
+  useConditionalFeature: jest.fn(),
+}));
+
+jest.mock('../../../hooks/useViewSize', () => ({
+  ...(jest.requireActual('../../../hooks/useViewSize') as Record<
+    string,
+    unknown
+  >),
+  useViewSizeClient: jest.fn(),
+}));
+
+const mockFeature = jest.mocked(useConditionalFeature);
+const mockViewSize = jest.mocked(useViewSizeClient);
+
+const LogContext = getLogContextStatic();
+
+const render = ({
+  feedName = SharedFeedPage.MyFeed as string,
+  disableAds = false,
+  isPlus = false,
+}: { feedName?: string; disableAds?: boolean; isPlus?: boolean } = {}) =>
+  renderHook(() => useSponsorStrip({ feedName, disableAds }), {
+    wrapper: ({ children }) => (
+      <AuthContext.Provider
+        value={
+          {
+            isAuthReady: true,
+            user: { id: 'u1', isPlus },
+          } as unknown as AuthContextData
+        }
+      >
+        <LogContext.Provider
+          value={{ logEvent: jest.fn() } as unknown as LogContextData}
+        >
+          {children}
+        </LogContext.Provider>
+      </AuthContext.Provider>
+    ),
+  });
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockFeature.mockReturnValue({ value: true, isLoading: false });
+  mockViewSize.mockReturnValue(true);
+});
+
+it('should be on for a feed that can show the Happening Now card', () => {
+  expect(render().result.current).toBe(true);
+});
+
+it('should be off when the experiment is off', () => {
+  mockFeature.mockReturnValue({ value: false, isLoading: false });
+
+  expect(render().result.current).toBe(false);
+});
+
+it('should be off for a Plus subscriber, who paid for no ads', () => {
+  expect(render({ isPlus: true }).result.current).toBe(false);
+});
+
+it('should be off on a feed with ads switched off', () => {
+  expect(render({ disableAds: true }).result.current).toBe(false);
+});
+
+it('should be off below tablet, where a logo wall costs more feed than it holds logos', () => {
+  mockViewSize.mockReturnValue(false);
+
+  expect(render().result.current).toBe(false);
+});
+
+it('should be off on a feed that never shows the card', () => {
+  expect(render({ feedName: SharedFeedPage.Search }).result.current).toBe(
+    false,
+  );
+  expect(render({ feedName: 'squad' }).result.current).toBe(false);
+});
+it('should not evaluate the experiment for anyone who could not see it', () => {
+  render({ isPlus: true });
+
+  expect(mockFeature).toHaveBeenCalledWith(
+    expect.objectContaining({ shouldEvaluate: false }),
+  );
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useSponsorStrip.ts b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStrip.ts
new file mode 100644
index 00000000000..fa3ea00bb6b
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStrip.ts
@@ -0,0 +1,48 @@
+import { usePlusSubscription } from '../../../hooks/usePlusSubscription';
+import { useConditionalFeature } from '../../../hooks/useConditionalFeature';
+import { HERO_ELIGIBLE_FEEDS } from '../../../hooks/useFeed';
+import { ViewSize, useViewSizeClient } from '../../../hooks/useViewSize';
+import { featureSponsorStrip } from '../../../lib/featureManagement';
+import type { AllFeedPages } from '../../../lib/query';
+
+interface UseSponsorStripProps {
+  feedName?: string;
+  /** The feed's own ads switch (feed previews, squads) — never inventory. */
+  disableAds?: boolean;
+}
+
+/**
+ * The strip shows on the feeds that can show a Happening Now card, and on no
+ * others. Sharing one set with the card means the two can never disagree: the
+ * strip cannot appear on a feed whose card it does not replace, and the card
+ * cannot be suppressed on a feed the strip never reaches.
+ */
+const isSponsorStripFeed = (feedName?: string): boolean =>
+  !!feedName && HERO_ELIGIBLE_FEEDS.has(feedName as AllFeedPages);
+
+/**
+ * The single gate for the sponsor strip. Both the strip itself and the feed's
+ * Happening Now suppression read it, so "is the strip showing" and "is the
+ * card hidden" are the same answer rather than two conditions that have to be
+ * kept in step.
+ */
+export const useSponsorStrip = ({
+  feedName,
+  disableAds,
+}: UseSponsorStripProps = {}): boolean => {
+  const { isPlus } = usePlusSubscription();
+  // `useViewSizeClient`, not `useViewSize`: the latter reads matchMedia in its
+  // first client render while the server renders `false`, so the dock would
+  // appear during hydration and React would throw the whole root away and
+  // re-render it. This one matches the server until after mount.
+  const isTablet = useViewSizeClient(ViewSize.Tablet);
+  // A logo wall on a phone costs more feed than it can hold logos.
+  const isEligible =
+    !isPlus && !disableAds && isTablet && isSponsorStripFeed(feedName);
+  const { value: isOn } = useConditionalFeature({
+    feature: featureSponsorStrip,
+    shouldEvaluate: isEligible,
+  });
+
+  return isEligible && isOn;
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripAds.ts b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripAds.ts
new file mode 100644
index 00000000000..4b8c6a06c6a
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripAds.ts
@@ -0,0 +1,157 @@
+import { useCallback, useLayoutEffect, useMemo, useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { useIsLightTheme } from '../../../hooks/utils/useThemedAsset';
+import { AdPlacement } from '../../../lib/ads';
+import { disabledRefetch, shuffleArray } from '../../../lib/func';
+import { RequestKey } from '../../../lib/query';
+import { ONE_HOUR } from '../../../lib/time';
+import { fetchSponsorStripAds } from './mockSponsorStripAds';
+import { fittedSlotCount } from './sponsorLogoSizing';
+import type {
+  ResolvedSponsor,
+  SponsorStripCreative,
+} from './sponsorStripCreative';
+import { parseSponsors, resolveSponsor } from './sponsorStripCreative';
+import { PREMIUM_SLOT_COUNT, partitionByTier } from './sponsorStripSlots';
+
+interface UseSponsorStripAds {
+  gold: ResolvedSponsor | null;
+  premium: ResolvedSponsor[];
+  community: ResolvedSponsor[];
+  /** Attach to the wall; its width decides how many marks the row holds. */
+  wallRef: (node: HTMLElement | null) => void;
+  /**
+   * Whether the ad query has answered. The dock holds the row's height open
+   * until it has, so a fill landing cannot move the row.
+   */
+  isSettled: boolean;
+}
+
+/**
+ * How many fixed-width slots the wall holds.
+ *
+ * Nothing is drawn until the row has been measured, which matters for money
+ * rather than for looks: an optimistic first paint renders every creative in
+ * the pool, and each one that renders logs an impression and fires the ad
+ * server's pixel before the row trims a frame later. Measuring in a layout
+ * effect keeps the wall from ever showing a mark it is about to take away, and
+ * the reader sees no empty frame because it runs before the browser paints.
+ */
+const useFittedSlots = (
+  maxSlots: number,
+): { ref: (node: HTMLElement | null) => void; count: number } => {
+  const [element, setElement] = useState<HTMLElement | null>(null);
+  const [fitted, setFitted] = useState<number | null>(null);
+  const ref = useCallback((node: HTMLElement | null) => setElement(node), []);
+
+  useLayoutEffect(() => {
+    if (!element) {
+      return undefined;
+    }
+
+    const measure = (width: number) => {
+      const count = fittedSlotCount(width);
+
+      if (count !== null) {
+        setFitted(count);
+      }
+    };
+
+    measure(element.getBoundingClientRect().width);
+
+    if (typeof ResizeObserver === 'undefined') {
+      return undefined;
+    }
+
+    const observer = new ResizeObserver(([entry]) =>
+      measure(entry.contentRect.width),
+    );
+    observer.observe(element);
+
+    return () => observer.disconnect();
+  }, [element]);
+
+  return { ref, count: fitted === null ? 0 : Math.min(maxSlots, fitted) };
+};
+
+/**
+ * The pool in a stable random order, dealt once per page load.
+ *
+ * That is the whole turnover story: the row a reader sees holds for as long as
+ * the page does, and the next load deals a different set, so no advertiser is
+ * permanently first — or permanently the one a narrow window drops. Shuffling
+ * on mount rather than during render also keeps the server markup and the
+ * first client render in agreement.
+ */
+const useDeck = (pool: SponsorStripCreative[]): SponsorStripCreative[] => {
+  // Identity, not the array: the pool is rebuilt on every render of the query,
+  // and reshuffling then would deal a new row under the reader.
+  const poolKey = pool.map(({ gen_id: genId }) => genId).join(',');
+
+  return useMemo(
+    () => shuffleArray(pool),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [poolKey],
+  );
+};
+
+export const useSponsorStripAds = ({
+  enabled,
+}: {
+  enabled: boolean;
+}): UseSponsorStripAds => {
+  const isLight = useIsLightTheme();
+  const { data, isPending } = useQuery({
+    queryKey: [RequestKey.Ads, AdPlacement.SponsorStrip],
+    queryFn: fetchSponsorStripAds,
+    enabled,
+    staleTime: ONE_HOUR,
+    ...disabledRefetch,
+  });
+
+  const pools = useMemo(() => partitionByTier(parseSponsors(data)), [data]);
+  const premiumDeck = useDeck(pools.premium);
+  const communityDeck = useDeck(pools.community);
+
+  // One gold, four premium, and community takes whatever the row has left —
+  // fewer premium slots than community by design. The two tiers share one
+  // measured run so they cannot argue over the same pixels, and the upper
+  // bound is the pool itself: a wider window shows more advertisers rather
+  // than the same few further apart.
+  const { ref: wallRef, count: wallSlots } = useFittedSlots(
+    PREMIUM_SLOT_COUNT + communityDeck.length,
+  );
+
+  // Reserved from the pool rather than read off the rendered row: the row
+  // fills a render later than the measurement does, and a community count that
+  // subtracted an as-yet-empty premium row would open slots it is about to
+  // take back — each one logging an impression and firing a pixel on its way
+  // through.
+  const premiumSlots = Math.min(PREMIUM_SLOT_COUNT, premiumDeck.length);
+
+  // Themed logos resolve here rather than in the decks, so switching theme
+  // repaints the row without dealing anybody a different slot.
+  return useMemo(
+    () => ({
+      gold: pools.gold ? resolveSponsor(pools.gold, isLight) : null,
+      premium: premiumDeck
+        .slice(0, premiumSlots)
+        .map((creative) => resolveSponsor(creative, isLight)),
+      community: communityDeck
+        .slice(0, Math.max(0, wallSlots - premiumSlots))
+        .map((creative) => resolveSponsor(creative, isLight)),
+      wallRef,
+      isSettled: !isPending,
+    }),
+    [
+      pools.gold,
+      premiumDeck,
+      communityDeck,
+      premiumSlots,
+      wallSlots,
+      isLight,
+      wallRef,
+      isPending,
+    ],
+  );
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripFeed.spec.tsx b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripFeed.spec.tsx
new file mode 100644
index 00000000000..17703298f59
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripFeed.spec.tsx
@@ -0,0 +1,69 @@
+import { renderHook } from '@testing-library/react';
+import type { PostHighlight } from '../../../graphql/highlights';
+import { useSponsorStrip } from './useSponsorStrip';
+import { useSponsorStripFeed } from './useSponsorStripFeed';
+import { useStripHeadlines } from './useStripHeadlines';
+
+jest.mock('./useSponsorStrip', () => ({ useSponsorStrip: jest.fn() }));
+jest.mock('./useStripHeadlines', () => ({ useStripHeadlines: jest.fn() }));
+
+const mockStrip = jest.mocked(useSponsorStrip);
+const mockHeadlines = jest.mocked(useStripHeadlines);
+
+const headline = { id: 'h1' } as PostHighlight;
+
+const settled = (headlines: PostHighlight[]) => ({
+  headlines,
+  isSettled: true,
+});
+
+const render = () =>
+  renderHook(() => useSponsorStripFeed({ feedName: 'my-feed' }));
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockStrip.mockReturnValue(true);
+  mockHeadlines.mockReturnValue(settled([headline]));
+});
+
+it('should drop the feed card when the strip is carrying the headlines', () => {
+  expect(render().result.current.disableHighlightItems).toBe(true);
+});
+
+it('should keep the feed card once the query settles with no headlines', () => {
+  // An empty ticker cannot stand in for the card, and suppressing it then
+  // would take breaking news out of the product altogether.
+  mockHeadlines.mockReturnValue(settled([]));
+
+  expect(render().result.current.disableHighlightItems).toBe(false);
+});
+
+// The headlines are their own round trip, landing after the feed has painted.
+// Waiting for them flipped this mid-scroll and pulled the card out of the
+// middle of the feed.
+it('should drop the feed card before the headlines have arrived', () => {
+  mockHeadlines.mockReturnValue({ headlines: [], isSettled: false });
+
+  expect(render().result.current.disableHighlightItems).toBe(true);
+});
+
+it('should keep the feed card when the strip is off', () => {
+  mockStrip.mockReturnValue(false);
+
+  expect(render().result.current.disableHighlightItems).toBe(false);
+});
+
+it('should not query headlines when the strip is off', () => {
+  mockStrip.mockReturnValue(false);
+  render();
+
+  expect(mockHeadlines).toHaveBeenCalledWith(false);
+});
+
+it('should hand the strip the same headlines it decided with', () => {
+  const { result } = render();
+
+  expect(result.current.headlines).toEqual([headline]);
+  expect(result.current.isEnabled).toBe(true);
+  expect(result.current.headlinesSettled).toBe(true);
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripFeed.ts b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripFeed.ts
new file mode 100644
index 00000000000..c92c13c271e
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useSponsorStripFeed.ts
@@ -0,0 +1,50 @@
+import type { PostHighlight } from '../../../graphql/highlights';
+import { useSponsorStrip } from './useSponsorStrip';
+import { useStripHeadlines } from './useStripHeadlines';
+
+interface UseSponsorStripFeedProps {
+  feedName?: string;
+  disableAds?: boolean;
+}
+
+interface UseSponsorStripFeed {
+  isEnabled: boolean;
+  headlines: PostHighlight[];
+  /** Whether the headlines query has answered; the dock reserves until it has. */
+  headlinesSettled: boolean;
+  /**
+   * Drop the feed's Happening Now card, because the strip carries those
+   * headlines in its place.
+   *
+   * Decided from the strip being up rather than from the headlines having
+   * arrived. The headlines are their own round trip and land after the feed
+   * has painted, so reading them here flipped this mid-scroll and pulled the
+   * card out of the middle of the feed, jumping everything below it. The one
+   * case that gives the card back is the query settling with nothing at all:
+   * breaking news must never fall out of the product entirely just because
+   * the experiment is on.
+   */
+  disableHighlightItems: boolean;
+}
+
+/**
+ * Everything a feed layout needs from the sponsor strip, in one place: whether
+ * to mount it, the headlines it carries, and whether the feed underneath
+ * should give up its Happening Now card. One evaluation of the flag and one
+ * headlines query, so the strip and the feed can never be told different
+ * things.
+ */
+export const useSponsorStripFeed = ({
+  feedName,
+  disableAds,
+}: UseSponsorStripFeedProps): UseSponsorStripFeed => {
+  const isEnabled = useSponsorStrip({ feedName, disableAds });
+  const { headlines, isSettled } = useStripHeadlines(isEnabled);
+
+  return {
+    isEnabled,
+    headlines,
+    headlinesSettled: isSettled,
+    disableHighlightItems: isEnabled && (!isSettled || headlines.length > 0),
+  };
+};
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useStripHeadlines.spec.tsx b/packages/shared/src/features/monetization/sponsorStrip/useStripHeadlines.spec.tsx
new file mode 100644
index 00000000000..7d6f1f3d7d1
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useStripHeadlines.spec.tsx
@@ -0,0 +1,143 @@
+import React from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import type { MajorHeadlinesData } from '../../../graphql/highlights';
+import { majorHeadlinesQueryOptions } from '../../../graphql/highlights';
+import { ONE_HOUR } from '../../../lib/time';
+import { useStripHeadlines } from './useStripHeadlines';
+
+jest.mock('../../../graphql/highlights', () => ({
+  ...(jest.requireActual('../../../graphql/highlights') as Record<
+    string,
+    unknown
+  >),
+  majorHeadlinesQueryOptions: jest.fn(),
+}));
+
+const mockQueryOptions = jest.mocked(majorHeadlinesQueryOptions);
+
+const headline = (id: string, ageMs = 0) => ({
+  node: {
+    id,
+    channel: 'agents',
+    headline: `Headline ${id}`,
+    highlightedAt: new Date(Date.now() - ageMs).toISOString(),
+    post: { id: `post-${id}`, commentsPermalink: `https://daily.dev/p/${id}` },
+  },
+});
+
+const setHeadlines = (edges: ReturnType<typeof headline>[]) =>
+  mockQueryOptions.mockReturnValue({
+    queryKey: ['major-headlines', edges.length],
+    queryFn: async () =>
+      ({
+        majorHeadlines: {
+          pageInfo: { hasNextPage: false, endCursor: '' },
+          edges,
+        },
+      } as MajorHeadlinesData),
+  } as ReturnType<typeof majorHeadlinesQueryOptions>);
+
+const render = () => {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+
+  return renderHook(() => useStripHeadlines(true), {
+    wrapper: ({ children }) => (
+      <QueryClientProvider client={client}>{children}</QueryClientProvider>
+    ),
+  });
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+it('should carry the headlines the API returned', async () => {
+  setHeadlines([headline('h1'), headline('h2')]);
+  const { result } = render();
+
+  await waitFor(() =>
+    expect(result.current.headlines.map(({ id }) => id)).toEqual(['h1', 'h2']),
+  );
+});
+
+// The row stands in for the feed's Happening Now card, which applies no age
+// filter of its own — a stale-only day must still fill the ticker rather than
+// silently dropping the dock to one row.
+it('should carry headlines the backend still serves however old they are', async () => {
+  setHeadlines([
+    headline('old', 36 * ONE_HOUR),
+    headline('older', 92 * ONE_HOUR),
+  ]);
+  const { result } = render();
+
+  await waitFor(() =>
+    expect(result.current.headlines.map(({ id }) => id)).toEqual([
+      'old',
+      'older',
+    ]),
+  );
+});
+
+it('should keep the order the API returned rather than resorting', async () => {
+  setHeadlines([
+    headline('newest'),
+    headline('middle', 40 * ONE_HOUR),
+    headline('oldest', 90 * ONE_HOUR),
+  ]);
+  const { result } = render();
+
+  await waitFor(() =>
+    expect(result.current.headlines.map(({ id }) => id)).toEqual([
+      'newest',
+      'middle',
+      'oldest',
+    ]),
+  );
+});
+
+it('should leave the row empty when the API has no headlines at all', async () => {
+  setHeadlines([]);
+  const { result } = render();
+
+  await waitFor(() => expect(mockQueryOptions).toHaveBeenCalled());
+  expect(result.current.headlines).toEqual([]);
+});
+
+it('should not query at all while the strip is off', async () => {
+  setHeadlines([headline('h1')]);
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  const { result } = renderHook(() => useStripHeadlines(false), {
+    wrapper: ({ children }) => (
+      <QueryClientProvider client={client}>{children}</QueryClientProvider>
+    ),
+  });
+
+  await waitFor(() => expect(result.current.headlines).toEqual([]));
+});
+
+it('should report settled only once the query has answered', async () => {
+  setHeadlines([headline('h1')]);
+  const { result } = render();
+
+  expect(result.current.isSettled).toBe(false);
+  await waitFor(() => expect(result.current.isSettled).toBe(true));
+});
+
+it('should count as settled while the strip is off so the feed keeps its card', () => {
+  setHeadlines([headline('h1')]);
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  const { result } = renderHook(() => useStripHeadlines(false), {
+    wrapper: ({ children }) => (
+      <QueryClientProvider client={client}>{children}</QueryClientProvider>
+    ),
+  });
+
+  expect(result.current.isSettled).toBe(true);
+});
diff --git a/packages/shared/src/features/monetization/sponsorStrip/useStripHeadlines.ts b/packages/shared/src/features/monetization/sponsorStrip/useStripHeadlines.ts
new file mode 100644
index 00000000000..104d24c237c
--- /dev/null
+++ b/packages/shared/src/features/monetization/sponsorStrip/useStripHeadlines.ts
@@ -0,0 +1,49 @@
+import { useQuery } from '@tanstack/react-query';
+import type { PostHighlight } from '../../../graphql/highlights';
+import { majorHeadlinesQueryOptions } from '../../../graphql/highlights';
+import { ONE_MINUTE } from '../../../lib/time';
+
+const HEADLINE_LIMIT = 12;
+
+interface StripHeadlines {
+  headlines: PostHighlight[];
+  /**
+   * Whether the query has answered. The feed has to decide about its own
+   * Happening Now card before the answer lands, and cannot wait for it.
+   */
+  isSettled: boolean;
+}
+
+/**
+ * The headlines the strip carries. Same `majorHeadlines` field the /highlights
+ * page and the post-page widget read, and the same query document as the
+ * widget — the strip is a third view of one set of headlines, not a new source
+ * of them. /highlights wraps the field in its own document only because its
+ * cards need the post bodies, which cost 147KB at its page size and would put
+ * all of it on the feed for four fields this row renders.
+ *
+ * No client-side freshness filter, because the row stands in for the feed's
+ * Happening Now card and has to behave like it: that card renders whatever the
+ * backend serves it, and so does /highlights. Deciding what still counts as a
+ * major headline is the backend's call, and a second opinion held only by this
+ * row emptied it on any day `majorHeadlines` went quiet — which it routinely
+ * does for 36 hours or more — dropping the dock from two rows to one for no
+ * reason the reader could see. The API already returns newest first, and every
+ * row renders its own relative timestamp.
+ */
+export const useStripHeadlines = (enabled: boolean): StripHeadlines => {
+  const { data, isPending } = useQuery({
+    ...majorHeadlinesQueryOptions({ first: HEADLINE_LIMIT }),
+    enabled,
+    refetchInterval: ONE_MINUTE,
+  });
+
+  if (!enabled) {
+    return { headlines: [], isSettled: true };
+  }
+
+  return {
+    headlines: (data?.majorHeadlines?.edges ?? []).map(({ node }) => node),
+    isSettled: !isPending,
+  };
+};
diff --git a/packages/shared/src/hooks/feed/mockFeedHighlights.spec.ts b/packages/shared/src/hooks/feed/mockFeedHighlights.spec.ts
new file mode 100644
index 00000000000..493fd075daf
--- /dev/null
+++ b/packages/shared/src/hooks/feed/mockFeedHighlights.spec.ts
@@ -0,0 +1,103 @@
+import type { FeedItemData } from '../../graphql/feed';
+import type { Post } from '../../graphql/posts';
+import { withMockFeedHighlights } from './mockFeedHighlights';
+
+jest.mock('../../lib/constants', () => ({
+  ...(jest.requireActual('../../lib/constants') as Record<string, unknown>),
+  isDevelopment: true,
+}));
+
+const mockConstants = jest.requireMock('../../lib/constants') as {
+  isDevelopment: boolean;
+};
+
+const postNode = (id: string) => ({
+  node: {
+    itemType: 'post' as const,
+    post: { id, commentsPermalink: `https://daily.dev/posts/${id}` } as Post,
+    feedMeta: null,
+  },
+});
+
+const pages = (): FeedItemData[] => [
+  {
+    page: {
+      pageInfo: { hasNextPage: false, endCursor: '' },
+      edges: [postNode('p1'), postNode('p2'), postNode('p3')],
+    },
+  },
+];
+
+const itemTypes = (data: FeedItemData[]): string[] =>
+  data[0].page.edges.map(({ node }) => node.itemType);
+
+beforeEach(() => {
+  mockConstants.isDevelopment = true;
+});
+
+it('should leave the feed alone unless it was asked', () => {
+  const data = pages();
+
+  expect(withMockFeedHighlights(data, false)).toBe(data);
+});
+
+it('should never inject outside development, whatever the query says', () => {
+  mockConstants.isDevelopment = false;
+  const data = pages();
+
+  expect(withMockFeedHighlights(data, true)).toBe(data);
+});
+
+it('should insert one card into the first page', () => {
+  const data = withMockFeedHighlights(pages(), true);
+
+  expect(itemTypes(data)).toEqual(['post', 'post', 'highlight', 'post']);
+});
+
+it('should point the rows at real posts so they link somewhere', () => {
+  const data = withMockFeedHighlights(pages(), true);
+  const [{ node }] = data[0].page.edges.filter(
+    ({ node: item }) => item.itemType === 'highlight',
+  );
+
+  expect(node.itemType === 'highlight' && node.highlights.length).toBeTruthy();
+  expect(
+    node.itemType === 'highlight' &&
+      node.highlights.every(({ post }) => !!post.commentsPermalink),
+  ).toBe(true);
+});
+
+it('should keep out of the way when the API sent real highlights', () => {
+  const data: FeedItemData[] = [
+    {
+      page: {
+        pageInfo: { hasNextPage: false, endCursor: '' },
+        edges: [
+          postNode('p1'),
+          {
+            node: {
+              itemType: 'highlight' as const,
+              highlights: [],
+              feedMeta: null,
+            },
+          },
+        ],
+      },
+    },
+  ];
+
+  expect(withMockFeedHighlights(data, true)).toBe(data);
+});
+
+it('should not inject into a page with no posts to link to', () => {
+  const data: FeedItemData[] = [
+    {
+      page: {
+        pageInfo: { hasNextPage: false, endCursor: '' },
+        edges: [],
+      },
+    },
+  ];
+
+  expect(withMockFeedHighlights(data, true)).toBe(data);
+});
diff --git a/packages/shared/src/hooks/feed/mockFeedHighlights.ts b/packages/shared/src/hooks/feed/mockFeedHighlights.ts
new file mode 100644
index 00000000000..a93895f2ee5
--- /dev/null
+++ b/packages/shared/src/hooks/feed/mockFeedHighlights.ts
@@ -0,0 +1,87 @@
+import type { FeedApiItem, FeedItemData } from '../../graphql/feed';
+import { isFeedApiPostItem } from '../../graphql/feed';
+import type { PostHighlight } from '../../graphql/highlights';
+import { isDevelopment } from '../../lib/constants';
+
+/**
+ * TEMPORARY, development only. The Happening Now card comes from the feed API,
+ * which returns no highlight items for a local session, so there is nothing to
+ * watch the sponsor-strip experiment take away. This injects one card into the
+ * first page so both sides of the experiment can be seen locally: with the
+ * strip on the card should be gone, with it off it should be back.
+ *
+ * Opt in with `?mockHighlights=1`. Delete this module and its call in
+ * `useFeed` once the experiment is decided.
+ */
+
+const MOCK_HEADLINES = [
+  'Postgres 18 ships async I/O',
+  'Rust in the Linux kernel: one year on',
+  'The quiet death of the REST client',
+  'We deleted our CI cache and got faster',
+];
+
+/** Far enough in to sit in the feed proper rather than the first row. */
+const INSERT_AT = 2;
+
+const buildMockHighlights = (
+  page: FeedItemData['page'],
+): PostHighlight[] | null => {
+  const posts = page.edges
+    .map(({ node }) => node)
+    .filter(isFeedApiPostItem)
+    .map(({ post }) => post);
+
+  // Real posts, so the rows link somewhere and the card is worth clicking.
+  if (!posts.length) {
+    return null;
+  }
+
+  return MOCK_HEADLINES.map((headline, index) => {
+    const post = posts[index % posts.length];
+
+    return {
+      id: `mock-highlight-${index}`,
+      channel: 'agents',
+      headline,
+      highlightedAt: new Date(Date.now() - index * 45 * 60_000).toISOString(),
+      post: {
+        id: post.id,
+        commentsPermalink: post.commentsPermalink,
+      },
+    };
+  });
+};
+
+export const withMockFeedHighlights = (
+  pages: FeedItemData[],
+  enabled: boolean,
+): FeedItemData[] => {
+  // The environment check is here rather than at the call site so no query
+  // param can put a fixture in front of a real reader.
+  if (!enabled || !isDevelopment || !pages.length) {
+    return pages;
+  }
+
+  const [first, ...rest] = pages;
+
+  if (first.page.edges.some(({ node }) => node.itemType === 'highlight')) {
+    return pages;
+  }
+
+  const highlights = buildMockHighlights(first.page);
+
+  if (!highlights) {
+    return pages;
+  }
+
+  const node: FeedApiItem = {
+    itemType: 'highlight',
+    highlights,
+    feedMeta: null,
+  };
+  const edges = [...first.page.edges];
+  edges.splice(Math.min(INSERT_AT, edges.length), 0, { node });
+
+  return [{ ...first, page: { ...first.page, edges } }, ...rest];
+};
diff --git a/packages/shared/src/hooks/useFeed.ts b/packages/shared/src/hooks/useFeed.ts
index 3176ad002c7..5a06a222ab0 100644
--- a/packages/shared/src/hooks/useFeed.ts
+++ b/packages/shared/src/hooks/useFeed.ts
@@ -63,6 +63,7 @@ import { AdPlacement } from '../lib/ads';
 import { SharedFeedPage } from '../components/utilities';
 import { useTranslation } from './translation/useTranslation';
 import { useFetchAd } from '../features/monetization/useFetchAd';
+import { withMockFeedHighlights } from './feed/mockFeedHighlights';
 import type { Squad } from '../graphql/sources';
 
 interface FeedItemBase<T extends FeedItemType> {
@@ -267,6 +268,13 @@ export interface UseFeedOptionalParams<T> {
    * row, so hero placement is disabled entirely.
    */
   isHorizontal?: boolean;
+  /**
+   * Drop the Happening Now card from the feed. Set while the sponsor strip is
+   * showing, which is where breaking news goes instead; the user's own
+   * `highlightsPlacement` setting is left alone so the card comes back when
+   * the experiment ends.
+   */
+  disableHighlightItems?: boolean;
   /**
    * Drop pinned posts from the feed. `sourceFeed` always orders pinned posts
    * (welcome post, squad pins) first and offers no way to opt out server-side,
@@ -296,6 +304,7 @@ export default function useFeed<T>(
     disableTopHero = false,
     isHorizontal = false,
     excludePinnedPosts = false,
+    disableHighlightItems = false,
   } = params;
   const { numCards: numCardsBySpaciness } = useContext(FeedContext);
   const numCards = numCardsBySpaciness.eco;
@@ -321,6 +330,10 @@ export default function useFeed<T>(
     queryKey: feedQueryKey,
     queryType: 'feed',
   });
+  // TEMPORARY: `?mockHighlights=1` puts a Happening Now card in the feed so
+  // the sponsor-strip experiment can be checked locally, where the API returns
+  // no highlights. Development only — see `mockFeedHighlights`.
+  const shouldMockHighlights = !!router.query?.mockHighlights;
   const isFeedPreview = feedQueryKey?.[0] === RequestKey.FeedPreview;
   const avoidRetry =
     params?.settings?.feedName === SharedFeedPage.Custom && !isPlus;
@@ -692,7 +705,12 @@ export default function useFeed<T>(
         visualCellsSoFar += placement.colSpan;
       };
 
-      feedQuery.data.pages.forEach(({ page }, pageIndex) => {
+      const feedPages = withMockFeedHighlights(
+        feedQuery.data.pages,
+        shouldMockHighlights,
+      );
+
+      feedPages.forEach(({ page }, pageIndex) => {
         page.edges.forEach(({ node }, index: number) => {
           // Bail before the ad slot is claimed, otherwise dropping the post
           // would leave an ad stranded in a slot with nothing after it.
@@ -707,7 +725,7 @@ export default function useFeed<T>(
           }
 
           if (node.itemType === 'highlight') {
-            if (!node.highlights.length) {
+            if (disableHighlightItems || !node.highlights.length) {
               return;
             }
             pushAndAdvance({
@@ -769,6 +787,8 @@ export default function useFeed<T>(
     cadence,
     widenableTypes,
     excludePinnedPosts,
+    disableHighlightItems,
+    shouldMockHighlights,
     effectiveFirstSlotOffset,
   ]);
 
diff --git a/packages/shared/src/lib/ads.ts b/packages/shared/src/lib/ads.ts
index 2588a9addf1..6920fd6452d 100644
--- a/packages/shared/src/lib/ads.ts
+++ b/packages/shared/src/lib/ads.ts
@@ -9,6 +9,11 @@ export enum AdActions {
   // Rendered and seen by IAB rules, unlike `Impression` which only means the
   // creative reached the viewport.
   Viewable = 'viewable impression',
+  // Duration event: logged through `logEventStart`/`logEventEnd`, so it lands
+  // with `event_duration` set to how long the creative held its slot. A
+  // rotating placement needs it because a count of impressions says nothing
+  // about how long any one logo was actually up.
+  AirTime = 'air time',
 }
 
 export enum AdPlacement {
@@ -16,6 +21,11 @@ export enum AdPlacement {
   PostSidebar = 'post-sidebar',
   PostComment = 'post-comment',
   SquadDirectory = 'squad-directory',
+  /**
+   * The sponsor strip's logo wall. The wire value is the ad server's own
+   * placement name, which is why it does not match the client vocabulary.
+   */
+  SponsorStrip = 'footer_logo',
 }
 
 export interface FetchAdByPlacementOptions {
diff --git a/packages/shared/src/lib/featureManagement.ts b/packages/shared/src/lib/featureManagement.ts
index 258912c6013..68306ce0c19 100644
--- a/packages/shared/src/lib/featureManagement.ts
+++ b/packages/shared/src/lib/featureManagement.ts
@@ -258,6 +258,18 @@ export const featureOnboardingChrome = new Feature<OnboardingChromeVariant>(
   OnboardingChromeVariant.Control,
 );
 
+/**
+ * Experiment: the sponsor strip — a logo wall docked under the main feeds with
+ * the breaking-news ticker under it. While the strip carries those headlines,
+ * the feed drops its Happening Now card, so the two never show it twice.
+ *
+ * On in development and off everywhere else, the way `cores`, `quest_offers`
+ * and `post_boost_ads` are: `isDevelopment` is false in a production build, so
+ * this cannot ship the experiment to anyone — GrowthBook ramps it — while a
+ * local session still gets the strip without anybody forcing a flag.
+ */
+export const featureSponsorStrip = new Feature('sponsor_strip', isDevelopment);
+
 export const featureLayoutV2 = new Feature('layout_v2', false);
 
 export const featureEngagementBarV2 = new Feature('engagement_bar_v2', false);