@jant/core 0.3.39 → 0.3.40

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

@@ -561,7 +561,7 @@ describe("Timeline data assembly", () => {
     ]);
 
     const result = await assembleCollectionTimeline(createTimelineContext(), {
-      collectionId: collection.id,
+      collectionIds: [collection.id],
       isAuthenticated: true,
       sortOrder: "newest",
     });
@@ -611,7 +611,7 @@ describe("Timeline data assembly", () => {
     });
 
     const result = await assembleCollectionTimeline(createTimelineContext(), {
-      collectionId: collection.id,
+      collectionIds: [collection.id],
       isAuthenticated: true,
       sortOrder: "newest",
     });
@@ -635,6 +635,88 @@ describe("Timeline data assembly", () => {
     );
   });
 
+  it("highlights the union of collected posts across multiple collections", async () => {
+    const smart = await collectionService.create({
+      slug: "smart",
+      title: "Smart",
+    });
+    const movies = await collectionService.create({
+      slug: "movies",
+      title: "Movies",
+    });
+    const firstRoot = await postService.create({
+      format: "note",
+      bodyMarkdown: "Thread root",
+    });
+    const smartReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Smart reply",
+      replyToId: firstRoot.id,
+    });
+    await postService.create({
+      format: "note",
+      bodyMarkdown: "Hidden middle reply",
+      replyToId: firstRoot.id,
+    });
+    const movieReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Movie reply",
+      replyToId: firstRoot.id,
+    });
+    const secondRoot = await postService.create({
+      format: "note",
+      bodyMarkdown: "Second thread root",
+    });
+
+    await db.insert(postCollections).values([
+      {
+        siteId: DEFAULT_TEST_SITE_ID,
+        postId: smartReply.id,
+        collectionId: smart.id,
+        createdAt: 100,
+      },
+      {
+        siteId: DEFAULT_TEST_SITE_ID,
+        postId: movieReply.id,
+        collectionId: movies.id,
+        createdAt: 200,
+      },
+      {
+        siteId: DEFAULT_TEST_SITE_ID,
+        postId: secondRoot.id,
+        collectionId: movies.id,
+        createdAt: 300,
+      },
+    ]);
+
+    const result = await assembleCollectionTimeline(createTimelineContext(), {
+      collectionIds: [smart.id, movies.id],
+      isAuthenticated: true,
+      sortOrder: "newest",
+    });
+
+    expect(result.items).toHaveLength(2);
+    expect(result.items[0]?.post.id).toBe(secondRoot.id);
+    expect(result.items[1]?.post.id).toBe(firstRoot.id);
+    expect(result.items[1]?.curatedThread?.segments).toEqual([
+      expect.objectContaining({
+        post: expect.objectContaining({ id: firstRoot.id }),
+        hiddenBeforeCount: 0,
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: smartReply.id }),
+        hiddenBeforeCount: 0,
+        highlighted: true,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: movieReply.id }),
+        hiddenBeforeCount: 1,
+        highlighted: true,
+      }),
+    ]);
+  });
+
   it("omits private timeline items from unauthenticated partial refreshes", async () => {
     const root = await postService.create({
       format: "note",

package/src/lib/collection-groups.ts

@@ -0,0 +1,69 @@
+/**
+ * Helpers for deriving aggregate collection groups from divider sections.
+ */
+
+export interface GroupableCollectionItem {
+  type: "collection" | "divider";
+  label?: string | null;
+  collection?: {
+    slug: string;
+  };
+}
+
+export interface DividerCollectionGroup {
+  slugExpression: string;
+  collectionCount: number;
+}
+
+/**
+ * Returns the aggregate collection selection that belongs to a divider.
+ *
+ * A divider maps to the consecutive collection items that follow it until the
+ * next divider. Groups with fewer than two collections do not produce an
+ * aggregate selection.
+ *
+ * @param items - Ordered collection directory items
+ * @param dividerIndex - Index of the divider item to inspect
+ * @returns Aggregate slug expression and count, or `null`
+ *
+ * @example
+ * ```ts
+ * getDividerCollectionGroup(
+ *   [
+ *     { type: "divider", label: "Reading" },
+ *     { type: "collection", collection: { slug: "books" } },
+ *     { type: "collection", collection: { slug: "essays" } },
+ *   ],
+ *   0,
+ * );
+ * ```
+ */
+export function getDividerCollectionGroup(
+  items: readonly GroupableCollectionItem[],
+  dividerIndex: number,
+): DividerCollectionGroup | null {
+  const divider = items[dividerIndex];
+  if (!divider || divider.type !== "divider" || !divider.label) {
+    return null;
+  }
+
+  const slugs: string[] = [];
+
+  for (let index = dividerIndex + 1; index < items.length; index += 1) {
+    const item = items[index];
+    if (!item) break;
+    if (item.type === "divider") break;
+    const slug = item.collection?.slug;
+    if (!slug) continue;
+    slugs.push(slug);
+  }
+
+  if (slugs.length < 2) {
+    return null;
+  }
+
+  return {
+    slugExpression: slugs.join("+"),
+    collectionCount: slugs.length,
+  };
+}

package/src/lib/constants.ts

@@ -32,6 +32,16 @@ export const RESERVED_PATHS = [
 
 export type ReservedPath = (typeof RESERVED_PATHS)[number];
 
+/**
+ * Reserved collection slugs within the `/c/*` namespace.
+ *
+ * These values are valid top-level paths elsewhere but are unavailable as
+ * collection slugs because they collide with dedicated collection routes.
+ */
+export const RESERVED_COLLECTION_SLUGS = ["new"] as const;
+
+export type ReservedCollectionSlug = (typeof RESERVED_COLLECTION_SLUGS)[number];
+
 /**
  * Check if a path is reserved
  */
@@ -40,6 +50,16 @@ export function isReservedPath(path: string): boolean {
   return RESERVED_PATHS.includes(firstSegment as ReservedPath);
 }
 
+/**
+ * Check if a collection slug is reserved within the collection namespace.
+ */
+export function isReservedCollectionSlug(slug: string): boolean {
+  const normalized = slug.trim().toLowerCase();
+  return RESERVED_COLLECTION_SLUGS.includes(
+    normalized as ReservedCollectionSlug,
+  );
+}
+
 /**
  * Settings keys - derived from CONFIG_FIELDS (Single Source of Truth)
  *

package/src/lib/schemas.ts

@@ -30,6 +30,7 @@ import {
 import { ValidationError } from "./errors.js";
 import { createTypeIdSchema, ID_PREFIX } from "./ids.js";
 import { normalizeSlug } from "./slug-format.js";
+import { isReservedCollectionSlug } from "./constants.js";
 import { sanitizeUrl, normalizePath } from "./url.js";
 
 // =============================================================================
@@ -459,6 +460,9 @@ export const CollectionSlugSchema = z
   .max(MAX_COLLECTION_SLUG_LENGTH, {
     message: `Keep this link under ${MAX_COLLECTION_SLUG_LENGTH} characters.`,
   })
+  .refine((value) => !value.includes("+"), {
+    message: "Use lowercase letters, numbers, and hyphens only.",
+  })
   .transform(normalizeSlug)
   .pipe(
     z
@@ -467,7 +471,10 @@ export const CollectionSlugSchema = z
       .max(MAX_COLLECTION_SLUG_LENGTH, {
         message: `Keep this link under ${MAX_COLLECTION_SLUG_LENGTH} characters.`,
       })
-      .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/),
+      .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/)
+      .refine((value) => !isReservedCollectionSlug(value), {
+        message: "This link is reserved. Choose something else.",
+      }),
   );
 
 export const CollectionTitleSchema = sanitizeText(

package/src/lib/slug-format.ts

@@ -15,6 +15,7 @@ export type SlugValidationIssue = "invalid" | "reserved" | "too_long";
 
 interface SlugValidationOptions {
   maxLength?: number;
+  additionalReservedValues?: readonly string[];
 }
 
 /**
@@ -67,6 +68,13 @@ export function getSlugValidationIssue(
   if (options.maxLength && slug.length > options.maxLength) return "too_long";
   if (!SLUG_PATTERN.test(slug)) return "invalid";
   if (isReservedPath(slug)) return "reserved";
+  if (
+    options.additionalReservedValues?.some(
+      (value) => value.toLowerCase() === slug.toLowerCase(),
+    )
+  ) {
+    return "reserved";
+  }
   return null;
 }
 

package/src/lib/timeline.ts

@@ -26,6 +26,7 @@ export interface TimelineResult {
   items: TimelineItemView[];
   currentPage: number;
   totalPages: number;
+  totalCount: number;
 }
 
 type CuratedThreadSelectionMap = Map<string, Set<string>>;
@@ -299,8 +300,8 @@ async function buildCuratedThreadItems(
  *
  * @example
  * ```ts
- * const { items, currentPage, totalPages } = await assembleTimeline(c);
- * const { items, currentPage, totalPages } = await assembleTimeline(c, { page: 2 });
+ * const { items, currentPage, totalPages, totalCount } = await assembleTimeline(c);
+ * const { items, currentPage, totalPages, totalCount } = await assembleTimeline(c, { page: 2 });
  * ```
  */
 export async function assembleTimeline(
@@ -334,12 +335,12 @@ export async function assembleTimeline(
   const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
 
   if (posts.length === 0) {
-    return { items: [], currentPage: page, totalPages };
+    return { items: [], currentPage: page, totalPages, totalCount };
   }
 
   const items = await buildTimelineItems(c, posts);
 
-  return { items, currentPage: page, totalPages };
+  return { items, currentPage: page, totalPages, totalCount };
 }
 
 /**
@@ -407,7 +408,7 @@ export async function assembleFeaturedTimeline(
   const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
 
   if (rootIds.length === 0) {
-    return { items: [], currentPage: page, totalPages };
+    return { items: [], currentPage: page, totalPages, totalCount };
   }
 
   const threadsByRootId =
@@ -431,7 +432,7 @@ export async function assembleFeaturedTimeline(
     selectedPostIdsByThread,
   );
 
-  return { items, currentPage: page, totalPages };
+  return { items, currentPage: page, totalPages, totalCount };
 }
 
 /**
@@ -442,13 +443,13 @@ export async function assembleFeaturedTimeline(
  * expanded and intervening non-collected posts collapse into hidden-count gaps.
  *
  * @param c - Hono context (provides services + appConfig)
- * @param options - Collection ID, optional page number, auth state, and sort
+ * @param options - Collection IDs, optional page number, auth state, and sort
  * @returns Collection timeline items with pagination info
  */
 export async function assembleCollectionTimeline(
   c: Context<Env>,
   options: {
-    collectionId: string;
+    collectionIds: string[];
     page?: number;
     isAuthenticated?: boolean;
     sortOrder?: CollectionSortOrder;
@@ -460,29 +461,35 @@ export async function assembleCollectionTimeline(
   const excludePrivate = !(options.isAuthenticated ?? false);
 
   const [totalCount, rootIds] = await Promise.all([
-    c.var.services.posts.countCollectionThreadRoots(options.collectionId, {
-      status: "published",
-      excludePrivate,
-    }),
-    c.var.services.posts.listCollectionThreadRootIds(options.collectionId, {
-      status: "published",
-      excludePrivate,
-      sortOrder: options.sortOrder,
-      limit: pageSize,
-      offset,
-    }),
+    c.var.services.posts.countCollectionThreadRootsForCollections(
+      options.collectionIds,
+      {
+        status: "published",
+        excludePrivate,
+      },
+    ),
+    c.var.services.posts.listCollectionThreadRootIdsForCollections(
+      options.collectionIds,
+      {
+        status: "published",
+        excludePrivate,
+        sortOrder: options.sortOrder,
+        limit: pageSize,
+        offset,
+      },
+    ),
   ]);
 
   const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
 
   if (rootIds.length === 0) {
-    return { items: [], currentPage: page, totalPages };
+    return { items: [], currentPage: page, totalPages, totalCount };
   }
 
   const [threadsByRootId, collectedPostIdsByThread] = await Promise.all([
     c.var.services.posts.getPublishedThreads(rootIds),
-    c.var.services.posts.getCollectionPostIdsByThread(
-      options.collectionId,
+    c.var.services.posts.getCollectionPostIdsByThreadForCollections(
+      options.collectionIds,
       rootIds,
     ),
   ]);
@@ -499,5 +506,5 @@ export async function assembleCollectionTimeline(
     selectedPostIdsByThread,
   );
 
-  return { items, currentPage: page, totalPages };
+  return { items, currentPage: page, totalPages, totalCount };
 }

package/src/routes/pages/collection.tsx

@@ -28,6 +28,16 @@ type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const collectionRoutes = new Hono<Env>();
 
+function buildCollectionSelectionTitle(
+  collections: { title: string }[],
+): string {
+  return collections.map((collection) => collection.title).join(" + ");
+}
+
+function getCanonicalSelectionPath(slugExpression: string): string {
+  return `/c/${slugExpression}`;
+}
+
 function resolveReturnHref(
   value: string | undefined,
   fallback: string,
@@ -73,38 +83,53 @@ collectionRoutes.get("/:slug/edit", async (c) => {
 });
 
 collectionRoutes.get("/:slug", async (c) => {
-  const slug = c.req.param("slug");
+  const slugExpression = c.req.param("slug");
   const page = parsePageNumber(c.req.query("page"));
   const paginatedPageTitle = formatPageLabel(page);
 
-  // Start navData + collection fetch in parallel
-  const [collection, navData] = await Promise.all([
-    c.var.services.collections.getBySlug(slug),
+  const [selection, navData] = await Promise.all([
+    c.var.services.collections.resolveSelection(slugExpression),
     getNavigationData(c),
   ]);
-  if (!collection) return c.notFound();
+  if (!selection) return c.notFound();
+
+  const canonicalPagePath = getCanonicalSelectionPath(selection.slugExpression);
+  if (slugExpression !== selection.slugExpression) {
+    const search = new URL(c.req.url).search;
+    return c.redirect(
+      toPublicPath(`${canonicalPagePath}${search}`, navData.sitePathPrefix),
+      301,
+    );
+  }
+
   const sortQuery = c.req.query("sort");
   const requestedSort =
     sortQuery && CollectionSortOrderSchema.safeParse(sortQuery).success
       ? CollectionSortOrderSchema.parse(sortQuery)
       : undefined;
+  const primaryCollection = selection.collections[0];
+  if (!primaryCollection) return c.notFound();
+  const collectionIds = selection.collections.map(
+    (collection) => collection.id,
+  );
+  const isAggregate = selection.collections.length > 1;
 
-  const [totalThreadCount, ratedPostCount] = await Promise.all([
-    c.var.services.posts.countCollectionThreadRoots(collection.id, {
-      status: "published",
-      excludePrivate: !navData.isAuthenticated,
-    }),
-    c.var.services.posts.count({
-      collectionId: collection.id,
+  const ratedPostCount = await c.var.services.posts.countUpTo(
+    {
+      collectionIds,
       status: "published",
       excludePrivate: !navData.isAuthenticated,
       hasRating: true,
-    }),
-  ]);
+    },
+    2,
+  );
   const showRatingSort = supportsCollectionRatingSort(ratedPostCount);
+  const requestedDefaultSort = isAggregate
+    ? "newest"
+    : primaryCollection.sortOrder;
   const defaultSort = resolveCollectionSortOrder(
     undefined,
-    collection.sortOrder,
+    requestedDefaultSort,
     showRatingSort,
   );
   const currentSort = resolveCollectionSortOrder(
@@ -113,32 +138,40 @@ collectionRoutes.get("/:slug", async (c) => {
     showRatingSort,
   );
 
-  const { items, totalPages } = await assembleCollectionTimeline(c, {
-    collectionId: collection.id,
+  const {
+    items,
+    totalCount: totalThreadCount,
+    totalPages,
+  } = await assembleCollectionTimeline(c, {
+    collectionIds,
     page,
     isAuthenticated: navData.isAuthenticated,
     sortOrder: currentSort,
   });
+  const selectionTitle = buildCollectionSelectionTitle(selection.collections);
 
   return renderPublicPage(c, {
     title:
       page > 1
-        ? buildPageTitle(collection.title, paginatedPageTitle, navData.siteName)
-        : buildPageTitle(collection.title, navData.siteName),
-    description: collection.description ?? undefined,
+        ? buildPageTitle(selectionTitle, paginatedPageTitle, navData.siteName)
+        : buildPageTitle(selectionTitle, navData.siteName),
+    description: isAggregate
+      ? undefined
+      : (primaryCollection.description ?? undefined),
     navData,
     content: (
       <CollectionPage
-        collection={collection}
+        collections={selection.collections}
         items={items}
         totalThreadCount={totalThreadCount}
         currentPage={page}
         totalPages={totalPages}
+        pagePath={canonicalPagePath}
         baseUrl={
           currentSort === defaultSort
-            ? toPublicPath(`/c/${collection.slug}`, navData.sitePathPrefix)
+            ? toPublicPath(canonicalPagePath, navData.sitePathPrefix)
             : toPublicPath(
-                `/c/${collection.slug}?sort=${currentSort}`,
+                `${canonicalPagePath}?sort=${currentSort}`,
                 navData.sitePathPrefix,
               )
         }
@@ -154,25 +187,40 @@ collectionRoutes.get("/:slug", async (c) => {
 
 // Collection RSS feed
 collectionRoutes.get("/:slug/feed", async (c) => {
-  const slug = c.req.param("slug");
+  const slugExpression = c.req.param("slug");
 
-  const collection = await c.var.services.collections.getBySlug(slug);
-  if (!collection) return c.notFound();
+  const selection =
+    await c.var.services.collections.resolveSelection(slugExpression);
+  if (!selection) return c.notFound();
+
+  if (slugExpression !== selection.slugExpression) {
+    const search = new URL(c.req.url).search;
+    return c.redirect(
+      toPublicPath(
+        `${getCanonicalSelectionPath(selection.slugExpression)}/feed${search}`,
+        c.var.appConfig.sitePathPrefix,
+      ),
+      301,
+    );
+  }
 
   const { appConfig } = c.var;
   const siteName = appConfig.siteName;
   const siteUrl = appConfig.siteUrl;
   const siteLanguage = appConfig.siteLanguage;
   const feedLimit = appConfig.rssFeedLimit;
+  const primaryCollection = selection.collections[0];
+  if (!primaryCollection) return c.notFound();
 
-  const entries = await c.var.services.posts.listCollectionFeedEntries(
-    collection.id,
-    {
-      status: "published",
-      excludePrivate: true,
-      limit: feedLimit,
-    },
-  );
+  const entries =
+    await c.var.services.posts.listCollectionFeedEntriesForCollections(
+      selection.collections.map((collection) => collection.id),
+      {
+        status: "published",
+        excludePrivate: true,
+        limit: feedLimit,
+      },
+    );
   const posts = entries.map((entry) => entry.post);
 
   // Batch load media for enclosures
@@ -205,13 +253,17 @@ collectionRoutes.get("/:slug/feed", async (c) => {
       feedUpdatedAt: feedTimestamp,
     };
   });
+  const selectionTitle = buildCollectionSelectionTitle(selection.collections);
 
   const xml = defaultRssRenderer({
-    siteName: buildPageTitle(collection.title, siteName),
-    siteDescription: collection.description ?? "",
+    siteName: buildPageTitle(selectionTitle, siteName),
+    siteDescription:
+      selection.collections.length === 1
+        ? (primaryCollection.description ?? "")
+        : "",
     siteUrl,
     selfUrl: toAbsoluteSiteUrl(
-      `/c/${collection.slug}/feed`,
+      `${getCanonicalSelectionPath(selection.slugExpression)}/feed`,
       siteUrl,
       appConfig.sitePathPrefix,
     ),

package/src/runtime/__tests__/readiness.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { getInstanceReadiness } from "../readiness.js";
+
+const HOSTED_SHARED_ENV = {
+  HOSTED_CONTROL_PLANE_BASE_URL: "https://cloud-jant.localtest.me",
+  HOSTED_CONTROL_PLANE_DOMAIN_CHECK_SECRET:
+    "cloud-domain-check-secret-cloud-domain-check-secret",
+  HOSTED_CONTROL_PLANE_INTERNAL_TOKEN: "internal-token-123456",
+  HOSTED_CONTROL_PLANE_SSO_SECRET: "cloud-sso-secret-cloud-sso-secret",
+  INTERNAL_ADMIN_TOKEN: "internal-admin-token-123456",
+  SITE_RESOLUTION_MODE: "host-based" as const,
+};
+
+describe("getInstanceReadiness", () => {
+  it("reports ready when startup config and database checks pass", async () => {
+    const { sqlite } = createTestDatabase();
+
+    await expect(
+      getInstanceReadiness({
+        ...HOSTED_SHARED_ENV,
+        AUTH_SECRET: "test-secret-with-enough-entropy-for-readiness",
+        NODE_SQLITE: sqlite,
+      }),
+    ).resolves.toEqual({
+      status: "ok",
+      checks: {
+        startupConfig: { ok: true },
+        database: { ok: true },
+      },
+    });
+  });
+
+  it("reports startup configuration failures", async () => {
+    const { sqlite } = createTestDatabase();
+
+    await expect(
+      getInstanceReadiness({
+        NODE_SQLITE: sqlite,
+      }),
+    ).resolves.toEqual({
+      status: "error",
+      checks: {
+        startupConfig: {
+          ok: false,
+          error: "AUTH_SECRET must be set before Jant can accept traffic.",
+        },
+        database: { ok: true },
+      },
+    });
+  });
+
+  it("reports host-based startup issues when required env is missing", async () => {
+    const { sqlite } = createTestDatabase();
+
+    const result = await getInstanceReadiness({
+      AUTH_SECRET: "test-secret-with-enough-entropy-for-readiness",
+      NODE_SQLITE: sqlite,
+      SITE_RESOLUTION_MODE: "host-based",
+    });
+
+    expect(result.status).toBe("error");
+    expect(result.checks.database).toEqual({ ok: true });
+    expect(result.checks.startupConfig.ok).toBe(false);
+    expect(result.checks.startupConfig.error).toContain(
+      "HOSTED_CONTROL_PLANE_BASE_URL",
+    );
+    expect(result.checks.startupConfig.error).toContain(
+      "HOSTED_CONTROL_PLANE_INTERNAL_TOKEN",
+    );
+  });
+
+  it("reports a missing database binding", async () => {
+    await expect(
+      getInstanceReadiness({
+        AUTH_SECRET: "test-secret-with-enough-entropy-for-readiness",
+      }),
+    ).resolves.toEqual({
+      status: "error",
+      checks: {
+        startupConfig: { ok: true },
+        database: {
+          ok: false,
+          error: "No database binding is configured for this runtime.",
+        },
+      },
+    });
+  });
+});