@jant/core 0.6.11 → 0.6.12

package/src/services/__tests__/navigation.test.ts

@@ -9,11 +9,50 @@ import { now } from "../../lib/time.js";
 
 const TEST_COLLECTION_ID = "col_test00000000000000000000001";
 const TEST_COLLECTION_ID_2 = "col_test00000000000000000000002";
+const TEST_POST_ID = "pst_test00000000000000000000001";
+const TEST_POST_ID_2 = "pst_test00000000000000000000002";
+
+function insertTestPath(
+  sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
+  input: {
+    id: string;
+    path: string;
+    kind: "slug" | "alias" | "redirect" | "archive";
+    postId?: string | null;
+    collectionId?: string | null;
+    redirectToPath?: string | null;
+    redirectType?: 301 | 302 | null;
+    archiveQuery?: string | null;
+  },
+) {
+  const ts = now();
+  sqlite
+    .prepare(
+      `INSERT INTO path_registry (
+        id, site_id, path, kind, post_id, collection_id, redirect_to_path,
+        redirect_type, archive_query, created_at, updated_at
+      )
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      input.id,
+      DEFAULT_TEST_SITE_ID,
+      input.path,
+      input.kind,
+      input.postId ?? null,
+      input.collectionId ?? null,
+      input.redirectToPath ?? null,
+      input.redirectType ?? null,
+      input.archiveQuery ?? null,
+      ts,
+      ts,
+    );
+}
 
 function insertTestCollection(
   sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
   id: string,
-  _slug: string,
+  slug: string,
   title: string,
 ) {
   const ts = now();
@@ -23,6 +62,51 @@ function insertTestCollection(
        VALUES (?, ?, ?, 'newest', ?, ?)`,
     )
     .run(id, DEFAULT_TEST_SITE_ID, title, ts, ts);
+  insertTestPath(sqlite, {
+    id: `pth_col_${id.slice(4)}`,
+    path: slug,
+    kind: "slug",
+    collectionId: id,
+  });
+}
+
+function insertTestPost(
+  sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
+  input: {
+    id: string;
+    slug: string;
+    title: string | null;
+    status?: "draft" | "published";
+    visibility?: "public" | "latest_hidden" | "private";
+  },
+) {
+  const ts = now();
+  sqlite
+    .prepare(
+      `INSERT INTO post (
+        id, site_id, format, status, visibility, title, thread_id,
+        published_at, last_activity_at, created_at, updated_at
+      )
+       VALUES (?, ?, 'note', ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      input.id,
+      DEFAULT_TEST_SITE_ID,
+      input.status ?? "published",
+      input.visibility ?? "latest_hidden",
+      input.title,
+      input.id,
+      ts,
+      ts,
+      ts,
+      ts,
+    );
+  insertTestPath(sqlite, {
+    id: `pth_pst_${input.id.slice(4)}`,
+    path: input.slug,
+    kind: "slug",
+    postId: input.id,
+  });
 }
 
 describe("NavItemService", () => {
@@ -277,6 +361,111 @@ describe("NavItemService", () => {
     });
   });
 
+  describe("listSuggestedLinks", () => {
+    it("suggests a published /about page as a normal link", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About me",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([
+        {
+          key: "about",
+          label: "About me",
+          url: "/about",
+          targetType: "page",
+          navItemType: "link",
+        },
+      ]);
+    });
+
+    it("suggests a canonical /now collection as a collection nav item", async () => {
+      insertTestCollection(sqlite, TEST_COLLECTION_ID, "now", "Now");
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([
+        {
+          key: "now",
+          label: "Now",
+          url: "/now",
+          targetType: "collection",
+          navItemType: "collection",
+          collectionId: TEST_COLLECTION_ID,
+        },
+      ]);
+    });
+
+    it("suggests a /now collection alias as a normal link to preserve the path", async () => {
+      insertTestCollection(sqlite, TEST_COLLECTION_ID, "updates", "Updates");
+      insertTestPath(sqlite, {
+        id: "pth_now_alias",
+        path: "now",
+        kind: "alias",
+        collectionId: TEST_COLLECTION_ID,
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([
+        {
+          key: "now",
+          label: "Updates",
+          url: "/now",
+          targetType: "collection",
+          navItemType: "link",
+        },
+      ]);
+    });
+
+    it("hides suggestions already represented by path or collection id", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+      });
+      insertTestCollection(sqlite, TEST_COLLECTION_ID, "now", "Now");
+
+      await navItemService.create({
+        type: "link",
+        label: "About",
+        url: "/about/",
+      });
+      await navItemService.create({
+        type: "collection",
+        collectionId: TEST_COLLECTION_ID,
+        label: "Now",
+        url: "/now",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([]);
+    });
+
+    it("does not suggest draft or private posts", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+        status: "draft",
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_2,
+        slug: "now",
+        title: "Now",
+        visibility: "private",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([]);
+    });
+  });
+
   describe("update", () => {
     it("updates a nav item's label", async () => {
       const created = await navItemService.create({

package/src/services/__tests__/post-timeline.test.ts

@@ -464,8 +464,86 @@ describe("PostService - Timeline features", () => {
     });
   });
 
+  describe("listCollectionThreadRootIds", () => {
+    it("bumps a hidden collection thread when a non-quiet reply is published", async () => {
+      const collection = await collectionService.create({
+        slug: "thinking",
+        title: "Thinking",
+      });
+      const hiddenRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Hidden root",
+        visibility: "latest_hidden",
+        publishedAt: 1000,
+      });
+      const newerRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Newer root",
+        publishedAt: 2000,
+      });
+
+      await collectionService.addPost(collection.id, hiddenRoot.id);
+      await collectionService.addPost(collection.id, newerRoot.id);
+
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Normal reply",
+        replyToId: hiddenRoot.id,
+        publishedAt: 3000,
+      });
+
+      const rootIds = await postService.listCollectionThreadRootIds(
+        collection.id,
+        {
+          status: "published",
+          sortOrder: "newest",
+        },
+      );
+
+      expect(rootIds).toEqual([hiddenRoot.id, newerRoot.id]);
+    });
+
+    it("does not bump a collection thread when a reply is quiet", async () => {
+      const collection = await collectionService.create({
+        slug: "quiet",
+        title: "Quiet",
+      });
+      const olderRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Older root",
+        publishedAt: 1000,
+      });
+      const newerRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Newer root",
+        publishedAt: 2000,
+      });
+
+      await collectionService.addPost(collection.id, olderRoot.id);
+      await collectionService.addPost(collection.id, newerRoot.id);
+
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Quiet reply",
+        replyToId: olderRoot.id,
+        publishedAt: 3000,
+        quietReply: true,
+      });
+
+      const rootIds = await postService.listCollectionThreadRootIds(
+        collection.id,
+        {
+          status: "published",
+          sortOrder: "newest",
+        },
+      );
+
+      expect(rootIds).toEqual([newerRoot.id, olderRoot.id]);
+    });
+  });
+
   describe("listCollectionFeedEntries", () => {
-    it("orders collection feeds by publishedAt and returns thread roots", async () => {
+    it("orders collection feeds by thread activity and returns thread roots", async () => {
       const collection = await collectionService.create({
         slug: "reading",
         title: "Reading",
@@ -565,11 +643,50 @@ describe("PostService - Timeline features", () => {
       );
 
       expect(entries).toHaveLength(2);
-      // Sorted by publishedAt DESC: secondRoot created last has latest publishedAt
       expect(entries[0]?.post.id).toBe(secondRoot.id);
       expect(entries[0]?.collectedAt).toBe(200);
       expect(entries[1]?.post.id).toBe(sharedRoot.id);
       expect(entries[1]?.collectedAt).toBe(300);
     });
+
+    it("orders collection feeds by thread activity from non-quiet replies", async () => {
+      const collection = await collectionService.create({
+        slug: "activity",
+        title: "Activity",
+      });
+      const hiddenRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Hidden root",
+        visibility: "latest_hidden",
+        publishedAt: 1000,
+      });
+      const newerRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Newer root",
+        publishedAt: 2000,
+      });
+
+      await collectionService.addPost(collection.id, hiddenRoot.id);
+      await collectionService.addPost(collection.id, newerRoot.id);
+
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Normal reply",
+        replyToId: hiddenRoot.id,
+        publishedAt: 3000,
+      });
+
+      const entries = await postService.listCollectionFeedEntries(
+        collection.id,
+        {
+          status: "published",
+        },
+      );
+
+      expect(entries.map((entry) => entry.post.id)).toEqual([
+        hiddenRoot.id,
+        newerRoot.id,
+      ]);
+    });
   });
 });

package/src/services/about-page.ts

@@ -0,0 +1,143 @@
+/**
+ * About Page Service
+ *
+ * Treats `/about` as the standard site About page. The page itself remains a
+ * normal post; this service reads that convention and can create the page when
+ * the author follows the settings prompt.
+ */
+
+import { ValidationError } from "../lib/errors.js";
+import type { Visibility } from "../types.js";
+import type { CollectionService } from "./collection.js";
+import type { PathService } from "./path.js";
+import type { PostService } from "./post.js";
+
+export const ABOUT_PAGE_PATH = "/about";
+export const ABOUT_PAGE_SLUG = "about";
+
+export type AboutPageStatus =
+  | {
+      state: "missing";
+      path: typeof ABOUT_PAGE_PATH;
+    }
+  | {
+      state: "ready";
+      path: typeof ABOUT_PAGE_PATH;
+      post: {
+        id: string;
+        title: string | null;
+        status: "draft" | "published";
+        visibility: Visibility;
+      };
+    }
+  | {
+      state: "conflict";
+      path: typeof ABOUT_PAGE_PATH;
+      conflict: {
+        targetType: "collection" | "redirect" | "archive" | "post";
+        id: string | null;
+        title: string | null;
+      };
+    };
+
+export interface AboutPageService {
+  getStatus(): Promise<AboutPageStatus>;
+  ensurePage(): Promise<Extract<AboutPageStatus, { state: "ready" }>["post"]>;
+}
+
+export function createAboutPageService(deps: {
+  paths: PathService;
+  posts: PostService;
+  collections: CollectionService;
+}): AboutPageService {
+  async function readStatus(): Promise<AboutPageStatus> {
+    const resolved = await deps.paths.resolve(ABOUT_PAGE_SLUG);
+    const base = {
+      path: ABOUT_PAGE_PATH,
+    } as const;
+
+    if (!resolved) {
+      return { ...base, state: "missing" };
+    }
+
+    if (resolved.targetType === "post" && resolved.postId) {
+      const post = await deps.posts.getById(resolved.postId);
+      if (!post) {
+        return {
+          ...base,
+          state: "conflict",
+          conflict: {
+            targetType: "post",
+            id: resolved.postId,
+            title: null,
+          },
+        };
+      }
+
+      return {
+        ...base,
+        state: "ready",
+        post: {
+          id: post.id,
+          title: post.title,
+          status: post.status,
+          visibility: post.visibility,
+        },
+      };
+    }
+
+    if (resolved.targetType === "collection" && resolved.collectionId) {
+      const collection = await deps.collections.getById(resolved.collectionId);
+      return {
+        ...base,
+        state: "conflict",
+        conflict: {
+          targetType: "collection",
+          id: resolved.collectionId,
+          title: collection?.title ?? null,
+        },
+      };
+    }
+
+    return {
+      ...base,
+      state: "conflict",
+      conflict: {
+        targetType: resolved.targetType,
+        id: null,
+        title: null,
+      },
+    };
+  }
+
+  return {
+    getStatus: readStatus,
+
+    async ensurePage() {
+      const status = await readStatus();
+      if (status.state === "ready") {
+        return status.post;
+      }
+
+      if (status.state === "conflict") {
+        throw new ValidationError(
+          "/about is already used. Rename that item before creating an About page.",
+        );
+      }
+
+      const post = await deps.posts.create({
+        format: "note",
+        title: "About",
+        slug: ABOUT_PAGE_SLUG,
+        status: "published",
+        visibility: "latest_hidden",
+      });
+      return {
+        id: post.id,
+        title: post.title,
+        status: post.status,
+        visibility: post.visibility,
+      };
+    },
+  };
+}

package/src/services/export-theme/layouts/_default/rss.xml

@@ -23,7 +23,8 @@
         body    → Hugo-rendered .Content (stripped of <script>/<style>)
         rating  → <p>★★★★☆ 4/5</p>
         link    → trailing <p><a href=permalink> ★ </a></p>
-        replies → <hr/> + <p><small><time>{dt}</time></small></p> + content
+        replies → <hr/> + <p><small><time>{dt}</time></small></p>
+                  + inline title/link metadata + content
 
   Hugo's default RSS media-type override (`[outputFormats.RSS]`) makes this
   template produce application/atom+xml at /{section}/index.xml.

package/src/services/export-theme/layouts/partials/feed-post-content.xml

@@ -8,6 +8,8 @@
                      link-format "★" suffix)
     includeReplies — when true, appends each public reply separated by
                      <hr/> + <small><time></time></small>
+    inline         — when true, renders title/link metadata that top-level
+                     Atom entries expose through their entry fields
 
   Output is raw HTML suitable for embedding inside Atom
   <content type="html"><![CDATA[...]]></content>. Since CDATA ends at the
@@ -18,9 +20,31 @@
 {{- $post := .post -}}
 {{- $permalink := .permalink -}}
 {{- $includeReplies := .includeReplies -}}
+{{- $inline := false -}}
+{{- with .inline -}}{{- $inline = . -}}{{- end -}}
 {{- $format := $post.Params.format | default "note" -}}
 {{- $parts := slice -}}
 
+{{- /* --- Inline title/link metadata for thread replies --- */ -}}
+{{- if and $inline (ne $format "quote") -}}
+  {{- $title := $post.Title | default "" -}}
+  {{- $linkUrl := string ($post.Params.link_url | default "") -}}
+  {{- if eq $format "link" -}}
+    {{- if ne $linkUrl "" -}}
+      {{- $domain := $linkUrl -}}
+      {{- with urls.Parse $linkUrl -}}{{- if .Host -}}{{- $domain = replaceRE `^(www|m|mobile)\.` "" .Host -}}{{- end -}}{{- end -}}
+      {{- $parts = $parts | append (printf `<p><a href=%q>%s</a></p>` $linkUrl (transform.XMLEscape $domain)) -}}
+    {{- end -}}
+    {{- if ne $title "" -}}
+      {{- $titleHref := $permalink -}}
+      {{- if ne $linkUrl "" -}}{{- $titleHref = $linkUrl -}}{{- end -}}
+      {{- $parts = $parts | append (printf `<h2><a href=%q>%s</a></h2>` $titleHref (transform.XMLEscape $title)) -}}
+    {{- end -}}
+  {{- else if ne $title "" -}}
+    {{- $parts = $parts | append (printf `<h2><a href=%q>%s</a></h2>` $permalink (transform.XMLEscape $title)) -}}
+  {{- end -}}
+{{- end -}}
+
 {{- /* --- Quote block (format=quote) --- */ -}}
 {{- if eq $format "quote" -}}
   {{- $quoteText := string ($post.Params.quote_text | default "") -}}
@@ -100,7 +124,7 @@
     {{- $replyLabel := .Date.Format "Jan 2, 2006 15:04" -}}
     {{- $parts = $parts | append "<hr/>" -}}
     {{- $parts = $parts | append (printf `<p><small><time datetime=%q>%s</time></small></p>` $replyDatetime (transform.XMLEscape $replyLabel)) -}}
-    {{- $parts = $parts | append (partial "feed-post-content.xml" (dict "post" . "permalink" $replyPermalink "includeReplies" false)) -}}
+    {{- $parts = $parts | append (partial "feed-post-content.xml" (dict "post" . "permalink" $replyPermalink "includeReplies" false "inline" true)) -}}
   {{- end -}}
 {{- end -}}
 

package/src/services/export-theme/styles/main.css

@@ -84,13 +84,11 @@ h1 {
 
 h2 {
   font-size: var(--type-content-title);
-  font-style: italic;
   margin: 2.1rem 0 1.4rem;
 }
 
 h3 {
   font-size: var(--type-content-subtitle);
-  font-style: italic;
   margin: 2rem 0 1.4rem;
 }
 
@@ -119,6 +117,12 @@ kbd,
 samp {
   font-family: var(--font-mono);
   font-size: var(--type-code);
+  line-height: 1.42;
+}
+
+code {
+  color: var(--site-code-text);
+  overflow-wrap: break-word;
 }
 
 pre {
@@ -127,23 +131,26 @@ pre {
   line-height: 1.5;
   padding: 1rem;
   overflow-x: auto;
-  background-color: var(--site-feed-card-bg);
-  border: 1px solid var(--site-feed-card-border);
-  border-radius: 0.375rem;
+  color: var(--site-code-text);
+  background-color: var(--site-code-block-bg);
+  border: 1px solid var(--site-code-block-border);
+  border-radius: 6px;
 }
 
 pre code {
   padding: 0;
   background: transparent;
   border: 0;
+  color: inherit;
   font-size: inherit;
 }
 
 :not(pre) > code {
-  padding: 0.1em 0.35em;
-  background-color: var(--site-feed-card-bg);
-  border: 1px solid var(--site-feed-card-border);
-  border-radius: 0.25rem;
+  padding: 0.08em 0.28em;
+  background-color: var(--site-code-bg);
+  border-radius: 0.22em;
+  box-decoration-break: clone;
+  -webkit-box-decoration-break: clone;
 }
 
 /* Blockquotes — tinted background card with quote icon (matches main site). */
@@ -217,13 +224,13 @@ blockquote cite {
 
 ul,
 ol {
-  padding-left: 1.625em;
+  padding-left: 1.4em;
   margin: 1.25em 0;
 }
 
 li {
-  margin-top: 1.2em;
-  margin-bottom: 1.2em;
+  margin-top: 0.65em;
+  margin-bottom: 0.65em;
 }
 
 /* Normalize li > p so list spacing is controlled by li alone,
@@ -850,6 +857,31 @@ hr.feed-divider {
   color: var(--site-reading-body);
 }
 
+.post-card > .post-card-summary :is(h1, h2),
+.post-card > .post-card-quote-commentary :is(h1, h2) {
+  font-size: calc(var(--type-content-body) * 1.12);
+  font-weight: var(--fw-medium);
+  margin-top: 1.45rem;
+  margin-bottom: 0.55rem;
+}
+
+.post-card > .post-card-summary :is(h3, h4),
+.post-card > .post-card-quote-commentary :is(h3, h4) {
+  font-size: var(--type-content-body);
+  font-weight: var(--fw-medium);
+  margin-top: 1.2rem;
+  margin-bottom: 0.45rem;
+}
+
+.post-card > .post-card-summary :is(h5, h6),
+.post-card > .post-card-quote-commentary :is(h5, h6) {
+  font-size: var(--type-secondary);
+  font-weight: var(--fw-medium);
+  color: var(--site-text-secondary);
+  margin-top: 1rem;
+  margin-bottom: 0.35rem;
+}
+
 /* Link card domain row — shown ABOVE the title (matches main site's
    `.feed-link-domain` pattern). Inline flex with icon + host text. */
 .post-card-link-domain,
@@ -1009,8 +1041,8 @@ hr.feed-divider {
 .post-card-quote-content {
   font-family: var(--font-serif);
   color: var(--site-text-primary);
-  font-size: var(--type-content-subtitle);
-  line-height: var(--type-heading-leading);
+  font-size: var(--type-content-quote);
+  line-height: var(--type-content-quote-leading);
   white-space: pre-line;
   text-wrap: pretty;
   margin: 0;