@jant/core 0.7.0 → 0.7.1

package/src/lib/image.ts

@@ -34,7 +34,11 @@ export interface ImageOptions {
  * - Cloudinary
  * - Any service with similar URL-based transformation API
  *
- * @param originalUrl - The original image URL
+ * A root-relative source is written without its leading slash, the form the
+ * transformation service resolves against its own host. Kept, it would produce
+ * `…/width=200//media/abc123`, which Cloudflare cannot fetch (`err=9404`).
+ *
+ * @param originalUrl - The original image URL, absolute or root-relative
  * @param transformUrl - The base URL for transformations (e.g., `https://example.com/cdn-cgi/image`)
  * @param options - Transformation options (width, height, quality, format, fit)
  * @returns The transformed URL or original URL if transformations are not configured
@@ -45,9 +49,13 @@ export interface ImageOptions {
  * getImageUrl("/media/abc123", undefined, { width: 200 });
  * // Returns: "/media/abc123"
  *
- * // With transform URL - returns transformed
+ * // With transform URL and a root-relative source
  * getImageUrl("/media/abc123", "https://example.com/cdn-cgi/image", { width: 200, quality: 80 });
- * // Returns: "https://example.com/cdn-cgi/image/width=200,quality=80/https://example.com/media/abc123"
+ * // Returns: "https://example.com/cdn-cgi/image/width=200,quality=80/media/abc123"
+ *
+ * // With transform URL and an absolute source
+ * getImageUrl("https://cdn.example.com/media/abc123", "https://example.com/cdn-cgi/image", { width: 200 });
+ * // Returns: "https://example.com/cdn-cgi/image/width=200/https://cdn.example.com/media/abc123"
  * ```
  */
 export function getImageUrl(
@@ -70,7 +78,12 @@ export function getImageUrl(
     return originalUrl;
   }
 
-  return `${transformUrl}/${params.join(",")}/${originalUrl}`;
+  const base = transformUrl.replace(/\/+$/, "");
+  const source =
+    originalUrl.startsWith("/") && !originalUrl.startsWith("//")
+      ? originalUrl.slice(1)
+      : originalUrl;
+  return `${base}/${params.join(",")}/${source}`;
 }
 
 /**

package/src/lib/markdown-manager.ts

@@ -1,12 +1,20 @@
 import {
   Extension,
   Node,
+  getSchema,
   type AnyExtension,
   type Extensions,
   type JSONContent,
 } from "@tiptap/core";
+import { Fragment, type Schema } from "@tiptap/pm/model";
 import { MarkdownManager } from "@tiptap/markdown";
 import CodeBlock from "@tiptap/extension-code-block";
+import { OrderedList } from "@tiptap/extension-list";
+import HardBreak from "@tiptap/extension-hard-break";
+import Paragraph from "@tiptap/extension-paragraph";
+import Bold from "@tiptap/extension-bold";
+import Italic from "@tiptap/extension-italic";
+import Strike from "@tiptap/extension-strike";
 import Link from "@tiptap/extension-link";
 import StarterKit from "@tiptap/starter-kit";
 import {
@@ -224,6 +232,333 @@ const SemanticLink = Link.extend({
   clearable: false,
 });
 
+const LINE_START_BLOCK_SYNTAX: ReadonlyArray<[RegExp, string]> = [
+  // `1986. A good year`, `2) Second`: an ordered-list marker
+  [/^([ \t]{0,3})(\d{1,9})([.)])(?=[ \t]|$)/, "$1$2\\$3"],
+  // `- note`, `+ note`: a bullet-list marker (`*` is escaped inline already)
+  [/^([ \t]{0,3})([-+])(?=[ \t]|$)/, "$1\\$2"],
+  // `# note`: an ATX heading
+  [/^([ \t]{0,3})(#{1,6})(?=[ \t]|$)/, "$1\\$2"],
+  // `---`, `===`: a thematic break or a setext underline for the line above
+  [/^([ \t]{0,3})([-=])(?=[-= \t]*$)/, "$1\\$2"],
+];
+
+/**
+ * Backslash-escape block syntax that a paragraph line happens to open with.
+ *
+ * Text nodes only get inline escaping, so a paragraph reading `1. Pony`, or a
+ * hard break followed by `- note`, came back from the Markdown as a list.
+ *
+ * @param markdown - A paragraph's rendered Markdown
+ * @returns The same Markdown with each line's leading block syntax escaped
+ * @example
+ * escapeLineStartBlockSyntax("Update:  \n1. Pony"); // "Update:  \n1\\. Pony"
+ */
+function escapeLineStartBlockSyntax(markdown: string): string {
+  return markdown
+    .split("\n")
+    .map((line) =>
+      LINE_START_BLOCK_SYNTAX.reduce(
+        (escaped, [pattern, replacement]) =>
+          escaped.replace(pattern, replacement),
+        line,
+      ),
+    )
+    .join("\n");
+}
+
+/** The HTML tag each emphasis mark falls back to. */
+const HTML_EMPHASIS_TAGS = {
+  bold: "strong",
+  italic: "em",
+  strike: "s",
+} as const;
+
+type EmphasisMarkType = keyof typeof HTML_EMPHASIS_TAGS;
+
+const EMPHASIS_MARK_TYPES = Object.keys(
+  HTML_EMPHASIS_TAGS,
+) as EmphasisMarkType[];
+
+/** Marks that write their own delimiter characters around the text. */
+const DELIMITED_MARK_TYPES = new Set<string>([
+  ...EMPHASIS_MARK_TYPES,
+  "code",
+  "link",
+]);
+
+/**
+ * Serialization-only mark attribute: write this run with HTML tags. It is
+ * set by `markEmphasisDelimiters` on a copy of the document and never stored.
+ */
+const HTML_EMPHASIS_ATTR = "markdownAsHtml";
+
+type FlankingClass = "space" | "punctuation" | "other";
+
+function classifyFlankingChar(char: string | undefined): FlankingClass {
+  if (char === undefined || /\s/u.test(char)) return "space";
+  return /[\p{P}\p{S}]/u.test(char) ? "punctuation" : "other";
+}
+
+function hasMark(node: JSONContent | undefined, type: string): boolean {
+  return node?.marks?.some((mark) => mark.type === type) ?? false;
+}
+
+/**
+ * Whether a `**`, `*`, or `~~` at one end of a run can open or close it.
+ *
+ * CommonMark's flanking rule, which GFM strikethrough shares: the character
+ * on the text side must not be whitespace, and when it is punctuation, the
+ * character on the outside must be whitespace or punctuation too. The rule is
+ * symmetric, so one check covers the opening and the closing delimiter.
+ *
+ * @param nodes - The inline nodes of one block
+ * @param index - The run's first node (`side: "start"`) or last (`"end"`)
+ * @param side - Which end of the run
+ * @param markType - The run's mark
+ * @returns True when Markdown delimiters work at this end
+ */
+function delimiterFlanks(
+  nodes: JSONContent[],
+  index: number,
+  side: "start" | "end",
+  markType: string,
+): boolean {
+  const node = nodes[index];
+  const neighbor = nodes[side === "start" ? index - 1 : index + 1];
+  const chars = [...(node?.text ?? "")];
+  const edge = side === "start" ? chars : chars.slice().reverse();
+  const innerChar = edge.find((char) => !/\s/u.test(char));
+
+  // Another mark opening or closing at the same edge writes its delimiter
+  // between ours and the text; it counts as punctuation.
+  const sharesEdge =
+    node?.marks?.some(
+      (mark) =>
+        mark.type !== markType &&
+        DELIMITED_MARK_TYPES.has(mark.type) &&
+        !hasMark(neighbor, mark.type),
+    ) ?? false;
+  const inner = sharesEdge ? "punctuation" : classifyFlankingChar(innerChar);
+
+  // The serializer moves whitespace at a run's edge outside the delimiter.
+  let outer: FlankingClass;
+  if (edge[0] !== undefined && /\s/u.test(edge[0])) outer = "space";
+  else if (!neighbor || neighbor.type === "hardBreak") outer = "space";
+  else if (neighbor.type === "text") {
+    const neighborChars = [...(neighbor.text ?? "")];
+    outer = classifyFlankingChar(
+      side === "start" ? neighborChars.at(-1) : neighborChars[0],
+    );
+  } else outer = "punctuation"; // `![…](…)`, `[^1]`
+
+  return inner !== "space" && (inner !== "punctuation" || outer !== "other");
+}
+
+function markEmphasisRuns(nodes: JSONContent[]): JSONContent[] {
+  const result = nodes.map((node) => ({ ...node }));
+
+  for (const markType of EMPHASIS_MARK_TYPES) {
+    let start = 0;
+    while (start < result.length) {
+      if (result[start]?.type !== "text" || !hasMark(result[start], markType)) {
+        start += 1;
+        continue;
+      }
+
+      // The serializer closes marks around any non-text node, so a run is
+      // consecutive text nodes.
+      let end = start;
+      while (
+        result[end + 1]?.type === "text" &&
+        hasMark(result[end + 1], markType)
+      ) {
+        end += 1;
+      }
+
+      if (
+        !delimiterFlanks(result, start, "start", markType) ||
+        !delimiterFlanks(result, end, "end", markType)
+      ) {
+        for (let index = start; index <= end; index += 1) {
+          const node = result[index] as JSONContent;
+          node.marks = node.marks?.map((mark) =>
+            mark.type === markType
+              ? {
+                  ...mark,
+                  attrs: { ...mark.attrs, [HTML_EMPHASIS_ATTR]: true },
+                }
+              : mark,
+          );
+        }
+      }
+
+      start = end + 1;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Flag the emphasis runs whose Markdown delimiters a CommonMark parser would
+ * leave as literal characters, so they serialize as HTML tags instead.
+ *
+ * Chinese and Japanese put no space around punctuation, so `**说话。**来的人`
+ * is common, and neither Hugo (goldmark) nor Jant's own parser reads the
+ * closing `**` after `。` followed by `来`. `<strong>…</strong>` reads the
+ * same in both, and the rest of the Markdown stays as it was.
+ *
+ * @param node - A TipTap document or descendant
+ * @returns A copy with unflankable runs flagged
+ * @example
+ * markEmphasisDelimiters(doc); // bold "说话。" before "来" gets the flag
+ */
+function markEmphasisDelimiters(node: JSONContent): JSONContent {
+  if (!node.content || node.type === "codeBlock") return node;
+
+  const content = node.content.map(markEmphasisDelimiters);
+  const hasInline = content.some(
+    (child) => child.type === "text" || child.type === "hardBreak",
+  );
+  return { ...node, content: hasInline ? markEmphasisRuns(content) : content };
+}
+
+function renderEmphasis(
+  node: JSONContent,
+  content: string,
+  markType: EmphasisMarkType,
+  delimiter: string,
+): string {
+  if (!node.attrs?.[HTML_EMPHASIS_ATTR]) {
+    return `${delimiter}${content}${delimiter}`;
+  }
+  const tag = HTML_EMPHASIS_TAGS[markType];
+  return `<${tag}>${content}</${tag}>`;
+}
+
+const MarkdownBold = Bold.extend({
+  renderMarkdown(node, helpers) {
+    return renderEmphasis(node, helpers.renderChildren(node), "bold", "**");
+  },
+});
+
+const MarkdownItalic = Italic.extend({
+  renderMarkdown(node, helpers) {
+    return renderEmphasis(node, helpers.renderChildren(node), "italic", "*");
+  },
+});
+
+const MarkdownStrike = Strike.extend({
+  renderMarkdown(node, helpers) {
+    return renderEmphasis(node, helpers.renderChildren(node), "strike", "~~");
+  },
+});
+
+/** Marked token for each HTML emphasis tag the parser accepts. */
+const HTML_EMPHASIS_TOKEN_TYPES: Record<string, "strong" | "em" | "del"> = {
+  strong: "strong",
+  b: "strong",
+  em: "em",
+  i: "em",
+  s: "del",
+  del: "del",
+};
+
+const HTML_EMPHASIS_OPEN_PATTERN = /<(?:strong|b|em|i|s|del)>/i;
+const HTML_EMPHASIS_PATTERN = /^<(strong|b|em|i|s|del)>([\s\S]*?)<\/\1>/i;
+
+/**
+ * Reads the HTML tags `markEmphasisDelimiters` writes back as marks.
+ *
+ * Only bare tags: `<strong onclick=…>` and every other tag stay text, as
+ * inline HTML always has. The content between the tags is Markdown.
+ */
+const MarkdownHtmlEmphasis = Extension.create({
+  name: "markdownHtmlEmphasis",
+
+  markdownTokenizer: {
+    name: "htmlEmphasis",
+    level: "inline",
+    start(src: string) {
+      return src.search(HTML_EMPHASIS_OPEN_PATTERN);
+    },
+    tokenize(src: string, _tokens, helpers) {
+      const match = HTML_EMPHASIS_PATTERN.exec(src);
+      if (!match) return undefined;
+
+      const [raw, tag = "", text = ""] = match;
+      const type = HTML_EMPHASIS_TOKEN_TYPES[tag.toLowerCase()];
+      if (!type) return undefined;
+      return { type, raw, text, tokens: helpers.inlineTokens(text) };
+    },
+  },
+});
+
+/**
+ * Hard breaks as two trailing spaces, except where that line would be blank.
+ *
+ * A break at the start of a paragraph, or right after another break, puts
+ * the spaces on a line of their own. A line of spaces is blank in Markdown:
+ * it ended the paragraph, and `-   ` left a list item empty with the text
+ * after it outside the list. The backslash form keeps something on the line.
+ */
+const MarkdownHardBreak = HardBreak.extend({
+  renderMarkdown(_node, _helpers, context) {
+    const previous = context?.previousNode;
+    return !previous || previous.type === "hardBreak" ? "\\\n" : "  \n";
+  },
+});
+
+const renderParagraphMarkdown = Paragraph.config.renderMarkdown;
+
+const MarkdownParagraph = Paragraph.extend({
+  renderMarkdown(node, helpers, context) {
+    const rendered =
+      renderParagraphMarkdown?.call(this, node, helpers, context) ?? "";
+    return escapeLineStartBlockSyntax(rendered);
+  },
+});
+
+/**
+ * Ordered lists with CommonMark markers: digits only.
+ *
+ * Tiptap's ordered list also reads letters and roman numerals as markers
+ * (`a.`, `IV.`, anything of one or two letters), so a line such as
+ * `PS. 补充一句` or `Mr. Smith went` became a list item and lost its first
+ * word. Its tokenizer also measured a marker's width without the `.`, which
+ * left one stray space on every line of a code block inside a list item.
+ *
+ * Jant's Markdown is CommonMark plus GFM (docs/internal/markdown-contract.md),
+ * the same dialect Hugo reads in an export, so list tokenizing goes back to
+ * marked: a tokenizer that never matches leaves the built-in one in charge,
+ * and marked's list items go to `listItem` the way bullet lists' do. Tiptap's
+ * plain-text paste plugin goes too; it applied the same markers, and the
+ * editors already parse pasted plain text as Markdown (`MarkdownClipboard`).
+ */
+const CommonMarkOrderedList = OrderedList.extend({
+  markdownTokenizer: {
+    name: "orderedList",
+    level: "block",
+    start: () => -1,
+    tokenize: () => undefined,
+  },
+
+  parseMarkdown: (token, helpers) => {
+    if (token.type !== "list" || !token.ordered) return [];
+    const start = typeof token.start === "number" ? token.start : 1;
+    return {
+      type: "orderedList",
+      ...(start === 1 ? {} : { attrs: { start } }),
+      content: token.items ? helpers.parseChildren(token.items) : [],
+    };
+  },
+
+  addProseMirrorPlugins() {
+    return [];
+  },
+});
+
 const MarkdownFigureImageSupport = Extension.create({
   name: "markdownFigureImageSupport",
 
@@ -824,8 +1159,21 @@ export function createMarkdownContentExtensions(
       heading: { levels: [1, 2, 3] },
       link: false,
       codeBlock: false,
+      orderedList: false,
+      paragraph: false,
+      hardBreak: false,
+      bold: false,
+      italic: false,
+      strike: false,
       trailingNode: { notAfter: ["footnoteDefinition"] },
     }),
+    MarkdownParagraph,
+    MarkdownHardBreak,
+    MarkdownBold,
+    MarkdownItalic,
+    MarkdownStrike,
+    MarkdownHtmlEmphasis,
+    CommonMarkOrderedList,
     SemanticLink.configure({
       openOnClick: false,
       autolink: false,
@@ -1050,12 +1398,54 @@ export function getMarkdownManager(): MarkdownManager {
   return sharedMarkdownManager;
 }
 
+let sharedContentSchema: Schema | null = null;
+
+function getContentSchema(): Schema {
+  sharedContentSchema ??= getSchema(createMarkdownContentExtensions());
+  return sharedContentSchema;
+}
+
+/**
+ * Fill in the children a node's schema requires but the document left out.
+ *
+ * A list item must hold a paragraph, a blockquote a block, a doc a block.
+ * Documents that skipped one (an empty `1. ` item from an older Markdown
+ * parser, or JSON posted through the API) made the Markdown serializer throw.
+ * Each empty node that cannot be empty gets what `createAndFill` would give it.
+ *
+ * @param node - A TipTap document or descendant
+ * @returns A copy whose empty required containers are filled
+ * @example
+ * fillRequiredContent({ type: "listItem", content: [] });
+ * // { type: "listItem", content: [{ type: "paragraph" }] }
+ */
+export function fillRequiredContent(node: JSONContent): JSONContent {
+  const nodeType = node.type ? getContentSchema().nodes[node.type] : undefined;
+  if (!nodeType || nodeType.isLeaf) return node;
+
+  const content = node.content?.map(fillRequiredContent);
+  if ((content?.length ?? 0) === 0 && !nodeType.contentMatch.validEnd) {
+    const filled = nodeType.contentMatch.fillBefore(Fragment.empty, true);
+    if (filled) {
+      return { ...node, content: filled.toJSON() as JSONContent[] };
+    }
+  }
+
+  return content ? { ...node, content } : node;
+}
+
 export function parseMarkdownDocument(markdown: string): JSONContent {
-  return normalizeMarkdownDocument(getMarkdownManager().parse(markdown));
+  return fillRequiredContent(
+    normalizeMarkdownDocument(getMarkdownManager().parse(markdown)),
+  );
 }
 
 export function serializeMarkdownDocument(doc: JSONContent): string {
   return expandCodeBlockFences(
-    getMarkdownManager().serialize(normalizeFootnoteArtifacts(doc)),
+    getMarkdownManager().serialize(
+      normalizeFootnoteArtifacts(
+        markEmphasisDelimiters(fillRequiredContent(doc)),
+      ),
+    ),
   );
 }

package/src/lib/post-body-html.ts

@@ -8,6 +8,7 @@
 
 import type { JSONContent } from "@tiptap/core";
 import { upgradeLegacyFootnotes } from "./footnotes.js";
+import { fillRequiredContent } from "./markdown-manager.js";
 import {
   renderTiptapDocument,
   type TiptapRenderResult,
@@ -50,8 +51,9 @@ export function renderPostBodyHtml(postId: string, body: string): string {
 }
 
 /**
- * Normalize recognized historical footnotes and render the current HTML
- * projection in one parse pass.
+ * Normalize recognized historical footnotes, fill in children the schema
+ * requires (an empty list item gets its paragraph), and render the current
+ * HTML projection in one parse pass.
  *
  * @param postId - Immutable post TypeID
  * @param body - Canonical TipTap JSON
@@ -73,10 +75,15 @@ export function tryPreparePostBodyHtml(
     }
 
     const upgraded = upgradeLegacyFootnotes(parsed);
+    const doc = fillRequiredContent(upgraded.doc);
+    const canonical = JSON.stringify(doc);
     return {
       ok: true,
-      body: upgraded.upgraded ? JSON.stringify(upgraded.doc) : body,
-      html: renderTiptapDocument(upgraded.doc, { namespace: postId }),
+      body:
+        upgraded.upgraded || canonical !== JSON.stringify(upgraded.doc)
+          ? canonical
+          : body,
+      html: renderTiptapDocument(doc, { namespace: postId }),
       upgradedLegacyFootnotes: upgraded.upgraded,
     };
   } catch (error) {

package/src/lib/resolve-config.ts

@@ -27,9 +27,63 @@ import { getPublicUrlForProvider, getMediaUrl, getImageUrl } from "./image.js";
 import { normalizeTimeZone } from "./timezones.js";
 import { getSiteOrigin, getSitePathPrefix, normalizeSiteUrl } from "./url.js";
 
+/**
+ * Whether an empty stored value means "never configured" for this field.
+ *
+ * The test is whether the editor could have produced the empty value, and it
+ * mirrors what `normalizeConfigEditorDefinitionValue` accepts. A boolean takes
+ * only `true` or `false`; a number has to parse; an enum has to name one of its
+ * options. None of those can be stored empty, so an empty row for one of them
+ * is not a choice anybody made — it comes from a path that skips validation,
+ * and a snapshot's `db.sql`, replayed as raw SQL, is exactly that. Read as a
+ * configured value it silences the environment variable the operator did set,
+ * for as long as the row exists.
+ *
+ * Text is the opposite: clearing a description or a footer is an ordinary edit,
+ * so an empty value there is a decision and keeps its precedence. So is an enum
+ * that lists `""` among its options, the way `DASHBOARD_LANGUAGE` does, and one
+ * whose options come from a runtime source, where nothing here can rule it
+ * out.
+ *
+ * @param field - Config registry entry for the key being resolved
+ * @returns True when an empty stored value should fall through to env/default
+ *
+ * @example
+ * ```ts
+ * isUnsetWhenEmpty(CONFIG_FIELDS.NOINDEX); // true  (boolean)
+ * isUnsetWhenEmpty(CONFIG_FIELDS.SITE_FOOTER); // false (string)
+ * ```
+ */
+function isUnsetWhenEmpty(
+  field: (typeof CONFIG_FIELDS)[keyof typeof CONFIG_FIELDS],
+): boolean {
+  if (!("editor" in field)) return false;
+  const editor = field.editor;
+  switch (editor.type) {
+    case "boolean":
+    case "number":
+      return true;
+    case "enum":
+      // Only a fixed option list proves the value is impossible. `""` is a real
+      // choice for `DASHBOARD_LANGUAGE`, which offers it, and an enum drawing
+      // its options from a runtime source cannot rule it out either.
+      return (
+        "options" in editor &&
+        !(editor.options as readonly string[]).includes("")
+      );
+    default:
+      return false;
+  }
+}
+
 /**
  * Resolve a single config value following priority rules.
  *
+ * Settings saved in the dashboard outrank the environment, which outranks the
+ * default. The exception is an empty boolean or numeric value — see
+ * {@link isUnsetWhenEmpty}, which explains why that is absence rather than
+ * choice.
+ *
  * @param key - CONFIG_FIELDS key
  * @param allSettings - DB settings map
  * @param env - Worker bindings
@@ -46,7 +100,10 @@ function resolve(
 
   // User-configurable: DB > ENV > Default
   if (!field.envOnly && Object.hasOwn(allSettings, key)) {
-    return allSettings[key] ?? "";
+    const stored = allSettings[key] ?? "";
+    if (stored !== "" || !isUnsetWhenEmpty(field)) {
+      return stored;
+    }
   }
 
   // ENV > Default

package/src/lib/schemas.ts

@@ -195,10 +195,14 @@ export const NavItemTypeSchema = z.enum(NAV_ITEM_TYPES);
 export const SystemNavKeySchema = z.enum(SYSTEM_NAV_KEY_VALUES);
 
 /**
- * Redirect type enum schema
- * Form input validation for redirect type (stored as number in DB)
+ * Redirect type, as forms send it ("301") or as the API answers it (301).
+ * Parses to the string form; stored as a number.
  */
-export const RedirectTypeSchema = z.enum(["301", "302"]);
+export const RedirectTypeSchema = z.union([
+  z.enum(["301", "302"]),
+  z.literal(301).transform(() => "301" as const),
+  z.literal(302).transform(() => "302" as const),
+]);
 
 /**
  * Custom URL target type enum schema.
@@ -547,15 +551,32 @@ function refineSlugPathExclusivity<T extends { slug?: string; path?: string }>(
   });
 }
 
+/**
+ * Create only: a post's own record timestamps, in Unix seconds. An import or
+ * a migration restores them, so "last edited" (feed `<updated>`, sitemap
+ * `lastmod`) and Thread order (the root, then replies by creation time, then
+ * ID) survive the move.
+ * Omitted, both are the time of the request; `updatedAt` alone defaults to
+ * `createdAt`.
+ */
+const RestoredTimestampFields = {
+  createdAt: z.number().int().positive().optional(),
+  updatedAt: z.number().int().positive().optional(),
+};
+
 /**
  * API request body schema for creating a post
  */
 export const CreatePostSchema = refineSlugPathExclusivity(
-  refineCreatePostFormatShape(refineBodyExclusivity(PostFieldsSchema)),
+  refineCreatePostFormatShape(
+    refineBodyExclusivity(PostFieldsSchema.extend(RestoredTimestampFields)),
+  ),
 );
 
 export const CreatePostApiSchema = refineSlugPathExclusivity(
-  refineCreatePostFormatShape(refineBodyExclusivity(ApiPostFieldsSchema)),
+  refineCreatePostFormatShape(
+    refineBodyExclusivity(ApiPostFieldsSchema.extend(RestoredTimestampFields)),
+  ),
 );
 
 /**
@@ -1054,6 +1075,30 @@ export const SetupSiteSchema = SetupLanguageSchema.extend({
 /** The answers the last setup screen collects from either install kind. */
 export type SetupLanguageAnswers = z.infer<typeof SetupLanguageSchema>;
 
+/**
+ * Both setup screens' answers at once, for `jant setup`: a self-hosted install
+ * set up by its deployment rather than in a browser.
+ *
+ * Only the credentials are required. Everything the second screen asks has
+ * the default an empty answer gets there, and a browser's guesses — its
+ * language, its time zone — have no counterpart here.
+ */
+export const InstanceSetupSchema = SetupAccountSchema.extend({
+  siteId: createTypeIdSchema(ID_PREFIX.site).optional(),
+  siteName: z
+    .string()
+    .trim()
+    .min(1, "Site name cannot be empty")
+    .max(MAX_SITE_NAME_LENGTH)
+    .optional(),
+  siteLanguage: ContentLanguageSchema.optional(),
+  timeZone: z
+    .string()
+    .refine(isSupportedTimeZone, "Choose a valid time zone.")
+    .transform(normalizeTimeZone)
+    .optional(),
+});
+
 /**
  * Sign-in form validation schema
  */

package/src/lib/thread-fold.ts

@@ -106,9 +106,9 @@ export interface ThreadFold<T> {
  *
  * Takes the same slices the SQL path ranks for: the first
  * `THREAD_LEADING_REPLIES`, and the last `THREAD_TRAILING_REPLIES` with the
- * newest as the hero. `getPublishedThreads` orders replies by
- * `(threadId, createdAt, id)` ascending, which is the window function's own
- * `ORDER BY`, so position in this array *is* the rank — no approximation.
+ * newest as the hero. `getPublishedThreads` returns each Thread in Thread
+ * order, the same `threadOrder` the window functions rank by, so once the root
+ * is set aside position in this array *is* the rank — no approximation.
  *
  * @param replies - Every published reply, oldest first
  * @returns The fold, or null when the thread has no replies