@jant/core 0.3.40 → 1.0.0

package/src/lib/resolve-config.ts

@@ -12,7 +12,7 @@
 import type { Bindings } from "../types/bindings.js";
 import type { AppConfig } from "../types/config.js";
 import { CONFIG_FIELDS } from "../types/config.js";
-import { getPublicAssetBasePath } from "./asset-path.js";
+import { ASSET_BASE_SEGMENT, getPublicAssetBasePath } from "./asset-path.js";
 import {
   getAuthSecret,
   getConfiguredSingleSiteUrl,
@@ -142,15 +142,9 @@ export function resolveConfig(
     siteDescription: resolve("SITE_DESCRIPTION", allSettings, env),
     siteDescriptionExplicit,
     siteLanguage: resolve("SITE_LANGUAGE", allSettings, env),
+    cjkSerifFont: resolve("CJK_SERIF_FONT", allSettings, env),
     homeDefaultView: resolve("HOME_DEFAULT_VIEW", allSettings, env),
     mainRssFeed: resolve("MAIN_RSS_FEED", allSettings, env),
-    headerNavMaxVisible: (() => {
-      const parsed = parseInt(
-        resolve("HEADER_NAV_MAX_VISIBLE", allSettings, env),
-        10,
-      );
-      return Math.max(0, Math.min(5, isNaN(parsed) ? 2 : parsed));
-    })(),
     timeZone: normalizeTimeZone(resolve("TIME_ZONE", allSettings, env)),
     siteFooter: resolve("SITE_FOOTER", allSettings, env),
     showJantBrandingOnHome:
@@ -161,7 +155,14 @@ export function resolveConfig(
     siteUrl,
     siteOrigin,
     sitePathPrefix,
-    assetBasePath: getPublicAssetBasePath(sitePathPrefix),
+    assetBasePath: (() => {
+      const assetBaseUrl = (getEnvString(env, "ASSET_BASE_URL") ?? "")
+        .trim()
+        .replace(/\/+$/, "");
+      return assetBaseUrl
+        ? `${assetBaseUrl}/${ASSET_BASE_SEGMENT}`
+        : getPublicAssetBasePath(sitePathPrefix);
+    })(),
     authConfigured: !!getAuthSecret(env),
 
     // Media (ENV only)
@@ -198,17 +199,28 @@ export function resolveConfig(
     demoMode,
 
     // Theme (DB internal)
-    themeId: allSettings["THEME"] ?? "",
+    themeId:
+      allSettings["THEME"] ||
+      getEnvString(env, "DEFAULT_THEME") ||
+      CONFIG_FIELDS.DEFAULT_THEME.defaultValue,
     defaultThemeId:
       getEnvString(env, "DEFAULT_THEME") ||
       CONFIG_FIELDS.DEFAULT_THEME.defaultValue,
-    fontThemeId: allSettings["FONT_THEME"] ?? "",
+    fontThemeId:
+      allSettings["FONT_THEME"] ||
+      getEnvString(env, "DEFAULT_FONT_THEME") ||
+      CONFIG_FIELDS.DEFAULT_FONT_THEME.defaultValue,
+    defaultFontThemeId:
+      getEnvString(env, "DEFAULT_FONT_THEME") ||
+      CONFIG_FIELDS.DEFAULT_FONT_THEME.defaultValue,
     themeMode:
       allSettings["THEME_MODE"] === "light" ||
       allSettings["THEME_MODE"] === "dark"
         ? allSettings["THEME_MODE"]
         : "auto",
     customCSS: allSettings["CUSTOM_CSS"] ?? "",
+    customHeadHtml: allSettings["CUSTOM_HEAD_HTML"] ?? "",
+    customBodyEndHtml: allSettings["CUSTOM_BODY_END_HTML"] ?? "",
 
     // Site appearance (DB internal)
     siteAvatar,

package/src/lib/rich-image.ts

@@ -0,0 +1,89 @@
+import { escapeHtml } from "./html.js";
+import { sanitizeUrl } from "./url.js";
+
+export interface RichImageAttrs {
+  src?: string;
+  alt?: string;
+  title?: string;
+  caption?: string;
+  href?: string;
+  layout?: string;
+}
+
+interface NormalizedRichImageAttrs {
+  src: string;
+  alt: string;
+  title: string;
+  caption: string;
+  href: string;
+  layout: string;
+}
+
+function normalizeRichImageAttrs(
+  attrs: RichImageAttrs,
+): NormalizedRichImageAttrs {
+  const layout =
+    attrs.layout && String(attrs.layout) !== "regular"
+      ? String(attrs.layout)
+      : "regular";
+
+  return {
+    src: String(attrs.src ?? ""),
+    alt: String(attrs.alt ?? ""),
+    title: String(attrs.title ?? ""),
+    caption: String(attrs.caption ?? ""),
+    href: String(attrs.href ?? ""),
+    layout,
+  };
+}
+
+function renderRichImageBody(attrs: NormalizedRichImageAttrs): string {
+  const imgAttrs = [`src="${escapeHtml(attrs.src)}"`];
+  if (attrs.alt) imgAttrs.push(`alt="${escapeHtml(attrs.alt)}"`);
+  if (attrs.title) imgAttrs.push(`title="${escapeHtml(attrs.title)}"`);
+
+  const imgTag = `<img ${imgAttrs.join(" ")}>`;
+  const href = attrs.href ? sanitizeUrl(attrs.href) : "";
+  const content = href ? `<a href="${escapeHtml(href)}">${imgTag}</a>` : imgTag;
+  const caption = attrs.caption
+    ? `<figcaption>${escapeHtml(attrs.caption)}</figcaption>`
+    : "";
+
+  return `${content}${caption}`;
+}
+
+export function renderPublishedImageFigure(attrs: RichImageAttrs): string {
+  const normalized = normalizeRichImageAttrs(attrs);
+  const layoutAttr =
+    normalized.layout !== "regular"
+      ? ` data-layout="${escapeHtml(normalized.layout)}"`
+      : "";
+
+  return `<figure${layoutAttr}>${renderRichImageBody(normalized)}</figure>`;
+}
+
+export function renderMarkdownImageFigure(attrs: RichImageAttrs): string {
+  const normalized = normalizeRichImageAttrs(attrs);
+  const figureAttrs = ['data-jant-node="image"'];
+  if (normalized.layout !== "regular") {
+    figureAttrs.push(`data-jant-layout="${escapeHtml(normalized.layout)}"`);
+  }
+
+  return `<figure ${figureAttrs.join(" ")}>${renderRichImageBody(normalized)}</figure>`;
+}
+
+export function renderMarkdownImage(attrs: RichImageAttrs): string {
+  const normalized = normalizeRichImageAttrs(attrs);
+
+  if (
+    normalized.caption ||
+    normalized.href ||
+    normalized.layout !== "regular"
+  ) {
+    return renderMarkdownImageFigure(normalized);
+  }
+
+  return normalized.title
+    ? `![${normalized.alt}](${normalized.src} "${normalized.title}")`
+    : `![${normalized.alt}](${normalized.src})`;
+}

package/src/lib/schemas.ts

@@ -18,6 +18,7 @@ import {
   NAV_ITEM_TYPES,
   SYSTEM_NAV_KEY_VALUES,
   MAX_MEDIA_ATTACHMENTS,
+  MAX_THREAD_POSTS,
   MAX_COLLECTION_SLUG_LENGTH,
   MAX_COLLECTION_TITLE_LENGTH,
   MAX_COLLECTION_DESCRIPTION_LENGTH,
@@ -30,7 +31,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 { isReservedPath } from "./constants.js";
 import { sanitizeUrl, normalizePath } from "./url.js";
 
 // =============================================================================
@@ -77,6 +78,56 @@ function sanitizeSettingText(maxLength: number) {
     .transform((s) => s.replace(CONTROL_CHAR_RE, ""));
 }
 
+/** Trim and strip control characters, preserving omitted fields and using null to clear values on update. */
+function sanitizeNullableUpdateText(maxLength: number) {
+  return z
+    .union([
+      z
+        .string()
+        .trim()
+        .max(maxLength)
+        .transform((s) => {
+          const sanitized = s.replace(CONTROL_CHAR_RE, "");
+          return sanitized === "" ? null : sanitized;
+        }),
+      z.null(),
+    ])
+    .optional();
+}
+
+/** Accept update-time URL clears as null while still validating non-empty URLs. */
+function sanitizeNullableUpdateUrl() {
+  return z
+    .union([
+      z
+        .string()
+        .trim()
+        .url()
+        .refine((val) => sanitizeUrl(val) !== "", {
+          message: "URL must use http:, https:, or mailto: protocol",
+        }),
+      z
+        .string()
+        .trim()
+        .length(0)
+        .transform(() => null),
+      z.null(),
+    ])
+    .optional();
+}
+
+/** Preserve omitted ratings and normalize explicit clears to null on update. */
+function createNullableUpdateRatingSchema() {
+  return z
+    .union([
+      z.coerce.number().int().min(0).max(5),
+      z.literal("").transform(() => null),
+      z.null(),
+    ])
+    .optional()
+    .transform((value) => (value === 0 ? null : value));
+}
+
 /**
  * Post format enum schema
  * Based on FORMATS from types.ts
@@ -118,6 +169,7 @@ export const CustomUrlTargetTypeSchema = z.enum([
   "post",
   "collection",
   "redirect",
+  "archive",
 ]);
 
 /**
@@ -175,10 +227,32 @@ const PostFieldsSchema = z.object({
   bodyMarkdown: z.string().optional(),
   status: StatusSchema.optional(),
   visibility: z.enum(VISIBILITIES).optional(),
+  // Admin UI sends boolean flags; the Hugo importer and API clients can
+  // instead send explicit ISO-8601 or Unix-second timestamps via
+  // `pinnedAt` / `featuredAt`. The refine below at the API-body level
+  // collapses whichever form is present into a single internal field.
   pinned: z
     .union([z.boolean(), z.literal("on").transform(() => true)])
     .optional(),
   featured: z.boolean().optional(),
+  pinnedAt: z
+    .union([
+      z.iso
+        .datetime()
+        .transform((iso) => Math.floor(new Date(iso).getTime() / 1000)),
+      z.number().int().positive(),
+      z.null(),
+    ])
+    .optional(),
+  featuredAt: z
+    .union([
+      z.iso
+        .datetime()
+        .transform((iso) => Math.floor(new Date(iso).getTime() / 1000)),
+      z.number().int().positive(),
+      z.null(),
+    ])
+    .optional(),
   url: z
     .url()
     .refine((val) => sanitizeUrl(val) !== "", {
@@ -199,7 +273,18 @@ const PostFieldsSchema = z.object({
     .array(CollectionIdSchema)
     .optional()
     .or(z.literal("").transform(() => undefined)),
+  collectionEntries: z
+    .array(
+      z.object({
+        collectionId: CollectionIdSchema,
+        createdAt: z.number().int().positive().optional(),
+        position: z.number().int().nonnegative().optional(),
+        pinnedAt: z.union([z.number().int().positive(), z.null()]).optional(),
+      }),
+    )
+    .optional(),
   replyToId: PostIdSchema.optional(),
+  quietReply: z.boolean().optional(),
   publishedAt: z.number().int().positive().optional(),
   mediaIds: z.array(MediaIdSchema).max(MAX_MEDIA_ATTACHMENTS).optional(),
   mediaAlts: z.record(MediaIdSchema, z.string()).optional(),
@@ -252,7 +337,7 @@ const ApiPostFieldsSchema = PostFieldsSchema.omit({
 
 /** Mutual exclusivity: body and bodyMarkdown cannot both be provided */
 function refineBodyExclusivity<
-  T extends { body?: string; bodyMarkdown?: string },
+  T extends { body?: string | null; bodyMarkdown?: string | null },
 >(schema: z.ZodType<T>) {
   return schema.refine((data) => !(data.body && data.bodyMarkdown), {
     message: "Provide either body or bodyMarkdown, not both",
@@ -397,15 +482,53 @@ export const CreatePostApiSchema = refineSlugPathExclusivity(
   refineCreatePostFormatShape(refineBodyExclusivity(ApiPostFieldsSchema)),
 );
 
+/**
+ * API request body schema for creating a thread (multiple chained posts atomically).
+ * posts[0] is the root; subsequent posts are sequential replies.
+ */
+export const CreateThreadApiSchema = z.object({
+  posts: z
+    .array(CreatePostApiSchema)
+    .min(2, "A thread needs at least 2 posts.")
+    .max(
+      MAX_THREAD_POSTS,
+      `Threads can include up to ${MAX_THREAD_POSTS} posts.`,
+    ),
+  /** When re-editing a thread draft, the root post ID of the old thread to replace */
+  replaceThreadId: createTypeIdSchema(ID_PREFIX.post).optional(),
+});
+
 /**
  * API request body schema for updating a post
  */
+const UpdatePostFieldsSchema = PostFieldsSchema.partial().extend({
+  title: sanitizeNullableUpdateText(300),
+  sourceName: sanitizeNullableUpdateText(300),
+  body: z.string().nullable().optional(),
+  bodyMarkdown: z.string().nullable().optional(),
+  url: sanitizeNullableUpdateUrl(),
+  sourceUrl: sanitizeNullableUpdateUrl(),
+  quoteText: z.string().nullable().optional(),
+  rating: createNullableUpdateRatingSchema(),
+});
+
+const UpdatePostApiFieldsSchema = ApiPostFieldsSchema.partial().extend({
+  title: sanitizeNullableUpdateText(300),
+  sourceName: sanitizeNullableUpdateText(300),
+  body: z.string().nullable().optional(),
+  bodyMarkdown: z.string().nullable().optional(),
+  url: sanitizeNullableUpdateUrl(),
+  sourceUrl: sanitizeNullableUpdateUrl(),
+  quoteText: z.string().nullable().optional(),
+  rating: createNullableUpdateRatingSchema(),
+});
+
 export const UpdatePostSchema = refineSlugPathExclusivity(
-  refineBodyExclusivity(PostFieldsSchema.partial()),
+  refineBodyExclusivity(UpdatePostFieldsSchema),
 );
 
 export const UpdatePostApiSchema = refineSlugPathExclusivity(
-  refineBodyExclusivity(ApiPostFieldsSchema.partial()),
+  refineBodyExclusivity(UpdatePostApiFieldsSchema),
 );
 
 /**
@@ -421,10 +544,18 @@ export const CreateNavItemSchema = z.discriminatedUnion("type", [
       .refine((val) => sanitizeUrl(val) !== "", {
         message: "URL must use http:, https:, or mailto: protocol",
       }),
+    placement: z.enum(["header", "more"]).optional(),
   }),
   z.object({
     type: z.literal("system"),
     systemKey: SystemNavKeySchema,
+    placement: z.enum(["header", "more"]).optional(),
+  }),
+  z.object({
+    type: z.literal("collection"),
+    collectionId: z.string().min(1),
+    label: sanitizeText(100).pipe(z.string().min(1)).optional(),
+    placement: z.enum(["header", "more"]).optional(),
   }),
 ]);
 
@@ -432,7 +563,7 @@ export const CreateNavItemSchema = z.discriminatedUnion("type", [
  * API request body schema for updating a navigation item
  */
 export const UpdateNavItemSchema = z.object({
-  label: sanitizeText(100).pipe(z.string().min(1)).optional(),
+  label: sanitizeSettingText(100).optional(),
   url: z
     .string()
     .min(1)
@@ -440,6 +571,44 @@ export const UpdateNavItemSchema = z.object({
       message: "URL must use http:, https:, or mailto: protocol",
     })
     .optional(),
+  placement: z.enum(["header", "more"]).optional(),
+});
+
+export const CollectionDirectoryLabelSchema = z.string().trim().max(60);
+export const CollectionDirectoryLinkLabelSchema = sanitizeText(60).pipe(
+  z.string().min(1),
+);
+export const CollectionDirectoryLinkUrlSchema = z
+  .string()
+  .min(1)
+  .refine((val) => sanitizeUrl(val) !== "", {
+    message: "URL must use http:, https:, or mailto: protocol",
+  });
+
+export const CollectionDescriptionValueSchema = sanitizeText(
+  MAX_COLLECTION_DESCRIPTION_LENGTH,
+);
+
+export const CreateCollectionDirectoryItemSchema = z.discriminatedUnion(
+  "type",
+  [
+    z.object({
+      type: z.literal("divider"),
+      label: CollectionDirectoryLabelSchema.nullable().optional(),
+    }),
+    z.object({
+      type: z.literal("link"),
+      label: CollectionDirectoryLinkLabelSchema,
+      url: CollectionDirectoryLinkUrlSchema,
+      description: CollectionDescriptionValueSchema.nullable().optional(),
+    }),
+  ],
+);
+
+export const UpdateCollectionDirectoryItemSchema = z.object({
+  label: z.union([CollectionDirectoryLabelSchema, z.null()]).optional(),
+  url: CollectionDirectoryLinkUrlSchema.optional(),
+  description: CollectionDescriptionValueSchema.nullable().optional(),
 });
 
 export {
@@ -472,7 +641,7 @@ export const CollectionSlugSchema = z
         message: `Keep this link under ${MAX_COLLECTION_SLUG_LENGTH} characters.`,
       })
       .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/)
-      .refine((value) => !isReservedCollectionSlug(value), {
+      .refine((value) => !isReservedPath(value), {
         message: "This link is reserved. Choose something else.",
       }),
   );
@@ -481,10 +650,6 @@ export const CollectionTitleSchema = sanitizeText(
   MAX_COLLECTION_TITLE_LENGTH,
 ).pipe(z.string().min(1));
 
-export const CollectionDescriptionValueSchema = sanitizeText(
-  MAX_COLLECTION_DESCRIPTION_LENGTH,
-);
-
 export const CreateCollectionSchema = z.object({
   slug: CollectionSlugSchema,
   title: CollectionTitleSchema,
@@ -536,13 +701,15 @@ export const CreateCustomUrlSchema = z.object({
     .min(1)
     .max(512)
     .regex(
-      /^\/[a-z0-9][a-z0-9\-/]*$/,
-      "Path must start with / and contain only lowercase alphanumeric characters, hyphens, and slashes",
-    ),
+      /^\/?[a-z0-9][a-z0-9\-/]*$/,
+      "Path must contain only lowercase alphanumeric characters, hyphens, and slashes",
+    )
+    .transform((p) => (p.startsWith("/") ? p : `/${p}`)),
   targetType: CustomUrlTargetTypeSchema,
   targetId: z.string().optional(),
   toPath: z.string().optional(),
   redirectType: RedirectTypeSchema.optional(),
+  archiveQuery: z.string().optional(),
 });
 
 // =============================================================================

package/src/lib/summary.ts

@@ -1,18 +1,38 @@
 /**
  * Summary Extraction from Tiptap JSON
  *
- * Extracts a plain-text summary from a Tiptap JSON document for use
- * in feeds, meta descriptions, and article previews.
+ * Extracts plain-text and HTML summaries from a Tiptap JSON document
+ * for use in feeds, meta descriptions, and article previews.
  */
 
+import type { JSONContent } from "@tiptap/core";
+import { renderTiptapDocument } from "./tiptap-render.js";
+
 interface TiptapNode {
   type: string;
   content?: TiptapNode[];
   text?: string;
-  marks?: unknown[];
+  marks?: Array<{
+    type: string;
+    attrs?: Record<string, unknown>;
+  }>;
   attrs?: Record<string, unknown>;
 }
 
+/**
+ * Block node types that carry user-visible content for summary extraction.
+ * Structural nodes (horizontalRule, moreBreak, image) are excluded.
+ */
+const SUMMARY_BLOCK_TYPES = new Set([
+  "paragraph",
+  "heading",
+  "bulletList",
+  "orderedList",
+  "blockquote",
+  "codeBlock",
+  "table",
+]);
+
 /**
  * Recursively extracts plain text from a Tiptap node, ignoring marks.
  */
@@ -59,6 +79,7 @@ const SEARCHABLE_TYPES = new Set([
   "tableRow",
   "tableCell",
   "tableHeader",
+  "footnoteDefinition",
   "text",
   "hardBreak",
 ]);
@@ -109,7 +130,7 @@ export function extractBodyText(bodyJson: string): string | null {
 
 export function extractSummary(
   bodyJson: string,
-  maxParagraphs: number,
+  maxBlocks: number,
   maxChars: number,
 ): string | null {
   let doc: TiptapNode;
@@ -123,36 +144,122 @@ export function extractSummary(
 
   const nodes = doc.content;
 
-  // Check for moreBreak — collect paragraph text before it
+  // Check for moreBreak — collect text from all content nodes before it
   const moreBreakIdx = nodes.findIndex((n) => n.type === "moreBreak");
   if (moreBreakIdx !== -1) {
-    const paragraphs: string[] = [];
+    const blocks: string[] = [];
     for (let i = 0; i < moreBreakIdx; i++) {
       const node = nodes[i];
-      if (!node) continue;
-      if (node.type === "paragraph") {
-        const text = extractPlainText(node).trim();
-        if (text) paragraphs.push(text);
-      }
+      if (!node || !SUMMARY_BLOCK_TYPES.has(node.type)) continue;
+      const text = extractPlainText(node).trim();
+      if (text) blocks.push(text);
     }
-    return paragraphs.length > 0 ? paragraphs.join("\n\n") : null;
+    return blocks.length > 0 ? blocks.join("\n\n") : null;
   }
 
-  // No moreBreak — accumulate paragraphs up to limits
-  const paragraphs: string[] = [];
+  // No moreBreak — accumulate content blocks up to limits
+  const blocks: string[] = [];
   let totalChars = 0;
 
   for (const node of nodes) {
-    if (node.type !== "paragraph") continue;
+    if (!SUMMARY_BLOCK_TYPES.has(node.type)) continue;
 
     const text = extractPlainText(node).trim();
     if (!text) continue;
 
-    if (paragraphs.length >= maxParagraphs || totalChars >= maxChars) break;
+    if (
+      (blocks.length >= maxBlocks || totalChars + text.length > maxChars) &&
+      blocks.length > 0
+    )
+      break;
 
-    paragraphs.push(text);
+    blocks.push(text);
     totalChars += text.length;
   }
 
-  return paragraphs.length > 0 ? paragraphs.join("\n\n") : null;
+  return blocks.length > 0 ? blocks.join("\n\n") : null;
+}
+
+/**
+ * Extracts an HTML summary from a Tiptap JSON body by taking the first
+ * N content-bearing block nodes and rendering them as HTML.
+ *
+ * Unlike the plain-text `extractSummary`, this preserves the original
+ * structure (lists, blockquotes, headings, etc.) for rich previews.
+ *
+ * @param bodyJson - Tiptap JSON string
+ * @param maxBlocks - Maximum number of top-level blocks to include
+ * @param maxChars - Maximum total plain-text character count
+ * @returns HTML summary and whether content was truncated, or null
+ *
+ * @example
+ * ```ts
+ * const result = extractSummaryHtml(body, 5, 500);
+ * // { html: "<ul><li><p>Item</p></li></ul>", hasMore: true }
+ * ```
+ */
+export function extractSummaryHtml(
+  bodyJson: string,
+  maxBlocks: number = 5,
+  maxChars: number = 500,
+): { html: string; hasMore: boolean } | null {
+  let doc: TiptapNode;
+  try {
+    doc = JSON.parse(bodyJson) as TiptapNode;
+  } catch {
+    return null;
+  }
+
+  if (doc.type !== "doc" || !doc.content) return null;
+
+  const nodes = doc.content;
+  const totalContentNodes = nodes.filter((n) =>
+    SUMMARY_BLOCK_TYPES.has(n.type),
+  ).length;
+
+  // Check for moreBreak — take all content nodes before it
+  const moreBreakIdx = nodes.findIndex((n) => n.type === "moreBreak");
+  if (moreBreakIdx !== -1) {
+    const selected = nodes
+      .slice(0, moreBreakIdx)
+      .filter((n) => SUMMARY_BLOCK_TYPES.has(n.type));
+    if (selected.length === 0) return null;
+    const subDoc: JSONContent = {
+      type: "doc",
+      content: selected as JSONContent[],
+    };
+    return {
+      html: renderTiptapDocument(subDoc),
+      hasMore: true,
+    };
+  }
+
+  // No moreBreak — accumulate blocks up to limits
+  const selected: TiptapNode[] = [];
+  let totalChars = 0;
+
+  for (const node of nodes) {
+    if (!SUMMARY_BLOCK_TYPES.has(node.type)) continue;
+
+    const text = extractPlainText(node).trim();
+    if (
+      (selected.length >= maxBlocks || totalChars + text.length > maxChars) &&
+      selected.length > 0
+    )
+      break;
+
+    selected.push(node);
+    totalChars += text.length;
+  }
+
+  if (selected.length === 0) return null;
+
+  const subDoc: JSONContent = {
+    type: "doc",
+    content: selected as JSONContent[],
+  };
+  return {
+    html: renderTiptapDocument(subDoc),
+    hasMore: selected.length < totalContentNodes,
+  };
 }