From f887086bec1726d3001e35a49a2730e86a4c928f Mon Sep 17 00:00:00 2001
From: Anthony Ettinger <anthony@chovy.com>
Date: Tue, 18 Aug 2026 14:35:03 +0000
Subject: [PATCH 1/2] Sell the feed: an ad format for RSS, Atom and JSON Feed

Every unit so far assumed a runtime we control the shape of -- a browser
running ad.js, or a terminal printing text. A feed is neither. The document is
built by somebody else's static site generator, spliced into a <channel> whose
root element we did not write, and then kept for weeks by software that
remembers what it has already shown. So `feed_item` is a new format rather
than a new renderer for an old one, and three constraints drove it.

**No namespaces.** The RSS fragment uses core RSS 2.0 elements only and the
Atom fragment core Atom only. A <dc:creator> whose prefix the publisher never
declared does not make our item ugly, it makes their whole feed not
well-formed -- every reader drops the entire document rather than the one
element. That rules out the advertiser name in dc: and the logo in Media RSS,
both nicer, neither worth an outage for every subscriber of every publisher
carrying the unit. A test asserts no prefixed element can appear.

**No CSS.** Readers strip <style> blocks and most strip style= too, so the
hierarchy is carried by semantic elements and the body reads correctly with
every attribute removed. Links are rel="sponsored nofollow noopener": a paid
link copied verbatim into every aggregator that mirrors the feed is the exact
shape of a link scheme.

**A periodic identity.** guid is the whole of a reader's memory. Mint one per
fetch and the ad resurfaces as unread on every rebuild, which is how a feed
gets unsubscribed from; freeze it forever and the advertiser reaches each
subscriber once. So it rotates -- daily by default, keyed by *slot* rather
than campaign, because the campaign changes on every fill and would defeat the
mechanism within the hour. weekly/fill/static are there for feeds the default
is wrong for.

Seven wire shapes off one creative (rss, atom, json, html, markdown, text,
fields) and three body styles (text, card, terminal). `fields` is the
integration contract: a consumer that already builds all three formats should
render the ad through its own renderers, so that one piece of software decides
how a title gets escaped inside one document.

Two things this would have got wrong without care. Feed builders identify as
HTTP libraries, which the generic tracker calls a bot, and bots get the
unmetered house ad -- so a feed slot could never have earned a cent.
feedDeviceType fixes that the way terminalDeviceType did, and checks the
reader patterns *before* the crawler ones because Feedly's fetcher advertises
itself as "like FeedFetcher-Google". And feed fills take the short /a/<code>
click URL: as=text, as=markdown and style=terminal all print it as literal
text, where the 70-character form does not fit the box.

Also: snippets are data now. The banners needed two branches in a component
because the browser was the runtime; the feed unit has to be installed in
whatever language builds the publisher's feed, so lib/ads/snippets carries 36
recipes across Node, Next, Express, Hono, Eleventy, Hugo, Jekyll, Astro,
WordPress, PHP, Python, Django, Ruby, Go and Cloudflare Workers. Every one of
them fails open, because a feed build that throws when an ad server is slow
takes the publisher's whole deploy with it.

Metering is unchanged and worth being explicit about: the impression is
recorded at fetch time, so one build produces one impression for a document
thousands then read. Feed impressions undercount reach by design; clicks are
exact.

The migration follows terminal_ascii exactly -- widen the CHECK, add the
format to slot inventory, backfill a creative per campaign from the copy it
already has. Apply by hand via psql over the pooler; prod history diverged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 app/(marketing)/ads/page.tsx                  |  22 +-
 app/api/ads/feed/route.ts                     | 232 +++++
 components/ads/slot-manager.tsx               |  87 +-
 lib/ads/creative.ts                           |  17 +
 lib/ads/feeditem.ts                           | 699 +++++++++++++++
 lib/ads/formats.ts                            |  20 +
 lib/ads/house.ts                              |  31 +-
 lib/ads/serve.ts                              |  18 +-
 lib/ads/snippets.ts                           | 800 ++++++++++++++++++
 package-lock.json                             | 129 +++
 package.json                                  |   1 +
 .../20260818120000_ad_feed_item.sql           |  87 ++
 tests/ads-feed-item.test.ts                   | 395 +++++++++
 13 files changed, 2489 insertions(+), 49 deletions(-)
 create mode 100644 app/api/ads/feed/route.ts
 create mode 100644 lib/ads/feeditem.ts
 create mode 100644 lib/ads/snippets.ts
 create mode 100644 supabase/migrations/20260818120000_ad_feed_item.sql
 create mode 100644 tests/ads-feed-item.test.ts

diff --git a/app/(marketing)/ads/page.tsx b/app/(marketing)/ads/page.tsx
index 32979d16..9b117058 100644
--- a/app/(marketing)/ads/page.tsx
+++ b/app/(marketing)/ads/page.tsx
@@ -14,6 +14,8 @@ import {
   PUBLISHER_FORMAT_IDS,
   TERMINAL_FORMAT_ID,
   TERMINAL_COLS_LABEL,
+  FEED_FORMAT_ID,
+  FEED_ITEM_LABEL,
   formatSpec,
 } from "@/lib/ads/formats";
 
@@ -54,6 +56,7 @@ export default async function AdsMarketingPage() {
   const perClickPayout = creditsToPayoutCents(CPC_CREDITS);
   const publisherFormats = PUBLISHER_FORMAT_IDS.map((id) => formatSpec(id));
   const terminal = AD_FORMATS.find((f) => f.id === TERMINAL_FORMAT_ID);
+  const feed = AD_FORMATS.find((f) => f.id === FEED_FORMAT_ID);
 
   return (
     <main className="mx-auto max-w-5xl px-4 py-16 sm:px-6">
@@ -99,7 +102,7 @@ export default async function AdsMarketingPage() {
           />
           <Card
             title="Every size at once"
-            body={`${AD_FORMATS.length} formats from one campaign: the standard display sizes, a borderless text link that reads as part of the page, and an ASCII unit for terminals.`}
+            body={`${AD_FORMATS.length} formats from one campaign: the standard display sizes, a borderless text link that reads as part of the page, an ASCII unit for terminals, and a syndication item for RSS and Atom feeds.`}
           />
           <Card
             title="A budget that actually stops"
@@ -230,6 +233,12 @@ export default async function AdsMarketingPage() {
               </span>
             </span>
           )}
+          {feed && (
+            <span className="rounded-lg border border-[var(--color-border)] bg-[var(--color-card)] px-3 py-2 text-sm">
+              {feed.label}{" "}
+              <span className="font-mono text-xs text-[var(--color-muted)]">{FEED_ITEM_LABEL}</span>
+            </span>
+          )}
         </div>
         <p className="mt-4 max-w-3xl text-sm text-[var(--color-muted)]">
           The terminal unit is the odd one out and the point of it is that nobody else sells it:
@@ -237,6 +246,17 @@ export default async function AdsMarketingPage() {
           into an SSH login banner, a shell MOTD, a BBS screen or a CLI tool&apos;s output. It is fetched
           over HTTP rather than embedded, so it works in places a browser never reaches.
         </p>
+        <p className="mt-3 max-w-3xl text-sm text-[var(--color-muted)]">
+          The feed unit is the other one. Ask{" "}
+          <span className="font-mono">/api/ads/feed</span> for an RSS{" "}
+          <span className="font-mono">&lt;item&gt;</span>, an Atom{" "}
+          <span className="font-mono">&lt;entry&gt;</span>, a JSON Feed item, or a bare
+          HTML, Markdown or plain-text body, and splice it into a feed you already publish —
+          typically one sponsored item every ten posts. There are copy-and-paste
+          recipes for Node, Next.js, Hugo, Eleventy, Jekyll, Astro, WordPress, PHP, Python,
+          Django, Ruby, Go and Cloudflare Workers. Your subscribers see it in the reader they
+          already use, and nothing on your site has to load a script.
+        </p>
       </section>
 
       {/* ── Both sides ──────────────────────────────────────────────── */}
diff --git a/app/api/ads/feed/route.ts b/app/api/ads/feed/route.ts
new file mode 100644
index 00000000..38766d2a
--- /dev/null
+++ b/app/api/ads/feed/route.ts
@@ -0,0 +1,232 @@
+// Feed ad fill — a creative as a syndication item.
+//
+//   curl -s "https://crawlproof.com/api/ads/feed?slot=<slot_id>"
+//   curl -s "https://crawlproof.com/api/ads/feed?slot=<slot_id>&as=atom"
+//   curl -s "https://crawlproof.com/api/ads/feed?slot=<slot_id>&as=fields&n=3"
+//
+// Meant to be called by whatever builds a feed — a static site generator, a
+// CMS, a cron job, an aggregator like rssamplifier.com — and the result pasted
+// into the document being built. Nothing here renders in a browser and nothing
+// here is embedded: like /api/ads/motd, this is fetched.
+//
+// Parameters, all optional:
+//
+//   slot   the publisher placement being filled; impressions and click earnings
+//          are credited to it. Omitted falls back to ADS_DEFAULT_SLOT_ID, so a
+//          bare curl still rotates real campaigns.
+//   as     wire shape: rss | atom | json | html | markdown | text | fields.
+//          Default rss. See lib/ads/feeditem for what each one is for.
+//   style  body style: text | card | terminal. Default text — the long thin one.
+//   guid   identity rotation: daily | weekly | fill | static. Default daily.
+//   n      how many ads to return, 1..5. Each is an independent fill with its
+//          own impression and its own identity.
+//   label  disclosure wording. Defaults to "Sponsored", and cannot be removed.
+//   cols   box width for style=terminal.
+//   src    publisher's surface tag, recorded on the impression.
+//   v      visitor id, if the caller has one.
+//
+// Metering matches every other serving path: serveAd records the impression
+// server-side, at fetch time. That is worth being explicit about, because a
+// feed is fan-out — one fetch by a publisher's build produces one impression,
+// and the document it lands in may then be read by thousands of subscribers.
+// Feed impressions therefore undercount reach by design. Clicks are exact: they
+// go through the ordinary redirector and are metered per click.
+
+import { NextRequest, NextResponse } from "next/server";
+import { serveAd } from "@/lib/ads/serve";
+import { houseFill } from "@/lib/ads/house";
+import { FEED_FORMAT_ID } from "@/lib/ads/formats";
+import {
+  feedDeviceType,
+  feedFields,
+  isFeedShape,
+  isFeedStyle,
+  isGuidMode,
+  jsonFeedItem,
+  renderFeedAd,
+  type FeedItemInput,
+  type FeedRenderOpts,
+  type FeedShape,
+} from "@/lib/ads/feeditem";
+import { clampCols } from "@/lib/ads/terminal";
+import { clientIpFromHeaders, lookupGeo } from "@/lib/tracker/geo";
+import { parseDevice } from "@/lib/tracker/device";
+import { env } from "@/lib/env";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/** Most ads a single request will return, however many were asked for. */
+const MAX_ADS = 5;
+
+function headers(request: Request, contentType: string): Record<string, string> {
+  const origin = request.headers.get("origin");
+  return {
+    "content-type": contentType,
+    // Every request is a fresh fill and a fresh impression, so nothing shared
+    // may cache it. A publisher who wants to fetch less often should cache on
+    // their side, where they can key it to their own build.
+    "cache-control": "no-store",
+    "access-control-allow-origin": origin ?? "*",
+    "access-control-allow-methods": "GET, OPTIONS",
+    vary: "Origin",
+    "x-robots-tag": "noindex",
+  };
+}
+
+export function OPTIONS(request: NextRequest) {
+  return new NextResponse(null, {
+    status: 204,
+    headers: headers(request, "text/plain; charset=utf-8"),
+  });
+}
+
+/** Publisher's surface tag. Sanitised hard — it is recorded and re-emitted. */
+function cleanSrc(v: string | null): string {
+  return (v ?? "").trim().replace(/[^\w.-]/g, "").slice(0, 32);
+}
+
+/**
+ * Put a query parameter on a URL, leaving it alone if it will not parse.
+ *
+ * Only used for the house ad's surface tag — see below.
+ */
+function withParam(rawUrl: string, key: string, value: string): string {
+  try {
+    const u = new URL(rawUrl);
+    u.searchParams.set(key, value);
+    return u.toString();
+  } catch {
+    return rawUrl;
+  }
+}
+
+function clampCount(v: string | null): number {
+  const n = parseInt(String(v ?? ""), 10);
+  if (!Number.isFinite(n)) return 1;
+  return Math.min(MAX_ADS, Math.max(1, n));
+}
+
+/**
+ * The empty answer for a shape.
+ *
+ * A feed build is usually string concatenation, so the failure that costs a
+ * publisher least is one that contributes nothing: an empty fragment splices
+ * into a document invisibly, while an error page spliced into a `<channel>`
+ * makes the whole feed unparseable for every subscriber. Status stays 200 for
+ * the same reason — a build script checking `res.ok` should not abort the
+ * publisher's deploy because our ad server had a bad minute.
+ */
+function emptyBody(shape: FeedShape): string {
+  if (shape === "json") return "[]\n";
+  if (shape === "fields") return `${JSON.stringify({ ok: false, count: 0, items: [] }, null, 2)}\n`;
+  return "";
+}
+
+export async function GET(request: NextRequest) {
+  const url = new URL(request.url);
+  const shape: FeedShape = isFeedShape(url.searchParams.get("as"))
+    ? (url.searchParams.get("as") as FeedShape)
+    : "rss";
+
+  try {
+    const slotId = url.searchParams.get("slot") || env.adsDefaultSlotId;
+    const visitorId = url.searchParams.get("v");
+    const src = cleanSrc(url.searchParams.get("src"));
+    const count = clampCount(url.searchParams.get("n"));
+
+    const styleParam = url.searchParams.get("style");
+    const guidParam = url.searchParams.get("guid");
+    const opts: FeedRenderOpts = {
+      style: isFeedStyle(styleParam) ? styleParam : "text",
+      guidMode: isGuidMode(guidParam) ? guidParam : "daily",
+      label: url.searchParams.get("label") ?? undefined,
+      cols: url.searchParams.has("cols")
+        ? clampCols(url.searchParams.get("cols"))
+        : undefined,
+    };
+
+    // Geo and device are resolved once and reused across the fills: they
+    // describe the caller, and the caller does not change between ad one and
+    // ad three of the same request.
+    const ip = clientIpFromHeaders(request.headers);
+    const geo = await lookupGeo(ip).catch(() => null);
+    const ua = request.headers.get("user-agent");
+    // Feed builders identify as HTTP libraries, which the generic tracker calls
+    // a bot — and bots get the unmetered house ad. feedDeviceType keeps real
+    // crawlers out while letting builders and readers through; anything it
+    // cannot place falls back to ordinary parsing. Without this a feed slot
+    // could never earn. Same trap, same fix as the terminal endpoint.
+    const device = feedDeviceType(ua) ?? parseDevice(ua).deviceType;
+
+    // Fills are sequential rather than concurrent on purpose: serveAd picks by
+    // weighted lottery and writes an impression row per call, and firing them
+    // in parallel against the same slot is how you get the same campaign three
+    // times in one document.
+    const inputs: FeedItemInput[] = [];
+    for (let i = 0; i < count; i += 1) {
+      let fill = null;
+      if (slotId) {
+        fill = await serveAd(slotId, FEED_FORMAT_ID, {
+          visitorId,
+          ip,
+          country: geo?.countryCode ?? null,
+          device,
+          src: src || null,
+        });
+      }
+      // No slot given, or the slot is inactive / has no feed inventory. A feed
+      // is a document somebody already published, so a missing fill is better
+      // filled by the house ad than left as a hole in their river.
+      if (!fill) fill = houseFill(FEED_FORMAT_ID);
+
+      // A paid fill already carries the publisher's surface tag on its
+      // impression row, which /a/<code> reads back when it builds utm_content.
+      // A house fill has no impression row, so its tag has to ride the URL —
+      // /h re-applies it server-side. Same split as the MOTD endpoint.
+      const isHouse = fill.campaignId === "house";
+      const clickUrl = src && isHouse ? withParam(fill.clickUrl, "s", src) : fill.clickUrl;
+
+      inputs.push({
+        creative: fill.creative,
+        clickUrl,
+        slotId: slotId || "default",
+        impressionId: fill.impressionId,
+        tier: fill.tier,
+        position: i,
+      });
+    }
+
+    // The JSON shapes are collections rather than concatenated documents, so
+    // they are assembled here instead of joined as strings.
+    if (shape === "json") {
+      const items = inputs.map((input) => jsonFeedItem(input, opts));
+      return new NextResponse(`${JSON.stringify(items, null, 2)}\n`, {
+        status: 200,
+        headers: headers(request, "application/json; charset=utf-8"),
+      });
+    }
+    if (shape === "fields") {
+      const items = inputs.map((input) => feedFields(input, opts));
+      return new NextResponse(
+        `${JSON.stringify({ ok: true, count: items.length, items }, null, 2)}\n`,
+        { status: 200, headers: headers(request, "application/json; charset=utf-8") },
+      );
+    }
+
+    const parts = inputs.map((input) => renderFeedAd(shape, input, opts));
+    const contentType = parts[0]?.contentType ?? "text/plain; charset=utf-8";
+    return new NextResponse(parts.map((p) => p.body).join(""), {
+      status: 200,
+      headers: headers(request, contentType),
+    });
+  } catch {
+    // Never break somebody's feed build. See emptyBody.
+    return new NextResponse(emptyBody(shape), {
+      status: 200,
+      headers: headers(request, shape === "json" || shape === "fields"
+        ? "application/json; charset=utf-8"
+        : "text/plain; charset=utf-8"),
+    });
+  }
+}
diff --git a/components/ads/slot-manager.tsx b/components/ads/slot-manager.tsx
index f7925600..c9596115 100644
--- a/components/ads/slot-manager.tsx
+++ b/components/ads/slot-manager.tsx
@@ -4,6 +4,9 @@ import { useState, useTransition } from "react";
 import { useRouter } from "next/navigation";
 import { createSlot, setSlotStatus, saveSlotPayout, requestPayout } from "@/app/actions/ads";
 import {
+  FEED_FORMAT_ID,
+  FEED_ITEM_LABEL,
+  PUBLISHER_FEED_FORMAT_IDS,
   PUBLISHER_FORMAT_IDS,
   PUBLISHER_TEXT_FORMAT_IDS,
   TERMINAL_COLS_LABEL,
@@ -11,51 +14,23 @@ import {
   formatSpec,
   type AdFormatId,
 } from "@/lib/ads/formats";
+import { formatBlurb, snippetsFor } from "@/lib/ads/snippets";
 
 // Every unit a publisher can install: HTML embeds first, then the fetch-based
-// text formats (terminal/MOTD).
+// formats — the terminal box (printed by a shell), then the feed item (spliced
+// into a document the publisher generates).
 const INSTALLABLE_FORMAT_IDS: AdFormatId[] = [
   ...PUBLISHER_FORMAT_IDS,
   ...PUBLISHER_TEXT_FORMAT_IDS,
+  ...PUBLISHER_FEED_FORMAT_IDS,
 ];
 
-// The paste-once embed for a given size. data-format tells /ad.js which creative
-// to request; the medium rectangle stays the default the auto-installer uses.
-// The terminal format isn't embedded at all — it's curled, so it gets a shell
-// snippet instead of markup.
-function embedFor(slotId: string, format: AdFormatId, origin: string): string {
-  if (format === TERMINAL_FORMAT_ID) {
-    return [
-      "# Terminal ad — plain ASCII over HTTP. No JavaScript, no HTML, no iframe.",
-      "# Drop in ~/.zshrc, /etc/profile.d/, /etc/update-motd.d, or any CLI banner.",
-      `curl -fsS --max-time 3 "${origin}/api/ads/motd?slot=${slotId}&cols=72"`,
-      "",
-      "# Options: &color=1 for ANSI colour, &cols=44..120 for width,",
-      "# &src=<tag> to tell surfaces apart (rides through to the click URL).",
-      "",
-      "# Repeat visitors: &v=<id>. A terminal has no cookies and no localStorage,",
-      "# so unlike the web tag we can't mint this for you — without it every",
-      "# fetch looks like a brand new person. Generate one stable random id per",
-      "# machine at install time and pass it every time:",
-      "#   id=$(cat /etc/crawlproof-visitor 2>/dev/null) || {",
-      "#     id=$(head -c16 /dev/urandom | od -An -tx1 | tr -d ' \\n')",
-      "#     printf '%s' \"$id\" >/etc/crawlproof-visitor",
-      "#   }",
-      `#   curl -fsS "${origin}/api/ads/motd?slot=${slotId}&cols=72&v=$id"`,
-      "# Use an opaque random value — never a hostname, username, or IP.",
-      "",
-      "# Rendering a template server-side? Leave a token where the ad goes —",
-      "#   {{ads}}  {{ads:64}}  {{ads:terminal:64}}",
-      "# — and swap it for the fetched text before you send the response.",
-    ].join("\n");
-  }
-  return `<div data-cp-ad data-slot="${slotId}" data-format="${format}"></div>\n<script src="${origin}/ad.js" async></script>`;
-}
-
-// Button caption: pixel sizes for banners, columns for the terminal box.
+// Button caption: pixel sizes for banners, columns for the terminal box, and
+// "1 item" for the feed unit — which has neither.
 function formatButtonLabel(id: AdFormatId): string {
   const spec = formatSpec(id);
   if (id === TERMINAL_FORMAT_ID) return `${spec.label} · ${TERMINAL_COLS_LABEL}`;
+  if (id === FEED_FORMAT_ID) return `${spec.label} · ${FEED_ITEM_LABEL}`;
   return `${spec.label} · ${spec.w}×${spec.h}`;
 }
 
@@ -131,13 +106,22 @@ export function SlotManager({
   // Which size's embed is currently revealed, and whether the code block is open.
   const [fmt, setFmt] = useState<AdFormatId>(PUBLISHER_FORMAT_IDS[0]);
   const [showCode, setShowCode] = useState(true);
+  // Which recipe within that size. Keyed by id rather than index so that
+  // switching formats and coming back does not land on an unrelated language
+  // just because it happened to sit at the same position.
+  const [snippetId, setSnippetId] = useState<string | null>(null);
   const [prBusy, setPrBusy] = useState(false);
   const [prMsg, setPrMsg] = useState<{ ok: boolean; text: string; url?: string } | null>(null);
   const [repoChoices, setRepoChoices] = useState<
     { owner: string; repo: string; installation_id: number }[] | null
   >(null);
 
-  const embed = slot ? embedFor(slot.id, fmt, origin) : null;
+  const snippets = slot ? snippetsFor(fmt, slot.id, origin) : [];
+  // The first recipe is the canonical one for each unit, so an unset selection
+  // (or one left over from another format) falls back to it rather than to
+  // nothing.
+  const snippet = snippets.find((sn) => sn.id === snippetId) ?? snippets[0] ?? null;
+  const embed = snippet?.code ?? null;
 
   function enable() {
     start(async () => {
@@ -285,7 +269,7 @@ export function SlotManager({
           )}
           <div>
             <div className="text-xs uppercase tracking-wider text-[var(--color-muted)]">
-              Embed — pick a unit, paste on your page (or in your shell)
+              Install — pick a unit, then the stack you build with
             </div>
             {/* One button per available size. Clicking reveals that size's code;
                 clicking the open size again collapses it. */}
@@ -302,6 +286,9 @@ export function SlotManager({
                         setShowCode((s) => !s);
                       } else {
                         setFmt(id);
+                        // Formats do not share recipes, so a selection made for
+                        // the last one cannot carry over.
+                        setSnippetId(null);
                         setShowCode(true);
                       }
                     }}
@@ -311,14 +298,34 @@ export function SlotManager({
                 );
               })}
             </div>
-            {showCode && embed && (
+            {showCode && snippet && (
               <>
+                <p className="mt-2 text-xs text-[var(--color-muted)]">{formatBlurb(fmt)}</p>
+                {/* One button per stack. The banners need this least — a script
+                    tag is a script tag — and the feed unit needs it most, since
+                    the snippet has to be written in whatever language builds
+                    the publisher's feed. */}
+                <div className="mt-2 flex flex-wrap gap-1.5">
+                  {snippets.map((sn) => (
+                    <button
+                      key={sn.id}
+                      className={`btn px-2 py-1 text-[11px] ${sn.id === snippet.id ? "btn-primary" : ""}`}
+                      aria-pressed={sn.id === snippet.id}
+                      onClick={() => setSnippetId(sn.id)}
+                    >
+                      {sn.label}
+                    </button>
+                  ))}
+                </div>
                 <pre className="mt-2 overflow-x-auto rounded border border-[var(--color-border)] bg-black/30 p-3 text-xs">
-                  {embed}
+                  {snippet.code}
                 </pre>
+                {snippet.note && (
+                  <p className="mt-1 text-xs text-[var(--color-muted)]">{snippet.note}</p>
+                )}
                 <div className="mt-2">
                   <button className="btn text-xs" onClick={copy}>
-                    {copied ? "Copied!" : "Copy embed"}
+                    {copied ? "Copied!" : `Copy ${snippet.label} snippet`}
                   </button>
                 </div>
               </>
diff --git a/lib/ads/creative.ts b/lib/ads/creative.ts
index 1270f43b..3016294e 100644
--- a/lib/ads/creative.ts
+++ b/lib/ads/creative.ts
@@ -8,6 +8,7 @@ import { generateStructuredOutput } from "@/lib/lx/backendAi";
 import { extractSiteBrand, type SiteBrand } from "./brand";
 import { resolveAdHeroImage } from "./heroImage";
 import { renderCreativeText, renderTerminalHtml } from "./terminal";
+import { renderFeedHtml } from "./feeditem";
 import {
   AD_FORMATS,
   AD_FORMAT_IDS,
@@ -194,6 +195,22 @@ export function renderCreativeHtml(creative: AdCreative, clickUrl: string): stri
     return renderTerminalHtml(creative, clickUrl);
   }
 
+  // Feed ad — the sponsored line as it will appear inside somebody's reader.
+  // Canonically delivered as a syndication item by /api/ads/feed; this path is
+  // what makes the same creative previewable in the browser, so it deliberately
+  // adds no styling the feed body would not survive. The wrapper only supplies
+  // a readable page background, since a feed body is rendered by the reader's
+  // own stylesheet rather than by ours.
+  if (creative.format === "feed_item") {
+    return `<!doctype html><html><head><meta charset="utf-8"><style>
+      body{margin:0;padding:12px;background:${creative.bgColor};color:${creative.fgColor};
+        font-family:${creative.fontFamily};font-size:14px;line-height:1.45}
+      a{color:${creative.accentColor}}
+      pre{overflow:auto;font:12px/1.35 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+      hr{border:0;border-top:1px solid rgba(255,255,255,.14)}
+    </style></head><body>${renderFeedHtml(creative, clickUrl)}</body></html>`;
+  }
+
   // Native text link — a borderless, full-width single line. No image/box.
   if (creative.format === "text_link") {
     const body = creative.body
diff --git a/lib/ads/feeditem.ts b/lib/ads/feeditem.ts
new file mode 100644
index 00000000..3ec710d7
--- /dev/null
+++ b/lib/ads/feeditem.ts
@@ -0,0 +1,699 @@
+// Feed ads — a creative rendered as a syndication item.
+//
+// The consumer here is neither a browser nor a TTY: it is somebody else's RSS,
+// Atom or JSON Feed document, being built by a static site generator, a CMS, or
+// a directory like rssamplifier.com. So the unit is not a box with pixels, it
+// is an *item* — a title, a link, a date, an identity, and a body — spliced
+// into a river of real posts every ~10 entries.
+//
+// Three constraints drive every decision below, and none of them apply to the
+// web or terminal formats:
+//
+//  1. **No namespaces.** A fragment is pasted inside a `<channel>` whose root
+//     element we did not write. If we emit `<dc:creator>` or `<media:content>`
+//     and the publisher's `<rss>` never declared that prefix, the document is
+//     not merely ugly — it is not well-formed, and every reader drops the whole
+//     feed rather than the one item. So the RSS fragment uses core RSS 2.0
+//     elements only, and the Atom fragment uses core Atom elements only (which
+//     need no prefix: they inherit the default namespace from `<feed>`).
+//
+//  2. **No CSS.** Feed readers strip `<style>` blocks outright and most strip
+//     `style=` attributes too. The markup therefore has to read correctly with
+//     zero styling applied — semantic elements carrying the hierarchy, never a
+//     layout that collapses into a heap once the attributes are gone.
+//
+//  3. **A stable identity.** `<guid>` is what tells a reader "you have seen
+//     this". Mint a fresh one per fetch and the ad resurfaces as unread on
+//     every rebuild, which is how a feed gets unsubscribed from. Freeze it
+//     forever and the advertiser reaches each subscriber exactly once. Neither
+//     is right, so the identity is periodic — see `adGuid`.
+//
+// Pure and client-safe (no server-only imports) so an editor preview renders
+// exactly what the endpoint serves — the same rule ./formats and ./terminal
+// follow.
+
+import { FEED_FORMAT_ID, FEED_ITEM_LABEL, type AdCreative } from "./formats";
+import { renderCreativeText } from "./terminal";
+
+// The format id and its caption live in ./formats, which is the one module that
+// names a format — re-exported here so a call site working with feed ads has a
+// single import rather than two.
+export { FEED_FORMAT_ID, FEED_ITEM_LABEL };
+
+/**
+ * The wire shapes `/api/ads/feed` can return.
+ *
+ * `rss`/`atom`/`json` are ready-to-splice items. `html`/`markdown`/`text` are
+ * just the *body*, for a publisher whose feed builder wants to own the item
+ * envelope. `fields` is the raw material for anyone templating it themselves —
+ * it is also the integration contract rssamplifier.com consumes, precisely so
+ * that its own renderers keep doing its own escaping.
+ */
+export const FEED_SHAPES = ["rss", "atom", "json", "html", "markdown", "text", "fields"] as const;
+export type FeedShape = (typeof FEED_SHAPES)[number];
+
+/**
+ * How much of the ad the body carries.
+ *
+ * `text` is the long thin one — a single sponsored line that reads as a line of
+ * the feed rather than an interruption of it. `card` adds the logo and puts the
+ * call to action on its own line. `terminal` is the ASCII box, for feeds whose
+ * readers are developers.
+ */
+export const FEED_STYLES = ["text", "card", "terminal"] as const;
+export type FeedStyle = (typeof FEED_STYLES)[number];
+
+/** How the item's identity rotates. See `adGuid`. */
+export const GUID_MODES = ["daily", "weekly", "fill", "static"] as const;
+export type GuidMode = (typeof GUID_MODES)[number];
+
+/** Default disclosure word. Configurable in wording, never removable. */
+export const DEFAULT_LABEL = "Sponsored";
+/** Attribution line, the feed twin of the terminal box's bottom border. */
+export const ATTRIBUTION = "Ads by CrawlProof";
+export const ATTRIBUTION_URL = "https://crawlproof.com/ads";
+
+/**
+ * `rel` on every link we emit.
+ *
+ * `sponsored` and `nofollow` are not decoration. A feed ad is a paid link that
+ * gets copied verbatim into every aggregator that mirrors the feed, which is
+ * the exact shape of a link scheme — leaving them off would put the publisher's
+ * feed, and ours, at risk of a manual action. `noopener` is the ordinary
+ * defence for `target="_blank"`.
+ */
+const LINK_REL = "sponsored nofollow noopener";
+
+/**
+ * The control characters XML 1.0 forbids outright.
+ *
+ * There is no escape for them: a document containing one does not degrade, it
+ * fails to parse. Ad copy reaches us through an LLM and a form, so it is
+ * stripped rather than trusted.
+ */
+// eslint-disable-next-line no-control-regex
+const XML_ILLEGAL = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
+
+export function isFeedShape(v: string | null | undefined): v is FeedShape {
+  return !!v && (FEED_SHAPES as readonly string[]).includes(v);
+}
+
+export function isFeedStyle(v: string | null | undefined): v is FeedStyle {
+  return !!v && (FEED_STYLES as readonly string[]).includes(v);
+}
+
+export function isGuidMode(v: string | null | undefined): v is GuidMode {
+  return !!v && (GUID_MODES as readonly string[]).includes(v);
+}
+
+// ------------------------------------------------------------------ escaping
+
+/** Escape for XML text and attributes alike, dropping the illegal controls. */
+export function esc(v: unknown): string {
+  return String(v ?? "")
+    .replace(XML_ILLEGAL, "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+/**
+ * Wrap a body in CDATA, which is how essentially every feed carries HTML.
+ *
+ * The one sequence CDATA cannot contain is its own terminator, and there is no
+ * escape for it — the only legal move is to close the section and open a new
+ * one around the `>`. Our own markup never produces `]]>`, but the copy inside
+ * it is advertiser-authored, so this is a correctness guard rather than a
+ * theoretical one.
+ */
+export function cdata(html: string): string {
+  const safe = String(html ?? "").replace(XML_ILLEGAL, "");
+  return `<![CDATA[${safe.replace(/]]>/g, "]]]]><![CDATA[>")}]]>`;
+}
+
+/** Collapse copy onto one line and trim it. Titles and summaries are one line. */
+export function oneLine(v: unknown): string {
+  return String(v ?? "")
+    .replace(XML_ILLEGAL, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/**
+ * A call to action with any trailing arrow removed.
+ *
+ * Advertiser copy frequently already ends in one ("Try it free →"), and we add
+ * our own, so without this the rendered unit reads "Try it free → →".
+ */
+export function ctaLabel(v: unknown): string {
+  return oneLine(v).replace(/\s*(->|→|>|:)\s*$/, "").trim() || "Learn more";
+}
+
+// -------------------------------------------------------------------- identity
+
+/**
+ * The item's identity, and the date that goes with it.
+ *
+ * A feed ad is read by software that remembers what it has already shown, and
+ * the guid is the whole of that memory. The rotation period is therefore a
+ * product decision rather than an implementation detail:
+ *
+ * - `daily` (the default) — one sponsored item per slot per UTC day. A reader
+ *   polling every 15 minutes sees the ad once; a publisher rebuilding hourly
+ *   does not spam anybody. This is the polite setting and should stay default.
+ * - `weekly` — the same, at a week's cadence, for a low-volume feed where a
+ *   daily ad would outnumber the posts.
+ * - `fill` — unique per fetch. Every rebuild is a new unread item. Correct only
+ *   for a high-churn river where the ad would otherwise scroll away unseen,
+ *   and genuinely rude anywhere else.
+ * - `static` — one identity, forever. The ad is seen once per subscriber and
+ *   never resurfaces. For a publisher who wants a permanent, unobtrusive
+ *   sponsor line and does not care about repeat delivery.
+ *
+ * The key is namespaced by **slot**, not by campaign, and that is deliberate:
+ * the campaign rotates on every fill, so keying by it would defeat the whole
+ * mechanism — a daily guid would change several times an hour. Keying by slot
+ * means "today's sponsor slot for this publisher", whichever advertiser won it.
+ *
+ * The consequence, which callers need to know: within a period the guid is
+ * fixed while the creative behind it is not, so a reader keeps whichever fill
+ * it saw first. Rebuilding more often than the period buys the advertiser
+ * nothing, which is why the fetcher on the consuming side should cache.
+ *
+ * `position` is what keeps a multi-ad request honest. A 50-item feed asking for
+ * three ads gets three fills, and under a periodic mode all three would
+ * otherwise resolve to the same daily key — one identity for three different
+ * items, which is the one thing a guid may never be. Numbering them by their
+ * place in the feed also keeps each position's identity stable across rebuilds,
+ * so the ad two thirds of the way down stays the same item it was an hour ago.
+ *
+ * @param mode rotation period
+ * @param ctx slot the ad filled, the fill's impression id, its position, "now"
+ * @returns the tag: URI to use as guid/id, and the date to publish it under
+ */
+export function adGuid(
+  mode: GuidMode,
+  ctx: { slotId: string; impressionId: string; position?: number; now?: Date },
+): { guid: string; published: Date } {
+  const now = ctx.now ?? new Date();
+  const slot = String(ctx.slotId || "default").replace(/[^\w.:-]/g, "");
+  // Position 0 adds nothing to the key, so a single-ad request keeps exactly
+  // the identity it had before positions existed — an established subscriber
+  // must not see every ad resurface because we started numbering them.
+  const at = Number.isFinite(ctx.position) && Number(ctx.position) > 0 ? `/${Number(ctx.position)}` : "";
+
+  if (mode === "fill") {
+    return { guid: tagUri(`ad/${slot}/fill/${ctx.impressionId}`), published: now };
+  }
+  if (mode === "static") {
+    return { guid: tagUri(`ad/${slot}${at}`), published: now };
+  }
+
+  const start = mode === "weekly" ? startOfUtcWeek(now) : startOfUtcDay(now);
+  const key = start.toISOString().slice(0, 10);
+  return {
+    guid: tagUri(`ad/${slot}/${mode === "weekly" ? "w" : "d"}/${key}${at}`),
+    published: start,
+  };
+}
+
+/**
+ * A `tag:` URI, which is what an Atom `<id>` has to be — an IRI, not a URL.
+ *
+ * The date is the authority date RFC 4151 requires, and it is a constant on
+ * purpose: it identifies *when we took ownership of the naming scheme*, not
+ * when the item was made, so changing it would silently re-identify every ad
+ * ever emitted and resurface all of them as unread.
+ */
+function tagUri(path: string): string {
+  return `tag:crawlproof.com,2026:${path}`;
+}
+
+function startOfUtcDay(d: Date): Date {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+}
+
+/** Monday 00:00 UTC of the week containing `d`. */
+function startOfUtcWeek(d: Date): Date {
+  const day = startOfUtcDay(d);
+  // getUTCDay() is 0 for Sunday, which is 6 days into an ISO week, not 0.
+  const offset = (day.getUTCDay() + 6) % 7;
+  return new Date(day.getTime() - offset * 86_400_000);
+}
+
+/** Day and month names — RFC 822 dates are English regardless of locale. */
+const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const MONTHS = [
+  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+];
+
+/**
+ * A Date as RFC 822, which is what an RSS `<pubDate>` is.
+ *
+ * Hand-built rather than `toUTCString()`: that method is specified to produce
+ * this format, but it is also the one place runtimes are free to differ on the
+ * day-name abbreviations, and a reader that cannot parse pubDate does not fail
+ * loudly — it sorts the publisher's whole feed wrongly.
+ */
+export function rfc822(d: Date): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return (
+    `${DAYS[d.getUTCDay()]}, ${pad(d.getUTCDate())} ${MONTHS[d.getUTCMonth()]} ${d.getUTCFullYear()} ` +
+    `${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())} GMT`
+  );
+}
+
+// ------------------------------------------------------- client classification
+
+/**
+ * Crawlers that must stay off paid inventory even on a feed endpoint.
+ *
+ * Deliberately checked *after* FEED_RE below. Several legitimate aggregators
+ * put a bot-ish word in their user agent — Feedly's fetcher advertises itself
+ * as "like FeedFetcher-Google" — and bucketing those as crawlers would mean the
+ * biggest feed readers on the internet could never fill a paid slot.
+ */
+const CRAWLER_RE = /googlebot|bingbot|yandexbot|ahrefs|semrush|petalbot|dotbot|mj12|headless|screenshot|archive\.org|ia_archiver/i;
+
+/**
+ * The real audience for a feed ad: whatever builds or fetches a feed document.
+ *
+ * That is almost never a browser. It is a static site generator running in CI,
+ * a CMS rendering `/feed.xml`, a server-side aggregator, or a reader's polling
+ * fetcher — and every one of them identifies as an HTTP library. The generic
+ * tracker (lib/tracker/device) buckets all of those as "bot", which is right
+ * for a web page and exactly wrong here: `isBotDevice` sends bots to the
+ * unmetered house ad, so without this a feed slot would serve nothing but house
+ * ads and never earn a cent. This is the same trap `terminalDeviceType` exists
+ * to avoid, for the same reason.
+ */
+const FEED_RE =
+  /feed|rss|atom|syndicat|feedly|inoreader|newsblur|miniflux|freshrss|tt-?rss|netnewswire|reeder|feedbin|newsboat|liferea|akregator|thunderbird|granary|curl|wget|httpie|python-requests|node-fetch|undici|go-http|okhttp|libwww|lwp|axios|got \(|guzzle|faraday|hugo|eleventy|jekyll|gatsby|astro|next\.js/i;
+
+/**
+ * Device bucket for a feed-ad request.
+ *
+ * Returns "bot" for real crawlers, "feed" for feed builders and readers (and
+ * for a missing user agent, which server-side fetchers routinely omit), and
+ * null to let the caller fall back to its own classification.
+ */
+export function feedDeviceType(userAgent: string | null | undefined): string | null {
+  const ua = (userAgent ?? "").trim();
+  if (!ua) return "feed";
+  if (FEED_RE.test(ua)) return "feed";
+  if (CRAWLER_RE.test(ua)) return "bot";
+  return null;
+}
+
+// ---------------------------------------------------------------------- bodies
+
+export type FeedRenderOpts = {
+  /** Body style. Default 'text' — the long thin one. */
+  style?: FeedStyle;
+  /** Disclosure wording. Blank falls back to 'Sponsored'; it is never dropped. */
+  label?: string;
+  /** Identity rotation. Default 'daily'. */
+  guidMode?: GuidMode;
+  /** Box width for the terminal style. */
+  cols?: number;
+  /** Clock injection, for tests. */
+  now?: Date;
+};
+
+/** Disclosure wording, sanitised. Empty input falls back rather than removing it. */
+export function labelText(v: string | null | undefined): string {
+  const s = oneLine(v).replace(/[[\]]/g, "").slice(0, 24);
+  return s || DEFAULT_LABEL;
+}
+
+/**
+ * The item title.
+ *
+ * The disclosure is in the title rather than only in the body because a great
+ * many readers show titles in a list and bodies only on click — a sponsored
+ * item whose sponsorship is disclosed exclusively in the body is, for those
+ * readers, an undisclosed one.
+ */
+export function feedTitle(creative: AdCreative, label = DEFAULT_LABEL): string {
+  return `[${labelText(label)}] ${oneLine(creative.headline) || "A message from our sponsor"}`;
+}
+
+/**
+ * The ad as minimal HTML, for a `<description>` / `<content>` / `content_html`.
+ *
+ * Every element here survives the strictest sanitiser in common use, and the
+ * hierarchy is carried by the elements themselves rather than by attributes, so
+ * stripping every `style=` on the way in costs the unit nothing.
+ */
+export function renderFeedHtml(
+  creative: AdCreative,
+  clickUrl: string,
+  opts: FeedRenderOpts = {},
+): string {
+  const style = opts.style ?? "text";
+  const label = labelText(opts.label);
+  const href = esc(clickUrl);
+  const link = (inner: string) =>
+    `<a href="${href}" rel="${LINK_REL}" target="_blank">${inner}</a>`;
+  const headline = esc(oneLine(creative.headline));
+  const body = esc(oneLine(creative.body));
+  const cta = esc(ctaLabel(creative.ctaText));
+  const credit = `<a href="${esc(ATTRIBUTION_URL)}" rel="${LINK_REL}" target="_blank">${esc(ATTRIBUTION)}</a>`;
+
+  if (style === "terminal") {
+    // The same ASCII box the MOTD endpoint serves, in the one element every
+    // reader renders monospaced and un-reflowed. Escaped after rendering, since
+    // the artwork legitimately contains characters XML reserves.
+    const art = renderCreativeText(creative, clickUrl, { cols: opts.cols, color: false });
+    return [
+      `<p><strong>${esc(label)}</strong></p>`,
+      `<pre>${esc(art)}</pre>`,
+      `<p><small>${credit}</small></p>`,
+    ].join("\n");
+  }
+
+  if (style === "card") {
+    const parts = [`<hr />`, `<p><strong>${esc(label)}</strong></p>`];
+    // Dimensions are attributes rather than CSS for the same reason as
+    // everything else here, and are capped small: this is a feed item, not a
+    // banner, and an oversized logo is what makes an ad feel like an intrusion.
+    if (creative.logoUrl) {
+      parts.push(
+        `<p>${link(`<img src="${esc(creative.logoUrl)}" alt="" width="120" height="32" />`)}</p>`,
+      );
+    }
+    parts.push(`<p>${link(`<strong>${headline}</strong>`)}</p>`);
+    if (body) parts.push(`<p>${body}</p>`);
+    parts.push(`<p>${link(`<strong>${cta} &#8594;</strong>`)}</p>`);
+    parts.push(`<p><small>${credit}</small></p>`, `<hr />`);
+    return parts.join("\n");
+  }
+
+  // 'text' — one line. The em dash and middle dot are the separators because
+  // they survive plain-text degradation, which a border never does.
+  const middle = body ? ` &#8212; ${body}` : "";
+  return (
+    `<p><strong>${esc(label)}</strong> &#183; ` +
+    `${link(`<strong>${headline}</strong>`)}${middle} ` +
+    `${link(`${cta} &#8594;`)} ` +
+    `<small>(${credit})</small></p>`
+  );
+}
+
+/**
+ * The ad as Markdown, for feed builders and newsletters that template in it.
+ *
+ * Kept to the subset every Markdown implementation agrees on — no tables, no
+ * raw HTML, no reference links — because this is very often pasted into
+ * somebody's static site generator rather than parsed by ours.
+ */
+export function renderFeedMarkdown(
+  creative: AdCreative,
+  clickUrl: string,
+  opts: FeedRenderOpts = {},
+): string {
+  const style = opts.style ?? "text";
+  const label = labelText(opts.label);
+  const headline = mdEsc(oneLine(creative.headline));
+  const body = mdEsc(oneLine(creative.body));
+  const cta = mdEsc(ctaLabel(creative.ctaText));
+  const url = mdUrl(clickUrl);
+  const credit = `*[${mdEsc(ATTRIBUTION)}](${mdUrl(ATTRIBUTION_URL)})*`;
+
+  if (style === "terminal") {
+    const art = renderCreativeText(creative, clickUrl, { cols: opts.cols, color: false });
+    // A fenced block, because the box is fixed-width art and indenting it four
+    // spaces would break the moment a line already starts with whitespace.
+    return [`**${label}**`, "", "```", art, "```", "", credit].join("\n");
+  }
+
+  if (style === "card") {
+    const lines = ["---", "", `**${label}**`, ""];
+    if (creative.logoUrl) lines.push(`[![](${mdUrl(creative.logoUrl)})](${url})`, "");
+    lines.push(`### [${headline}](${url})`, "");
+    if (body) lines.push(body, "");
+    lines.push(`[**${cta} →**](${url})`, "", credit, "", "---");
+    return lines.join("\n");
+  }
+
+  const middle = body ? ` — ${body}` : "";
+  return `**${label}** · [**${headline}**](${url})${middle} [${cta} →](${url}) ${credit}`;
+}
+
+/**
+ * The ad as plain text, for a `content_text`, a digest email, or a Gemini or
+ * Gopher mirror of the feed.
+ */
+export function renderFeedText(
+  creative: AdCreative,
+  clickUrl: string,
+  opts: FeedRenderOpts = {},
+): string {
+  const label = labelText(opts.label);
+  if ((opts.style ?? "text") === "terminal") {
+    return renderCreativeText(creative, clickUrl, { cols: opts.cols, color: false });
+  }
+  const headline = oneLine(creative.headline);
+  const body = oneLine(creative.body);
+  const cta = ctaLabel(creative.ctaText);
+  return [`[${label}] ${headline}`, body, `${cta}: ${clickUrl}`, `-- ${ATTRIBUTION} (${ATTRIBUTION_URL})`]
+    .filter(Boolean)
+    .join("\n");
+}
+
+/** Escape the Markdown punctuation that would otherwise reformat ad copy. */
+function mdEsc(v: string): string {
+  return String(v ?? "").replace(/([\\`*_[\]()<>#+\-!|])/g, "\\$1");
+}
+
+/**
+ * A URL safe to sit inside `(...)` in a Markdown link.
+ *
+ * Only spaces and parentheses can terminate the target early, and percent
+ * encoding them is understood everywhere — escaping them with a backslash is
+ * not.
+ *
+ * The encoding is spelled out rather than delegated to encodeURIComponent,
+ * which does *not* escape parentheses: they are unreserved as far as URI syntax
+ * is concerned, and it is only Markdown's link grammar that cares. Using it
+ * here made this function a no-op on exactly the input it exists to handle.
+ */
+const MD_URL_ESCAPES: Record<string, string> = { "(": "%28", ")": "%29", " ": "%20" };
+
+function mdUrl(v: string): string {
+  return String(v ?? "").replace(/[()\s]/g, (c) => MD_URL_ESCAPES[c] ?? encodeURIComponent(c));
+}
+
+// ----------------------------------------------------------------- envelopes
+
+export type FeedItemInput = {
+  creative: AdCreative;
+  clickUrl: string;
+  /** The slot being filled — namespaces the guid. */
+  slotId: string;
+  /** The fill's impression id, for `guidMode: 'fill'` and for the debug field. */
+  impressionId: string;
+  /** Which inventory the fill came from. Surfaced so a consumer can log it. */
+  tier?: string;
+  /** 0-based place in a multi-ad request. Namespaces the guid — see `adGuid`. */
+  position?: number;
+};
+
+/** Everything the shapes below are rendered from, computed once. */
+function assemble(input: FeedItemInput, opts: FeedRenderOpts) {
+  const { guid, published } = adGuid(opts.guidMode ?? "daily", {
+    slotId: input.slotId,
+    impressionId: input.impressionId,
+    position: input.position,
+    now: opts.now,
+  });
+  return {
+    guid,
+    published,
+    title: feedTitle(input.creative, opts.label),
+    label: labelText(opts.label),
+    html: renderFeedHtml(input.creative, input.clickUrl, opts),
+    markdown: renderFeedMarkdown(input.creative, input.clickUrl, opts),
+    text: renderFeedText(input.creative, input.clickUrl, opts),
+  };
+}
+
+/**
+ * An RSS 2.0 `<item>`, ready to splice into somebody else's `<channel>`.
+ *
+ * Core elements only — see the namespace note at the top of this file. That
+ * rules out `<dc:creator>` for the advertiser name and Media RSS for the logo,
+ * both of which would be nicer and neither of which is worth invalidating a
+ * publisher's document over. `<category>` carries the disclosure in a form a
+ * reader can filter on.
+ */
+export function renderRssItem(input: FeedItemInput, opts: FeedRenderOpts = {}): string {
+  const a = assemble(input, opts);
+  return [
+    "<item>",
+    `  <title>${esc(a.title)}</title>`,
+    `  <link>${esc(input.clickUrl)}</link>`,
+    // isPermaLink="false" because the guid is a tag: URI. Left at the default
+    // (true), a reader is entitled to treat it as a fetchable address.
+    `  <guid isPermaLink="false">${esc(a.guid)}</guid>`,
+    `  <pubDate>${esc(rfc822(a.published))}</pubDate>`,
+    `  <category>${esc(a.label)}</category>`,
+    `  <description>${cdata(a.html)}</description>`,
+    "</item>",
+  ].join("\n");
+}
+
+/**
+ * An Atom 1.0 `<entry>`.
+ *
+ * Atom is the stricter of the two: `<id>` must be an IRI and `<updated>` is
+ * mandatory, which is why the identity above is a tag: URI rather than a bare
+ * string. No prefixes are needed — these inherit the default namespace from the
+ * publisher's `<feed>` element.
+ */
+export function renderAtomEntry(input: FeedItemInput, opts: FeedRenderOpts = {}): string {
+  const a = assemble(input, opts);
+  const iso = a.published.toISOString();
+  return [
+    "<entry>",
+    `  <title>${esc(a.title)}</title>`,
+    `  <id>${esc(a.guid)}</id>`,
+    `  <updated>${esc(iso)}</updated>`,
+    `  <published>${esc(iso)}</published>`,
+    `  <link rel="alternate" type="text/html" href="${esc(input.clickUrl)}" />`,
+    `  <category term="sponsored" label="${esc(a.label)}" />`,
+    `  <rights>${esc(`${a.label} — ${ATTRIBUTION}`)}</rights>`,
+    `  <content type="html">${cdata(a.html)}</content>`,
+    "</entry>",
+  ].join("\n");
+}
+
+/**
+ * A JSON Feed 1.1 item object.
+ *
+ * `_crawlproof` is an extension field: the leading underscore is the spec's own
+ * way of saying "this is ours", and a reader that does not recognise it is
+ * required to ignore it rather than choke. It carries the machine-readable
+ * disclosure, which `tags` carries only as a human string.
+ */
+export function jsonFeedItem(
+  input: FeedItemInput,
+  opts: FeedRenderOpts = {},
+): Record<string, unknown> {
+  const a = assemble(input, opts);
+  return {
+    id: a.guid,
+    url: input.clickUrl,
+    title: a.title,
+    content_html: a.html,
+    content_text: a.text,
+    date_published: a.published.toISOString(),
+    tags: [a.label],
+    _crawlproof: {
+      sponsored: true,
+      label: a.label,
+      attribution: ATTRIBUTION,
+      impression_id: input.impressionId,
+      ...(input.tier ? { tier: input.tier } : {}),
+    },
+  };
+}
+
+/**
+ * The raw material, for anyone templating the item themselves.
+ *
+ * This is the integration shape rather than a convenience: a consumer that
+ * already builds RSS, Atom and JSON — rssamplifier.com does — is far better off
+ * rendering the ad through its own renderers than splicing our fragment into
+ * its document, because then there is exactly one place that decides how a
+ * title gets escaped. Every pre-rendered body is included too, so a consumer
+ * can take the parts it wants and ignore the rest.
+ */
+export function feedFields(
+  input: FeedItemInput,
+  opts: FeedRenderOpts = {},
+): Record<string, unknown> {
+  const a = assemble(input, opts);
+  const c = input.creative;
+  return {
+    ok: true,
+    sponsored: true,
+    guid: a.guid,
+    title: a.title,
+    label: a.label,
+    headline: oneLine(c.headline),
+    body: oneLine(c.body),
+    cta: ctaLabel(c.ctaText),
+    url: input.clickUrl,
+    publishedAt: a.published.toISOString(),
+    attribution: ATTRIBUTION,
+    attributionUrl: ATTRIBUTION_URL,
+    impressionId: input.impressionId,
+    position: input.position ?? 0,
+    tier: input.tier ?? null,
+    logoUrl: c.logoUrl,
+    imageUrl: c.imageUrl,
+    colors: { bg: c.bgColor, fg: c.fgColor, accent: c.accentColor },
+    html: a.html,
+    markdown: a.markdown,
+    text: a.text,
+  };
+}
+
+/**
+ * Render a fill in whichever shape was asked for.
+ *
+ * Returns the body plus the content type to send it with, so the route stays a
+ * parameter-parsing exercise and every decision about the document itself lives
+ * in this file.
+ */
+export function renderFeedAd(
+  shape: FeedShape,
+  input: FeedItemInput,
+  opts: FeedRenderOpts = {},
+): { body: string; contentType: string } {
+  switch (shape) {
+    case "rss":
+      // application/xml rather than application/rss+xml: this is a *fragment*,
+      // not a feed, and labelling it as one makes a reader that follows the
+      // link try to subscribe to a document with no channel in it.
+      return {
+        body: `${renderRssItem(input, opts)}\n`,
+        contentType: "application/xml; charset=utf-8",
+      };
+    case "atom":
+      return {
+        body: `${renderAtomEntry(input, opts)}\n`,
+        contentType: "application/xml; charset=utf-8",
+      };
+    case "json":
+      return {
+        body: `${JSON.stringify(jsonFeedItem(input, opts), null, 2)}\n`,
+        contentType: "application/json; charset=utf-8",
+      };
+    case "fields":
+      return {
+        body: `${JSON.stringify(feedFields(input, opts), null, 2)}\n`,
+        contentType: "application/json; charset=utf-8",
+      };
+    case "html":
+      return {
+        body: `${renderFeedHtml(input.creative, input.clickUrl, opts)}\n`,
+        contentType: "text/html; charset=utf-8",
+      };
+    case "markdown":
+      return {
+        body: `${renderFeedMarkdown(input.creative, input.clickUrl, opts)}\n`,
+        contentType: "text/markdown; charset=utf-8",
+      };
+    case "text":
+    default:
+      return {
+        body: `${renderFeedText(input.creative, input.clickUrl, opts)}\n`,
+        contentType: "text/plain; charset=utf-8",
+      };
+  }
+}
diff --git a/lib/ads/formats.ts b/lib/ads/formats.ts
index 51f306a6..19d250ab 100644
--- a/lib/ads/formats.ts
+++ b/lib/ads/formats.ts
@@ -15,6 +15,11 @@ export const AD_FORMATS = [
   // preview when the same creative is rendered in a <pre>. The real dimension
   // is TERMINAL_COLS (see ./terminal).
   { id: "terminal_ascii", label: "Terminal (ASCII)", w: 600, h: 148 },
+  // Syndication item — an RSS <item> / Atom <entry> / JSON Feed item, spliced
+  // into somebody else's feed document. Like the terminal format there is no
+  // pixel box: w/h is only the nominal size the web preview uses when the same
+  // creative is rendered as HTML. The real dimension is "one item".
+  { id: "feed_item", label: "Feed (RSS/Atom/JSON)", w: 600, h: 120 },
 ] as const;
 
 export type AdFormatId = (typeof AD_FORMATS)[number]["id"];
@@ -39,14 +44,29 @@ export const PUBLISHER_FORMAT_IDS: AdFormatId[] = [
 // (serving, the MOTD endpoint, the publisher snippet) branch on it.
 export const TERMINAL_FORMAT_ID = "terminal_ascii" as const;
 
+// The feed format id. Same reasoning as above — serving, /api/ads/feed and the
+// publisher snippets all branch on it. Declared here rather than imported from
+// ./feeditem so that this module stays the one place a format id is named, and
+// so ./feeditem can import ./formats without a cycle.
+export const FEED_FORMAT_ID = "feed_item" as const;
+
 // Caption for the terminal unit's real dimension — it has columns, not pixels.
 export const TERMINAL_COLS_LABEL = "76 cols";
 
+// Same for the feed unit, whose dimension is an item in a river.
+export const FEED_ITEM_LABEL = "1 item";
+
 // Formats a publisher consumes over plain HTTP as text rather than embedding —
 // `curl https://crawlproof.com/api/ads/motd?slot=<id>` in a login banner, MOTD,
 // or CLI. Shown as their own group on the Monetize page.
 export const PUBLISHER_TEXT_FORMAT_IDS: AdFormatId[] = [TERMINAL_FORMAT_ID];
 
+// Formats a publisher splices into a document they generate themselves — an
+// RSS/Atom/JSON feed, a newsletter, a static-site build. Fetched at build time
+// and pasted into the output, so like the text formats they are never embedded
+// and never rendered by /ad.js.
+export const PUBLISHER_FEED_FORMAT_IDS: AdFormatId[] = [FEED_FORMAT_ID];
+
 export function formatSpec(id: AdFormatId) {
   return AD_FORMATS.find((f) => f.id === id) ?? AD_FORMATS[0];
 }
diff --git a/lib/ads/house.ts b/lib/ads/house.ts
index 77a738e0..9f9812f7 100644
--- a/lib/ads/house.ts
+++ b/lib/ads/house.ts
@@ -1,8 +1,9 @@
 import crypto from "node:crypto";
 import { env } from "@/lib/env";
 import { formatSpec, type AdCreative, type AdFormatId } from "./creative";
-import { TERMINAL_FORMAT_ID } from "./formats";
+import { FEED_FORMAT_ID, TERMINAL_FORMAT_ID } from "./formats";
 import { renderCreativeText, renderTerminalHtml } from "./terminal";
+import { renderFeedHtml } from "./feeditem";
 import type { Fill } from "./serve";
 
 // Default "house" ad for the CrawlProof Ad Network. Shown when a slot has no
@@ -83,6 +84,20 @@ function imageUrlFor(format: AdFormatId): string {
   return `${env.siteUrl}/ads/house/${rect ? "promo-rect" : "promo-wide"}.webp`;
 }
 
+/**
+ * Artwork the house ad carries, per format.
+ *
+ * The feed unit gets none. Its body is `text` style — a single sponsored line
+ * — so an `imageUrl` would never be rendered, and leaving one on the creative
+ * would put a promo banner into the `imageUrl` field of every `as=fields`
+ * payload, where a consumer templating its own item would reasonably render it.
+ */
+function houseImageFor(format: AdFormatId): string | null {
+  return format === FEED_FORMAT_ID || format === TERMINAL_FORMAT_ID
+    ? null
+    : imageUrlFor(format);
+}
+
 function esc(s: string): string {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -101,6 +116,12 @@ export function renderHouseAdHtml(
     return renderTerminalHtml(houseCreative(format, copy), clickUrl);
   }
 
+  // Feed ad — the same sponsored line the /api/ads/feed body carries, so an
+  // unsold feed slot previews as what it would actually syndicate.
+  if (format === FEED_FORMAT_ID) {
+    return renderFeedHtml(houseCreative(format, copy), clickUrl, { label: "Sponsored" });
+  }
+
   // Native text link — no artwork, single full-width line.
   if (format === "text_link") {
     return `<!doctype html><html><head><meta charset="utf-8"><style>
@@ -171,7 +192,7 @@ function houseCreative(format: AdFormatId, copy: HouseCopy): AdCreative {
     accentColor: "#6ee7b7",
     fontFamily: "system-ui, -apple-system, Segoe UI, Roboto, sans-serif",
     logoUrl: null,
-    imageUrl: imageUrlFor(format),
+    imageUrl: houseImageFor(format),
   };
 }
 
@@ -186,8 +207,12 @@ export function houseFill(format: AdFormatId): Fill {
   // wider than the 40 columns a 44-col box has to spend, so it got pushed
   // outside the frame. /h is 24, and still fits once a publisher's &s=<surface>
   // tag is appended.
+  //
+  // The feed unit takes the same short form, and for the same reason: as=text,
+  // as=markdown and the terminal body style all print the URL as literal text.
+  // /h re-applies the utm params server-side, so attribution is unchanged.
   const clickUrl =
-    format === TERMINAL_FORMAT_ID
+    format === TERMINAL_FORMAT_ID || format === FEED_FORMAT_ID
       ? `${env.siteUrl}/h`
       : `${env.siteUrl}/?utm_source=house-ad&utm_medium=ad&utm_campaign=crawlproof-ads&utm_content=${copy.slug}`;
   const creative = houseCreative(format, copy);
diff --git a/lib/ads/serve.ts b/lib/ads/serve.ts
index c83bae27..9b3a31ea 100644
--- a/lib/ads/serve.ts
+++ b/lib/ads/serve.ts
@@ -9,7 +9,7 @@ import {
   type AdCreative,
   type AdFormatId,
 } from "./creative";
-import { TERMINAL_FORMAT_ID } from "./formats";
+import { FEED_FORMAT_ID, TERMINAL_FORMAT_ID } from "./formats";
 import { houseFill, HOUSE_AD_ROTATION_RATE } from "./house";
 import { CREDIT_CENTS, DEFAULT_BID_CREDITS, PLATFORM_RATE } from "./pricing";
 import {
@@ -292,10 +292,18 @@ export async function serveAd(
   // destination with ?ref= applied. Terminals print the URL as literal text, so
   // the terminal format gets the short /a/<code> form — it resolves the
   // slot/campaign/creative from the impression row instead of the query string.
-  const clickUrl =
-    format === TERMINAL_FORMAT_ID
-      ? `${env.siteUrl}/a/${clickRef}`
-      : `${env.siteUrl}/api/ads/click?i=${impressionId}&s=${slotId}&c=${campaign.id}&cr=${pick.id}`;
+  //
+  // Feed ads take the short form too, for two reasons. The soft one is that a
+  // click URL in a feed is *seen*: readers show the destination on hover, and a
+  // 70-character tracking URL beside a headline reads as spam next to
+  // crawlproof.com/a/<code>. The hard one is that several feed shapes print it
+  // as literal text rather than putting it in an href — as=text, as=markdown,
+  // and the terminal body style, which renders the same fixed-width ASCII box
+  // the MOTD endpoint serves and has exactly as little room to spare.
+  const shortClick = format === TERMINAL_FORMAT_ID || format === FEED_FORMAT_ID;
+  const clickUrl = shortClick
+    ? `${env.siteUrl}/a/${clickRef}`
+    : `${env.siteUrl}/api/ads/click?i=${impressionId}&s=${slotId}&c=${campaign.id}&cr=${pick.id}`;
 
   return {
     impressionId,
diff --git a/lib/ads/snippets.ts b/lib/ads/snippets.ts
new file mode 100644
index 00000000..7eaa6676
--- /dev/null
+++ b/lib/ads/snippets.ts
@@ -0,0 +1,800 @@
+// Install snippets — the copy-and-paste recipe for every unit, in every place
+// a publisher might be installing it.
+//
+// This used to be two branches inside <SlotManager>: a `<script>` tag for the
+// banners and a `curl` line for the terminal. That was enough while every unit
+// was rendered by /ad.js or printed by a shell, because in both cases the
+// publisher's stack did not matter — the browser or the terminal was the
+// runtime.
+//
+// The feed unit broke that assumption. It is not embedded and not printed: it
+// is *fetched at build time and spliced into a document the publisher's own
+// code generates*, which means the snippet has to be written in whatever
+// language builds that document. A Hugo site, an Eleventy build, a WordPress
+// install, and a Go service all need the same three HTTP parameters and four
+// completely different pieces of code.
+//
+// So snippets are data here rather than markup in a component, keyed by format
+// and then by target. Adding a language is one array entry.
+//
+// Client-safe: no server-only imports, because the Monetize page renders these
+// in the browser.
+
+import {
+  FEED_FORMAT_ID,
+  TERMINAL_FORMAT_ID,
+  type AdFormatId,
+} from "./formats";
+
+export type Snippet = {
+  /** Stable key — also the button caption's identity across re-renders. */
+  id: string;
+  /** What the publisher recognises: "Node.js", "Hugo", "WordPress". */
+  label: string;
+  /** Language hint, for the code block. */
+  lang: string;
+  /** One line on the catch, when there is one. Rendered under the code. */
+  note?: string;
+  code: string;
+};
+
+/** The ad endpoint for a slot, with whatever parameters a recipe needs. */
+export function feedAdUrl(
+  origin: string,
+  slotId: string,
+  params: Record<string, string | number> = {},
+): string {
+  const qs = new URLSearchParams({ slot: slotId });
+  for (const [k, v] of Object.entries(params)) qs.set(k, String(v));
+  return `${origin}/api/ads/feed?${qs.toString()}`;
+}
+
+// --------------------------------------------------------------- web formats
+
+/**
+ * Snippets for the units /ad.js renders: the three banners and the text link.
+ *
+ * The first is the canonical one — everything else is the same two attributes
+ * expressed in a framework's own syntax, because a publisher on Astro should
+ * not have to work out that `data-cp-ad` survives JSX.
+ */
+function webSnippets(slotId: string, format: AdFormatId, origin: string): Snippet[] {
+  const div = `<div data-cp-ad data-slot="${slotId}" data-format="${format}"></div>`;
+  const script = `<script src="${origin}/ad.js" async></script>`;
+  const frame = `${origin}/api/ads/frame?slot=${slotId}&format=${format}`;
+
+  return [
+    {
+      id: "html",
+      label: "HTML",
+      lang: "html",
+      note: "Put the script tag once per page; the div goes wherever the unit belongs.",
+      code: `${div}\n${script}`,
+    },
+    {
+      id: "iframe",
+      label: "iframe (no JS)",
+      lang: "html",
+      note: "No JavaScript at all — works on Tor hidden services and anywhere scripts are blocked.",
+      code: [
+        `<iframe src="${frame}"`,
+        `        width="300" height="250" frameborder="0" scrolling="no"`,
+        `        style="border:0;max-width:100%" loading="lazy"></iframe>`,
+      ].join("\n"),
+    },
+    {
+      id: "react",
+      label: "React",
+      lang: "jsx",
+      note: "ad.js scans once on DOMContentLoaded, so load it in your app shell, not per component.",
+      code: [
+        "export function Ad({ format = '" + format + "' }) {",
+        "  return <div data-cp-ad=\"\" data-slot=\"" + slotId + "\" data-format={format} />;",
+        "}",
+        "",
+        "// Once, in your root layout / index.html:",
+        "// " + script,
+      ].join("\n"),
+    },
+    {
+      id: "vue",
+      label: "Vue",
+      lang: "vue",
+      code: [
+        "<template>",
+        `  <div data-cp-ad data-slot="${slotId}" :data-format="format" />`,
+        "</template>",
+        "",
+        "<script setup>",
+        `defineProps({ format: { type: String, default: '${format}' } })`,
+        "</script>",
+      ].join("\n"),
+    },
+    {
+      id: "svelte",
+      label: "Svelte",
+      lang: "svelte",
+      code: [
+        "<script>",
+        `  export let format = '${format}';`,
+        "</script>",
+        "",
+        `<div data-cp-ad data-slot="${slotId}" data-format={format}></div>`,
+      ].join("\n"),
+    },
+    {
+      id: "astro",
+      label: "Astro",
+      lang: "astro",
+      code: [
+        "---",
+        `const { format = '${format}' } = Astro.props;`,
+        "---",
+        `<div data-cp-ad data-slot="${slotId}" data-format={format}></div>`,
+        `<script is:inline async src="${origin}/ad.js"></script>`,
+      ].join("\n"),
+    },
+    {
+      id: "hugo",
+      label: "Hugo",
+      lang: "html",
+      note: "Save as layouts/partials/ad.html, then call it with {{ partial \"ad.html\" . }}.",
+      code: [
+        `<div data-cp-ad data-slot="${slotId}" data-format="${format}"></div>`,
+        "{{ if not .Scratch.Get \"cp-ad-loaded\" }}",
+        `  ${script}`,
+        "  {{ .Scratch.Set \"cp-ad-loaded\" true }}",
+        "{{ end }}",
+      ].join("\n"),
+    },
+    {
+      id: "wordpress",
+      label: "WordPress",
+      lang: "php",
+      note: "Drop in your theme's functions.php; use [crawlproof_ad] in any post or widget.",
+      code: [
+        "<?php",
+        "add_shortcode('crawlproof_ad', function ($atts) {",
+        "    $a = shortcode_atts(['format' => '" + format + "'], $atts);",
+        "    return sprintf(",
+        "        '<div data-cp-ad data-slot=\"%s\" data-format=\"%s\"></div>',",
+        "        esc_attr('" + slotId + "'),",
+        "        esc_attr($a['format'])",
+        "    );",
+        "});",
+        "",
+        "add_action('wp_enqueue_scripts', function () {",
+        "    wp_enqueue_script('crawlproof-ads', '" + origin + "/ad.js', [], null, true);",
+        "});",
+      ].join("\n"),
+    },
+  ];
+}
+
+// ------------------------------------------------------------ terminal format
+
+function terminalSnippets(slotId: string, origin: string): Snippet[] {
+  const url = `${origin}/api/ads/motd?slot=${slotId}&cols=72`;
+
+  return [
+    {
+      id: "curl",
+      label: "curl",
+      lang: "bash",
+      note: "Add &color=1 for ANSI, &cols=44..120 for width, &src=<tag> to tell surfaces apart.",
+      code: [
+        "# Plain ASCII over HTTP. No JavaScript, no HTML, no iframe.",
+        `curl -fsS --max-time 3 "${url}"`,
+      ].join("\n"),
+    },
+    {
+      id: "visitor",
+      label: "Repeat visitors",
+      lang: "bash",
+      note: "Use an opaque random value — never a hostname, username, or IP.",
+      code: [
+        "# A terminal has no cookies and no localStorage, so unlike the web tag we",
+        "# cannot mint a visitor id for you: without one, every fetch looks like a",
+        "# brand new person. Generate one stable random id per machine at install",
+        "# time and pass it on every request.",
+        "id=$(cat /etc/crawlproof-visitor 2>/dev/null) || {",
+        "  id=$(head -c16 /dev/urandom | od -An -tx1 | tr -d ' \\n')",
+        "  printf '%s' \"$id\" >/etc/crawlproof-visitor",
+        "}",
+        `curl -fsS --max-time 3 "${url}&v=$id"`,
+      ].join("\n"),
+    },
+    {
+      id: "shellrc",
+      label: "Shell profile",
+      lang: "bash",
+      note: "--max-time keeps a slow network from delaying every new shell you open.",
+      code: [
+        "# ~/.zshrc, ~/.bashrc, or /etc/profile.d/crawlproof.sh",
+        `curl -fsS --max-time 2 "${url}" 2>/dev/null || true`,
+      ].join("\n"),
+    },
+    {
+      id: "motd",
+      label: "MOTD (Ubuntu)",
+      lang: "bash",
+      note: "Save as /etc/update-motd.d/99-crawlproof and chmod +x. Runs at login.",
+      code: [
+        "#!/bin/sh",
+        `curl -fsS --max-time 2 "${url}&src=motd" 2>/dev/null || true`,
+      ].join("\n"),
+    },
+    {
+      id: "sshd",
+      label: "SSH banner",
+      lang: "bash",
+      note: "sshd reads Banner from a file, so refresh it on a timer rather than per login.",
+      code: [
+        "# Refresh the banner file from cron, then point sshd at it:",
+        `*/30 * * * * curl -fsS --max-time 3 "${url}&src=ssh" > /etc/ssh/banner.txt`,
+        "",
+        "# /etc/ssh/sshd_config",
+        "Banner /etc/ssh/banner.txt",
+      ].join("\n"),
+    },
+    {
+      id: "node-cli",
+      label: "Node.js CLI",
+      lang: "javascript",
+      note: "Never let the ad block your CLI: fail open, always.",
+      code: [
+        "async function printAd() {",
+        "  try {",
+        "    const ctl = AbortSignal.timeout(1500);",
+        `    const res = await fetch('${url}&src=cli', { signal: ctl });`,
+        "    if (res.ok) console.log(await res.text());",
+        "  } catch {",
+        "    // no network, slow network, bad day — print nothing and carry on",
+        "  }",
+        "}",
+      ].join("\n"),
+    },
+    {
+      id: "python-cli",
+      label: "Python CLI",
+      lang: "python",
+      code: [
+        "import urllib.request",
+        "",
+        "def print_ad():",
+        "    try:",
+        `        with urllib.request.urlopen('${url}&src=cli', timeout=1.5) as r:`,
+        "            print(r.read().decode('utf-8'))",
+        "    except Exception:",
+        "        pass  # an ad is never worth failing a command over",
+      ].join("\n"),
+    },
+    {
+      id: "template",
+      label: "Template token",
+      lang: "text",
+      code: [
+        "# Rendering a banner template server-side? Leave a token where the ad goes",
+        "#   {{ads}}   {{ads:64}}   {{ads:terminal:64}}",
+        "# and swap it for the fetched text before you send the response.",
+      ].join("\n"),
+    },
+  ];
+}
+
+// ---------------------------------------------------------------- feed format
+
+/**
+ * Snippets for the feed unit.
+ *
+ * The recurring shape, in every language: fetch, with a short timeout, inside a
+ * try/catch that yields nothing on failure, and splice the result into the feed
+ * you were already building. The failure branch is not boilerplate — a feed
+ * build that throws because an ad server was slow takes the publisher's whole
+ * deploy down, which is a far worse outcome than an unsold slot. Every recipe
+ * below therefore fails open, and says so.
+ */
+function feedSnippets(slotId: string, origin: string): Snippet[] {
+  const rssUrl = feedAdUrl(origin, slotId, { as: "rss" });
+  const atomUrl = feedAdUrl(origin, slotId, { as: "atom" });
+  const jsonUrl = feedAdUrl(origin, slotId, { as: "json" });
+  const fieldsUrl = feedAdUrl(origin, slotId, { as: "fields" });
+  const mdUrl = feedAdUrl(origin, slotId, { as: "markdown" });
+  const htmlUrl = feedAdUrl(origin, slotId, { as: "html" });
+
+  return [
+    {
+      id: "curl-feed",
+      label: "curl",
+      lang: "bash",
+      // No &v= here on purpose: the caller of this endpoint is a build, not a
+      // reader, so a visitor id would identify the publisher's CI box rather
+      // than a person and would make every impression look like one visitor.
+      note: "as=rss|atom|json|html|markdown|text|fields · style=text|card|terminal · guid=daily|weekly|fill|static · n=1..5",
+      code: [
+        "# One RSS <item>, ready to paste inside your <channel>:",
+        `curl -fsS "${rssUrl}"`,
+        "",
+        "# Three of them, for a long feed:",
+        `curl -fsS "${rssUrl}&n=3"`,
+        "",
+        "# The raw fields, if you render your own items:",
+        `curl -fsS "${fieldsUrl}"`,
+      ].join("\n"),
+    },
+    {
+      id: "node-rss",
+      label: "Node.js",
+      lang: "javascript",
+      note: "Splices one ad after every 10th item. Returns the feed unchanged if the fetch fails.",
+      code: [
+        "const AD_EVERY = 10;",
+        "",
+        "async function fetchAds(n) {",
+        "  try {",
+        `    const res = await fetch('${rssUrl}&n=' + n, {`,
+        "      signal: AbortSignal.timeout(2000),",
+        "    });",
+        "    if (!res.ok) return [];",
+        "    const xml = await res.text();",
+        "    // The endpoint returns n items concatenated; split them back apart.",
+        "    return xml.match(/<item>[\\s\\S]*?<\\/item>/g) ?? [];",
+        "  } catch {",
+        "    return []; // never fail a build over an ad",
+        "  }",
+        "}",
+        "",
+        "// itemsXml is your array of rendered <item> strings.",
+        "async function withAds(itemsXml) {",
+        "  const wanted = Math.floor(itemsXml.length / AD_EVERY);",
+        "  if (wanted < 1) return itemsXml; // too short to carry one",
+        "",
+        "  const ads = await fetchAds(Math.min(wanted, 5));",
+        "  const out = [];",
+        "  let next = 0;",
+        "  for (let i = 0; i < itemsXml.length; i++) {",
+        "    out.push(itemsXml[i]);",
+        "    if ((i + 1) % AD_EVERY === 0 && next < ads.length) out.push(ads[next++]);",
+        "  }",
+        "  return out;",
+        "}",
+      ].join("\n"),
+    },
+    {
+      id: "node-feed-pkg",
+      label: "Node — feed pkg",
+      lang: "javascript",
+      note: "For the `feed` npm package, which builds the item for you — so take as=fields, not as=rss.",
+      code: [
+        "import { Feed } from 'feed';",
+        "",
+        "async function addSponsor(feed) {",
+        "  try {",
+        `    const res = await fetch('${fieldsUrl}', { signal: AbortSignal.timeout(2000) });`,
+        "    if (!res.ok) return;",
+        "    const { items } = await res.json();",
+        "    for (const ad of items) {",
+        "      feed.addItem({",
+        "        title: ad.title,",
+        "        id: ad.guid,",
+        "        link: ad.url,",
+        "        description: ad.body,",
+        "        content: ad.html,",
+        "        date: new Date(ad.publishedAt),",
+        "        category: [{ name: ad.label }],",
+        "      });",
+        "    }",
+        "  } catch {",
+        "    // unsold is fine; broken is not",
+        "  }",
+        "}",
+      ].join("\n"),
+    },
+    {
+      id: "next-route",
+      label: "Next.js",
+      lang: "javascript",
+      note: "app/feed.xml/route.js. force-dynamic, or Next caches one advertiser's ad forever.",
+      code: [
+        "export const dynamic = 'force-dynamic';",
+        "",
+        "export async function GET() {",
+        "  const items = await renderItems(); // your <item> strings",
+        "",
+        "  let ads = [];",
+        "  try {",
+        `    const res = await fetch('${rssUrl}&n=3', {`,
+        "      signal: AbortSignal.timeout(2000),",
+        "      cache: 'no-store',",
+        "    });",
+        "    if (res.ok) ads = (await res.text()).match(/<item>[\\s\\S]*?<\\/item>/g) ?? [];",
+        "  } catch {}",
+        "",
+        "  const body = interleave(items, ads, 10).join('\\n');",
+        "  return new Response(rssShell(body), {",
+        "    headers: { 'content-type': 'application/rss+xml; charset=utf-8' },",
+        "  });",
+        "}",
+      ].join("\n"),
+    },
+    {
+      id: "express",
+      label: "Express",
+      lang: "javascript",
+      code: [
+        "app.get('/feed.xml', async (req, res) => {",
+        "  const items = await renderItems();",
+        "",
+        "  let ad = '';",
+        "  try {",
+        `    const r = await fetch('${rssUrl}', { signal: AbortSignal.timeout(2000) });`,
+        "    if (r.ok) ad = await r.text();",
+        "  } catch {}",
+        "",
+        "  items.splice(10, 0, ad); // after the 10th post",
+        "  res.type('application/rss+xml').send(rssShell(items.join('\\n')));",
+        "});",
+      ].join("\n"),
+    },
+    {
+      id: "hono",
+      label: "Hono / Deno / Bun",
+      lang: "javascript",
+      code: [
+        "app.get('/feed.xml', async (c) => {",
+        "  let ad = '';",
+        "  try {",
+        `    const r = await fetch('${rssUrl}', { signal: AbortSignal.timeout(2000) });`,
+        "    if (r.ok) ad = await r.text();",
+        "  } catch {}",
+        "",
+        "  const items = await renderItems();",
+        "  items.splice(10, 0, ad);",
+        "  return c.body(rssShell(items.join('\\n')), 200, {",
+        "    'content-type': 'application/rss+xml; charset=utf-8',",
+        "  });",
+        "});",
+      ].join("\n"),
+    },
+    {
+      id: "eleventy",
+      label: "Eleventy (11ty)",
+      lang: "javascript",
+      note: "Fetched once per build in .eleventy.js, then read as a global in your feed template.",
+      code: [
+        "// .eleventy.js",
+        "module.exports = function (cfg) {",
+        "  cfg.addGlobalData('sponsor', async () => {",
+        "    try {",
+        `      const r = await fetch('${fieldsUrl}', { signal: AbortSignal.timeout(2000) });`,
+        "      if (!r.ok) return null;",
+        "      return (await r.json()).items[0] ?? null;",
+        "    } catch {",
+        "      return null;",
+        "    }",
+        "  });",
+        "};",
+        "",
+        "<!-- feed.njk, inside your <channel> -->",
+        "{% if sponsor %}",
+        "<item>",
+        "  <title>{{ sponsor.title }}</title>",
+        "  <link>{{ sponsor.url }}</link>",
+        "  <guid isPermaLink=\"false\">{{ sponsor.guid }}</guid>",
+        "  <category>{{ sponsor.label }}</category>",
+        "  <description>{{ sponsor.html }}</description>",
+        "</item>",
+        "{% endif %}",
+      ].join("\n"),
+    },
+    {
+      id: "hugo",
+      label: "Hugo",
+      lang: "html",
+      note: "getJSON caches for the whole build, so one fetch covers every feed Hugo renders.",
+      code: [
+        "{{/* layouts/_default/rss.xml — inside <channel>, after the range */}}",
+        `{{ $ad := getJSON "${fieldsUrl}" }}`,
+        "{{ with (index $ad.items 0) }}",
+        "<item>",
+        "  <title>{{ .title }}</title>",
+        "  <link>{{ .url }}</link>",
+        "  <guid isPermaLink=\"false\">{{ .guid }}</guid>",
+        "  <pubDate>{{ .publishedAt }}</pubDate>",
+        "  <category>{{ .label }}</category>",
+        "  <description>{{ .html }}</description>",
+        "</item>",
+        "{{ end }}",
+      ].join("\n"),
+    },
+    {
+      id: "jekyll",
+      label: "Jekyll",
+      lang: "ruby",
+      note: "Liquid cannot make HTTP calls, so the fetch is a generator plugin; the template reads site.data.",
+      code: [
+        "# _plugins/crawlproof.rb",
+        "require 'net/http'",
+        "require 'json'",
+        "",
+        "Jekyll::Hooks.register :site, :after_init do |site|",
+        "  begin",
+        `    uri = URI('${fieldsUrl}')`,
+        "    res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 2, read_timeout: 2) do |http|",
+        "      http.get(uri.request_uri)",
+        "    end",
+        "    site.config['sponsor'] = JSON.parse(res.body)['items'].first if res.is_a?(Net::HTTPSuccess)",
+        "  rescue StandardError",
+        "    site.config['sponsor'] = nil",
+        "  end",
+        "end",
+      ].join("\n"),
+    },
+    {
+      id: "astro-rss",
+      label: "Astro (@astrojs/rss)",
+      lang: "javascript",
+      note: "@astrojs/rss builds the item, so take as=fields and hand it customData for the disclosure.",
+      code: [
+        "import rss from '@astrojs/rss';",
+        "",
+        "export async function GET(context) {",
+        "  const posts = await getPosts();",
+        "",
+        "  let ad = null;",
+        "  try {",
+        `    const r = await fetch('${fieldsUrl}', { signal: AbortSignal.timeout(2000) });`,
+        "    if (r.ok) ad = (await r.json()).items[0];",
+        "  } catch {}",
+        "",
+        "  const items = posts.map(toRssItem);",
+        "  if (ad) {",
+        "    items.splice(10, 0, {",
+        "      title: ad.title,",
+        "      link: ad.url,",
+        "      pubDate: new Date(ad.publishedAt),",
+        "      content: ad.html,",
+        "      customData: '<category>' + ad.label + '</category>',",
+        "    });",
+        "  }",
+        "",
+        "  return rss({ title: 'My blog', description: '…', site: context.site, items });",
+        "}",
+      ].join("\n"),
+    },
+    {
+      id: "wordpress-feed",
+      label: "WordPress",
+      lang: "php",
+      note: "rss2_item fires inside each <item>, so this appends the ad to the 10th post's own item.",
+      code: [
+        "<?php",
+        "add_action('rss2_item', function () {",
+        "    static $n = 0;",
+        "    if (++$n !== 10) return;",
+        "",
+        `    $res = wp_remote_get('${rssUrl}', ['timeout' => 2]);`,
+        "    if (is_wp_error($res) || wp_remote_retrieve_response_code($res) !== 200) {",
+        "        return; // unsold, unreachable, whatever — the feed is unaffected",
+        "    }",
+        "    // Closes this <item> and opens the next, so the ad is a sibling.",
+        "    echo '</item>' . wp_remote_retrieve_body($res) . '<item>';",
+        "});",
+      ].join("\n"),
+    },
+    {
+      id: "php",
+      label: "PHP",
+      lang: "php",
+      code: [
+        "<?php",
+        "function crawlproof_ad(): string {",
+        "    $ctx = stream_context_create(['http' => ['timeout' => 2, 'ignore_errors' => true]]);",
+        `    $body = @file_get_contents('${rssUrl}', false, $ctx);`,
+        "    return $body === false ? '' : $body;",
+        "}",
+        "",
+        "// Inside your <channel>, after the tenth item:",
+        "echo crawlproof_ad();",
+      ].join("\n"),
+    },
+    {
+      id: "python-feedgen",
+      label: "Python (feedgen)",
+      lang: "python",
+      code: [
+        "import requests",
+        "from feedgen.feed import FeedGenerator",
+        "",
+        "def add_sponsor(fg: FeedGenerator) -> None:",
+        "    try:",
+        `        r = requests.get('${fieldsUrl}', timeout=2)`,
+        "        r.raise_for_status()",
+        "        ad = r.json()['items'][0]",
+        "    except Exception:",
+        "        return  # an unsold slot must never break the feed",
+        "",
+        "    e = fg.add_entry()",
+        "    e.id(ad['guid'])",
+        "    e.title(ad['title'])",
+        "    e.link(href=ad['url'])",
+        "    e.description(ad['html'])",
+        "    e.category(term=ad['label'])",
+        "    e.pubDate(ad['publishedAt'])",
+      ].join("\n"),
+    },
+    {
+      id: "django",
+      label: "Django",
+      lang: "python",
+      note: "Django's syndication framework builds items from objects, so wrap the ad in one.",
+      code: [
+        "import requests",
+        "from django.contrib.syndication.views import Feed",
+        "",
+        "class PostFeed(Feed):",
+        "    def items(self):",
+        "        posts = list(Post.objects.order_by('-published')[:50])",
+        "        ad = self._sponsor()",
+        "        if ad and len(posts) > 10:",
+        "            posts.insert(10, ad)",
+        "        return posts",
+        "",
+        "    def _sponsor(self):",
+        "        try:",
+        `            r = requests.get('${fieldsUrl}', timeout=2)`,
+        "            r.raise_for_status()",
+        "            return SponsorItem(r.json()['items'][0])",
+        "        except Exception:",
+        "            return None",
+      ].join("\n"),
+    },
+    {
+      id: "ruby",
+      label: "Ruby",
+      lang: "ruby",
+      code: [
+        "require 'net/http'",
+        "require 'json'",
+        "",
+        "def crawlproof_ad",
+        `  uri = URI('${fieldsUrl}')`,
+        "  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 2, read_timeout: 2) do |http|",
+        "    http.get(uri.request_uri)",
+        "  end",
+        "  res.is_a?(Net::HTTPSuccess) ? JSON.parse(res.body)['items'].first : nil",
+        "rescue StandardError",
+        "  nil",
+        "end",
+      ].join("\n"),
+    },
+    {
+      id: "go",
+      label: "Go",
+      lang: "go",
+      code: [
+        "func crawlproofAd(ctx context.Context) string {",
+        "    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)",
+        "    defer cancel()",
+        "",
+        `    req, err := http.NewRequestWithContext(ctx, "GET", "${rssUrl}", nil)`,
+        "    if err != nil {",
+        `        return ""`,
+        "    }",
+        "    res, err := http.DefaultClient.Do(req)",
+        "    if err != nil {",
+        `        return "" // unsold beats a failed build`,
+        "    }",
+        "    defer res.Body.Close()",
+        "    if res.StatusCode != http.StatusOK {",
+        `        return ""`,
+        "    }",
+        "    b, _ := io.ReadAll(res.Body)",
+        "    return string(b)",
+        "}",
+      ].join("\n"),
+    },
+    {
+      id: "worker",
+      label: "Cloudflare Worker",
+      lang: "javascript",
+      note: "Monetise a feed you do not generate: fetch the origin's, inject, serve.",
+      code: [
+        "export default {",
+        "  async fetch(request) {",
+        "    const upstream = await fetch('https://example.com/feed.xml');",
+        "    let xml = await upstream.text();",
+        "",
+        "    try {",
+        `      const r = await fetch('${rssUrl}&src=worker');`,
+        "      if (r.ok) {",
+        "        const ad = await r.text();",
+        "        // After the 10th </item>, or at the end of the channel if shorter.",
+        "        let n = 0;",
+        "        xml = xml.replace(/<\\/item>/g, (m) => (++n === 10 ? m + ad : m));",
+        "      }",
+        "    } catch {}",
+        "",
+        "    return new Response(xml, {",
+        "      headers: { 'content-type': 'application/rss+xml; charset=utf-8' },",
+        "    });",
+        "  },",
+        "};",
+      ].join("\n"),
+    },
+    {
+      id: "jsonfeed",
+      label: "JSON Feed",
+      lang: "javascript",
+      note: "as=json returns an array of JSON Feed 1.1 items — splice it straight into feed.items.",
+      code: [
+        "const feed = { version: 'https://jsonfeed.org/version/1.1', title: 'My blog', items };",
+        "",
+        "try {",
+        `  const r = await fetch('${jsonUrl}&n=3', { signal: AbortSignal.timeout(2000) });`,
+        "  if (r.ok) {",
+        "    const ads = await r.json();",
+        "    ads.forEach((ad, i) => feed.items.splice(10 * (i + 1) + i, 0, ad));",
+        "  }",
+        "} catch {}",
+      ].join("\n"),
+    },
+    {
+      id: "atom",
+      label: "Atom",
+      lang: "bash",
+      note: "as=atom returns an <entry> using core Atom elements only — no namespace to declare.",
+      code: [
+        "# Paste inside your <feed>, between entries:",
+        `curl -fsS "${atomUrl}"`,
+      ].join("\n"),
+    },
+    {
+      id: "markdown",
+      label: "Markdown",
+      lang: "bash",
+      note: "For newsletters, digests, and static-site builds that template in Markdown.",
+      code: [
+        `curl -fsS "${mdUrl}"`,
+        "",
+        "# style=card for a headline, body and its own call-to-action line:",
+        `curl -fsS "${mdUrl}&style=card"`,
+      ].join("\n"),
+    },
+    {
+      id: "html-body",
+      label: "HTML body",
+      lang: "bash",
+      note: "Just the body — for when your generator already owns the item envelope.",
+      code: [
+        `curl -fsS "${htmlUrl}"`,
+        "",
+        "# style=terminal renders the ASCII box in a <pre>, for developer feeds:",
+        `curl -fsS "${htmlUrl}&style=terminal"`,
+      ].join("\n"),
+    },
+  ];
+}
+
+/**
+ * Every snippet for a format.
+ *
+ * The first entry is the one shown by default, so each list leads with the
+ * recipe most publishers of that unit actually want.
+ */
+export function snippetsFor(format: AdFormatId, slotId: string, origin: string): Snippet[] {
+  if (format === TERMINAL_FORMAT_ID) return terminalSnippets(slotId, origin);
+  if (format === FEED_FORMAT_ID) return feedSnippets(slotId, origin);
+  return webSnippets(slotId, format, origin);
+}
+
+/** One line under the format buttons explaining what this unit *is*. */
+export function formatBlurb(format: AdFormatId): string {
+  if (format === TERMINAL_FORMAT_ID) {
+    return "Fetched as plain text and printed by a shell — MOTDs, SSH banners, CLI tools.";
+  }
+  if (format === FEED_FORMAT_ID) {
+    return "Fetched at build time and spliced into a feed you generate — RSS, Atom, JSON Feed, newsletters.";
+  }
+  return "Rendered in the browser by ad.js inside an isolated iframe.";
+}
diff --git a/package-lock.json b/package-lock.json
index 1c477047..e4c27ea5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -49,6 +49,7 @@
         "@types/node": "^22.9.0",
         "@types/react": "^19.0.0",
         "@types/react-dom": "^19.0.0",
+        "fast-xml-parser": "^5.11.0",
         "postcss": "^8.4.49",
         "tailwindcss": "^4.0.0",
         "tsx": "^4.19.0",
@@ -1550,6 +1551,19 @@
         "node": ">= 10"
       }
     },
+    "node_modules/@nodable/entities": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-3.0.0.tgz",
+      "integrity": "sha512-8L9xFeTYKhm49xfIypoe2W5wV1m/3Z58kT+7kR9A8OyFxcPduI4VmxaUMQyKYrRjUoLLSXv6EKKID5Tvj9cUVw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodable"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/@oxc-project/types": {
       "version": "0.129.0",
       "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.129.0.tgz",
@@ -2795,6 +2809,19 @@
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
       "license": "MIT"
     },
+    "node_modules/anynum": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz",
+      "integrity": "sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/assertion-error": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
@@ -3935,6 +3962,47 @@
       ],
       "license": "BSD-3-Clause"
     },
+    "node_modules/fast-xml-builder": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.3.1.tgz",
+      "integrity": "sha512-pIM/1n3ntFXKYrUZwW7QCK0gAW7XY+wzj1YMIV3tLDvPj/V+zTGJK5e3/4WJfwj0qWw2ElNXiTixda/R+3YSug==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "path-expression-matcher": "^1.6.2",
+        "xml-naming": "^0.3.0"
+      }
+    },
+    "node_modules/fast-xml-parser": {
+      "version": "5.11.0",
+      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.11.0.tgz",
+      "integrity": "sha512-9IGxMqvqLOnqP+Egi1nqDHKv5k8aZ7r9n558enxcucmyVGEBNPAU+MOg/8jPIS7rO7sSq4gFm1/nHtiaubMruw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@nodable/entities": "^3.0.0",
+        "fast-xml-builder": "^1.2.0",
+        "is-unsafe": "^2.0.0",
+        "path-expression-matcher": "^1.6.2",
+        "strnum": "^2.4.2",
+        "xml-naming": "^0.3.0"
+      },
+      "bin": {
+        "fxparser": "src/cli/cli.js"
+      }
+    },
     "node_modules/fdir": {
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -4425,6 +4493,19 @@
       "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
       "license": "MIT"
     },
+    "node_modules/is-unsafe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-2.0.0.tgz",
+      "integrity": "sha512-2LdV822R+wmI86unXA93WCFpL6g+av8ynWk0nrHyJqGop5VoocYsSLFgN8jrfalT6iGeLNM4KXuVSsULP53kEA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -5561,6 +5642,22 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/path-expression-matcher": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.2.tgz",
+      "integrity": "sha512-enSlaiat05iasnzmgNxRj8reFdj3puY2QpNgP1aPIaVfT6nn9ICuPoFlKHk8EN22HcwewshO+mN2DGbkCEOtqQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/path-key": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
@@ -6566,6 +6663,22 @@
         "node": ">=12.*"
       }
     },
+    "node_modules/strnum": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.4.2.tgz",
+      "integrity": "sha512-rDG3Ah4TV0k1hWvLSzkZtMmLN9+eS+h3knq4MP6A42Y3Yh5qGNnOUs1jJkoSr8FG5dsL28c7KgkIBzSEykqtuw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "anynum": "^1.0.1"
+      }
+    },
     "node_modules/styled-jsx": {
       "version": "5.1.6",
       "resolved": "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.6.tgz",
@@ -7256,6 +7369,22 @@
         }
       }
     },
+    "node_modules/xml-naming": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.3.0.tgz",
+      "integrity": "sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/yallist": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
diff --git a/package.json b/package.json
index c3f0a728..948a942c 100644
--- a/package.json
+++ b/package.json
@@ -61,6 +61,7 @@
     "@types/node": "^22.9.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
+    "fast-xml-parser": "^5.11.0",
     "postcss": "^8.4.49",
     "tailwindcss": "^4.0.0",
     "tsx": "^4.19.0",
diff --git a/supabase/migrations/20260818120000_ad_feed_item.sql b/supabase/migrations/20260818120000_ad_feed_item.sql
new file mode 100644
index 00000000..91a55872
--- /dev/null
+++ b/supabase/migrations/20260818120000_ad_feed_item.sql
@@ -0,0 +1,87 @@
+-- Feed ad format.
+--
+-- Adds `feed_item` — a creative served as a syndication item (RSS <item>, Atom
+-- <entry>, JSON Feed item, or a bare HTML/Markdown/text body) from
+-- /api/ads/feed, for splicing into a feed document a publisher generates. Four
+-- parts, mirroring how terminal_ascii was introduced:
+--   1. widen the creative format CHECK,
+--   2. add the format to slot inventory (default + backfill) so serveAd() will
+--      actually fill it,
+--   3. backfill a feed creative for every existing campaign, derived from the
+--      copy it already has — no LLM call, no advertiser action needed,
+--   4. nothing else: the impression and click tables are format-agnostic, and a
+--      feed fill meters through exactly the same path a banner does.
+--
+-- NOTE: prod migration history diverged — apply this single file via psql over
+-- the pooler, do NOT `supabase db push`.
+
+alter table public.ad_creatives drop constraint if exists ad_creatives_format_check;
+alter table public.ad_creatives
+  add constraint ad_creatives_format_check
+  check (format in ('banner_300x250', 'banner_728x90', 'banner_320x50', 'text_link', 'terminal_ascii', 'feed_item'));
+
+alter table public.ad_slots
+  alter column formats
+  set default array['banner_300x250', 'banner_728x90', 'banner_320x50', 'text_link', 'terminal_ascii', 'feed_item'];
+
+update public.ad_slots
+  set formats = array_append(formats, 'feed_item')
+  where not ('feed_item' = any (formats));
+
+-- Backfill: one feed creative per campaign that doesn't have one yet.
+--
+-- Copy is cloned from the campaign's best existing creative. text_link is
+-- preferred first because it is the closest relative — a headline, one benefit
+-- line and a CTA, designed to read as a single line rather than fill a box,
+-- which is exactly what the default feed body is. terminal_ascii comes next for
+-- the same reason, then the rectangle. banner_320x50 is last because it carries
+-- the *shortened* mobile headline, and a feed item has no width problem that
+-- would justify the truncated copy.
+--
+-- image_url is dropped: the default feed body is a single sponsored line and
+-- never renders artwork, and carrying a banner URL would put it in the
+-- `imageUrl` field of every as=fields payload, where a consumer templating its
+-- own item would reasonably render it. logo_url is kept — style=card does use
+-- it. Colours are kept because they drive the optional ANSI palette on
+-- style=terminal and the campaign preview. The source creative's status is
+-- carried over so a rejected campaign does not gain a servable creative.
+insert into public.ad_creatives (
+  campaign_id, owner_id, format, headline, body, cta_text,
+  image_url, logo_url, bg_color, fg_color, accent_color, font_family,
+  ai_provenance, status
+)
+select distinct on (c.campaign_id)
+  c.campaign_id,
+  c.owner_id,
+  'feed_item',
+  c.headline,
+  c.body,
+  c.cta_text,
+  null,
+  c.logo_url,
+  c.bg_color,
+  c.fg_color,
+  c.accent_color,
+  c.font_family,
+  jsonb_build_object(
+    'source', 'backfill_feed_item',
+    'from_creative', c.id,
+    'from_format', c.format
+  ),
+  c.status
+from public.ad_creatives c
+where c.format <> 'feed_item'
+  and not exists (
+    select 1 from public.ad_creatives f
+    where f.campaign_id = c.campaign_id and f.format = 'feed_item'
+  )
+order by
+  c.campaign_id,
+  case c.format
+    when 'text_link' then 0
+    when 'terminal_ascii' then 1
+    when 'banner_300x250' then 2
+    when 'banner_728x90' then 3
+    else 4
+  end,
+  c.created_at;
diff --git a/tests/ads-feed-item.test.ts b/tests/ads-feed-item.test.ts
new file mode 100644
index 00000000..b4deef11
--- /dev/null
+++ b/tests/ads-feed-item.test.ts
@@ -0,0 +1,395 @@
+import { describe, expect, it } from "vitest";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+import {
+  ATTRIBUTION,
+  adGuid,
+  cdata,
+  ctaLabel,
+  feedDeviceType,
+  feedFields,
+  feedTitle,
+  isFeedShape,
+  isFeedStyle,
+  isGuidMode,
+  jsonFeedItem,
+  labelText,
+  renderAtomEntry,
+  renderFeedHtml,
+  renderFeedMarkdown,
+  renderFeedText,
+  renderRssItem,
+  rfc822,
+  FEED_SHAPES,
+  FEED_STYLES,
+  GUID_MODES,
+  type FeedItemInput,
+} from "@/lib/ads/feeditem";
+import type { AdCreative } from "@/lib/ads/formats";
+
+// A feed ad is spliced into a document somebody else published, and read by
+// software that caches what it has already seen. Those two facts are what these
+// tests are actually about: the fragment must not be able to break the host
+// document, and the identity must rotate exactly as often as it claims to.
+
+const NOW = new Date("2026-08-18T15:04:05.000Z");
+
+const creative: AdCreative = {
+  format: "feed_item",
+  headline: "Ship faster with Widgets",
+  body: "Deploy in one command, roll back in one more.",
+  ctaText: "Try it free →",
+  bgColor: "#0b0d10",
+  fgColor: "#e7e9ee",
+  accentColor: "#6ee7b7",
+  fontFamily: "system-ui, sans-serif",
+  logoUrl: "https://widgets.example/logo.png",
+  imageUrl: null,
+};
+
+const input: FeedItemInput = {
+  creative,
+  clickUrl: "https://crawlproof.com/api/ads/click?i=imp-1&s=slot-1&c=camp-1&cr=cre-1",
+  slotId: "slot-1",
+  impressionId: "imp-1",
+  tier: "paid",
+};
+
+const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+
+/** Parse a fragment the way a reader would: inside a host document it did not write. */
+function inRssChannel(fragment: string): string {
+  return `<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Host</title>${fragment}</channel></rss>`;
+}
+
+function inAtomFeed(fragment: string): string {
+  return `<?xml version="1.0" encoding="UTF-8"?><feed xmlns="http://www.w3.org/2005/Atom"><title>Host</title>${fragment}</feed>`;
+}
+
+describe("guards", () => {
+  it("accepts every declared shape, style and guid mode", () => {
+    for (const s of FEED_SHAPES) expect(isFeedShape(s)).toBe(true);
+    for (const s of FEED_STYLES) expect(isFeedStyle(s)).toBe(true);
+    for (const m of GUID_MODES) expect(isGuidMode(m)).toBe(true);
+  });
+
+  it("rejects anything else", () => {
+    expect(isFeedShape("opml")).toBe(false);
+    expect(isFeedStyle("banner")).toBe(false);
+    expect(isGuidMode("hourly")).toBe(false);
+    expect(isFeedShape(null)).toBe(false);
+  });
+});
+
+describe("the fragment cannot break the host document", () => {
+  it("produces a well-formed RSS item inside a channel it did not write", () => {
+    const doc = inRssChannel(renderRssItem(input, { now: NOW }));
+    expect(XMLValidator.validate(doc)).toBe(true);
+  });
+
+  it("produces a well-formed Atom entry inside a feed it did not write", () => {
+    const doc = inAtomFeed(renderAtomEntry(input, { now: NOW }));
+    expect(XMLValidator.validate(doc)).toBe(true);
+  });
+
+  // The whole reason the renderer is restricted to core elements: a prefix the
+  // publisher's root never declared makes the *entire feed* unparseable, not
+  // just our item. Any dc:/media:/itunes: element here would be a live outage
+  // for every subscriber of every publisher carrying the unit.
+  it("emits no namespace-prefixed elements in either fragment", () => {
+    const prefixed = /<\s*[A-Za-z_][\w.-]*:/;
+    expect(renderRssItem(input, { now: NOW })).not.toMatch(prefixed);
+    expect(renderAtomEntry(input, { now: NOW })).not.toMatch(prefixed);
+  });
+
+  it("survives copy that is itself markup", () => {
+    const hostile: FeedItemInput = {
+      ...input,
+      creative: {
+        ...creative,
+        headline: 'Buy </description></item><item><title>Injected',
+        body: "5 > 3 && 2 < 4, \"quoted\" & 'apostrophed'",
+      },
+    };
+    const doc = inRssChannel(renderRssItem(hostile, { now: NOW }));
+    expect(XMLValidator.validate(doc)).toBe(true);
+
+    const parsed = parser.parse(doc);
+    // One item, not two: the injected element never became an element.
+    expect(Array.isArray(parsed.rss.channel.item)).toBe(false);
+    expect(String(parsed.rss.channel.item.title)).toContain("Injected");
+  });
+
+  it("closes and reopens CDATA around a body containing its terminator", () => {
+    const wrapped = cdata("before ]]> after");
+    expect(wrapped).toBe("<![CDATA[before ]]]]><![CDATA[> after]]>");
+    // And the result still parses inside a real document.
+    const doc = `<r><d>${wrapped}</d></r>`;
+    expect(XMLValidator.validate(doc)).toBe(true);
+    expect(parser.parse(doc).r.d).toBe("before ]]> after");
+  });
+
+  it("strips the control characters XML forbids outright", () => {
+    const withCtl: FeedItemInput = {
+      ...input,
+      creative: { ...creative, headline: "Bell\u0007and\u0000null" },
+    };
+    const doc = inRssChannel(renderRssItem(withCtl, { now: NOW }));
+    expect(XMLValidator.validate(doc)).toBe(true);
+    expect(doc).not.toMatch(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/);
+  });
+});
+
+describe("identity", () => {
+  it("is stable within a day and changes across days", () => {
+    const a = adGuid("daily", { slotId: "s", impressionId: "i1", now: NOW });
+    const b = adGuid("daily", {
+      slotId: "s",
+      impressionId: "i2", // a different fill, same day
+      now: new Date("2026-08-18T23:59:59.000Z"),
+    });
+    const c = adGuid("daily", {
+      slotId: "s",
+      impressionId: "i3",
+      now: new Date("2026-08-19T00:00:01.000Z"),
+    });
+
+    expect(a.guid).toBe(b.guid);
+    expect(a.guid).not.toBe(c.guid);
+    // Dated to the period, so the item does not keep jumping up the reader's
+    // sort order every time the publisher rebuilds.
+    expect(a.published.toISOString()).toBe("2026-08-18T00:00:00.000Z");
+  });
+
+  it("is stable within a week, and weeks start on Monday", () => {
+    // 2026-08-18 is a Tuesday; the Monday before it is the 17th.
+    const tue = adGuid("weekly", { slotId: "s", impressionId: "i", now: NOW });
+    const sun = adGuid("weekly", {
+      slotId: "s",
+      impressionId: "i",
+      now: new Date("2026-08-23T23:00:00.000Z"), // the Sunday of the same week
+    });
+    const mon = adGuid("weekly", {
+      slotId: "s",
+      impressionId: "i",
+      now: new Date("2026-08-24T00:00:00.000Z"), // the next Monday
+    });
+
+    expect(tue.published.toISOString()).toBe("2026-08-17T00:00:00.000Z");
+    expect(sun.guid).toBe(tue.guid);
+    expect(mon.guid).not.toBe(tue.guid);
+  });
+
+  it("is unique per fill under guid=fill", () => {
+    const a = adGuid("fill", { slotId: "s", impressionId: "i1", now: NOW });
+    const b = adGuid("fill", { slotId: "s", impressionId: "i2", now: NOW });
+    expect(a.guid).not.toBe(b.guid);
+  });
+
+  it("never changes under guid=static", () => {
+    const a = adGuid("static", { slotId: "s", impressionId: "i1", now: NOW });
+    const b = adGuid("static", {
+      slotId: "s",
+      impressionId: "i2",
+      now: new Date("2027-01-01T00:00:00.000Z"),
+    });
+    expect(a.guid).toBe(b.guid);
+  });
+
+  it("separates publishers, so one slot's ad is not another's", () => {
+    const a = adGuid("daily", { slotId: "slot-a", impressionId: "i", now: NOW });
+    const b = adGuid("daily", { slotId: "slot-b", impressionId: "i", now: NOW });
+    expect(a.guid).not.toBe(b.guid);
+  });
+
+  // Three ads in one document must be three items, not the same item thrice.
+  it("separates positions within a multi-ad request", () => {
+    const seen = new Set(
+      [0, 1, 2].map(
+        (position) => adGuid("daily", { slotId: "s", impressionId: "i", position, now: NOW }).guid,
+      ),
+    );
+    expect(seen.size).toBe(3);
+  });
+
+  // Position 0 must add nothing, or every existing subscriber would see the
+  // whole back catalogue of ads resurface the day this shipped.
+  it("leaves the single-ad identity untouched", () => {
+    const withOut = adGuid("daily", { slotId: "s", impressionId: "i", now: NOW });
+    const withZero = adGuid("daily", { slotId: "s", impressionId: "i", position: 0, now: NOW });
+    expect(withZero.guid).toBe(withOut.guid);
+  });
+
+  it("mints an Atom-legal id", () => {
+    const { guid } = adGuid("daily", { slotId: "s", impressionId: "i", now: NOW });
+    // An Atom <id> must be an absolute IRI; tag: is the scheme for names that
+    // are not fetchable addresses.
+    expect(guid).toMatch(/^tag:crawlproof\.com,2026:/);
+  });
+
+  it("marks the guid as not a permalink", () => {
+    expect(renderRssItem(input, { now: NOW })).toContain('<guid isPermaLink="false">');
+  });
+});
+
+describe("disclosure", () => {
+  it("is in the title, where a reader listing titles will see it", () => {
+    expect(feedTitle(creative)).toBe("[Sponsored] Ship faster with Widgets");
+  });
+
+  it("can be reworded but not removed", () => {
+    expect(feedTitle(creative, "Ad")).toBe("[Ad] Ship faster with Widgets");
+    expect(labelText("")).toBe("Sponsored");
+    expect(labelText("   ")).toBe("Sponsored");
+    expect(labelText(null)).toBe("Sponsored");
+    // Brackets would let a caller forge a second label inside the first.
+    expect(labelText("[not] an ad")).toBe("not an ad");
+  });
+
+  it("rides on the item as a category too", () => {
+    expect(renderRssItem(input, { now: NOW })).toContain("<category>Sponsored</category>");
+    expect(renderAtomEntry(input, { now: NOW })).toContain('<category term="sponsored"');
+  });
+
+  // The HTML bodies carry the attribution as a link, so they use the exact
+  // string. The terminal style delegates to the ASCII renderer, whose bottom
+  // border has carried its own wording ("ads by crawlproof.com") since the MOTD
+  // format shipped — so what is asserted across all styles is that the network
+  // is named, not that one phrasing won.
+  it("attributes the network in every body style", () => {
+    for (const style of FEED_STYLES) {
+      expect(renderFeedHtml(creative, input.clickUrl, { style }).toLowerCase()).toContain(
+        "crawlproof",
+      );
+      expect(renderFeedText(creative, input.clickUrl, { style }).toLowerCase()).toContain(
+        "crawlproof",
+      );
+    }
+    expect(renderFeedHtml(creative, input.clickUrl, { style: "text" })).toContain(ATTRIBUTION);
+    expect(renderFeedText(creative, input.clickUrl, { style: "text" })).toContain(ATTRIBUTION);
+  });
+});
+
+describe("bodies", () => {
+  it("marks every link as paid, in every style", () => {
+    for (const style of FEED_STYLES) {
+      const html = renderFeedHtml(creative, input.clickUrl, { style });
+      for (const rel of html.matchAll(/rel="([^"]*)"/g)) {
+        // A syndicated paid link that is not disclosed to crawlers is the
+        // textbook shape of a link scheme.
+        expect(rel[1]).toContain("sponsored");
+        expect(rel[1]).toContain("nofollow");
+      }
+      expect(html).toMatch(/rel="/);
+    }
+  });
+
+  it("uses no CSS, which readers strip anyway", () => {
+    for (const style of FEED_STYLES) {
+      const html = renderFeedHtml(creative, input.clickUrl, { style });
+      expect(html).not.toMatch(/<style/i);
+      expect(html).not.toMatch(/\sstyle=/i);
+      expect(html).not.toMatch(/<script/i);
+      expect(html).not.toMatch(/\sclass=/i);
+    }
+  });
+
+  it("renders the logo only in the card style", () => {
+    expect(renderFeedHtml(creative, input.clickUrl, { style: "card" })).toContain(creative.logoUrl!);
+    expect(renderFeedHtml(creative, input.clickUrl, { style: "text" })).not.toContain(
+      creative.logoUrl!,
+    );
+  });
+
+  it("does not double the arrow on copy that already has one", () => {
+    expect(ctaLabel("Try it free →")).toBe("Try it free");
+    expect(ctaLabel("Learn more ->")).toBe("Learn more");
+    expect(ctaLabel("  ")).toBe("Learn more");
+    expect(renderFeedText(creative, input.clickUrl)).not.toContain("→ →");
+  });
+
+  it("escapes Markdown punctuation so ad copy cannot reformat the page", () => {
+    const md = renderFeedMarkdown(
+      { ...creative, headline: "50% off *everything* [today]" },
+      input.clickUrl,
+    );
+    expect(md).toContain("\\*everything\\*");
+    expect(md).toContain("\\[today\\]");
+  });
+
+  it("percent-encodes a click URL that would end a Markdown link early", () => {
+    const md = renderFeedMarkdown(creative, "https://x.example/a(b)c");
+    expect(md).toContain("https://x.example/a%28b%29c");
+  });
+
+  it("keeps plain text plain", () => {
+    const text = renderFeedText(creative, input.clickUrl);
+    expect(text).toContain("[Sponsored] Ship faster with Widgets");
+    expect(text).toContain(input.clickUrl);
+    expect(text).not.toMatch(/<[a-z]/i);
+  });
+});
+
+describe("json shapes", () => {
+  it("builds a JSON Feed 1.1 item with the disclosure machine-readable", () => {
+    const item = jsonFeedItem(input, { now: NOW }) as Record<string, unknown>;
+    expect(item.id).toMatch(/^tag:crawlproof\.com,2026:/);
+    expect(item.url).toBe(input.clickUrl);
+    expect(item.tags).toEqual(["Sponsored"]);
+    expect((item._crawlproof as Record<string, unknown>).sponsored).toBe(true);
+    expect(String(item.date_published)).toBe("2026-08-18T00:00:00.000Z");
+  });
+
+  it("gives a consumer every part it might template from", () => {
+    const f = feedFields(input, { now: NOW }) as Record<string, unknown>;
+    for (const key of ["guid", "title", "headline", "body", "cta", "url", "publishedAt", "html", "markdown", "text"]) {
+      expect(f[key], key).toBeTruthy();
+    }
+    // The raw headline, without the disclosure prefix baked in, so a consumer
+    // that discloses its own way is not forced to string-strip ours.
+    expect(f.headline).toBe("Ship faster with Widgets");
+    expect(f.title).toBe("[Sponsored] Ship faster with Widgets");
+    expect(f.tier).toBe("paid");
+  });
+});
+
+describe("client classification", () => {
+  // The bug this exists to prevent: a feed builder identifies as an HTTP
+  // library, the generic tracker calls that a bot, isBotDevice sends bots to
+  // the unmetered house ad, and the slot can never earn. Same trap the terminal
+  // format hit.
+  it("treats feed builders and readers as the audience, not as bots", () => {
+    for (const ua of [
+      "Feedly/1.0 (+http://www.feedly.com/fetcher.html; like FeedFetcher-Google)",
+      "Inoreader/1.0 (+http://www.inoreader.com/feed-fetcher)",
+      "NetNewsWire/6.1",
+      "Miniflux/2.0.51",
+      "curl/8.5.0",
+      "node-fetch/1.0",
+      "Go-http-client/2.0",
+      "python-requests/2.31.0",
+      "Hugo Static Site Generator",
+    ]) {
+      expect(feedDeviceType(ua), ua).toBe("feed");
+    }
+  });
+
+  it("treats a missing user agent as a feed builder", () => {
+    expect(feedDeviceType(null)).toBe("feed");
+    expect(feedDeviceType("")).toBe("feed");
+  });
+
+  it("still keeps real crawlers off paid inventory", () => {
+    expect(feedDeviceType("Mozilla/5.0 (compatible; Googlebot/2.1)")).toBe("bot");
+    expect(feedDeviceType("AhrefsBot/7.0")).toBe("bot");
+  });
+
+  it("defers to the caller for anything it cannot place", () => {
+    expect(feedDeviceType("Mozilla/5.0 (Macintosh) Safari/605.1.15")).toBeNull();
+  });
+});
+
+describe("rfc822", () => {
+  it("formats a pubDate the way RSS specifies", () => {
+    expect(rfc822(new Date("2026-08-18T00:00:00.000Z"))).toBe("Tue, 18 Aug 2026 00:00:00 GMT");
+  });
+});

From 40fe79b05a2a5b01d77d6b7adeaf790c5141ba4c Mon Sep 17 00:00:00 2001
From: Anthony Ettinger <anthony@chovy.com>
Date: Tue, 18 Aug 2026 14:39:22 +0000
Subject: [PATCH 2/2] Preview the feed unit as a reader will show it

copyToCreatives maps over every format, so every new campaign now gets a
feed_item creative -- and AdPreview had no branch for it, so all three
advertiser screens (new, detail, edit) fell through to the banner renderer and
drew it as a 600x120 box. That is not what anybody receives.

The preview is deliberately not painted in the advertiser's brand colours. The
served body carries no CSS at all, because feed readers strip it, so its
appearance comes entirely from the subscriber's own stylesheet -- and showing
brand colours here would promise a look we have no way to deliver. What it
shows instead is the structure that does survive: the disclosure, the headline
as a link, the body, the call to action, the attribution, on the plain
serif-on-white a reader actually renders.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 components/ads/ad-preview.tsx | 52 ++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/components/ads/ad-preview.tsx b/components/ads/ad-preview.tsx
index 3d90249c..d0974e53 100644
--- a/components/ads/ad-preview.tsx
+++ b/components/ads/ad-preview.tsx
@@ -2,8 +2,15 @@
 
 import type { CSSProperties } from "react";
 import type { AdCreative } from "@/lib/ads/formats";
-import { brandInitial, formatSpec, hexToRgba, TERMINAL_FORMAT_ID } from "@/lib/ads/formats";
+import {
+  brandInitial,
+  formatSpec,
+  hexToRgba,
+  FEED_FORMAT_ID,
+  TERMINAL_FORMAT_ID,
+} from "@/lib/ads/formats";
 import { renderCreativeText } from "@/lib/ads/terminal";
+import { ATTRIBUTION, ctaLabel, DEFAULT_LABEL, oneLine } from "@/lib/ads/feeditem";
 
 // Stand-in for the real /a/<impression_id> click URL, so the preview box is the
 // width the served ad will actually be.
@@ -39,6 +46,49 @@ export function AdPreview({ creative, scale = 1 }: { creative: AdCreative; scale
     );
   }
 
+  // Feed ad — the sponsored line as a reader will actually show it.
+  //
+  // Deliberately *not* styled to match the other units. The served body carries
+  // no CSS at all (readers strip it), so its appearance comes entirely from the
+  // subscriber's own stylesheet — and a preview painted in the advertiser's
+  // brand colours would promise a look we have no way to deliver. What this
+  // shows instead is the structure the reader will get: the disclosure, the
+  // headline as a link, the body, the call to action, the attribution.
+  if (creative.format === FEED_FORMAT_ID) {
+    return (
+      <div style={{ width: w * scale, maxWidth: "100%", flex: "0 0 auto" }}>
+        <div
+          style={{
+            background: "#ffffff",
+            color: "#1a1a1a",
+            border: "1px solid rgba(255,255,255,.08)",
+            borderRadius: 8,
+            padding: "12px 14px",
+            fontFamily: "Georgia, 'Times New Roman', serif",
+            fontSize: 14,
+            lineHeight: 1.5,
+          }}
+        >
+          <p style={{ margin: 0 }}>
+            <strong>{DEFAULT_LABEL}</strong>
+            {" \u00b7 "}
+            <a style={{ color: "#0645ad", textDecoration: "underline" }}>
+              <strong>{oneLine(creative.headline) || "Your headline"}</strong>
+            </a>
+            {creative.body ? ` \u2014 ${oneLine(creative.body)}` : ""}{" "}
+            <a style={{ color: "#0645ad", textDecoration: "underline" }}>
+              {ctaLabel(creative.ctaText)} {"\u2192"}
+            </a>{" "}
+            <small style={{ color: "#666" }}>({ATTRIBUTION})</small>
+          </p>
+        </div>
+        <p style={{ margin: "6px 0 0", fontSize: 11, color: "var(--color-muted)" }}>
+          Shown in the subscriber&apos;s reader, which supplies its own styling.
+        </p>
+      </div>
+    );
+  }
+
   // Native text link — a borderless, full-width single line.
   if (creative.format === "text_link") {
     return (