@jant/core 0.7.0 → 0.7.1

package/src/lib/__tests__/markdown-to-tiptap.test.ts

@@ -90,6 +90,111 @@ describe("markdownToTiptapJson", () => {
       expect(doc.content[0].content).toHaveLength(3);
     });
 
+    // Tiptap's own tokenizer gave an empty item no content at all, which the
+    // schema rejects and the Markdown serializer threw on.
+    it("gives an empty list item the paragraph the schema requires", () => {
+      const doc = parse("1. First\n2.\n3. Third");
+      expect(doc.content[0].type).toBe("orderedList");
+      expect(doc.content[0].content).toHaveLength(3);
+      expect(doc.content[0].content[1].type).toBe("listItem");
+      expect(doc.content[0].content[1].content).toMatchObject([
+        { type: "paragraph" },
+      ]);
+    });
+
+    it.each([
+      ["<strong>粗</strong>", "bold"],
+      ["<b>粗</b>", "bold"],
+      ["<em>斜</em>", "italic"],
+      ["<i>斜</i>", "italic"],
+      ["<s>删</s>", "strike"],
+      ["<del>删</del>", "strike"],
+    ])("reads %s as a %s mark", (html, mark) => {
+      const doc = parse(`前${html}后`);
+      const marked = doc.content[0].content.find(
+        (node: TiptapNode) => node.marks?.length,
+      );
+      expect(marked.marks).toEqual([{ type: mark }]);
+      expect(
+        doc.content[0].content.map((n: TiptapNode) => n.text).join(""),
+      ).toBe(`前${html.replace(/<[^>]+>/g, "")}后`);
+    });
+
+    it("parses Markdown inside an HTML emphasis tag", () => {
+      const doc = parse("<strong>[链接](https://example.com)。</strong>后");
+      const first = doc.content[0].content[0];
+      expect(first.text).toBe("链接");
+      expect(first.marks.map((mark: TiptapMark) => mark.type).sort()).toEqual([
+        "bold",
+        "link",
+      ]);
+    });
+
+    it.each([
+      '<strong onclick="alert(1)">x</strong>',
+      "<span>x</span>",
+      "<script>x</script>",
+    ])("keeps %j as text", (html) => {
+      const doc = parse(html);
+      expect(doc.content[0].content).toEqual([{ type: "text", text: html }]);
+    });
+
+    it("keeps an ordered list's start number", () => {
+      const doc = parse("3. Third\n4. Fourth");
+      expect(doc.content[0].type).toBe("orderedList");
+      expect(doc.content[0].attrs).toEqual({ start: 3 });
+    });
+
+    // CommonMark list markers are digits. Tiptap's own tokenizer also takes
+    // letters and roman numerals, which ate the first word of these lines.
+    it.each([
+      "Ps. 今天发现苹果尼日利亚区的终身会员",
+      "PS. 补充一句",
+      "Mr. Smith went to Washington.",
+      "No. 5 is here.",
+      "OK. Fine.",
+      "I. Introduction",
+      "a. first",
+      "mix. of words",
+    ])("keeps %j a paragraph", (line) => {
+      const doc = parse(line);
+      expect(doc.content).toEqual([
+        { type: "paragraph", content: [{ type: "text", text: line }] },
+      ]);
+    });
+
+    it("keeps a code block inside a list item exactly as written", () => {
+      const doc = parse(
+        [
+          "1. Create the project:",
+          "   ```bash",
+          "   ├── .github",
+          "   │   └── workflows",
+          "   └── package.json",
+          "   ```",
+          "2. Clone it",
+        ].join("\n"),
+      );
+      const list = doc.content[0];
+      expect(list.type).toBe("orderedList");
+      expect(list.content).toHaveLength(2);
+      const codeBlock = list.content[0].content.find(
+        (node: TiptapNode) => node.type === "codeBlock",
+      );
+      expect(codeBlock.content[0].text).toBe(
+        "├── .github\n│   └── workflows\n└── package.json",
+      );
+    });
+
+    it("keeps a wide marker's continuation lines intact", () => {
+      const doc = parse("10. Run:\n\n    ```sh\n    ls -la\n    ```");
+      const codeBlock = doc.content[0].content[0].content.find(
+        (node: TiptapNode) => node.type === "codeBlock",
+      );
+      expect(doc.content[0].attrs).toEqual({ start: 10 });
+      expect(codeBlock.content[0].text).toBe("ls -la");
+    });
+
     it("converts horizontal rules", () => {
       const doc = parse("Above\n\n---\n\nBelow");
       const hr = doc.content.find(

package/src/lib/__tests__/markdown.test.ts

@@ -2,6 +2,16 @@ import { describe, it, expect } from "vitest";
 import { render, toPlainText, extractTitle } from "../markdown.js";
 
 describe("render", () => {
+  it("renders the HTML emphasis tags the serializer writes for CJK text", () => {
+    expect(render("而是：<strong>固定时间。</strong>来的人")).toBe(
+      "<p>而是：<strong>固定时间。</strong>来的人</p>",
+    );
+  });
+
+  it("escapes HTML tags outside the emphasis allowlist", () => {
+    expect(render("<span>x</span>")).toBe("<p>&lt;span&gt;x&lt;/span&gt;</p>");
+  });
+
   it("renders a heading", () => {
     const html = render("# Hello");
     expect(html).toContain("<h1>");

package/src/lib/__tests__/resolve-config.test.ts

@@ -52,6 +52,73 @@ describe("resolveConfig", () => {
     expect(config.siteName).toBe("FromEnv");
   });
 
+  // A settings row holding an empty string is not always the same thing. The
+  // editor decides: a boolean, a number, and an enum with fixed options cannot
+  // be saved empty, so an empty one of those came from a path that skipped
+  // validation — a snapshot import replaying raw SQL — and the environment
+  // variable should still be heard.
+  // Text can legitimately be empty, and then the row wins.
+  describe("empty settings rows", () => {
+    it("lets an environment value through an empty boolean row", () => {
+      const config = resolveConfig(makeEnv({ NOINDEX: "true" }), {
+        NOINDEX: "",
+      });
+
+      expect(config.noindex).toBe(true);
+    });
+
+    it("falls back to the default for an empty boolean row with no env value", () => {
+      const config = resolveConfig(makeEnv(), { NOINDEX: "" });
+
+      expect(config.noindex).toBe(false);
+    });
+
+    it("still lets a saved boolean row override the environment", () => {
+      const config = resolveConfig(makeEnv({ NOINDEX: "true" }), {
+        NOINDEX: "false",
+      });
+
+      expect(config.noindex).toBe(false);
+    });
+
+    it("lets an environment value through an empty numeric row", () => {
+      const config = resolveConfig(makeEnv({ PAGE_SIZE: "20" }), {
+        PAGE_SIZE: "",
+      });
+
+      expect(config.pageSize).toBe(20);
+    });
+
+    it("keeps an empty enum row ahead of the environment when empty is an option", () => {
+      // `DASHBOARD_LANGUAGE` lists "" among its options — it is how the
+      // dashboard is told to follow the site language.
+      const config = resolveConfig(makeEnv({ DASHBOARD_LANGUAGE: "zh-Hans" }), {
+        DASHBOARD_LANGUAGE: "",
+      });
+
+      expect(config.dashboardLanguage).toBe("");
+    });
+
+    it("keeps an empty text row ahead of the environment", () => {
+      const config = resolveConfig(
+        makeEnv({ SITE_FOOTER: "From environment" }),
+        { SITE_FOOTER: "" },
+      );
+
+      expect(config.siteFooter).toBe("");
+    });
+
+    it("lets an environment value through an empty enum row", () => {
+      // `MAIN_RSS_FEED` offers "featured" and "latest" and nothing else, so an
+      // empty row is as impossible to save as an empty boolean.
+      const config = resolveConfig(makeEnv({ MAIN_RSS_FEED: "latest" }), {
+        MAIN_RSS_FEED: "",
+      });
+
+      expect(config.mainRssFeed).toBe("latest");
+    });
+  });
+
   it("lets an explicit empty DB value override an environment fallback", () => {
     const config = resolveConfig(
       makeEnv({ SITE_DESCRIPTION: "From environment" }),

package/src/lib/__tests__/schemas.test.ts

@@ -61,10 +61,17 @@ describe("RedirectTypeSchema", () => {
     expect(RedirectTypeSchema.parse("302")).toBe("302");
   });
 
+  // The custom URL list answers `redirectType: 301`; sending that back to
+  // create one has to work.
+  it("accepts 301 and 302 as numbers, as the API answers them", () => {
+    expect(RedirectTypeSchema.parse(301)).toBe("301");
+    expect(RedirectTypeSchema.parse(302)).toBe("302");
+  });
+
   it("rejects other values", () => {
     expect(() => RedirectTypeSchema.parse("200")).toThrow();
     expect(() => RedirectTypeSchema.parse("404")).toThrow();
-    expect(() => RedirectTypeSchema.parse(301)).toThrow();
+    expect(() => RedirectTypeSchema.parse(308)).toThrow();
   });
 });
 
@@ -617,6 +624,25 @@ describe("CreatePostApiSchema", () => {
     status: "published",
   };
 
+  it("accepts the creation and edit times a restore passes", () => {
+    expect(
+      CreatePostApiSchema.parse({
+        ...validPost,
+        createdAt: 1700000000,
+        updatedAt: 1700009000,
+      }),
+    ).toMatchObject({ createdAt: 1700000000, updatedAt: 1700009000 });
+  });
+
+  it("leaves record timestamps out of updates", () => {
+    expect(
+      UpdatePostApiSchema.safeParse({ createdAt: 1700000000 }).success,
+    ).toBe(false);
+    expect(
+      UpdatePostApiSchema.safeParse({ updatedAt: 1700000000 }).success,
+    ).toBe(false);
+  });
+
   it("accepts ordered attachment inputs", () => {
     const mediaId = createEntityId("media");
     const result = CreatePostApiSchema.parse({

package/src/lib/__tests__/timeline.test.ts

@@ -733,6 +733,93 @@ describe("Timeline data assembly", () => {
     ]);
   });
 
+  // A reply can be older than its root (a post moved into the Thread keeps
+  // its creation time; an export without `created` dates posts by
+  // publication). The Thread still opens on its root.
+  async function createThreadWithOlderReplies() {
+    const root = await postService.create({
+      format: "note",
+      bodyMarkdown: "Root",
+      featured: true,
+      publishedAt: 3000,
+    });
+    const first = await postService.create({
+      format: "note",
+      bodyMarkdown: "First reply",
+      replyToId: root.id,
+      publishedAt: 1000,
+    });
+    const second = await postService.create({
+      format: "note",
+      bodyMarkdown: "Second reply",
+      replyToId: first.id,
+      publishedAt: 2000,
+    });
+    for (const [id, createdAt] of [
+      [root.id, 3000],
+      [first.id, 1000],
+      [second.id, 2000],
+    ] as const) {
+      await db.update(postTable).set({ createdAt }).where(eq(postTable.id, id));
+    }
+    return { root, first, second };
+  }
+
+  it("keeps a Featured Thread whose replies are older than its root", async () => {
+    const { root, second } = await createThreadWithOlderReplies();
+
+    const result = await assembleFeaturedTimeline(createTimelineContext(), {
+      isAuthenticated: true,
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]?.post.id).toBe(root.id);
+    expect(result.items[0]?.curatedThread?.segments).toEqual([
+      expect.objectContaining({
+        post: expect.objectContaining({ id: root.id }),
+        hiddenBeforeCount: 0,
+        highlighted: true,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: second.id }),
+        hiddenBeforeCount: 1,
+        highlighted: false,
+      }),
+    ]);
+  });
+
+  it("renders a collected Thread whose replies are older than its root", async () => {
+    const collection = await collectionService.create({
+      slug: "older-replies",
+      title: "Older replies",
+    });
+    const { root, first, second } = await createThreadWithOlderReplies();
+    await collectionService.addThread(collection.id, root.id);
+
+    const result = await assembleCollectionTimeline(createTimelineContext(), {
+      collectionIds: [collection.id],
+      isAuthenticated: true,
+      sortOrder: "newest",
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]?.post.id).toBe(root.id);
+    expect(result.items[0]?.curatedThread?.segments).toEqual([
+      expect.objectContaining({
+        post: expect.objectContaining({ id: root.id }),
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: first.id }),
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: second.id }),
+        highlighted: true,
+      }),
+    ]);
+  });
+
   it("deduplicates Threads selected through multiple collections", async () => {
     const smart = await collectionService.create({
       slug: "smart",

package/src/lib/__tests__/tiptap-to-markdown.test.ts

@@ -361,6 +361,154 @@ describe("tiptapJsonToMarkdown", () => {
       );
       expect(tiptapJsonToMarkdown(json)).toBe("Line 1  \nLine 2");
     });
+
+    // Trailing spaces on a line with nothing else on it make a blank line,
+    // which ends the paragraph (or leaves a list item empty).
+    it("keeps two hard breaks in a row inside one paragraph", () => {
+      const br = { type: "hardBreak" };
+      const json = doc(p(text("A"), br, br, text("B")));
+      const markdown = tiptapJsonToMarkdown(json);
+      expect(markdown).toBe("A  \n\\\nB");
+      expect(JSON.parse(markdownToTiptapJson(markdown))).toEqual(
+        JSON.parse(json),
+      );
+    });
+
+    it("keeps a list item that opens with a hard break in the list", () => {
+      const json = doc({
+        type: "bulletList",
+        content: [
+          {
+            type: "listItem",
+            content: [p({ type: "hardBreak" }, text("Ships in 3–7 days"))],
+          },
+          { type: "listItem", content: [p(text("Next"))] },
+        ],
+      });
+      const markdown = tiptapJsonToMarkdown(json);
+      expect(JSON.parse(markdownToTiptapJson(markdown))).toEqual(
+        JSON.parse(json),
+      );
+    });
+  });
+
+  // CommonMark only closes `**` after punctuation when a space or another
+  // punctuation mark follows, so `**句子。**后文` stays literal asterisks in
+  // Hugo and in Jant. Those runs use HTML tags, which both read.
+  describe("emphasis a delimiter can't open or close", () => {
+    const bold = [{ type: "bold" }];
+
+    it.each([
+      [
+        "bold ending in CJK punctuation before a letter",
+        [text("而是："), text("固定时间，一群人。", bold), text("来的人")],
+        "而是：<strong>固定时间，一群人。</strong>来的人",
+      ],
+      [
+        "bold opening on CJK punctuation after a letter",
+        [text("说"), text("「引用」", bold), text("后")],
+        "说<strong>「引用」</strong>后",
+      ],
+      [
+        "italic ending in punctuation before a letter",
+        [text("这是"), text("强调。", [{ type: "italic" }]), text("后面")],
+        "这是<em>强调。</em>后面",
+      ],
+      [
+        "strike ending in punctuation before a letter",
+        [text("价格"), text("100元。", [{ type: "strike" }]), text("现在")],
+        "价格<s>100元。</s>现在",
+      ],
+      [
+        "English bold ending in a period before a letter",
+        [text("Say "), text("hello.", bold), text("World")],
+        "Say <strong>hello.</strong>World",
+      ],
+    ])("writes %s as HTML", (_label, content, expected) => {
+      const json = doc(p(...content));
+      expect(tiptapJsonToMarkdown(json)).toBe(expected);
+      expect(JSON.parse(markdownToTiptapJson(expected))).toEqual(
+        JSON.parse(json),
+      );
+    });
+
+    it.each([
+      [
+        "between spaces",
+        [text("a "), text("bold", bold), text(" b")],
+        "a **bold** b",
+      ],
+      [
+        "inside CJK text",
+        [text("中"), text("加粗", bold), text("文")],
+        "中**加粗**文",
+      ],
+      [
+        "ending in punctuation before punctuation",
+        [text("说"), text("好。", bold), text("」")],
+        "说**好。**」",
+      ],
+    ])("keeps Markdown delimiters %s", (_label, content, expected) => {
+      const json = doc(p(...content));
+      expect(tiptapJsonToMarkdown(json)).toBe(expected);
+      expect(JSON.parse(markdownToTiptapJson(expected))).toEqual(
+        JSON.parse(json),
+      );
+    });
+  });
+
+  // Text that happens to open a line with block syntax must come back as the
+  // same paragraph, not as a list, heading, or setext underline.
+  describe("block markers at the start of a line", () => {
+    const br = { type: "hardBreak" };
+
+    it.each([
+      ["a numbered line", [text("1986. A good year")], "1986\\. A good year"],
+      ["a parenthesized number", [text("2) Second")], "2\\) Second"],
+      ["a dash", [text("- not a list")], "\\- not a list"],
+      ["a plus", [text("+ not a list")], "\\+ not a list"],
+      ["a hash", [text("# not a heading")], "\\# not a heading"],
+      [
+        "numbered lines after hard breaks",
+        [text("Update:"), br, text("1. Pony"), br, text("2. Next")],
+        "Update:  \n1\\. Pony  \n2\\. Next",
+      ],
+      [
+        "a dash rule after a hard break",
+        [text("Title"), br, text("---")],
+        "Title  \n\\---",
+      ],
+      [
+        "an equals rule after a hard break",
+        [text("Title"), br, text("===")],
+        "Title  \n\\===",
+      ],
+    ])("escapes %s", (_label, content, expected) => {
+      const json = doc(p(...content));
+      expect(tiptapJsonToMarkdown(json)).toBe(expected);
+      expect(JSON.parse(markdownToTiptapJson(expected))).toEqual(
+        JSON.parse(json),
+      );
+    });
+
+    it("leaves markers in the middle of a line alone", () => {
+      expect(tiptapJsonToMarkdown(doc(p(text("Step 1. then 2."))))).toBe(
+        "Step 1. then 2.",
+      );
+    });
+
+    it("escapes a numbered line inside a list item", () => {
+      const json = doc({
+        type: "orderedList",
+        content: [
+          { type: "listItem", content: [p(text("1. nested-looking"))] },
+        ],
+      });
+      expect(tiptapJsonToMarkdown(json)).toBe("1. 1\\. nested-looking");
+      expect(
+        JSON.parse(markdownToTiptapJson("1. 1\\. nested-looking")),
+      ).toEqual(JSON.parse(json));
+    });
   });
 
   describe("round-trip", () => {
@@ -411,12 +559,32 @@ describe("tiptapJsonToMarkdown", () => {
   });
 
   describe("edge cases", () => {
-    it("returns empty string for invalid JSON", () => {
-      expect(tiptapJsonToMarkdown("not json")).toBe("");
+    it("throws for invalid JSON instead of returning nothing", () => {
+      expect(() => tiptapJsonToMarkdown("not json")).toThrow();
     });
 
-    it("returns empty string for non-doc node", () => {
-      expect(tiptapJsonToMarkdown('{"type":"paragraph"}')).toBe("");
+    it("throws for a root that is not a doc", () => {
+      expect(() => tiptapJsonToMarkdown('{"type":"paragraph"}')).toThrow(/doc/);
+    });
+
+    // A stored body with an empty list item made the serializer throw, and
+    // the catch-all turned the whole post into "" in the export.
+    it("fills an empty list item instead of dropping the document", () => {
+      const json = doc(
+        { type: "heading", attrs: { level: 2 }, content: [text("Setup")] },
+        {
+          type: "orderedList",
+          content: [
+            { type: "listItem", content: [] },
+            { type: "listItem", content: [p(text("Install"))] },
+          ],
+        },
+        { type: "codeBlock", content: [text("nix run")] },
+      );
+      const markdown = tiptapJsonToMarkdown(json);
+      expect(markdown).toContain("## Setup");
+      expect(markdown).toContain("Install");
+      expect(markdown).toContain("nix run");
     });
 
     it("handles empty doc", () => {

package/src/lib/discover.ts

@@ -400,7 +400,9 @@ export function linkTerms(
  * than on the checkbox label. The settings page and the setup screen both
  * render their line through here, so the two can never link different words;
  * setup's line is the settings line's opening sentence, so only the name is
- * there to find.
+ * there to find. The notice that replaces the settings line while the box is
+ * locked in demo mode goes through here too, and it also names only the
+ * directory.
  *
  * @param intro - The translated help line
  * @param terms - The translated directory and rules-page names, as `intro`

package/src/lib/github-sync-repo-name.ts

@@ -0,0 +1,45 @@
+/**
+ * The repository name Jant proposes for a site's GitHub Sync mirror.
+ *
+ * The settings page prefills it on github.com/new, and a site export with no
+ * repository behind it uses it as the Worker name in `wrangler.jsonc`.
+ * Cloudflare names a Worker imported from a repository after the repository,
+ * so an export and a repository created with the default name agree without
+ * anyone editing either.
+ */
+
+/** Used when the site URL yields no host label. */
+const FALLBACK_REPO_NAME = "jant-site-sync";
+
+/**
+ * Derive the default repository name for a site's sync mirror.
+ *
+ * Uses the first DNS label of the site's host — a stable, URL-safe
+ * identifier tied to this Jant instance. A leading `www` is skipped: it
+ * names nothing about the site, and every `www.` site would otherwise
+ * propose the same `www-jant-sync`. It is kept when only a top-level domain
+ * follows it, since that label would say even less. The `-jant-sync` suffix
+ * tells the sync mirror apart from a user's own `{slug}-jant` source repo.
+ *
+ * @param siteUrl - The site's public URL.
+ * @returns A GitHub-safe repository name; `jant-site-sync` when the URL has
+ *   no usable host.
+ * @example
+ * suggestSyncRepoName("https://notes.example.com"); // "notes-jant-sync"
+ * suggestSyncRepoName("https://www.example.com"); // "example-jant-sync"
+ */
+export function suggestSyncRepoName(siteUrl: string): string {
+  let labels: string[] = [];
+  try {
+    labels = new URL(siteUrl).host.split(".");
+  } catch {
+    /* fall through */
+  }
+  const [first = "", second = "", ...more] = labels;
+  const label = first === "www" && more.length > 0 ? second : first;
+  const slug = label
+    .toLowerCase()
+    .replace(/[^a-z0-9-_]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return slug ? `${slug}-jant-sync` : FALLBACK_REPO_NAME;
+}

package/src/lib/hugo-markdown.ts

@@ -34,6 +34,24 @@ export interface HugoCollectionRef {
   pinned_at?: string | null;
 }
 
+/**
+ * A smart collection's conditions on its section page (`type:
+ * smart_collection`). The stored selection, with two changes of spelling:
+ * `collection` is one collection's slug rather than a list of IDs, and
+ * `media` is `any`, `none`, or a list of kinds. The theme's
+ * `smart-collection-members` partial evaluates it; an import recreates the
+ * smart collection from it.
+ */
+export interface HugoSmartCollectionSelection {
+  collection?: string;
+  format?: string;
+  title?: boolean;
+  year?: number;
+  media?: "any" | "none" | string[];
+  replies?: boolean;
+  visibility?: string;
+}
+
 /**
  * Jant media attachment descriptor. Stored flat inside the `media:` front-
  * matter array. `src` is either:
@@ -90,6 +108,12 @@ export interface HugoFrontMatter {
   id?: string;
   title?: string;
   date?: string;
+  /**
+   * When the post was created, written only when it differs from `date` (a
+   * published post dated before or after it was written). Restored on import
+   * so thread order and "last edited" survive a move.
+   */
+  created?: string;
   updated?: string;
   slug?: string;
   type?: string;
@@ -97,7 +121,20 @@ export interface HugoFrontMatter {
 
   // Hugo routing
   aliases?: string[];
+  /**
+   * Published root bundles only: the `<id>` Jant's feeds gave the Thread's
+   * entry — its permalink, absolute, with no trailing slash. The theme's feed
+   * writes it as the entry's `<id>` so readers don't show the post again after
+   * a move. Written by the export, never read by the import.
+   */
+  feed_id?: string;
   build?: HugoBuildOptions;
+  /**
+   * Reply bundles only: 1-based position in the Thread. Jant orders a Thread
+   * by creation time, then ID; replies written in the same second tie on
+   * `date`, so the theme and the importer order by this instead.
+   */
+  weight?: number;
 
   // Jant post payload (flat — no `extra` nesting)
   format?: string;
@@ -143,6 +180,14 @@ export interface HugoFrontMatter {
   collections?: HugoCollectionRef[];
   media?: JantMedia[];
 
+  // Smart collection section pages
+  selection?: HugoSmartCollectionSelection;
+  /**
+   * `list` or `grid`; absent when the smart collection follows the site's
+   * archive layout. Not `layout`, which Hugo reads as a template name.
+   */
+  display_layout?: string;
+
   // Escape hatch for page-specific export metadata.
   [key: string]: unknown;
 }
@@ -213,6 +258,7 @@ const FRONT_MATTER_KEY_ORDER: readonly string[] = [
   "type",
   "draft",
   "aliases",
+  "feed_id",
   "build",
 
   // Post payload