@gobing-ai/knowledge-kit 0.1.7 → 0.1.9

package/plugins/publishings/podcast-pub/dist/index.js

@@ -4866,10 +4866,13 @@ function writeLine(message, target) {
   target.write(`${message}
 `);
 }
+function echo(message, target = defaultStdoutTarget ?? processStream("stdout")) {
+  writeLine(message, target);
+}
 function echoError(message, target = defaultStderrTarget ?? processStream("stderr")) {
   writeLine(message, target);
 }
-var defaultStderrTarget;
+var defaultStdoutTarget, defaultStderrTarget;
 
 // ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.32/node_modules/@gobing-ai/ts-utils/dist/index.js
 var init_dist = __esm(() => {
@@ -11981,7 +11984,7 @@ function findProjectRoot(startDir) {
 var init_file_system_node = () => {};
 
 // ../../plugins/publishings/podcast-pub/src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { readFile } from "fs/promises";
 import { basename, dirname as dirname2, extname as extname2 } from "path";
 import { parseArgs } from "util";
@@ -12254,6 +12257,59 @@ var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx)
 init_file_system_node();
 init_config();
 
+// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.32+180a6e424da77181/node_modules/@gobing-ai/ts-runtime/dist/fs.js
+init_file_system_node();
+
+// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.32+180a6e424da77181/node_modules/@gobing-ai/ts-runtime/dist/path.js
+function normalizeSeparators(path) {
+  return path.replaceAll("\\", "/");
+}
+var SEP = globalThis.process?.platform === "win32" ? "\\" : "/";
+function splitRoot(path) {
+  const normalized = normalizeSeparators(path);
+  const drive = normalized.match(/^([A-Za-z]:)(?:\/|$)/);
+  if (drive) {
+    return { root: drive[1] ?? "", rest: normalized.slice((drive[1] ?? "").length).replace(/^\/+/, "") };
+  }
+  if (normalized.startsWith("/")) {
+    return { root: "/", rest: normalized.replace(/^\/+/, "") };
+  }
+  return { root: "", rest: normalized };
+}
+function dirnamePath(path) {
+  const input = normalizeSeparators(path);
+  const { root } = splitRoot(input);
+  if (root !== "" && input.replace(/\/+$/, "") === root)
+    return root === "/" ? "/" : `${root}/`;
+  if (/^\/+$/.test(input))
+    return "/";
+  const normalized = input.replace(/\/+$/, "");
+  if (normalized === "" || normalized === "/")
+    return normalized || ".";
+  const index = normalized.lastIndexOf("/");
+  if (index < 0)
+    return ".";
+  if (index === 0)
+    return "/";
+  return normalized.slice(0, index);
+}
+
+// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.32+180a6e424da77181/node_modules/@gobing-ai/ts-runtime/dist/fs.js
+async function ensureDirForFile(path, fs = createNodeFileSystem()) {
+  await fs.ensureDir(dirnamePath(path));
+}
+async function readJsonFile(path, fs = createNodeFileSystem()) {
+  const content = await fs.readFile(path);
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON file "${path}": ${error.message}`);
+  }
+}
+async function writeJsonFile(path, value, fs = createNodeFileSystem()) {
+  await fs.writeFile(path, `${JSON.stringify(value, null, 2)}
+`);
+}
 // ../../packages/kk-core/src/render-md.ts
 if (false) {}
 // ../../packages/publish-harness/src/index.ts
@@ -12305,104 +12361,1443 @@ class FakeFileCliTransport {
 // ../../plugins/publishings/podcast-pub/src/index.ts
 init_dist();
 
-// ../../plugins/publishings/podcast-pub/src/map.ts
-import { extname } from "path";
+// ../../plugins/publishings/podcast-pub/src/backfill.ts
+init_dist();
 
-// ../../plugins/publishings/podcast-pub/src/show-notes.ts
-function escapeHtml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+// ../../plugins/publishings/podcast-pub/src/microfeed-client.ts
+class MicrofeedRequestError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "MicrofeedRequestError";
+    this.status = status;
+  }
 }
-function renderInline(escaped) {
-  let out = "";
-  let rest = escaped;
-  for (;; ) {
-    const match = rest.match(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/);
-    if (!match || match.index === undefined)
-      break;
-    out += `${rest.slice(0, match.index)}<a href="${match[2]}" target="_blank" rel="noopener">${match[1]}</a>`;
-    rest = rest.slice(match.index + match[0].length);
+var MIN_TIMEOUT_MS = 1000;
+var DEFAULT_TIMEOUT_MS = 300000;
+function resolveTimeoutMs(raw) {
+  const parsed = raw === undefined ? Number.NaN : Number(raw);
+  if (!Number.isFinite(parsed) || parsed < MIN_TIMEOUT_MS) {
+    return DEFAULT_TIMEOUT_MS;
   }
-  return (out + rest).replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  return parsed;
 }
-function normalizeForMatch(text) {
-  return text.toLowerCase().replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, "");
+
+class MicrofeedClient {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  constructor(baseUrl, apiKey, timeoutMs) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+    this.timeoutMs = timeoutMs;
+  }
+  itemUrl(itemId) {
+    return `${this.baseUrl}/items/${itemId}`;
+  }
+  async request(path, init) {
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          Origin: this.baseUrl,
+          ...init.headers
+        },
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(`microfeed transport error (${init.method ?? "GET"} ${path}): ${reason}`);
+    }
+    if (!response.ok) {
+      const text = (await response.text()).slice(0, 1000);
+      let detail = text.trim();
+      try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.error === "string")
+          detail = parsed.error;
+      } catch {}
+      throw new MicrofeedRequestError(response.status, `microfeed API request failed (HTTP ${response.status} ${response.statusText} ${path}): ${detail || "Unknown error"}`);
+    }
+    try {
+      return await response.json();
+    } catch {
+      throw new Error(`microfeed API returned a non-JSON response from ${path}`);
+    }
+  }
+  async createItem(input, idempotencyKey) {
+    const data = await this.request("/api/v1/items", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
+      },
+      body: JSON.stringify(input)
+    });
+    if (typeof data.id !== "string" || data.id.length === 0) {
+      throw new Error("microfeed item create response is missing the item id");
+    }
+    return data.id;
+  }
+  async validateItem(input) {
+    await this.request("/api/v1/items/validate", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+  }
+  async getItem(itemId) {
+    return await this.request(`/api/v1/items/${encodeURIComponent(itemId)}`, {
+      method: "GET"
+    });
+  }
+  async updateItem(itemId, input) {
+    return await this.request(`/api/v1/items/${encodeURIComponent(itemId)}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+  }
+  async deleteItem(itemId) {
+    await this.request(`/api/v1/items/${encodeURIComponent(itemId)}`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  async listItems() {
+    const first = await this.request("/api/v1/feed", { method: "GET" });
+    const items = [...first.items ?? []];
+    const seen = new Set(["/api/v1/feed"]);
+    let next = typeof first.next_url === "string" ? first.next_url : "";
+    for (let page = 1;page < 20 && next !== "" && !seen.has(next); page++) {
+      seen.add(next);
+      const path = next.startsWith(this.baseUrl) ? next.slice(this.baseUrl.length) || "/" : next;
+      if (!path.startsWith("/"))
+        break;
+      const more = await this.request(path, { method: "GET" });
+      items.push(...more.items ?? []);
+      next = typeof more.next_url === "string" ? more.next_url : "";
+    }
+    return { ...first, items };
+  }
+  async prepareUpload(input) {
+    const data = await this.request("/api/v1/media_files/presigned_urls", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+    if (typeof data.presigned_url !== "string" || typeof data.media_url !== "string") {
+      throw new Error("microfeed upload-preparation response is missing presigned_url/media_url");
+    }
+    return { presignedUrl: data.presigned_url, mediaUrl: data.media_url };
+  }
+  async uploadBytes(presignedUrl, bytes, mimeType) {
+    let response;
+    try {
+      response = await fetch(presignedUrl, {
+        method: "PUT",
+        headers: { "Content-Type": mimeType },
+        body: bytes,
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(`microfeed transport error (PUT audio bytes): ${reason}`);
+    }
+    if (!response.ok) {
+      const text = (await response.text()).slice(0, 1000);
+      throw new Error(`microfeed audio upload failed (HTTP ${response.status} ${response.statusText}): ${text.trim() || "Unknown error"}`);
+    }
+  }
 }
-function formatOffset(seconds) {
-  if (!Number.isFinite(seconds) || seconds < 0)
-    return "--:--";
-  const m = Math.floor(seconds / 60);
-  const s = Math.round(seconds % 60);
-  return s === 60 ? `${m + 1}:00` : `${m}:${String(s).padStart(2, "0")}`;
+
+// ../../plugins/publishings/podcast-pub/src/seo.ts
+init_dist();
+import { readFileSync as readFileSync2 } from "fs";
+function codePointLength(value) {
+  return Array.from(value).length;
+}
+var WARN_PREFIX = "WARN podcast-pub:";
+function warn(message, sink) {
+  const line = message.startsWith(WARN_PREFIX) ? message : `${WARN_PREFIX} ${message}`;
+  echoError(line);
+  sink?.push(line);
+}
+var SEO_DEFAULTS = {
+  seo: true,
+  titleMode: "as-is",
+  titlePattern: "{series} \xB7 {date}\uFF1A{keywords}",
+  seriesName: "\u6BCF\u65E5AI\u4E71\u7096",
+  showName: "\u54B8\u8BDD\u54B8\u8BF4",
+  titleMax: 55,
+  titleMaxKeywords: 2,
+  seoTitleSuffix: "\uFF5C\u54B8\u8BDD\u54B8\u8BF4",
+  seoTitleMax: 60,
+  descriptionMin: 120,
+  descriptionMax: 155,
+  descriptionSource: "plan",
+  descriptionPattern: "{show}\xB7{series} {date}\uFF08\u7EA6 {minutes} \u5206\u949F\uFF09\uFF1A{clauses}\u3002",
+  summaryParagraph: true,
+  timelineStyle: "after",
+  autoEpisodeNumber: true,
+  titleSanitize: "normalize",
+  linkField: "none",
+  slugMode: "pattern",
+  slugPattern: "daily-ai-{date}",
+  socialImage: false,
+  socialImageAltPattern: "{series} {date} \u5C01\u9762\uFF1A{keywords}",
+  roundDuration: true
+};
+var ENV_KEYS = {
+  seo: "PODCAST_PUB_SEO",
+  titleMode: "PODCAST_PUB_EPISODE_TITLE_MODE",
+  titlePattern: "PODCAST_PUB_EPISODE_TITLE_PATTERN",
+  seriesName: "PODCAST_PUB_SERIES_NAME",
+  showName: "PODCAST_PUB_SHOW_NAME",
+  titleMax: "PODCAST_PUB_TITLE_MAX",
+  titleMaxKeywords: "PODCAST_PUB_TITLE_MAX_KEYWORDS",
+  seoTitleSuffix: "PODCAST_PUB_SEO_TITLE_SUFFIX",
+  seoTitleMax: "PODCAST_PUB_SEO_TITLE_MAX",
+  descriptionMin: "PODCAST_PUB_SEO_DESCRIPTION_MIN",
+  descriptionMax: "PODCAST_PUB_SEO_DESCRIPTION_MAX",
+  descriptionSource: "PODCAST_PUB_SEO_DESCRIPTION_SOURCE",
+  descriptionPattern: "PODCAST_PUB_SEO_DESCRIPTION_PATTERN",
+  summaryParagraph: "PODCAST_PUB_SUMMARY_PARAGRAPH",
+  timelineStyle: "PODCAST_PUB_TIMELINE_INLINE_STYLE",
+  autoEpisodeNumber: "PODCAST_PUB_AUTO_EPISODE_NUMBER",
+  titleSanitize: "PODCAST_PUB_TITLE_SANITIZE",
+  linkField: "PODCAST_PUB_LINK_FIELD",
+  slugMode: "PODCAST_PUB_SLUG",
+  slugPattern: "PODCAST_PUB_SLUG_PATTERN",
+  socialImage: "PODCAST_PUB_SOCIAL_IMAGE",
+  socialImageAltPattern: "PODCAST_PUB_SOCIAL_IMAGE_ALT_PATTERN",
+  roundDuration: "PODCAST_PUB_ROUND_DURATION"
+};
+function asRecord(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return;
 }
-function computeAudioOffsets(docs, segments) {
-  const fallback = () => {
-    const chars = docs.map((d) => Math.max((d.body ?? "").trim().length, 1));
-    const total = chars.reduce((a, b) => a + b, 0);
-    const sumDuration = (segments ?? []).reduce((a, s) => a + (s.duration ?? 0), 0);
-    let acc = 0;
-    return chars.map((c) => {
-      const at = acc;
-      acc += c / total * sumDuration;
-      return at;
-    });
+function podcastOf(metadata) {
+  return asRecord(metadata?.podcast) ?? {};
+}
+function pick2(metadata, podcastKey, envKey, env) {
+  const podcast = podcastOf(metadata);
+  if (Object.hasOwn(podcast, podcastKey)) {
+    const value = podcast[podcastKey];
+    if (value !== undefined && value !== "")
+      return { value, key: `metadata.podcast.${podcastKey}` };
+  }
+  const fromEnv = env[envKey];
+  if (fromEnv !== undefined && fromEnv !== "")
+    return { value: fromEnv, key: envKey };
+  return;
+}
+function invalid(key, value, expected) {
+  return `invalid ${key} "${String(value)}": expected ${expected}`;
+}
+function parseBool(raw, fallback) {
+  if (!raw)
+    return fallback;
+  const value = raw.value;
+  if (value === true || value === "true" || value === "1")
+    return true;
+  if (value === false || value === "false" || value === "0")
+    return false;
+  return invalid(raw.key, value, "true or false");
+}
+function parseIntIn(raw, fallback, min) {
+  if (!raw)
+    return fallback;
+  const value = typeof raw.value === "number" ? raw.value : Number(raw.value);
+  if (!Number.isInteger(value) || value < min)
+    return invalid(raw.key, raw.value, `an integer \u2265 ${min}`);
+  return value;
+}
+function parseEnum(raw, allowed, fallback) {
+  if (!raw)
+    return fallback;
+  const value = String(raw.value);
+  if (allowed.includes(value))
+    return value;
+  return invalid(raw.key, raw.value, allowed.join(" or "));
+}
+function resolvePodcastSeoConfig(metadata, env = process.env) {
+  const bool = (podcastKey, envKey, fallback) => parseBool(pick2(metadata, podcastKey, envKey, env), fallback);
+  const int = (podcastKey, envKey, fallback, min) => parseIntIn(pick2(metadata, podcastKey, envKey, env), fallback, min);
+  const text = (podcastKey, envKey, fallback) => {
+    const raw = pick2(metadata, podcastKey, envKey, env);
+    return raw ? String(raw.value) : fallback;
   };
-  if (!segments || segments.length < 2)
-    return fallback();
-  const starts = [];
-  let elapsed = 0;
-  const marks = segments.map((s) => {
-    const at = elapsed;
-    elapsed += s.duration ?? 0;
-    return { at, text: normalizeForMatch(s.transcription ?? "") };
-  });
-  let cursor = 1;
-  for (const d of docs) {
-    const title = normalizeForMatch(d.title ?? "");
-    const needle = title.slice(0, 12);
-    const hit = needle.length >= 4 ? marks.findIndex((m, i) => i >= cursor && m.text.includes(needle)) : -1;
-    if (hit >= 0) {
-      starts.push(marks[hit]?.at ?? 0);
-      cursor = hit + 1;
-    } else {
-      starts.push(Number.NaN);
+  const seo = bool("seo", ENV_KEYS.seo, SEO_DEFAULTS.seo);
+  const titleMode = parseEnum(pick2(metadata, "titleMode", ENV_KEYS.titleMode, env), ["as-is", "headline"], SEO_DEFAULTS.titleMode);
+  const titleMax = int("titleMax", ENV_KEYS.titleMax, SEO_DEFAULTS.titleMax, 1);
+  const titleMaxKeywords = int("titleMaxKeywords", ENV_KEYS.titleMaxKeywords, SEO_DEFAULTS.titleMaxKeywords, 1);
+  const seoTitleMax = int("seoTitleMax", ENV_KEYS.seoTitleMax, SEO_DEFAULTS.seoTitleMax, 1);
+  const descriptionMin = int("descriptionMin", ENV_KEYS.descriptionMin, SEO_DEFAULTS.descriptionMin, 1);
+  const descriptionMax = int("descriptionMax", ENV_KEYS.descriptionMax, SEO_DEFAULTS.descriptionMax, 1);
+  const descriptionSource = parseEnum(pick2(metadata, "descriptionSource", ENV_KEYS.descriptionSource, env), ["plan", "surfing"], SEO_DEFAULTS.descriptionSource);
+  const summaryParagraph = bool("summaryParagraph", ENV_KEYS.summaryParagraph, SEO_DEFAULTS.summaryParagraph);
+  const timelineStyle = parseEnum(pick2(metadata, "timelineInlineStyle", ENV_KEYS.timelineStyle, env), ["after", "before", "omit", "true", "false"], "after");
+  const autoEpisodeNumber = bool("autoEpisodeNumber", ENV_KEYS.autoEpisodeNumber, SEO_DEFAULTS.autoEpisodeNumber);
+  const titleSanitize = parseEnum(pick2(metadata, "titleSanitize", ENV_KEYS.titleSanitize, env), ["normalize", "reject"], SEO_DEFAULTS.titleSanitize);
+  const linkField = parseEnum(pick2(metadata, "linkField", ENV_KEYS.linkField, env), ["none", "url"], SEO_DEFAULTS.linkField);
+  const slugMode = parseEnum(pick2(metadata, "slug", ENV_KEYS.slugMode, env), ["auto", "pattern"], SEO_DEFAULTS.slugMode);
+  const socialImage = bool("socialImageEnabled", ENV_KEYS.socialImage, SEO_DEFAULTS.socialImage);
+  const roundDuration = bool("roundDuration", ENV_KEYS.roundDuration, SEO_DEFAULTS.roundDuration);
+  const parsed = [
+    seo,
+    titleMode,
+    titleMax,
+    titleMaxKeywords,
+    seoTitleMax,
+    descriptionMin,
+    descriptionMax,
+    descriptionSource,
+    summaryParagraph,
+    timelineStyle,
+    autoEpisodeNumber,
+    titleSanitize,
+    linkField,
+    slugMode,
+    socialImage,
+    roundDuration
+  ];
+  const failure = parsed.find((value) => typeof value === "string" && value.startsWith("invalid "));
+  if (typeof failure === "string")
+    return { error: failure };
+  if (descriptionMin > descriptionMax) {
+    return {
+      error: `invalid ${ENV_KEYS.descriptionMin}: ${String(descriptionMin)} is greater than ${ENV_KEYS.descriptionMax} ${String(descriptionMax)}`
+    };
+  }
+  const seoTitleSuffix = text("seoTitleSuffix", ENV_KEYS.seoTitleSuffix, SEO_DEFAULTS.seoTitleSuffix);
+  if (codePointLength(seoTitleSuffix) >= seoTitleMax) {
+    return {
+      error: `invalid ${ENV_KEYS.seoTitleSuffix}: suffix is longer than ${ENV_KEYS.seoTitleMax} (${String(seoTitleMax)})`
+    };
+  }
+  const styleRaw = timelineStyle;
+  const timeline = styleRaw === "true" || styleRaw === "after" ? "after" : styleRaw === "false" || styleRaw === "omit" ? "omit" : "before";
+  return {
+    config: {
+      seo,
+      titleMode,
+      titlePattern: text("titlePattern", ENV_KEYS.titlePattern, SEO_DEFAULTS.titlePattern),
+      seriesName: text("seriesName", ENV_KEYS.seriesName, SEO_DEFAULTS.seriesName),
+      showName: text("showName", ENV_KEYS.showName, SEO_DEFAULTS.showName),
+      titleMax,
+      titleMaxKeywords,
+      seoTitleSuffix,
+      seoTitleMax,
+      descriptionMin,
+      descriptionMax,
+      descriptionSource,
+      descriptionPattern: text("descriptionPattern", ENV_KEYS.descriptionPattern, SEO_DEFAULTS.descriptionPattern),
+      summaryParagraph,
+      timelineStyle: timeline,
+      autoEpisodeNumber,
+      titleSanitize,
+      linkField,
+      slugMode,
+      slugPattern: text("slugPattern", ENV_KEYS.slugPattern, SEO_DEFAULTS.slugPattern),
+      socialImage,
+      socialImageAltPattern: text("socialImageAltPattern", ENV_KEYS.socialImageAltPattern, SEO_DEFAULTS.socialImageAltPattern),
+      roundDuration
     }
+  };
+}
+function hasControlChar(value) {
+  for (const ch of value) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp <= 31 || cp >= 127 && cp <= 159 || cp === 8232 || cp === 8233)
+      return true;
   }
-  if (starts.some((v) => !Number.isFinite(v)))
-    return fallback();
-  return starts;
+  return false;
 }
-var isHttpUrl = (u) => /^https?:\/\//i.test(u.trim());
-var TIMELINE_STYLE = `<style>
-.kk-tl{margin:1em 0}
-.kk-tl-row{display:flex;gap:12px;padding:10px 0;border-bottom:1px solid rgba(128,128,128,.25)}
-.kk-tl-t{flex:0 0 56px;font-variant-numeric:tabular-nums;font-weight:700;color:#0969da}
-.kk-tl-body{flex:1;min-width:0}
-.kk-tl-title{font-weight:600}
-.kk-tl-brief{margin:4px 0 0;color:#666;font-size:.95em}
-</style>`;
-var TIMELINE_TAG = /^<\/?(?:div|p|a)(?:\s+(?:class="kk-tl(?:-[a-z]+)?"|href="https?:\/\/[^"<>\s]*"|target="_blank"|rel="noopener"))*\s*>$/;
-function isGeneratedTimeline(block) {
-  const rest = block.replace(TIMELINE_STYLE, "");
-  if (rest.includes("<style") || rest.includes("<!--"))
+function forbiddenChars(value) {
+  const found = [];
+  if (value.includes('"'))
+    found.push('"');
+  if (value.includes("\\"))
+    found.push("\\");
+  if (value.includes("<"))
+    found.push("<");
+  if (value.includes(">"))
+    found.push(">");
+  if (hasControlChar(value))
+    found.push("control");
+  return found;
+}
+function sanitizeTitle(value, mode) {
+  const forbidden = forbiddenChars(value);
+  if (mode === "reject" && forbidden.length > 0) {
+    return { ok: false, error: `title contains forbidden characters: ${forbidden.join(", ")}` };
+  }
+  const chars = Array.from(value);
+  const quoteAt = [];
+  chars.forEach((ch, index) => {
+    if (ch === '"')
+      quoteAt.push(index);
+  });
+  const odd = quoteAt.length % 2 === 1;
+  for (let n = 0;n < quoteAt.length; n++) {
+    const index = quoteAt[n] ?? 0;
+    const last = n === quoteAt.length - 1;
+    chars[index] = odd && last ? "\u201D" : n % 2 === 0 ? "\u201C" : "\u201D";
+  }
+  let out = "";
+  for (const ch of chars) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp <= 31 || cp >= 127 && cp <= 159 || cp === 8232 || cp === 8233)
+      continue;
+    if (ch === "\\")
+      out += "\uFF3C";
+    else if (ch === "<")
+      out += "\u3008";
+    else if (ch === ">")
+      out += "\u3009";
+    else
+      out += ch;
+  }
+  return { ok: true, value: out.trim() };
+}
+function spaceCjkLatin(text) {
+  return text.replace(/(\p{Script=Han})([A-Za-z0-9])/gu, "$1 $2").replace(/([A-Za-z0-9])(\p{Script=Han})/gu, "$1 $2");
+}
+function normalizeEpisodeTitle(title, seriesName) {
+  let out = title.replace(/\s+/g, " ").trim();
+  const legacy = /^(?:\u6BCF\u65E5 AI \u8D44\u8BAF|\u6BCF\u65E5AI\u8D44\u8BAF|AI \u4E71\u7096|AI\u4E71\u7096)/;
+  if (legacy.test(out))
+    out = out.replace(legacy, seriesName);
+  const trailing = /\s\u00B7\s*(\d{4}-\d{2}-\d{2})\s*$/;
+  const trail = trailing.exec(out);
+  if (trail?.[1] && out.slice(0, trail.index).includes(trail[1]))
+    out = out.slice(0, trail.index).trim();
+  if (seriesName.length > 0 && out.startsWith(seriesName)) {
+    let rest = spaceCjkLatin(out.slice(seriesName.length));
+    const seriesEndsCjk = /\p{Script=Han}$/u.test(seriesName);
+    if (seriesEndsCjk && /^[A-Za-z0-9]/.test(rest))
+      rest = ` ${rest}`;
+    out = seriesName + rest;
+  } else {
+    out = spaceCjkLatin(out);
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+function isRealDate(year, month, day) {
+  if (month < 1 || month > 12 || day < 1 || day > 31)
     return false;
-  return (rest.match(/<[^>]*>/g) ?? []).every((tag) => TIMELINE_TAG.test(tag)) && !/<(?![^>]*>)/.test(rest);
+  const utc = new Date(Date.UTC(year, month - 1, day));
+  return utc.getUTCFullYear() === year && utc.getUTCMonth() === month - 1 && utc.getUTCDate() === day;
 }
-function renderTimelineHtml(docs, offsets, articleUrl) {
-  const rows = docs.map((d, i) => {
-    const title = escapeHtml(d.title ?? `\u6761\u76EE ${i + 1}`);
-    const brief = escapeHtml(itemBrief(d));
-    const at = formatOffset(offsets[i] ?? Number.NaN);
-    const link = d.sourceUri && isHttpUrl(d.sourceUri) ? ` <a href="${escapeHtml(d.sourceUri)}" target="_blank" rel="noopener">\u6765\u6E90</a>` : "";
-    return `
-    <div class="kk-tl-row"><div class="kk-tl-t">${at}</div><div class="kk-tl-body"><div class="kk-tl-title">${i + 1}. ${title}${link}</div><p class="kk-tl-brief">${brief}</p></div></div>`;
-  }).join("");
-  const articleTail = isHttpUrl(articleUrl) ? `<p>\u5B8C\u6574\u56FE\u6587\u7248\uFF1A<a href="${escapeHtml(articleUrl)}" target="_blank" rel="noopener">${escapeHtml("\u672C\u671F\u5B8C\u6574\u6587\u7AE0")}</a></p>` : `<p>${escapeHtml("\u672C\u671F\u5B8C\u6574\u6587\u7AE0")}</p>`;
-  return `<!--kk:timeline-->
-${TIMELINE_STYLE}
-<div class="kk-tl">${rows}
-</div>
-${articleTail}
-<!--/kk:timeline-->`;
+function isoFromRunDate(raw) {
+  const digits = raw.replaceAll(/\D/g, "");
+  if (digits.length < 8)
+    return;
+  const year = Number(digits.slice(0, 4));
+  const month = Number(digits.slice(4, 6));
+  const day = Number(digits.slice(6, 8));
+  if (!isRealDate(year, month, day))
+    return;
+  return `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+function isoFromLosAngeles(ms) {
+  if (!Number.isFinite(ms))
+    return;
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/Los_Angeles",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(ms));
+  const year = parts.find((part) => part.type === "year")?.value;
+  const month = parts.find((part) => part.type === "month")?.value;
+  const day = parts.find((part) => part.type === "day")?.value;
+  if (!year || !month || !day)
+    return;
+  return `${year}-${month}-${day}`;
+}
+function resolveEpisodeDate(metadata, publishedAtMs) {
+  if (typeof metadata.runDate === "string") {
+    const fromRun = isoFromRunDate(metadata.runDate);
+    if (fromRun)
+      return fromRun;
+  }
+  if (publishedAtMs !== undefined)
+    return isoFromLosAngeles(publishedAtMs);
+  const publishedAt = metadata.publishedAt;
+  if (typeof publishedAt === "number")
+    return isoFromLosAngeles(publishedAt);
+  if (typeof publishedAt === "string" && publishedAt.length > 0) {
+    const parsed = Date.parse(publishedAt);
+    if (!Number.isNaN(parsed))
+      return isoFromLosAngeles(parsed);
+  }
+  return;
+}
+function seasonAndEpisode(isoDate) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(isoDate);
+  if (!match)
+    return;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (!isRealDate(year, month, day))
+    return;
+  const episode = Math.round((Date.UTC(year, month - 1, day) - Date.UTC(year, 0, 1)) / 86400000) + 1;
+  return { season: year, episode };
+}
+function isPositiveInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+function keywordsFromRefinedTitle(title) {
+  const index = title.indexOf("\uFF1A");
+  if (index < 0)
+    return [];
+  return title.slice(index + 1).split("\u3001").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function keywordFromDocTitle(title) {
+  const cut = title.split(/\uFF0C|,|\uFF1A|\uFF1B|\u2014\u2014/)[0]?.trim() ?? "";
+  return Array.from(cut).slice(0, 15).join("");
+}
+function clauseFromTitle(title) {
+  const cut = (title.split(/\uFF0C|,/)[0] ?? title).replaceAll("\u300C", "").replaceAll("\u300D", "");
+  return cut.replace(/\s+/g, " ").trim();
+}
+function firstSentence(text) {
+  const trimmed = text.replace(/\s+/g, " ").trim();
+  if (trimmed.length === 0)
+    return "";
+  const parts = trimmed.split(/(?<=[\u3002\uFF01\uFF1F.!?])/);
+  return (parts[0] ?? trimmed).trim();
+}
+function planItemsFromMetadata(metadata) {
+  const raw = podcastOf(metadata).planItems;
+  if (!Array.isArray(raw))
+    return [];
+  const items = [];
+  for (const entry of raw) {
+    const record = asRecord(entry);
+    if (!record)
+      continue;
+    const title = typeof record.title === "string" ? record.title.trim() : "";
+    const brief = typeof record.brief === "string" ? record.brief.trim() : "";
+    if (title.length === 0 && brief.length === 0)
+      continue;
+    items.push(brief.length > 0 ? { title, brief } : { title });
+  }
+  return items;
+}
+function stringList(value) {
+  if (!Array.isArray(value))
+    return;
+  const items = value.filter((entry) => typeof entry === "string").map((entry) => entry.trim());
+  return items.filter((entry) => entry.length > 0);
+}
+function cutAtBoundary(value, room) {
+  if (room <= 0)
+    return "";
+  const chars = Array.from(value);
+  if (chars.length <= room)
+    return value;
+  const sliced = chars.slice(0, room);
+  let cut = sliced.length;
+  for (let index = sliced.length - 1;index >= 0; index--) {
+    if (/[\uFF0C\u3002\uFF01\uFF1F\u3001\uFF1B\uFF1A,.\s]/.test(sliced[index] ?? "")) {
+      cut = index;
+      break;
+    }
+  }
+  const trimmed = sliced.slice(0, cut).join("").trim();
+  return trimmed.length > 0 ? trimmed : sliced.join("").trim();
+}
+function headlineFromKeywords(config, date, keywords, limit) {
+  const head = normalizeEpisodeTitle(config.titlePattern.replaceAll("{series}", config.seriesName).replaceAll("{date}", date).replaceAll("{keywords}", ""), config.seriesName);
+  const chosen = [];
+  for (const keyword of keywords) {
+    const title = normalizeEpisodeTitle(`${head}${[...chosen, keyword].join("\u3001")}`, config.seriesName);
+    if (codePointLength(title) <= limit)
+      chosen.push(keyword);
+    else
+      break;
+  }
+  if (chosen.length === 0 && keywords[0]) {
+    const room = limit - codePointLength(head);
+    const cut = cutAtBoundary(keywords[0], room);
+    if (cut.length > 0)
+      chosen.push(cut);
+  }
+  return normalizeEpisodeTitle(chosen.length > 0 ? `${head}${chosen.join("\u3001")}` : head, config.seriesName);
+}
+function pickKeywords(metadata, config) {
+  const podcast = podcastOf(metadata);
+  if (typeof podcast.title === "string" && podcast.title.trim().length > 0) {
+    return { explicitTitle: podcast.title.trim(), keywords: [] };
+  }
+  const explicit = stringList(podcast.titleKeywords);
+  if (explicit && explicit.length > 0)
+    return { keywords: explicit.slice(0, config.titleMaxKeywords) };
+  const refined = typeof podcast.refinedTitle === "string" ? keywordsFromRefinedTitle(podcast.refinedTitle) : [];
+  if (refined.length > 0)
+    return { keywords: refined.slice(0, config.titleMaxKeywords) };
+  const fromPlan = planItemsFromMetadata(metadata).map((item) => keywordFromDocTitle(item.title)).filter((keyword) => keyword.length > 0);
+  if (fromPlan.length > 0)
+    return { keywords: fromPlan.slice(0, config.titleMaxKeywords) };
+  return { keywords: [] };
+}
+function buildItemTitle(asIs, metadata, config, date, warnings) {
+  const picked = pickKeywords(metadata, config);
+  if (picked.explicitTitle)
+    return { title: picked.explicitTitle, keywords: [], explicit: true };
+  if (config.titleMode !== "headline")
+    return { title: asIs, keywords: picked.keywords, explicit: false };
+  if (!date) {
+    warnings.push(`${WARN_PREFIX} headline title skipped: episode date is unknown`);
+    return { title: asIs, keywords: [], explicit: false };
+  }
+  if (picked.keywords.length === 0) {
+    warnings.push(`${WARN_PREFIX} no keywords for the headline title; keeping the as-is title`);
+    return { title: asIs, keywords: [], explicit: false };
+  }
+  return {
+    title: headlineFromKeywords(config, date, picked.keywords, config.titleMax),
+    keywords: picked.keywords,
+    explicit: false
+  };
+}
+function fitSeoTitle(episodeTitle, keywords, config, date, explicit) {
+  const suffix = config.seoTitleSuffix;
+  let stem = episodeTitle;
+  let remaining = keywords;
+  let seo = `${stem}${suffix}`;
+  while (codePointLength(seo) > config.seoTitleMax && remaining.length > 0 && date && !explicit) {
+    remaining = remaining.slice(0, -1);
+    stem = headlineFromKeywords(config, date, remaining, config.titleMax);
+    seo = `${stem}${suffix}`;
+  }
+  if (codePointLength(seo) > config.seoTitleMax) {
+    const room = config.seoTitleMax - codePointLength(suffix);
+    stem = cutAtBoundary(stem, room);
+    seo = `${stem}${suffix}`;
+  }
+  return { stem, seo };
+}
+function cleanClause(value) {
+  return value.replace(/<[^>]*>/g, "").replace(/[*#`[\]]/g, "").replace(/[\u3002\uFF01\uFF1F.!?]+$/u, "").replace(/\s+/g, " ").trim();
+}
+function descriptionHead(config, date, minutes) {
+  const pattern = config.descriptionPattern.includes("{clauses}") ? config.descriptionPattern.split("{clauses}")[0] ?? config.descriptionPattern : config.descriptionPattern;
+  let head = pattern.replaceAll("{show}", config.showName).replaceAll("{series}", config.seriesName);
+  if (date)
+    head = head.replaceAll("{date}", date);
+  else
+    head = head.replaceAll(" {date}", "").replaceAll("{date}", "");
+  if (minutes !== undefined && minutes > 0)
+    head = head.replaceAll("{minutes}", String(minutes));
+  else
+    head = head.replaceAll("\uFF08\u7EA6 {minutes} \u5206\u949F\uFF09", "").replaceAll("{minutes}", "");
+  return head.replace(/\u3002\s*$/, "");
+}
+function durationMinutes(seconds) {
+  if (seconds === undefined || !Number.isFinite(seconds) || seconds <= 0)
+    return;
+  return Math.round(seconds / 60);
+}
+function buildSeoDescription(input) {
+  const head = descriptionHead(input.config, input.date, input.minutes);
+  const render = (parts) => parts.length === 0 ? head : `${head}${parts.join("\uFF1B")}\u3002`;
+  const picked = [];
+  const pushWhile = (candidates) => {
+    for (const candidate of candidates) {
+      const clause = cleanClause(candidate);
+      if (clause.length === 0 || picked.includes(clause))
+        continue;
+      const next = render([...picked, clause]);
+      if (codePointLength(next) <= input.config.descriptionMax)
+        picked.push(clause);
+    }
+  };
+  pushWhile(input.clauses);
+  if (codePointLength(render(picked)) < input.config.descriptionMin)
+    pushWhile(input.extraSentences);
+  const description = render(picked);
+  return { description, short: codePointLength(description) < input.config.descriptionMin };
+}
+function descriptionInputs(metadata, config, date, minutes) {
+  const podcast = podcastOf(metadata);
+  const plan = planItemsFromMetadata(metadata);
+  const summary = stringList(podcast.summaryClauses);
+  const surfing = config.descriptionSource === "surfing" && typeof podcast.refinedDescription === "string" ? podcast.refinedDescription.trim() : "";
+  const clauses = surfing ? [surfing] : summary && summary.length > 0 ? summary : plan.map((item) => clauseFromTitle(item.title)).filter((clause) => clause.length > 0);
+  const extras = plan.map((item) => item.brief ? firstSentence(item.brief) : "").filter((sentence) => sentence.length > 0);
+  return buildSeoDescription({ config, date, minutes, clauses, extraSentences: extras });
+}
+function isValidItemSlug(slug) {
+  return slug.length >= 1 && slug.length <= 120 && !slug.endsWith("-") && /^[a-z0-9][a-z0-9-]*$/.test(slug);
+}
+function renderSlug(pattern, date) {
+  if (!date)
+    return { warning: "skipping slug: episode date is unknown" };
+  const slug = pattern.replaceAll("{date}", date);
+  if (!isValidItemSlug(slug)) {
+    return {
+      error: `invalid PODCAST_PUB_SLUG_PATTERN output "${slug}": expected lowercase letters, digits and hyphens (^[a-z0-9][a-z0-9-]*$), at most 120 characters, and no trailing hyphen`
+    };
+  }
+  return { slug };
+}
+function roundDurationSeconds(seconds, enabled) {
+  if (seconds === undefined)
+    return;
+  return enabled ? Math.round(seconds) : seconds;
+}
+function imageMimeFromBytes(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "image/png";
+  }
+  if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 216)
+    return "image/jpeg";
+  return;
+}
+function readImageDimensions(bytes) {
+  const mime = imageMimeFromBytes(bytes);
+  if (mime === "image/png") {
+    if (bytes.length < 24)
+      return;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const width = view.getUint32(16);
+    const height = view.getUint32(20);
+    return { width, height, mime };
+  }
+  if (mime === "image/jpeg") {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = 2;
+    while (offset + 3 < bytes.length) {
+      if (bytes[offset] !== 255)
+        return;
+      const marker = bytes[offset + 1] ?? 0;
+      if (marker === 216 || marker === 217) {
+        offset += 2;
+        continue;
+      }
+      if (marker >= 208 && marker <= 215) {
+        offset += 2;
+        continue;
+      }
+      if (offset + 4 > bytes.length)
+        return;
+      const length = view.getUint16(offset + 2);
+      if (length < 2)
+        return;
+      const isSof = marker === 192 || marker === 193 || marker === 194 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207;
+      if (isSof) {
+        if (offset + 9 > bytes.length)
+          return;
+        return { height: view.getUint16(offset + 5), width: view.getUint16(offset + 7), mime };
+      }
+      offset += 2 + length;
+    }
+  }
+  return;
+}
+function readLocalBytes(path) {
+  try {
+    return new Uint8Array(readFileSync2(path));
+  } catch {
+    return;
+  }
+}
+function altText(config, date, keywords) {
+  const rendered = config.socialImageAltPattern.replaceAll("{series}", config.seriesName).replaceAll("{date}", date ?? "").replaceAll("{keywords}", keywords.join("\u3001"));
+  const sanitized = sanitizeTitle(rendered, "normalize");
+  const value = sanitized.ok ? sanitized.value : rendered;
+  if (codePointLength(value) <= 200)
+    return value;
+  return cutAtBoundary(value, 200);
+}
+function mustSanitize(value, mode, label) {
+  const sanitized = sanitizeTitle(value, mode);
+  if (!sanitized.ok)
+    return { ok: false, error: `${label}: ${sanitized.error}` };
+  return sanitized;
+}
+function prepareEpisodeFields(episode, metadata, config) {
+  const warnings = [];
+  const date = resolveEpisodeDate(metadata, episode.datePublishedMs);
+  const built = buildItemTitle(episode.title, metadata, config, date, warnings);
+  const sanitizedTitle = mustSanitize(built.title, config.titleSanitize, "item title");
+  if (!sanitizedTitle.ok)
+    return sanitizedTitle;
+  let title = built.explicit ? sanitizedTitle.value : config.titleMode === "headline" ? normalizeEpisodeTitle(sanitizedTitle.value, config.seriesName) : sanitizedTitle.value;
+  const itunes = { ...episode.itunes ?? {} };
+  if (itunes.season !== undefined && !isPositiveInt(itunes.season)) {
+    return {
+      ok: false,
+      error: `invalid metadata.itunes.season: expected an integer \u2265 1, got ${String(itunes.season)}`
+    };
+  }
+  if (itunes.episode !== undefined && !isPositiveInt(itunes.episode)) {
+    return {
+      ok: false,
+      error: `invalid metadata.itunes.episode: expected an integer \u2265 1, got ${String(itunes.episode)}`
+    };
+  }
+  if (config.autoEpisodeNumber) {
+    const derived = date ? seasonAndEpisode(date) : undefined;
+    if (derived) {
+      if (itunes.season === undefined)
+        itunes.season = derived.season;
+      if (itunes.episode === undefined)
+        itunes.episode = derived.episode;
+    } else if (itunes.season === undefined || itunes.episode === undefined) {
+      warnings.push(`${WARN_PREFIX} itunes season/episode left unset: episode date is unknown`);
+    }
+  }
+  if (itunes.title) {
+    const sanitizedItunes = mustSanitize(itunes.title, config.titleSanitize, "itunes:title");
+    if (!sanitizedItunes.ok)
+      return sanitizedItunes;
+    itunes.title = sanitizedItunes.value;
+  }
+  const minutes = durationMinutes(episode.durationSeconds);
+  let seo;
+  if (config.seo) {
+    const fitted = fitSeoTitle(title, built.keywords, config, date, built.explicit);
+    if (!built.explicit && config.titleMode === "headline" && fitted.stem.length > 0)
+      title = fitted.stem;
+    const seoTitle = mustSanitize(fitted.seo, config.titleSanitize, "seo.title");
+    if (!seoTitle.ok)
+      return seoTitle;
+    const described = descriptionInputs(metadata, config, date, minutes);
+    if (described.short) {
+      warnings.push(`${WARN_PREFIX} seo.description is ${codePointLength(described.description)} code points, under the ${config.descriptionMin} minimum; left unpadded`);
+    }
+    seo = { title: seoTitle.value, description: described.description };
+  }
+  let slug;
+  if (config.slugMode === "pattern") {
+    const rendered = renderSlug(config.slugPattern, date);
+    if (rendered.error)
+      return { ok: false, error: rendered.error };
+    if (rendered.warning)
+      warnings.push(`${WARN_PREFIX} ${rendered.warning}`);
+    slug = rendered.slug;
+  }
+  if (config.linkField === "url" && episode.link) {
+    warnings.push(`${WARN_PREFIX} PODCAST_PUB_LINK_FIELD=url sends metadata.articleUrl as the item url; microfeed uses that URL as the canonical and drops the episode from the podcast sitemap`);
+  }
+  let socialAlt;
+  let socialLocalPath;
+  let socialMime;
+  let socialRemoteUrl;
+  if (config.socialImage) {
+    const source = podcastOf(metadata).socialImage;
+    const alt = altText(config, date, built.keywords);
+    if (typeof source !== "string" || source.trim().length === 0) {
+      warnings.push(`${WARN_PREFIX} PODCAST_PUB_SOCIAL_IMAGE is on but metadata.podcast.socialImage is empty; skipping alt text`);
+    } else if (source.trim().startsWith("http")) {
+      socialAlt = alt;
+      socialRemoteUrl = source.trim();
+    } else {
+      const bytes = readLocalBytes(source.trim());
+      const dims = bytes ? readImageDimensions(bytes) : undefined;
+      if (dims?.width !== 1200 || dims?.height !== 630) {
+        warnings.push(`${WARN_PREFIX} social image skipped: expected a 1200\xD7630 PNG or JPEG, got ${dims ? `${dims.width}\xD7${dims.height}` : "an unreadable file"}`);
+      } else {
+        socialAlt = alt;
+        socialLocalPath = source.trim();
+        socialMime = dims.mime;
+      }
+    }
+  }
+  for (const line of warnings)
+    echoError(line);
+  return {
+    ok: true,
+    fields: {
+      title,
+      itunes,
+      durationSeconds: roundDurationSeconds(episode.durationSeconds, config.roundDuration),
+      ...config.linkField === "url" && episode.link ? { link: episode.link } : {},
+      ...seo ? { seo } : {},
+      ...slug ? { slug } : {},
+      warnings,
+      ...socialAlt ? { socialAlt } : {},
+      ...socialLocalPath ? { socialLocalPath, socialMime } : {},
+      ...socialRemoteUrl ? { socialRemoteUrl } : {}
+    }
+  };
+}
+function showNotesSummaryParagraph(input) {
+  const date = isoFromRunDate(input.runDate);
+  const metadata = {
+    ...date ? { runDate: date } : { runDate: input.runDate },
+    podcast: {
+      ...input.refinedDescription ? { refinedDescription: input.refinedDescription } : {},
+      ...input.summaryClauses ? { summaryClauses: input.summaryClauses } : {},
+      planItems: input.plan
+    }
+  };
+  const described = descriptionInputs(metadata, input.config, date, durationMinutes(input.durationSeconds));
+  const warnings = [];
+  if (described.short) {
+    warnings.push(`${WARN_PREFIX} seo.description is ${codePointLength(described.description)} code points, under the ${input.config.descriptionMin} minimum; left unpadded`);
+  }
+  const prefix = `${input.config.showName}\xB7`;
+  const stripped = described.description.startsWith(prefix) ? described.description.slice(prefix.length) : described.description;
+  const safeLabel = input.linkText.replaceAll("[", "").replaceAll("]", "").replaceAll("(", "").replaceAll(")", "");
+  const markdown = `${stripped} \u5B8C\u6574\u56FE\u6587\u7248\uFF1A[${safeLabel}](${input.articleUrl})`;
+  return { markdown, description: described.description, warnings };
+}
+function summaryParagraphHtml(description, showName, articleUrl, linkText) {
+  const prefix = `${showName}\xB7`;
+  const stripped = description.startsWith(prefix) ? description.slice(prefix.length) : description;
+  const text = stripped.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+  if (!articleUrl)
+    return `<p>${text}</p>`;
+  const href = articleUrl.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "");
+  const label = linkText.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+  return `<p>${text} \u5B8C\u6574\u56FE\u6587\u7248\uFF1A<a href="${href}" target="_blank" rel="noopener">${label}</a></p>`;
+}
+function stripMarkupTitle(raw) {
+  return raw.replace(/<[^>]+>/g, " ").replace(/\u6765\u6E90/g, "").replace(/^\s*\d+\s*[.\u3001]\s*/, "").replace(/\s+/g, " ").trim();
+}
+function titlesFromContentHtml(html) {
+  const timeline = [...html.matchAll(/class="kk-tl-title">([\s\S]*?)<\/div>/gi)].map((match) => stripMarkupTitle(match[1] ?? "")).filter((title) => title.length > 0);
+  if (timeline.length > 0)
+    return timeline;
+  return [...html.matchAll(/<h2[^>]*>([\s\S]*?)<\/h2>/gi)].map((match) => stripMarkupTitle(match[1] ?? "")).filter((title) => title.length > 0);
+}
+function insertAfterTimeline(html, insertion) {
+  const start = html.indexOf('<div class="kk-tl">');
+  if (start < 0)
+    return `${html.trim()}
+${insertion}`;
+  let depth = 0;
+  const tags = /<\/?div\b[^>]*>/gi;
+  tags.lastIndex = start;
+  let match = tags.exec(html);
+  while (match) {
+    depth += match[0].startsWith("</") ? -1 : 1;
+    if (depth === 0) {
+      const at = match.index + match[0].length;
+      const head = html.slice(0, at).replace(/\s*$/, "");
+      const tail = html.slice(at).replace(/^\s*/, "");
+      return tail.length > 0 ? `${head}
+${insertion}
+${tail}` : `${head}
+${insertion}`;
+    }
+    match = tags.exec(html);
+  }
+  return `${html.trim()}
+${insertion}`;
+}
+function rewriteEpisodeHtml(html, summaryHtml, moveStyle) {
+  let body = html;
+  if (moveStyle) {
+    const styleMatch = body.match(/<style>[\s\S]*?<\/style>/i);
+    if (styleMatch && styleMatch.index !== undefined) {
+      const style = styleMatch[0];
+      const without = `${body.slice(0, styleMatch.index)}${body.slice(styleMatch.index + style.length)}`;
+      body = insertAfterTimeline(without, style);
+    }
+  }
+  const trimmed = body.trim();
+  if (summaryHtml.length > 0 && (trimmed === summaryHtml || trimmed.startsWith(`${summaryHtml}
+`) || trimmed.startsWith(`${summaryHtml}<`))) {
+    return trimmed;
+  }
+  return `${summaryHtml}
+${trimmed}`;
+}
+function dateFromFeedItem(item) {
+  const title = typeof item.title === "string" ? item.title : "";
+  const inTitle = /(\d{4}-\d{2}-\d{2})/.exec(title);
+  if (inTitle?.[1] && isoFromRunDate(inTitle[1]))
+    return inTitle[1];
+  const msField = item.date_published_ms;
+  if (typeof msField === "number")
+    return isoFromLosAngeles(msField);
+  const published = item.date_published;
+  if (typeof published === "number")
+    return isoFromLosAngeles(published);
+  if (typeof published === "string") {
+    const parsed = Date.parse(published);
+    if (!Number.isNaN(parsed))
+      return isoFromLosAngeles(parsed);
+  }
+  return;
+}
+
+// ../../plugins/publishings/podcast-pub/src/backfill.ts
+var TARGET = "podcast-pub";
+function fail(error) {
+  return ResultSchema.parse({ ok: false, target: TARGET, error });
+}
+function asRecord2(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value))
+    return value;
+  return;
+}
+function flag(value) {
+  return value === true || value === "true" || value === "1";
+}
+function positiveInt(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1)
+    return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    const parsed = Number(value);
+    if (Number.isInteger(parsed) && parsed >= 1)
+      return parsed;
+  }
+  return;
+}
+function parseOverrides(raw) {
+  if (raw === undefined)
+    return { overrides: new Map };
+  if (!Array.isArray(raw))
+    return {
+      error: "invalid options.overrides: expected an array of {id, title?, titleKeywords?, summaryClauses?}"
+    };
+  const overrides = new Map;
+  for (const entry of raw) {
+    const record = asRecord2(entry);
+    if (!record || typeof record.id !== "string" || record.id.trim().length === 0) {
+      return { error: "invalid options.overrides: each entry needs a string id" };
+    }
+    const keywords = record.titleKeywords;
+    if (keywords !== undefined && (!Array.isArray(keywords) || keywords.some((keyword) => typeof keyword !== "string"))) {
+      return { error: `invalid options.overrides titleKeywords for "${record.id}": expected string[]` };
+    }
+    const clauses = record.summaryClauses;
+    if (clauses !== undefined && (!Array.isArray(clauses) || clauses.some((clause) => typeof clause !== "string"))) {
+      return { error: `invalid options.overrides summaryClauses for "${record.id}": expected string[]` };
+    }
+    if (record.title !== undefined && typeof record.title !== "string") {
+      return { error: `invalid options.overrides title for "${record.id}": expected a string` };
+    }
+    overrides.set(record.id, {
+      id: record.id,
+      ...typeof record.title === "string" ? { title: record.title } : {},
+      ...Array.isArray(keywords) ? { titleKeywords: keywords.filter((keyword) => typeof keyword === "string") } : {},
+      ...Array.isArray(clauses) ? { summaryClauses: clauses.filter((clause) => typeof clause === "string") } : {}
+    });
+  }
+  return { overrides };
+}
+function parseFlags(options) {
+  const overrides = parseOverrides(options.overrides);
+  if ("error" in overrides)
+    return overrides;
+  const since = options.since === undefined ? undefined : String(options.since);
+  const until = options.until === undefined ? undefined : String(options.until);
+  if (since !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(since)) {
+    return { error: `invalid options.since "${since}": expected YYYY-MM-DD` };
+  }
+  if (until !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(until)) {
+    return { error: `invalid options.until "${until}": expected YYYY-MM-DD` };
+  }
+  let ids;
+  if (options.ids !== undefined) {
+    if (!Array.isArray(options.ids) || options.ids.some((id) => typeof id !== "string")) {
+      return { error: "invalid options.ids: expected an array of item id strings" };
+    }
+    ids = new Set(options.ids);
+  }
+  return {
+    flags: {
+      apply: flag(options.apply),
+      retitle: flag(options.retitle),
+      rewriteBody: flag(options.rewriteBody),
+      applySlug: flag(options.applySlug),
+      ...since ? { since } : {},
+      ...until ? { until } : {},
+      ...ids ? { ids } : {},
+      ...typeof options.out === "string" && options.out.length > 0 ? { out: options.out } : {},
+      ...typeof options.plan === "string" && options.plan.length > 0 ? { planPath: options.plan } : {},
+      overrides: overrides.overrides
+    }
+  };
+}
+function microfeedOf(item) {
+  return asRecord2(item._microfeed) ?? {};
+}
+function durationOf(item) {
+  const attachments = item.attachments;
+  if (!Array.isArray(attachments))
+    return;
+  const first = asRecord2(attachments[0]);
+  const seconds = first?.duration_in_seconds;
+  return typeof seconds === "number" && Number.isFinite(seconds) ? seconds : undefined;
+}
+function articleUrlOf(html) {
+  const marked = /\u5B8C\u6574\u56FE\u6587\u7248\uFF1A<a href="([^"]+)"/.exec(html);
+  if (marked?.[1])
+    return marked[1];
+  const any = /href="(https?:\/\/[^"]+)"/.exec(html);
+  return any?.[1];
+}
+function inWindow(date, flags) {
+  if (!flags.since && !flags.until)
+    return true;
+  if (!date)
+    return false;
+  if (flags.since && date < flags.since)
+    return false;
+  if (flags.until && date > flags.until)
+    return false;
+  return true;
+}
+function planBackfillItem(item, config, flags, override) {
+  const id = typeof item.id === "string" ? item.id : "";
+  if (id.length === 0)
+    return { error: "backfill-seo: a feed item is missing id" };
+  const currentTitle = typeof item.title === "string" ? item.title : "";
+  const micro = microfeedOf(item);
+  const currentSeo = asRecord2(micro.seo);
+  const currentSeoTitle = typeof currentSeo?.title === "string" ? currentSeo.title : undefined;
+  const currentSeoDescription = typeof currentSeo?.description === "string" ? currentSeo.description : undefined;
+  const currentSeason = positiveInt(micro["itunes:season"]);
+  const currentEpisode = positiveInt(micro["itunes:episode"]);
+  const currentSlug = typeof micro.slug === "string" ? micro.slug : undefined;
+  const date = dateFromFeedItem(item);
+  const html = typeof item.content_html === "string" ? item.content_html : "";
+  const titles = titlesFromContentHtml(html);
+  const clauses = override?.summaryClauses ?? titles.map((title) => clauseFromTitle(title)).filter((clause) => clause.length > 0);
+  const keywords = override?.titleKeywords ?? titles.filter((title) => title.length > 0);
+  const metadata = {
+    ...date ? { runDate: date } : {},
+    ...durationOf(item) !== undefined ? { durationSeconds: durationOf(item) } : {},
+    podcast: {
+      titleMode: "headline",
+      ...override?.title ? { title: override.title } : {},
+      ...keywords.length > 0 ? { titleKeywords: keywords.slice(0, config.titleMaxKeywords) } : {},
+      ...clauses.length > 0 ? { summaryClauses: clauses } : {}
+    }
+  };
+  const prepared = prepareEpisodeFields({
+    title: currentTitle,
+    durationSeconds: durationOf(item),
+    itunes: {
+      ...currentSeason !== undefined ? { season: currentSeason } : {},
+      ...currentEpisode !== undefined ? { episode: currentEpisode } : {}
+    }
+  }, metadata, {
+    ...config,
+    seo: true,
+    titleMode: "headline",
+    slugMode: "auto",
+    linkField: "none",
+    socialImage: false,
+    autoEpisodeNumber: true
+  });
+  if (!prepared.ok)
+    return { error: `${id}: ${prepared.error}` };
+  const violations = [];
+  if (!date)
+    violations.push("episode date is unknown");
+  const patch = {};
+  const nextMicro = {};
+  if (flags.retitle && prepared.fields.title !== currentTitle)
+    patch.title = prepared.fields.title;
+  const seo = prepared.fields.seo;
+  if (seo) {
+    const seoPatch = {};
+    if (seo.title && seo.title !== currentSeoTitle)
+      seoPatch.title = seo.title;
+    if (seo.description && seo.description !== currentSeoDescription)
+      seoPatch.description = seo.description;
+    if (seoPatch.title || seoPatch.description)
+      nextMicro.seo = seoPatch;
+    if (seo.description && codePointLength(seo.description) < config.descriptionMin) {
+      violations.push(`seo.description is ${codePointLength(seo.description)} code points, under ${config.descriptionMin}`);
+    }
+    if (seo.description && /^\s*(\d|#|[-*])/.test(seo.description)) {
+      violations.push("seo.description starts with a forbidden character");
+    }
+  }
+  const numbered = prepared.fields.itunes;
+  if (numbered?.season !== undefined && currentSeason === undefined)
+    nextMicro["itunes:season"] = numbered.season;
+  if (numbered?.episode !== undefined && currentEpisode === undefined)
+    nextMicro["itunes:episode"] = numbered.episode;
+  if (flags.applySlug && date) {
+    const slug = renderSlug(config.slugPattern, date);
+    if (slug.slug && slug.slug !== currentSlug && isValidItemSlug(slug.slug))
+      nextMicro.slug = slug.slug;
+    if (slug.error)
+      violations.push(slug.error);
+  }
+  if (flags.rewriteBody && html.length > 0 && seo?.description) {
+    const summary = summaryParagraphHtml(seo.description, config.showName, articleUrlOf(html), "\u672C\u671F\u5B8C\u6574\u6587\u7AE0");
+    const rewritten = rewriteEpisodeHtml(html, summary, config.timelineStyle !== "omit");
+    if (rewritten !== html.trim())
+      patch.content_html = rewritten;
+  }
+  if (Object.keys(nextMicro).length > 0)
+    patch._microfeed = nextMicro;
+  const proposedTitle = typeof patch.title === "string" ? patch.title : currentTitle;
+  const proposedSeo = asRecord2(nextMicro.seo);
+  return {
+    id,
+    ...date ? { date } : {},
+    patch,
+    counts: {
+      ...proposedTitle ? { title: codePointLength(proposedTitle) } : {},
+      ...typeof proposedSeo?.title === "string" ? { seoTitle: codePointLength(proposedSeo.title) } : {},
+      ...typeof proposedSeo?.description === "string" ? { seoDescription: codePointLength(proposedSeo.description) } : {}
+    },
+    violations,
+    current: {
+      ...currentTitle ? { title: currentTitle } : {},
+      ...currentSeoTitle ? { seoTitle: currentSeoTitle } : {},
+      ...currentSeoDescription ? { seoDescription: currentSeoDescription } : {},
+      ...currentSeason !== undefined ? { season: currentSeason } : {},
+      ...currentEpisode !== undefined ? { episode: currentEpisode } : {},
+      ...currentSlug ? { slug: currentSlug } : {}
+    }
+  };
+}
+function describeEntry(entry) {
+  const seo = asRecord2(asRecord2(entry.patch._microfeed)?.seo);
+  const parts = [
+    `${entry.id}:`,
+    entry.date ? `date ${entry.date}` : "date unknown",
+    `title ${JSON.stringify(entry.current.title ?? "")} \u2192 ${JSON.stringify(entry.patch.title ?? entry.current.title ?? "")} (${entry.counts.title ?? 0})`,
+    `seo.title ${JSON.stringify(entry.current.seoTitle ?? "")} \u2192 ${JSON.stringify(seo?.title ?? entry.current.seoTitle ?? "")} (${entry.counts.seoTitle ?? codePointLength(String(entry.current.seoTitle ?? ""))})`,
+    `seo.description (${entry.counts.seoDescription ?? codePointLength(String(entry.current.seoDescription ?? ""))})`
+  ];
+  if (entry.violations.length > 0)
+    parts.push(`violations: ${entry.violations.join("; ")}`);
+  return parts.join(" | ");
+}
+async function writePlan(path, entries, apply) {
+  await ensureDirForFile(path);
+  await writeJsonFile(path, { dryRun: !apply, items: entries });
+}
+async function loadPlan(path) {
+  try {
+    const parsed = await readJsonFile(path);
+    const record = asRecord2(parsed);
+    const items = record?.items;
+    if (!Array.isArray(items))
+      return { error: `invalid backfill plan ${path}: expected { items: [...] }` };
+    const entries = [];
+    for (const item of items) {
+      const row = asRecord2(item);
+      if (!row || typeof row.id !== "string" || !asRecord2(row.patch)) {
+        return { error: `invalid backfill plan ${path}: each item needs id and patch` };
+      }
+      entries.push(row);
+    }
+    return { entries };
+  } catch (error) {
+    return { error: `invalid backfill plan ${path}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function withoutSlug(micro) {
+  const rest = {};
+  for (const [key, value] of Object.entries(micro)) {
+    if (key !== "slug")
+      rest[key] = value;
+  }
+  return rest;
+}
+async function putPatch(client, entry, warnings) {
+  const micro = asRecord2(entry.patch._microfeed);
+  const slug = typeof micro?.slug === "string" ? micro.slug : undefined;
+  if (!slug || !micro) {
+    await client.updateItem(entry.id, entry.patch);
+    return;
+  }
+  try {
+    await client.updateItem(entry.id, entry.patch);
+  } catch (error) {
+    if (!(error instanceof MicrofeedRequestError) || error.status !== 409)
+      throw error;
+    const retry = `${slug}-2`;
+    try {
+      await client.updateItem(entry.id, { ...entry.patch, _microfeed: { ...micro, slug: retry } });
+      warn(`slug "${slug}" for ${entry.id} conflicted (HTTP 409); retried as ${retry}`, warnings);
+    } catch (retryError) {
+      if (!(retryError instanceof MicrofeedRequestError) || retryError.status !== 409)
+        throw retryError;
+      const rest = withoutSlug(micro);
+      if (Object.keys(rest).length === 0) {
+        const { _microfeed: _dropped, ...other } = entry.patch;
+        if (Object.keys(other).length === 0) {
+          warn(`slug "${slug}" for ${entry.id} conflicted twice (HTTP 409); skipped the slug and no other fields changed`, warnings);
+          return;
+        }
+        await client.updateItem(entry.id, other);
+      } else {
+        await client.updateItem(entry.id, { ...entry.patch, _microfeed: rest });
+      }
+      warn(`slug "${slug}" for ${entry.id} conflicted twice (HTTP 409); applied the patch without a slug`, warnings);
+    }
+  }
+}
+async function runBackfill(client, options, config) {
+  const parsed = parseFlags(options);
+  if ("error" in parsed)
+    return fail(parsed.error);
+  const flags = parsed.flags;
+  const warnings = [];
+  let entries;
+  if (flags.apply && flags.planPath) {
+    const loaded = await loadPlan(flags.planPath);
+    if ("error" in loaded)
+      return fail(loaded.error);
+    entries = loaded.entries.filter((entry) => !flags.ids || flags.ids.has(entry.id));
+  } else {
+    const feed = await client.listItems();
+    entries = [];
+    for (const item of feed.items ?? []) {
+      const id = typeof item.id === "string" ? item.id : "";
+      if (flags.ids && !flags.ids.has(id))
+        continue;
+      const date = dateFromFeedItem(item);
+      if (!inWindow(date, flags))
+        continue;
+      const planned = planBackfillItem(item, config, flags, flags.overrides.get(id));
+      if ("error" in planned)
+        return fail(planned.error);
+      entries.push(planned);
+    }
+  }
+  for (const entry of entries)
+    echo(describeEntry(entry));
+  if (flags.out)
+    await writePlan(flags.out, entries, flags.apply);
+  if (!flags.apply) {
+    return ResultSchema.parse({
+      ok: true,
+      target: TARGET,
+      message: `backfill-seo dry-run for ${entries.length} item(s); no writes`,
+      metadata: { dryRun: true, items: entries, warnings }
+    });
+  }
+  let written = 0;
+  for (const entry of entries) {
+    if (Object.keys(entry.patch).length === 0)
+      continue;
+    await putPatch(client, entry, warnings);
+    written += 1;
+  }
+  return ResultSchema.parse({
+    ok: true,
+    target: TARGET,
+    message: `backfill-seo applied ${written} item(s)`,
+    metadata: { dryRun: false, applied: written, items: entries, warnings }
+  });
+}
+
+// ../../plugins/publishings/podcast-pub/src/map.ts
+import { extname } from "path";
+
+// ../../plugins/publishings/podcast-pub/src/show-notes.ts
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function renderInline(escaped) {
+  let out = "";
+  let rest = escaped;
+  for (;; ) {
+    const match = rest.match(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/);
+    if (!match || match.index === undefined)
+      break;
+    out += `${rest.slice(0, match.index)}<a href="${match[2]}" target="_blank" rel="noopener">${match[1]}</a>`;
+    rest = rest.slice(match.index + match[0].length);
+  }
+  return (out + rest).replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+}
+function normalizeForMatch(text) {
+  return text.toLowerCase().replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, "");
+}
+function formatOffset(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0)
+    return "--:--";
+  const m = Math.floor(seconds / 60);
+  const s = Math.round(seconds % 60);
+  return s === 60 ? `${m + 1}:00` : `${m}:${String(s).padStart(2, "0")}`;
+}
+function computeAudioOffsets(docs, segments) {
+  const fallback = () => {
+    const chars = docs.map((d) => Math.max((d.body ?? "").trim().length, 1));
+    const total = chars.reduce((a, b) => a + b, 0);
+    const sumDuration = (segments ?? []).reduce((a, s) => a + (s.duration ?? 0), 0);
+    let acc = 0;
+    return chars.map((c) => {
+      const at = acc;
+      acc += c / total * sumDuration;
+      return at;
+    });
+  };
+  if (!segments || segments.length < 2)
+    return fallback();
+  const starts = [];
+  let elapsed = 0;
+  const marks = segments.map((s) => {
+    const at = elapsed;
+    elapsed += s.duration ?? 0;
+    return { at, text: normalizeForMatch(s.transcription ?? "") };
+  });
+  let cursor = 1;
+  for (const d of docs) {
+    const title = normalizeForMatch(d.title ?? "");
+    const needle = title.slice(0, 12);
+    const hit = needle.length >= 4 ? marks.findIndex((m, i) => i >= cursor && m.text.includes(needle)) : -1;
+    if (hit >= 0) {
+      starts.push(marks[hit]?.at ?? 0);
+      cursor = hit + 1;
+    } else {
+      starts.push(Number.NaN);
+    }
+  }
+  if (starts.some((v) => !Number.isFinite(v)))
+    return fallback();
+  return starts;
+}
+var isHttpUrl = (u) => /^https?:\/\//i.test(u.trim());
+var TIMELINE_STYLE = `<style>
+.kk-tl{margin:1em 0}
+.kk-tl-row{display:flex;gap:12px;padding:10px 0;border-bottom:1px solid rgba(128,128,128,.25)}
+.kk-tl-t{flex:0 0 56px;font-variant-numeric:tabular-nums;font-weight:700;color:#0969da}
+.kk-tl-body{flex:1;min-width:0}
+.kk-tl-title{font-weight:600}
+.kk-tl-brief{margin:4px 0 0;color:#666;font-size:.95em}
+</style>`;
+var TIMELINE_TAG = /^<\/?(?:div|p|a)(?:\s+(?:class="kk-tl(?:-[a-z]+)?"|href="https?:\/\/[^"<>\s]*"|target="_blank"|rel="noopener"))*\s*>$/;
+function isGeneratedTimeline(block) {
+  const rest = block.replace(TIMELINE_STYLE, "");
+  if (rest.includes("<style") || rest.includes("<!--"))
+    return false;
+  return (rest.match(/<[^>]*>/g) ?? []).every((tag) => TIMELINE_TAG.test(tag)) && !/<(?![^>]*>)/.test(rest);
+}
+function renderTimelineHtml(docs, offsets, articleUrl, style) {
+  const rows = docs.map((d, i) => {
+    const title = escapeHtml(d.title ?? `\u6761\u76EE ${i + 1}`);
+    const brief = escapeHtml(itemBrief(d));
+    const at = formatOffset(offsets[i] ?? Number.NaN);
+    const link = d.sourceUri && isHttpUrl(d.sourceUri) ? ` <a href="${escapeHtml(d.sourceUri)}" target="_blank" rel="noopener">\u6765\u6E90</a>` : "";
+    return `
+    <div class="kk-tl-row"><div class="kk-tl-t">${at}</div><div class="kk-tl-body"><div class="kk-tl-title">${i + 1}. ${title}${link}</div><p class="kk-tl-brief">${brief}</p></div></div>`;
+  }).join("");
+  const articleTail = isHttpUrl(articleUrl) ? `<p>\u5B8C\u6574\u56FE\u6587\u7248\uFF1A<a href="${escapeHtml(articleUrl)}" target="_blank" rel="noopener">${escapeHtml("\u672C\u671F\u5B8C\u6574\u6587\u7AE0")}</a></p>` : `<p>${escapeHtml("\u672C\u671F\u5B8C\u6574\u6587\u7AE0")}</p>`;
+  const styleBlock = style === "omit" ? "" : `${TIMELINE_STYLE}
+`;
+  const before = style === "before" ? styleBlock : "";
+  const after = style === "after" ? styleBlock : "";
+  return `<!--kk:timeline-->
+${before}<div class="kk-tl">${rows}
+</div>
+${after}${articleTail}
+<!--/kk:timeline-->`;
 }
 function renderShowNotesHtml(markdown) {
   const blocks = [];
@@ -12476,7 +13871,7 @@ function itemBrief(d) {
     return meta.brief.trim();
   return (d.body ?? "").trim().split(/(?<=[\u3002\uFF01\uFF1F])\s*/).slice(0, 2).join("");
 }
-function renderShowNotesMarkdown(docs, opts) {
+function renderShowNotesMarkdown(docs, opts, warnings) {
   const slugify = (t) => {
     const s = t.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/[\s_]+/g, "-");
     return s.length > 0 ? s : "post";
@@ -12487,6 +13882,9 @@ function renderShowNotesMarkdown(docs, opts) {
   const postLocale = segments.find((s) => ["zh", "en", "ja"].includes(s)) ?? "zh";
   const localePrefix = postLocale === "en" ? "" : `/${postLocale}`;
   const articleUrl = postSlug.length > 0 ? `${baseUrl}${localePrefix}/posts/${postSlug}` : `${baseUrl}/zh/posts/${opts.runDate}-${slugify(opts.title)}`;
+  if (opts.briefMode === true && postSlug.length === 0) {
+    warn("brief mode requested but ARTICLE_POST_PATH is empty; using legacy layout", warnings);
+  }
   const briefMode = opts.briefMode === true && postSlug.length > 0;
   const sourceLabel = (d) => {
     const m = d.metadata ?? {};
@@ -12500,8 +13898,42 @@ function renderShowNotesMarkdown(docs, opts) {
   };
   const offsets = computeAudioOffsets(docs, opts.audioSegments);
   const lines = [`# ${opts.title}`, ""];
+  const summaryOn = opts.summaryParagraph !== false;
+  if (summaryOn) {
+    const segmentSeconds = opts.audioSegments?.reduce((sum, segment) => sum + (segment.duration ?? 0), 0);
+    const durationSeconds = opts.durationSeconds ?? (segmentSeconds && segmentSeconds > 0 ? segmentSeconds : undefined);
+    const plan = docs.map((doc) => {
+      const title = doc.title?.trim() ?? "";
+      const brief = itemBrief(doc);
+      return brief.length > 0 ? { title, brief } : { title };
+    });
+    const config = {
+      ...SEO_DEFAULTS,
+      ...opts.seriesName ? { seriesName: opts.seriesName } : {},
+      ...opts.showName ? { showName: opts.showName } : {},
+      ...opts.descriptionMin !== undefined ? { descriptionMin: opts.descriptionMin } : {},
+      ...opts.descriptionMax !== undefined ? { descriptionMax: opts.descriptionMax } : {},
+      ...opts.descriptionSource ? { descriptionSource: opts.descriptionSource } : {},
+      ...opts.descriptionPattern ? { descriptionPattern: opts.descriptionPattern } : {},
+      summaryParagraph: true,
+      timelineStyle: opts.timelineStyle ?? "after"
+    };
+    const summary = showNotesSummaryParagraph({
+      config,
+      runDate: opts.runDate,
+      ...durationSeconds !== undefined ? { durationSeconds } : {},
+      plan,
+      ...opts.refinedDescription ? { refinedDescription: opts.refinedDescription } : {},
+      ...opts.summaryClauses ? { summaryClauses: opts.summaryClauses } : {},
+      articleUrl,
+      linkText: opts.surfingTitle?.trim() || "\u672C\u671F\u5B8C\u6574\u6587\u7AE0"
+    });
+    for (const line of summary.warnings)
+      warn(line.replace(/^WARN podcast-pub:\s*/, ""), warnings);
+    lines.push(summary.markdown, "");
+  }
   if (briefMode) {
-    lines.push(renderTimelineHtml(docs, offsets, articleUrl), "");
+    lines.push(renderTimelineHtml(docs, offsets, articleUrl, opts.timelineStyle ?? "after"), "");
   } else {
     docs.forEach((d, i) => {
       const body = (d.body ?? "").trim();
@@ -12625,134 +14057,6 @@ function mapContentToEpisode(content) {
   };
 }
 
-// ../../plugins/publishings/podcast-pub/src/microfeed-client.ts
-var MIN_TIMEOUT_MS = 1000;
-var DEFAULT_TIMEOUT_MS = 300000;
-function resolveTimeoutMs(raw) {
-  const parsed = raw === undefined ? Number.NaN : Number(raw);
-  if (!Number.isFinite(parsed) || parsed < MIN_TIMEOUT_MS) {
-    return DEFAULT_TIMEOUT_MS;
-  }
-  return parsed;
-}
-
-class MicrofeedClient {
-  baseUrl;
-  apiKey;
-  timeoutMs;
-  constructor(baseUrl, apiKey, timeoutMs) {
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
-    this.apiKey = apiKey;
-    this.timeoutMs = timeoutMs;
-  }
-  itemUrl(itemId) {
-    return `${this.baseUrl}/items/${itemId}`;
-  }
-  async request(path, init) {
-    let response;
-    try {
-      response = await fetch(`${this.baseUrl}${path}`, {
-        ...init,
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Origin: this.baseUrl,
-          ...init.headers
-        },
-        signal: AbortSignal.timeout(this.timeoutMs)
-      });
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      throw new Error(`microfeed transport error (${init.method ?? "GET"} ${path}): ${reason}`);
-    }
-    if (!response.ok) {
-      const text = (await response.text()).slice(0, 1000);
-      let detail = text.trim();
-      try {
-        const parsed = JSON.parse(text);
-        if (typeof parsed.error === "string")
-          detail = parsed.error;
-      } catch {}
-      throw new Error(`microfeed API request failed (HTTP ${response.status} ${response.statusText} ${path}): ${detail || "Unknown error"}`);
-    }
-    try {
-      return await response.json();
-    } catch {
-      throw new Error(`microfeed API returned a non-JSON response from ${path}`);
-    }
-  }
-  async createItem(input, idempotencyKey) {
-    const data = await this.request("/api/v1/items", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
-      },
-      body: JSON.stringify(input)
-    });
-    if (typeof data.id !== "string" || data.id.length === 0) {
-      throw new Error("microfeed item create response is missing the item id");
-    }
-    return data.id;
-  }
-  async validateItem(input) {
-    await this.request("/api/v1/items/validate", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input)
-    });
-  }
-  async getItem(itemId) {
-    return await this.request(`/api/v1/items/${encodeURIComponent(itemId)}`, {
-      method: "GET"
-    });
-  }
-  async updateItem(itemId, input) {
-    return await this.request(`/api/v1/items/${encodeURIComponent(itemId)}`, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input)
-    });
-  }
-  async deleteItem(itemId) {
-    await this.request(`/api/v1/items/${encodeURIComponent(itemId)}`, {
-      method: "DELETE",
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  async listItems() {
-    return await this.request("/api/v1/feed", { method: "GET" });
-  }
-  async prepareUpload(input) {
-    const data = await this.request("/api/v1/media_files/presigned_urls", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input)
-    });
-    if (typeof data.presigned_url !== "string" || typeof data.media_url !== "string") {
-      throw new Error("microfeed upload-preparation response is missing presigned_url/media_url");
-    }
-    return { presignedUrl: data.presigned_url, mediaUrl: data.media_url };
-  }
-  async uploadBytes(presignedUrl, bytes, mimeType) {
-    let response;
-    try {
-      response = await fetch(presignedUrl, {
-        method: "PUT",
-        headers: { "Content-Type": mimeType },
-        body: bytes,
-        signal: AbortSignal.timeout(this.timeoutMs)
-      });
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      throw new Error(`microfeed transport error (PUT audio bytes): ${reason}`);
-    }
-    if (!response.ok) {
-      const text = (await response.text()).slice(0, 1000);
-      throw new Error(`microfeed audio upload failed (HTTP ${response.status} ${response.statusText}): ${text.trim() || "Unknown error"}`);
-    }
-  }
-}
-
 // ../../plugins/publishings/podcast-pub/src/index.ts
 function publicItemUrl(item, itemId, client) {
   const microfeed = item?._microfeed;
@@ -12762,8 +14066,8 @@ function publicItemUrl(item, itemId, client) {
   const feedUrl = typeof item?.url === "string" ? item.url : "";
   return feedUrl !== "" ? feedUrl : client.itemUrl(itemId);
 }
-var TARGET = "podcast-pub";
-var OPERATIONS = ["publish", "show-notes", "list", "get", "update", "delete", "validate"];
+var TARGET2 = "podcast-pub";
+var OPERATIONS = ["publish", "show-notes", "list", "get", "update", "delete", "validate", "backfill-seo"];
 function resolveClient() {
   const baseUrl = process.env.MICROFEED_BASE_URL;
   const apiKey = process.env.MICROFEED_API_KEY;
@@ -12781,8 +14085,8 @@ function resolveClient() {
     client: new MicrofeedClient(baseUrl.trim(), apiKey.trim(), resolveTimeoutMs(process.env.MICROFEED_TIMEOUT_MS))
   };
 }
-function fail(error) {
-  return ResultSchema.parse({ ok: false, target: TARGET, error });
+function fail2(error) {
+  return ResultSchema.parse({ ok: false, target: TARGET2, error });
 }
 var COVER_MIME = {
   ".png": "image/png",
@@ -12829,7 +14133,7 @@ function resolveShowNotesRenderOptions(options) {
   const audioContentPath = resolveOptionString(undefined, "PODCAST_PUB_AUDIO_CONTENT");
   if (audioContentPath !== undefined) {
     try {
-      const parsed = JSON.parse(readFileSync2(audioContentPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync3(audioContentPath, "utf-8"));
       const meta = parsed?.metadata;
       if (Array.isArray(meta?.segments)) {
         audioSegments = meta.segments.map((s) => ({
@@ -12839,6 +14143,10 @@ function resolveShowNotesRenderOptions(options) {
       }
     } catch {}
   }
+  const seoConfig = resolvePodcastSeoConfig(undefined);
+  if ("error" in seoConfig)
+    return { error: seoConfig.error };
+  const config = seoConfig.config;
   return {
     renderOptions: {
       title,
@@ -12847,7 +14155,15 @@ function resolveShowNotesRenderOptions(options) {
       ...briefMode ? { briefMode: true } : {},
       ...articlePostPath !== undefined ? { articlePostPath } : {},
       ...footerNote !== undefined ? { footerNote } : {},
-      ...audioSegments !== undefined ? { audioSegments } : {}
+      ...audioSegments !== undefined ? { audioSegments } : {},
+      summaryParagraph: config.summaryParagraph,
+      timelineStyle: config.timelineStyle,
+      seriesName: config.seriesName,
+      showName: config.showName,
+      descriptionMin: config.descriptionMin,
+      descriptionMax: config.descriptionMax,
+      descriptionSource: config.descriptionSource,
+      descriptionPattern: config.descriptionPattern
     }
   };
 }
@@ -12860,7 +14176,8 @@ function renderShowNotesFromOptions(options) {
   const renderOptions = resolveShowNotesRenderOptions(options);
   if ("error" in renderOptions)
     return { error: renderOptions.error };
-  return { markdown: renderShowNotesMarkdown(docs.data, renderOptions.renderOptions) };
+  const warnings = [];
+  return { markdown: renderShowNotesMarkdown(docs.data, renderOptions.renderOptions, warnings), warnings };
 }
 function resolveAssemblyOptions(options) {
   const assembly = {};
@@ -12895,27 +14212,124 @@ function audioAttachment(audio, mediaUrl, sizeInBytes, durationSeconds) {
     ...durationSeconds !== undefined ? { duration_in_seconds: durationSeconds } : {}
   };
 }
-function episodeExtras(episode) {
+function episodeExtras(episode, seo) {
   return {
     ...episode.imageUrl ? { image: episode.imageUrl } : {},
     ...episode.datePublishedMs !== undefined ? { date_published_ms: episode.datePublishedMs } : {},
     ...episode.link ? { url: episode.link } : {},
-    ...{
-      _microfeed: {
-        "itunes:episodeType": episode.itunes?.episodeType ?? "full",
-        ...episode.itunes?.title ? { "itunes:title": episode.itunes.title } : {},
-        ...episode.itunes?.season !== undefined ? { "itunes:season": episode.itunes.season } : {},
-        ...episode.itunes?.episode !== undefined ? { "itunes:episode": episode.itunes.episode } : {},
-        ...episode.itunes?.explicit !== undefined ? { "itunes:explicit": episode.itunes.explicit } : {},
-        ...episode.itunes?.block !== undefined ? { "itunes:block": episode.itunes.block } : {}
-      }
+    _microfeed: {
+      "itunes:episodeType": episode.itunes?.episodeType ?? "full",
+      ...episode.itunes?.title ? { "itunes:title": episode.itunes.title } : {},
+      ...episode.itunes?.season !== undefined ? { "itunes:season": episode.itunes.season } : {},
+      ...episode.itunes?.episode !== undefined ? { "itunes:episode": episode.itunes.episode } : {},
+      ...episode.itunes?.explicit !== undefined ? { "itunes:explicit": episode.itunes.explicit } : {},
+      ...episode.itunes?.block !== undefined ? { "itunes:block": episode.itunes.block } : {},
+      ...seo ? { seo } : {}
     }
   };
 }
+function shapedEpisode(episode, fields) {
+  return {
+    ...episode,
+    title: fields.title,
+    ...fields.itunes ? { itunes: fields.itunes } : {},
+    ...fields.durationSeconds !== undefined ? { durationSeconds: fields.durationSeconds } : { durationSeconds: undefined },
+    link: fields.link
+  };
+}
+async function createEpisodeItem(client, body, slug, warnings) {
+  const withSlug = (itemSlug) => {
+    const micro = body._microfeed ?? {};
+    return { ...body, _microfeed: { ...micro, slug: itemSlug } };
+  };
+  if (!slug)
+    return client.createItem(body, crypto.randomUUID());
+  try {
+    return await client.createItem(withSlug(slug), crypto.randomUUID());
+  } catch (error) {
+    if (!(error instanceof MicrofeedRequestError) || error.status !== 409)
+      throw error;
+    const retry = `${slug}-2`;
+    try {
+      return await client.createItem(withSlug(retry), crypto.randomUUID());
+    } catch (retryError) {
+      if (!(retryError instanceof MicrofeedRequestError) || retryError.status !== 409)
+        throw retryError;
+      warn(`slug "${slug}" conflicted (HTTP 409); publishing without a custom slug`, warnings);
+      return client.createItem(body, crypto.randomUUID());
+    }
+  }
+}
+async function resolveSocialImage(client, fields, warnings) {
+  if (!fields.socialAlt)
+    return;
+  if (fields.socialLocalPath && fields.socialMime) {
+    const bytes = new Uint8Array(await readFile(fields.socialLocalPath));
+    const prepared = await client.prepareUpload({
+      category: "image",
+      full_local_file_path: basename(fields.socialLocalPath),
+      size: bytes.byteLength,
+      type: fields.socialMime
+    });
+    await client.uploadBytes(prepared.presignedUrl, bytes, fields.socialMime);
+    return {
+      url: prepared.mediaUrl,
+      width: 1200,
+      height: 630,
+      mime_type: fields.socialMime,
+      alt: fields.socialAlt
+    };
+  }
+  if (!fields.socialRemoteUrl)
+    return;
+  let bytes;
+  try {
+    const response = await fetch(fields.socialRemoteUrl);
+    if (!response.ok)
+      throw new Error(`HTTP ${response.status}`);
+    bytes = new Uint8Array(await response.arrayBuffer());
+  } catch (error) {
+    warn(`social image skipped: could not read ${fields.socialRemoteUrl} (${error instanceof Error ? error.message : String(error)})`, warnings);
+    return;
+  }
+  const dims = readImageDimensions(bytes);
+  if (dims?.width !== 1200 || dims?.height !== 630) {
+    warn(`social image skipped: expected a 1200\xD7630 PNG or JPEG, got ${dims ? `${dims.width}\xD7${dims.height}` : "an unreadable file"}`, warnings);
+    return;
+  }
+  return {
+    url: fields.socialRemoteUrl,
+    width: 1200,
+    height: 630,
+    mime_type: dims.mime,
+    alt: fields.socialAlt
+  };
+}
+function mergeSocial(seo, social) {
+  if (!social)
+    return seo;
+  return { ...seo ?? {}, social_image: social };
+}
+function mappedValidateInput(content) {
+  const seoConfig = resolvePodcastSeoConfig(content.metadata);
+  if ("error" in seoConfig)
+    throw new Error(seoConfig.error);
+  const episode = mapContentToEpisode(content);
+  const policy = prepareEpisodeFields(episode, content.metadata ?? {}, seoConfig.config);
+  if (!policy.ok)
+    throw new Error(policy.error);
+  const shaped = shapedEpisode(episode, policy.fields);
+  return {
+    title: shaped.title,
+    content_html: shaped.contentHtml,
+    status: shaped.status,
+    ...episodeExtras(shaped, policy.fields.seo)
+  };
+}
 async function publishEpisode(client, payload, options) {
   const assembly = resolveAssemblyOptions(options);
   if ("error" in assembly)
-    return fail(assembly.error);
+    return fail2(assembly.error);
   const { audioFile, coverPath, durationSec } = assembly.assembly;
   const content = audioFile !== undefined || coverPath !== undefined || durationSec !== undefined ? {
     ...payload.content,
@@ -12930,17 +14344,31 @@ async function publishEpisode(client, payload, options) {
   try {
     episode = mapContentToEpisode(content);
   } catch (error) {
-    return fail(`Invalid Content: ${error instanceof Error ? error.message : String(error)}`);
+    return fail2(`Invalid Content: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const seoConfig = resolvePodcastSeoConfig(content.metadata);
+  if ("error" in seoConfig)
+    return fail2(seoConfig.error);
+  const policy = prepareEpisodeFields(episode, content.metadata ?? {}, seoConfig.config);
+  if (!policy.ok)
+    return fail2(policy.error);
+  const fields = policy.fields;
+  let social;
+  try {
+    social = await resolveSocialImage(client, fields, fields.warnings);
+  } catch (error) {
+    return fail2(error instanceof Error ? error.message : String(error));
   }
-  const idempotencyKey = crypto.randomUUID();
+  const seo = mergeSocial(fields.seo, social);
+  episode = shapedEpisode(episode, fields);
   if (episode.audio.kind === "url") {
-    const itemId = await client.createItem({
+    const itemId = await createEpisodeItem(client, {
       title: episode.title,
       content_html: episode.contentHtml,
       status: episode.status,
       attachments: [audioAttachment(episode.audio, episode.audio.url, undefined, episode.durationSeconds)],
-      ...episodeExtras(episode)
-    }, idempotencyKey);
+      ...episodeExtras(episode, seo)
+    }, fields.slug, fields.warnings);
     let hostedItem;
     try {
       hostedItem = (await client.getItem(itemId)).items?.[0];
@@ -12949,17 +14377,18 @@ async function publishEpisode(client, payload, options) {
     }
     return ResultSchema.parse({
       ok: true,
-      target: TARGET,
+      target: TARGET2,
       url: publicItemUrl(hostedItem, itemId, client),
       id: itemId,
-      message: "Published successfully to microfeed (hosted audio, single-call create)"
+      message: "Published successfully to microfeed (hosted audio, single-call create)",
+      ...fields.warnings.length > 0 ? { metadata: { warnings: fields.warnings } } : {}
     });
   }
-  const itemId = await client.createItem({
+  const itemId = await createEpisodeItem(client, {
     title: episode.title,
     content_html: episode.contentHtml,
     status: "unpublished"
-  }, idempotencyKey);
+  }, fields.slug, fields.warnings);
   const bytes = new Uint8Array(await readFile(episode.audio.path));
   const prepared = await client.prepareUpload({
     category: "audio",
@@ -12988,15 +14417,19 @@ async function publishEpisode(client, payload, options) {
     status: episode.status,
     attachments: [audioAttachment(episode.audio, prepared.mediaUrl, bytes.byteLength, episode.durationSeconds)],
     ...imageUrl ? { image: imageUrl } : {},
-    ...episodeExtras(episode)
+    ...episodeExtras(episode, seo)
   });
   return ResultSchema.parse({
     ok: true,
-    target: TARGET,
+    target: TARGET2,
     url: publicItemUrl(item, itemId, client),
     id: itemId,
     message: "Published successfully to microfeed (two-phase upload + publish)",
-    metadata: { itemId, imageUrl: imageUrl ?? null }
+    metadata: {
+      itemId,
+      imageUrl: imageUrl ?? null,
+      ...fields.warnings.length > 0 ? { warnings: fields.warnings } : {}
+    }
   });
 }
 
@@ -13006,21 +14439,24 @@ class PodcastPubTransport {
     const options = payload.options !== undefined && typeof payload.options === "object" && payload.options !== null ? payload.options : {};
     const routed = resolveOperation(options);
     if ("error" in routed)
-      return fail(routed.error);
+      return fail2(routed.error);
     if (routed.operation === "show-notes") {
       const rendered = renderShowNotesFromOptions(options);
       if ("error" in rendered)
-        return fail(rendered.error);
+        return fail2(rendered.error);
       return ResultSchema.parse({
         ok: true,
-        target: TARGET,
+        target: TARGET2,
         message: "Rendered show notes markdown (pure render; no microfeed API call)",
-        metadata: { markdown: rendered.markdown }
+        metadata: {
+          markdown: rendered.markdown,
+          ...rendered.warnings.length > 0 ? { warnings: rendered.warnings } : {}
+        }
       });
     }
     const resolved = resolveClient();
     if ("error" in resolved)
-      return fail(resolved.error);
+      return fail2(resolved.error);
     const { client } = resolved;
     try {
       switch (routed.operation) {
@@ -13030,7 +14466,7 @@ class PodcastPubTransport {
           const feed = await client.listItems();
           return ResultSchema.parse({
             ok: true,
-            target: TARGET,
+            target: TARGET2,
             url: typeof feed.feed_url === "string" ? feed.feed_url : undefined,
             message: `Listed ${feed.items?.length ?? 0} microfeed item(s)`,
             metadata: { items: feed.items ?? [] }
@@ -13039,14 +14475,14 @@ class PodcastPubTransport {
         case "get": {
           const itemId = resolveItemId(options);
           if ("error" in itemId)
-            return fail(itemId.error);
+            return fail2(itemId.error);
           const feed = await client.getItem(itemId.itemId);
           const item = feed.items?.[0];
           if (!item)
-            return fail(`microfeed item "${itemId.itemId}" not found in the feed response`);
+            return fail2(`microfeed item "${itemId.itemId}" not found in the feed response`);
           return ResultSchema.parse({
             ok: true,
-            target: TARGET,
+            target: TARGET2,
             id: itemId.itemId,
             url: typeof item.url === "string" ? item.url : undefined,
             message: `Fetched microfeed item ${itemId.itemId}`,
@@ -13056,14 +14492,14 @@ class PodcastPubTransport {
         case "update": {
           const itemId = resolveItemId(options);
           if ("error" in itemId)
-            return fail(itemId.error);
+            return fail2(itemId.error);
           if (options.item === undefined || typeof options.item !== "object" || options.item === null) {
-            return fail("options.item (microfeed item input object) is required for the update operation");
+            return fail2("options.item (microfeed item input object) is required for the update operation");
           }
           const item = await client.updateItem(itemId.itemId, options.item);
           return ResultSchema.parse({
             ok: true,
-            target: TARGET,
+            target: TARGET2,
             id: itemId.itemId,
             url: typeof item.url === "string" ? item.url : undefined,
             message: `Updated microfeed item ${itemId.itemId}`,
@@ -13073,34 +14509,33 @@ class PodcastPubTransport {
         case "delete": {
           const itemId = resolveItemId(options);
           if ("error" in itemId)
-            return fail(itemId.error);
+            return fail2(itemId.error);
           await client.deleteItem(itemId.itemId);
           return ResultSchema.parse({
             ok: true,
-            target: TARGET,
+            target: TARGET2,
             id: itemId.itemId,
             message: `Deleted microfeed item ${itemId.itemId}`
           });
         }
+        case "backfill-seo": {
+          const config = resolvePodcastSeoConfig(payload.content.metadata);
+          if ("error" in config)
+            return fail2(config.error);
+          return await runBackfill(client, options, config.config);
+        }
         case "validate": {
-          const input = options.item !== undefined && typeof options.item === "object" && options.item !== null ? options.item : (() => {
-            const episode = mapContentToEpisode(payload.content);
-            return {
-              title: episode.title,
-              content_html: episode.contentHtml,
-              status: episode.status
-            };
-          })();
+          const input = options.item !== undefined && typeof options.item === "object" && options.item !== null ? options.item : mappedValidateInput(payload.content);
           await client.validateItem(input);
           return ResultSchema.parse({
             ok: true,
-            target: TARGET,
+            target: TARGET2,
             message: "microfeed accepted the item input (POST /api/v1/items/validate)"
           });
         }
       }
     } catch (error) {
-      return fail(`${error instanceof Error ? error.message : String(error)}`);
+      return fail2(`${error instanceof Error ? error.message : String(error)}`);
     }
   }
 }
@@ -13121,7 +14556,7 @@ async function renderShowNotesIO(docs, outputPath) {
   const rendered = renderShowNotesFromOptions({ docs });
   if ("error" in rendered) {
     const message = `show-notes render failed: ${rendered.error}`;
-    await writePublishResult(outputPath, fail(message));
+    await writePublishResult(outputPath, fail2(message));
     throw new Error(message);
   }
   await createNodeFileSystem().writeFile(outputPath, rendered.markdown);
@@ -13143,7 +14578,7 @@ async function processPublishIO(inputPath, outputPath, transport = getPublishTra
     }
   } catch (error) {
     const message = `Invalid Content input: ${error instanceof Error ? error.message : String(error)}`;
-    await writePublishResult(outputPath, ResultSchema.parse({ ok: false, target: TARGET, error: message }));
+    await writePublishResult(outputPath, ResultSchema.parse({ ok: false, target: TARGET2, error: message }));
     throw new Error(message);
   }
   const result = await transport.publish({ content, options });