@alexkroman1/aai-cli 10.0.0 → 11.0.0

package/dist/templates/podcast-digest/agent.test.ts

@@ -2,18 +2,21 @@
 /**
  * What this template promises, checked without a network.
  *
- * Three kinds of thing are checked, and the workflow BODY is none of them: it is
- * only durable once the Workflow DevKit's build has transformed it, so a unit
- * test of it would exercise a plain async function and prove nothing about
- * replay. What IS here:
+ * Four kinds of thing are checked:
  *
  * - The DECLARATION — the config a deploy validates and the schema a `start()`
  *   is checked against.
  * - The PURE helpers, pulled out of the flow for exactly this reason.
- * - The STEPS, directly. A step is an ordinary exported async function, so one
- *   function is an ordinary async function, so its HTTP handling, its
- *   partial-failure policy and its `FatalError` guards are all reachable —
- *   `installStubStepFetch` answers the network and `stubGateway` answers the model.
+ * - The STEPS, directly. A step is an ordinary exported async function, so its
+ *   HTTP handling, its partial-failure policy and its `FatalError` guards are
+ *   all reachable — `installStubStepFetch` answers the network and
+ *   `stubGateway` answers the model.
+ * - The BODY, twice. `createWorkflowCtx` records what it asked for (the digest
+ *   loop, the shrinking pending set, the sleep BETWEEN digests and never after
+ *   the last), and `runWorkflow` runs it on the real replay engine — which is
+ *   what this file used to say a unit test could not do, on the ground that a
+ *   body "is only durable once the Workflow DevKit's build has transformed it".
+ *   That stopped being true when the DevKit was replaced.
  *
  * The cases worth having are the ones where a mistake is SILENT: a schema that
  * accepts a webhook pointing anywhere, a Slack payload in the shape the other
@@ -21,11 +24,18 @@
  * that fails to transcribe taking the whole digest down with it.
  */
 
-import { createWorkflowCtx, parseSchemaInput, schemaInputIssues } from "@alexkroman1/aai/testing";
+import { type FeedItem, parseFeed } from "@alexkroman1/aai/html";
+import {
+  createWorkflowCtx,
+  parseSchemaInput,
+  schemaInputIssues,
+  stubGatewayRoute,
+} from "@alexkroman1/aai/testing";
 import {
   installStubStepFetch,
   installStubGateway as stubGateway,
 } from "@alexkroman1/aai/testing/vitest";
+import { runWorkflow } from "@alexkroman1/aai-runtime/testing";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import agentDef, { dailyDigest } from "./agent.ts";
 import {
@@ -199,23 +209,53 @@ describe("podcast links", () => {
 });
 
 describe("reading a feed", () => {
-  const ITEM =
+  /**
+   * One entry, through the REAL parse.
+   *
+   * `episodeFromItem` takes a `FeedItem` now rather than a slice of XML, and
+   * building one by hand would test the mapping against a literal somebody
+   * typed. Going through `parseFeed` keeps the fixture what a feed actually
+   * says, which is where the interesting cases (CDATA, date formats, a missing
+   * enclosure) live.
+   */
+  const itemOf = (itemXml: string): FeedItem => {
+    const item = parseFeed(`<rss><channel>${itemXml}</channel></rss>`)?.items[0];
+    if (!item) throw new Error("fixture did not parse as one feed item");
+    return item;
+  };
+
+  const ITEM = itemOf(
     "<item><title>An Episode</title><link>https://example.com/ep</link>" +
-    '<guid isPermaLink="false">guid-1</guid><pubDate>Fri, 21 Aug 2026 00:00:00 GMT</pubDate>' +
-    '<enclosure url="https://example.com/a.mp3" type="audio/mpeg"/></item>';
+      '<guid isPermaLink="false">guid-1</guid><pubDate>Fri, 21 Aug 2026 00:00:00 GMT</pubDate>' +
+      '<enclosure url="https://example.com/a.mp3" type="audio/mpeg"/></item>',
+  );
 
   test("reads the fields a digest needs off an item", () => {
     expect(episodeFromItem(ITEM, "https://example.com/feed.xml", "Show", 0)).toMatchObject({
       title: "An Episode",
       url: "https://example.com/ep",
       audioUrl: "https://example.com/a.mp3",
-      published: "Fri, 21 Aug 2026 00:00:00 GMT",
+      // ISO, not the RFC 822 the feed wrote — so an RSS and an Atom feed sort
+      // against each other instead of against two formats.
+      published: "2026-08-21T00:00:00.000Z",
     });
   });
 
+  test("HTML inside CDATA arrives as text, not as markup", () => {
+    // The case `stripCdata` got wrong: it peeled the wrapper and left the
+    // entity and the tags for the model to read.
+    const item = itemOf(
+      "<item><title><![CDATA[Fish &amp; <b>Chips</b>]]></title>" +
+        '<enclosure url="https://example.com/a.mp3"/></item>',
+    );
+    expect(episodeFromItem(item, "https://example.com/feed.xml", "Show", 0)?.title).toBe(
+      "Fish & Chips",
+    );
+  });
+
   /** A feed legitimately mixes text posts in; there is nothing to transcribe. */
   test("drops an item with no audio rather than inventing a URL", () => {
-    const noAudio = "<item><title>A Post</title><link>https://example.com/p</link></item>";
+    const noAudio = itemOf("<item><title>A Post</title><link>https://example.com/p</link></item>");
     expect(episodeFromItem(noAudio, "https://example.com/feed.xml", "Show", 0)).toBeUndefined();
   });
 
@@ -227,13 +267,24 @@ describe("reading a feed", () => {
     expect(stableEpisodeId("a", "b")).not.toBe(stableEpisodeId("a", "c"));
   });
 
-  test("requires BOTH an rss root and an enclosure to call it a podcast feed", () => {
-    expect(looksLikePodcastFeed('<rss><enclosure url="https://a.test/a.mp3"/></rss>')).toBe(true);
-    // A blog feed: RSS, but nothing to transcribe.
-    expect(looksLikePodcastFeed("<rss><item><title>Post</title></item></rss>")).toBe(false);
+  test("requires BOTH a parseable feed and an enclosure to call it a podcast", () => {
+    const withAudio =
+      '<rss><channel><item><title>E</title><enclosure url="https://a.test/a.mp3"/></item></channel></rss>';
+    expect(looksLikePodcastFeed(withAudio)).toBe(true);
+    // A blog feed: a real feed, but nothing to transcribe.
+    expect(
+      looksLikePodcastFeed("<rss><channel><item><title>Post</title></item></channel></rss>"),
+    ).toBe(false);
     expect(looksLikePodcastFeed("<html></html>")).toBe(false);
   });
 
+  test("an ATOM podcast feed counts, which the `<rss` test refused outright", () => {
+    const atom =
+      '<feed xmlns="http://www.w3.org/2005/Atom"><title>Show</title>' +
+      '<entry><title>E</title><enclosure url="https://a.test/a.mp3"/></entry></feed>';
+    expect(looksLikePodcastFeed(atom)).toBe(true);
+  });
+
   test("finds an advertised feed in either attribute order, and resolves it", () => {
     const hrefFirst = '<link href="/feed.xml" type="application/rss+xml">';
     const typeFirst = '<link type="application/rss+xml" href="/feed.xml">';
@@ -531,21 +582,43 @@ describe("discoverEpisodes", () => {
   });
 
   test("names the four accepted shapes when a feed carries no episode audio", async () => {
-    // An `<enclosure>` outside any `<item>`: it looks like a podcast feed and
-    // yields nothing, which is the case a bare "no episodes" would not explain.
+    // Reached through APPLE, which resolves a feed URL from the lookup API and
+    // does not run it past `looksLikePodcastFeed` — so this is the one route
+    // left to a feed that resolves and yields nothing, and the case a bare "no
+    // episodes" would not explain. The plain-web route can no longer get here:
+    // the predicate asks whether some ITEM carries audio, which is the same
+    // question `readPodcastFeed` filters on, so a text-only feed is refused
+    // earlier with a message that names the URL.
     stub({
+      "itunes.apple.com/lookup": {
+        body: { results: [{ feedUrl: "https://show.test/feed.xml", collectionName: "T" }] },
+      },
       "show.test/feed.xml": {
-        body:
-          '<rss><channel><title>T</title><enclosure url="https://cdn.test/x.mp3"/>' +
-          "<item><title>No audio</title></item></channel></rss>",
+        body: "<rss><channel><title>T</title><item><title>No audio</title></item></channel></rss>",
       },
     });
 
-    await expect(discoverEpisodes("https://show.test/feed.xml", 5)).rejects.toThrow(
+    await expect(
+      discoverEpisodes("https://podcasts.apple.com/us/podcast/x/id123", 5),
+    ).rejects.toThrow(
       /Apple Podcasts show link, a Spotify show link, an RSS feed URL, or a podcast homepage/,
     );
   });
 
+  test("a text-only feed pasted directly is refused by NAME, not as an empty digest", async () => {
+    // The other half of the change above: this used to reach the generic "no
+    // episodes" message, and now names the URL the person actually pasted.
+    stub({
+      "show.test/feed.xml": {
+        body: "<rss><channel><title>T</title><item><title>No audio</title></item></channel></rss>",
+      },
+    });
+
+    await expect(discoverEpisodes("https://show.test/feed.xml", 5)).rejects.toThrow(
+      /Could not find a podcast RSS feed at https:\/\/show\.test\/feed\.xml/,
+    );
+  });
+
   test("propagates a feed that will not load, so the run can retry it", async () => {
     stub({ "show.test/feed.xml": { status: 503, body: "busy" } });
     await expect(discoverEpisodes("https://show.test/feed.xml", 1)).rejects.toThrow(/503/);
@@ -820,3 +893,171 @@ describe("the body — the run that IS the schedule", () => {
     for (const sleep of ctx.slept) expect(sleep.until).toBe(POLL_DELAY_MS);
   });
 });
+
+/**
+ * The schedule, on the real replay engine.
+ *
+ * The block above drives the same body through `createWorkflowCtx`, which
+ * RECORDS a sleep rather than taking one and replays nothing — right for the
+ * loop's logic, and silent about the property this template is: a run that
+ * sleeps for a day between digests and comes back. `runWorkflow`
+ * (`@alexkroman1/aai-runtime/testing`) is the real engine over an in-memory
+ * journal, so the run genuinely parks, genuinely resumes off its journal, and
+ * genuinely does not redo the digest it already posted.
+ *
+ * Two sleeps are in play and they are different things, which is exactly what a
+ * recorded one cannot show: the POLL cadence inside `waitForTranscripts`, and
+ * the SCHEDULE interval between digests. Both are `ctx.sleep`, so both end with
+ * `advanceSleep()` — the same call `ctx.workflows.wakeUp` makes.
+ */
+describe("the run is DURABLE", () => {
+  const FEED = feedXml(itemXml("newest", "Thu, 03 Jan 2030 00:00:00 GMT"));
+  const SUMMARY = '{"summary":"Otters are clever.","keyPoints":["They use tools","They float"]}';
+
+  const SCHEDULE = {
+    ...VALID,
+    slackWorkflowTextParam: "text",
+    maxEpisodesPerDigest: 1,
+    intervalEvery: 2,
+    intervalUnit: "hours" as const,
+  };
+
+  /**
+   * The feed, the provider, the model and Slack, behind ONE published
+   * `stepFetch`.
+   *
+   * Every step's HTTP goes through the slot, the model call included, so a
+   * gateway stub over `globalThis.fetch` beside these routes would be bypassed.
+   * `stubGatewayRoute` is the composition for it — the same note
+   * `link-digest/agent.test.ts` carries.
+   *
+   * `polls` is how many `GET /v2/transcript/:id` answers say "not yet" before
+   * the job is reported done, which is how a case decides whether the run has
+   * to sit through the poll cadence at all.
+   */
+  function stubWorld({ polls = 0 }: { polls?: number } = {}) {
+    const model = stubGatewayRoute(SUMMARY);
+    const seen = { feeds: 0, submits: 0, slack: 0, polls: 0 };
+    installStubStepFetch((request) => {
+      const routed = model.route(request);
+      if (routed) return routed;
+      if (request.url.includes("hooks.slack.com")) {
+        seen.slack += 1;
+        return { status: 200, body: "ok" };
+      }
+      if (request.url.includes("/v2/transcript")) {
+        if (request.method === "POST") {
+          seen.submits += 1;
+          return { status: 200, body: { id: "t_1", status: "queued" } };
+        }
+        seen.polls += 1;
+        return seen.polls <= polls
+          ? { status: 200, body: { id: "t_1", status: "processing" } }
+          : { status: 200, body: { id: "t_1", status: "completed", text: "Otters use tools." } };
+      }
+      seen.feeds += 1;
+      return { status: 200, body: FEED, headers: { "Content-Type": "application/xml" } };
+    });
+    return { model, seen };
+  }
+
+  beforeEach(() => vi.stubEnv("ASSEMBLYAI_API_KEY", "test-key"));
+
+  test("a one-digest run ends without sleeping, and posts once", async () => {
+    // The negative half of the schedule claim, and the cheap one: a run that has
+    // delivered everything it owes should END, not sleep for a day and then end.
+    const world = stubWorld();
+    const run = await runWorkflow(
+      dailyDigest,
+      { ...SCHEDULE, daysToRun: 1 },
+      { name: "dailyDigest" },
+    );
+
+    expect(run.status).toBe("completed");
+    expect(run.output?.digestsSent).toBe(1);
+    expect(run.deliveries).toBe(1);
+    expect(run.wakeAt).toBeUndefined();
+    expect(world.seen.slack).toBe(1);
+  });
+
+  test("parks on the poll cadence, and the resume does not re-submit the episode", async () => {
+    // The transcription is already paid for; a resume that submitted again would
+    // buy it twice and get a different job id.
+    const world = stubWorld({ polls: 1 });
+    const run = await runWorkflow(
+      dailyDigest,
+      { ...SCHEDULE, daysToRun: 1 },
+      { name: "dailyDigest" },
+    );
+
+    expect(run.status).toBe("running");
+    expect(run.wakeAt).toBeGreaterThan(Date.now());
+    expect(world.seen.submits).toBe(1);
+    expect(run.steps.map((step) => step.key)).toEqual([
+      "discoverEpisodes#0",
+      "pollTranscript#0",
+      "submitTranscript#0",
+    ]);
+
+    await run.advanceSleep();
+    expect(run.status).toBe("completed");
+    expect(run.output?.digestsSent).toBe(1);
+    // ONE submit across two walks — the first is read back out of the journal.
+    expect(world.seen.submits).toBe(1);
+    expect(world.seen.polls).toBe(2);
+  });
+
+  test("sleeps the SCHEDULE between digests, then runs the second one", async () => {
+    const world = stubWorld();
+    const started = Date.now();
+    const run = await runWorkflow(
+      dailyDigest,
+      { ...SCHEDULE, daysToRun: 2 },
+      { name: "dailyDigest" },
+    );
+
+    // Digest one is posted and the run is parked on the interval — two hours,
+    // which nothing here waits for.
+    expect(run.status).toBe("running");
+    expect(run.wakeAt).toBeGreaterThanOrEqual(started + scheduleIntervalMs(2, "hours"));
+    expect(world.seen.slack).toBe(1);
+    expect(run.output).toBeUndefined();
+
+    await run.advanceSleep();
+    expect(run.status).toBe("completed");
+    expect(run.output?.digestsSent).toBe(2);
+    expect(run.deliveries).toBe(2);
+    // TWO posts, and the second digest did its own discovery — the loop's second
+    // turn is `discoverEpisodes#1`, a different journal entry from the first, so
+    // a schedule really re-reads the feed rather than replaying yesterday's.
+    expect(world.seen.slack).toBe(2);
+    expect(run.steps.map((step) => step.key)).toContain("discoverEpisodes#1");
+    // And digest one's post is NOT made a second time: one `postDigest` entry
+    // per digest, both journaled.
+    expect(run.steps.filter((step) => step.name === "postDigest")).toHaveLength(2);
+  });
+
+  test("a worker that dies before the digest is posted replays the transcription", async () => {
+    // The expensive half. Transcribing and summarizing an episode is minutes of
+    // provider time; a resume must reach Slack without paying for either again.
+    const world = stubWorld();
+    const run = await runWorkflow(
+      dailyDigest,
+      { ...SCHEDULE, daysToRun: 1 },
+      { name: "dailyDigest", crashAt: "postDigest" },
+    );
+
+    expect(run.crashed).toBe(true);
+    expect(world.seen.slack).toBe(0);
+    expect(world.seen.submits).toBe(1);
+    expect(world.model.calls).toHaveLength(1);
+
+    await run.restart();
+    expect(run.status).toBe("completed");
+    expect(run.output?.digestsSent).toBe(1);
+    expect(world.seen.slack).toBe(1);
+    // Neither the provider nor the model was asked a second time.
+    expect(world.seen.submits).toBe(1);
+    expect(world.model.calls).toHaveLength(1);
+  });
+});

package/dist/templates/podcast-digest/workflows/digest.ts

@@ -227,7 +227,7 @@ export async function dailyDigestFlow(
 
     // Not after the last one: a run that has delivered everything it owes
     // should end, not sleep for a day and then end.
-    if (digestNumber < totalDigests) await ctx.sleep(intervalMs);
+    if (digestNumber < totalDigests) await ctx.sleep("nextDigest", intervalMs);
   }
 
   return {
@@ -284,7 +284,7 @@ async function waitForTranscripts(
       if (state.transcriptStatus !== "submitted") settled.set(state.id, state);
     }
     pending = polled.filter((state) => state.transcriptStatus === "submitted");
-    if (pending.length > 0) await ctx.sleep(POLL_DELAY_MS);
+    if (pending.length > 0) await ctx.sleep("poll", POLL_DELAY_MS);
   }
 
   for (const job of pending) settled.set(job.id, gaveUpOn(job));

package/dist/templates/podcast-digest/workflows/feeds.ts

@@ -33,20 +33,41 @@
  * somebody runs it. A template may import the SDK, `workflow`, `zod` and React.
  * Anything else has to earn a place in the scaffold manifest first.
  *
- * ## Regex over a real XML parser, deliberately
+ * ## A real parse, once the SDK could offer one
  *
- * There is no DOM in a step artifact and no XML parser in the scaffold, so the
- * feed reading below is regular expressions over the raw body. This is the
- * honest trade rather than a shortcut: a podcast feed is machine-generated and
- * the two fields that matter (`<enclosure url>` and `<item>`) are stable across
- * every generator in the wild, so the failure mode is a missing episode rather
- * than a corrupted one. {@link episodeFromItem} drops an item it cannot read a
- * media URL from instead of inventing one.
+ * The feed reading below used to be regular expressions over the raw body, on
+ * the argument that "there is no DOM in a step artifact and no XML parser in
+ * the scaffold". The second half was the load-bearing one and it stopped being
+ * true: `@alexkroman1/aai/html` publishes the parsers the SDK already carried
+ * for its own builtins, so a template can reach them under the same rule as
+ * `zod` — it is the SDK.
+ *
+ * Three things the patterns got wrong, all of them on feeds that exist:
+ *
+ * - `textBetween(xml, "<title>", "</title>")` read the FIRST `<title>` at any
+ *   depth. In an Atom feed that is the channel's only by luck of ordering; the
+ *   same read on an entry-first document answers with an episode's title.
+ * - `stripCdata` peeled `<![CDATA[…]]>` and left the HTML inside it. Show notes
+ *   are HTML in CDATA as a matter of course, so `&amp;` reached the model as an
+ *   entity and `<p>` tags reached it as tags.
+ * - `<pubDate>` and `<published>` were tried in turn and the raw string handed
+ *   on, so a caller had to parse a date whose format depended on the feed
+ *   (RFC 822 from RSS, ISO from Atom).
+ *
+ * What the patterns got RIGHT is kept: {@link episodeFromItem} still drops an
+ * entry it cannot read a media URL from rather than inventing one, because a
+ * feed legitimately mixes text posts in with episodes.
+ *
+ * One regex remains, in {@link extractAppleSerializedFeed}, and it is a
+ * different kind of thing: it reaches into ONE vendor's `<script>` tag for a
+ * JSON blob, which is vendor knowledge with a short half-life rather than XML
+ * parsing. It is the section below's subject, not this one's.
  */
 
+import { type FeedItem, pageMetadata, parseFeed } from "@alexkroman1/aai/html";
 import { report } from "@alexkroman1/aai/step";
 import { FatalError, stepFetchOk } from "@alexkroman1/aai/step-errors";
-import { decodeHtmlEntities, isRecord, omitUndefined, safeJsonParse } from "@alexkroman1/aai/utils";
+import { isRecord, omitUndefined, safeJsonParse } from "@alexkroman1/aai/utils";
 
 /** How long any one of these lookups may take before it is a failure. */
 const REQUEST_TIMEOUT_MS = 30_000;
@@ -190,8 +211,11 @@ async function resolveApplePodcastFeed(url: string): Promise<PodcastFeed> {
  */
 async function resolveSpotifyPodcastFeed(url: string): Promise<PodcastFeed> {
   const html = await fetchText(url);
-  const title = metaContent(html, "og:title") ?? textBetween(html, "<title>", "</title>") ?? "";
-  const description = metaContent(html, "og:description") ?? "";
+  // `pageMetadata` already prefers `og:title` over the `<title>` element and
+  // falls back to it, which is exactly the two-step this spelled out.
+  const meta = pageMetadata(html);
+  const title = meta.title ?? "";
+  const description = meta.description ?? "";
   const query = `${title} ${description}`.replace(/\s+/g, " ").trim();
   if (!query) throw new FatalError(`Could not read podcast metadata from ${url}.`);
 
@@ -212,45 +236,42 @@ async function resolveSpotifyPodcastFeed(url: string): Promise<PodcastFeed> {
 /** Every item in the feed that has audio attached, newest first by the caller. */
 async function readPodcastFeed(feed: PodcastFeed): Promise<Episode[]> {
   const xml = feed.xml ?? (await fetchText(feed.feedUrl));
-  const podcastTitle = decodeHtmlEntities(textBetween(xml, "<title>", "</title>") ?? feed.title);
+  const parsed = parseFeed(xml);
+  // `parsed.title` is the CHANNEL's, which is the whole reason to parse: the
+  // `indexOf` read this replaces took the first `<title>` at any depth.
+  const podcastTitle = parsed?.title ?? feed.title;
 
-  return [...xml.matchAll(/<item[\s\S]*?<\/item>/g)]
-    .map((match, index) => episodeFromItem(match[0], feed.feedUrl, podcastTitle, index))
+  return (parsed?.items ?? [])
+    .map((item, index) => episodeFromItem(item, feed.feedUrl, podcastTitle, index))
     .filter((episode): episode is Episode => episode !== undefined);
 }
 
-/** One `<item>`, or nothing when it carries no audio to transcribe. */
+/** One feed entry, or nothing when it carries no audio to transcribe. */
 export function episodeFromItem(
-  item: string,
+  item: FeedItem,
   feedUrl: string,
   podcastTitle: string,
   index: number,
 ): Episode | undefined {
-  const audioUrl = enclosureUrl(item);
+  const audioUrl = item.enclosureUrl;
   // Not an error: a feed legitimately mixes text posts in with episodes, and
   // there is nothing for this run to do with one.
-  if (!audioUrl) return undefined;
+  if (audioUrl === undefined) return undefined;
 
-  const guid = stripCdata(
-    textBetween(item, "<guid", "</guid>")?.replace(/^[^>]*>/, "") ?? "",
-  ).trim();
-  const link = decodeHtmlEntities(stripCdata(textBetween(item, "<link>", "</link>") ?? audioUrl));
+  const link = item.link ?? audioUrl;
   return {
-    id: stableEpisodeId(feedUrl, guid || link || audioUrl),
+    // `item.id` is the feed's `<guid>` or Atom `<id>`, already falling back to
+    // the link and then the enclosure — which is the three-way fallback this
+    // function used to spell out.
+    id: stableEpisodeId(feedUrl, item.id ?? audioUrl),
     feedUrl,
     podcastTitle,
-    title: decodeHtmlEntities(
-      stripCdata(textBetween(item, "<title>", "</title>") ?? `Episode ${index + 1}`),
-    ),
+    title: item.title ?? `Episode ${index + 1}`,
     url: link,
-    audioUrl: decodeHtmlEntities(audioUrl),
-    published: decodeHtmlEntities(
-      stripCdata(
-        textBetween(item, "<pubDate>", "</pubDate>") ??
-          textBetween(item, "<published>", "</published>") ??
-          "",
-      ),
-    ),
+    audioUrl,
+    // ISO whatever the feed wrote, so `publishedAt` below sorts RSS and Atom
+    // against each other rather than against two different formats.
+    published: item.published ?? "",
   };
 }
 
@@ -371,21 +392,32 @@ export function titleMatchesSpotify(
   );
 }
 
-/** An RSS document that actually carries audio — both halves are required. */
+/** A feed document that actually carries audio — both halves are required. */
 export function looksLikePodcastFeed(xml: string): boolean {
-  return /<rss\b/i.test(xml) && /<enclosure\b[^>]*\burl=/i.test(xml);
+  const parsed = parseFeed(xml);
+  // `parseFeed` answering at all is the "is this a feed" half, and it is
+  // stricter than the `<rss` test it replaces in the direction that matters:
+  // an HTML page mentioning `<rss` in prose is not a feed. It is also wider
+  // where being wide is right — an Atom podcast feed has no `<rss` root and
+  // was refused outright.
+  return parsed?.items.some((item) => item.enclosureUrl !== undefined) ?? false;
 }
 
-/** The feed a page advertises, in either attribute order. */
+/** The first feed a page advertises, resolved against the page's own URL. */
 export function discoverFeedUrl(html: string, pageUrl: string): string | undefined {
-  const match =
-    /<link\b[^>]*type=["']application\/(?:rss|atom)\+xml["'][^>]*href=["']([^"']+)["'][^>]*>/i.exec(
-      html,
-    ) ??
-    /<link\b[^>]*href=["']([^"']+)["'][^>]*type=["']application\/(?:rss|atom)\+xml["'][^>]*>/i.exec(
-      html,
-    );
-  return match?.[1] ? new URL(decodeHtmlEntities(match[1]), pageUrl).toString() : undefined;
+  // `pageMetadata` reads `<link>` off a parse, so attribute ORDER stops
+  // mattering — this needed one regex per order and still could not see a `>`
+  // inside a quoted href. It hands hrefs back exactly as the page wrote them,
+  // which is why the resolution is here: only the caller knows `pageUrl`.
+  const href = pageMetadata(html).feedUrls[0];
+  if (href === undefined) return undefined;
+  try {
+    return new URL(href, pageUrl).toString();
+  } catch {
+    // A page can advertise an href that is not a URL under any base. That is
+    // "no feed found", which the caller already has a sentence for.
+    return undefined;
+  }
 }
 
 /**
@@ -411,7 +443,7 @@ function publishedAt(episode: Episode): number {
 function feedFrom(feedUrl: string, body: string): PodcastFeed {
   return {
     feedUrl,
-    title: decodeHtmlEntities(textBetween(body, "<title>", "</title>") ?? hostOf(feedUrl)),
+    title: parseFeed(body)?.title ?? hostOf(feedUrl),
     xml: body,
   };
 }
@@ -424,10 +456,6 @@ function hostOf(url: string): string {
   }
 }
 
-function enclosureUrl(item: string): string | undefined {
-  return /<enclosure\b[^>]*\burl=["']([^"']+)["'][^>]*>/i.exec(item)?.[1];
-}
-
 function normalizeTitle(value: string): string {
   return value
     .toLowerCase()
@@ -458,29 +486,6 @@ function asString(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined;
 }
 
-export function textBetween(text: string, start: string, end: string): string | undefined {
-  const from = text.indexOf(start);
-  if (from < 0) return undefined;
-  const to = text.indexOf(end, from + start.length);
-  return to < 0 ? undefined : text.slice(from + start.length, to);
-}
-
-export function metaContent(html: string, property: string): string | undefined {
-  const escaped = property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const match =
-    new RegExp(`<meta[^>]+property=["']${escaped}["'][^>]+content=["']([^"']+)["']`, "i").exec(
-      html,
-    ) ??
-    new RegExp(`<meta[^>]+content=["']([^"']+)["'][^>]+property=["']${escaped}["']`, "i").exec(
-      html,
-    );
-  return decodeHtmlEntities(match?.[1] ?? "").trim() || undefined;
-}
-
-function stripCdata(text: string): string {
-  return text.replace(/^<!\[CDATA\[/, "").replace(/\]\]>$/, "");
-}
-
 // ---- HTTP -------------------------------------------------------------------
 
 /**