blume 2.0.1 → 2.0.2

package/src/core/sources/normalize.ts

@@ -3,12 +3,14 @@ import { existsSync, readFileSync } from "node:fs";
 import GithubSlugger from "github-slugger";
 import { extname } from "pathe";
 
-import { withBasePath } from "../base-path.ts";
+import { mountBasePath } from "../base-path.ts";
 import { nextFenceState } from "../code-fences.ts";
 import type { FenceState } from "../code-fences.ts";
 import { diagnosticsFromIssues, diagnosticsFromZod } from "../diagnostics.ts";
 import { occupySlug, parseHeadingMarkers } from "../heading-markers.ts";
 import { localePlacement, localizeRoute } from "../i18n.ts";
+import { titleWord } from "../navigation.ts";
+import { stripOrderingPrefix } from "../ordering-prefix.ts";
 import { pageMetaSchema } from "../schema.ts";
 import type {
   FrontmatterExtend,
@@ -20,13 +22,12 @@ import type { Diagnostic, Heading, PageLink, PageRecord } from "../types.ts";
 import { detectVersionRef, versionizeRoute } from "../versions.ts";
 import type { NormalizeContext, SourceEntry } from "./types.ts";
 
-const NUMERIC_PREFIX = /^\d+[-_.]/u;
 const GROUP_FOLDER = /^\((?<label>.+)\)$/u;
 const WORD_SPLIT = /[-_]/u;
 
 /** Strip a leading numeric ordering prefix (`01-intro` -> `intro`). */
 const stripNumericPrefix = (segment: string): string =>
-  segment.replace(NUMERIC_PREFIX, "");
+  stripOrderingPrefix(segment);
 
 /** Detect a group folder `(name)` and return its label, else null. */
 const groupLabel = (segment: string): string | null =>
@@ -63,13 +64,9 @@ export const slugify = (text: string): string =>
 export const slugifyPath = (text: string): string =>
   text.split("/").map(slugify).filter(Boolean).join("/");
 
-/** Title-case a slug segment for display. */
+/** Title-case a slug segment for display, acronyms as the sidebar spells them. */
 const titleCase = (value: string): string =>
-  value
-    .split(WORD_SPLIT)
-    .filter(Boolean)
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(" ");
+  value.split(WORD_SPLIT).filter(Boolean).map(titleWord).join(" ");
 
 /**
  * Strip characters that cannot survive the route → URL → output-file round
@@ -83,11 +80,15 @@ const titleCase = (value: string): string =>
 const sanitizeSegment = (segment: string): string =>
   segment.replaceAll(/[:\p{Cc}]/gu, "");
 
-/** Fold one raw path part into the accumulating route segments/groups. */
+/**
+ * Fold one raw path part into the accumulating route segments/groups.
+ * `ordered` parts are file or folder names, whose ordering prefix is dropped.
+ */
 const addRouteSegment = (
   part: string,
   segments: string[],
-  groups: string[]
+  groups: string[],
+  ordered: boolean
 ): void => {
   // A leading/trailing/double slash yields an empty part; keeping it would
   // produce a malformed route (`//foo`, `/foo/`) that nothing can link to.
@@ -99,7 +100,7 @@ const addRouteSegment = (
     groups.push(group);
     return;
   }
-  const clean = stripNumericPrefix(part);
+  const clean = ordered ? stripNumericPrefix(part) : part;
   if (clean === "index") {
     return;
   }
@@ -119,22 +120,31 @@ interface MappedRoute {
 }
 
 /**
- * Convert a content-root-relative path into URL + nav metadata. Not exported:
- * a source that needs to predict a route goes through
+ * Convert a source's route prefix and a content-root-relative path into URL +
+ * nav metadata. Only the path's parts lose an ordering prefix, and only when
+ * `ordered` says they are file and folder names: the route prefix, a slug,
+ * a release tag, or a CMS slug is a route spelled out, kept as written. Not
+ * exported: a source that needs to predict a route goes through
  * {@link resolveEntryRoute}, so there is exactly one derivation.
  */
-const mapRoute = (relativePath: string): MappedRoute => {
+const mapRoute = (
+  prefix: string | undefined,
+  relativePath: string,
+  ordered: boolean
+): MappedRoute => {
   const withoutExt = relativePath.slice(
     0,
     relativePath.length - extname(relativePath).length
   );
-  const rawParts = withoutExt.split("/");
 
   const segments: string[] = [];
   const groups: string[] = [];
 
-  for (const part of rawParts) {
-    addRouteSegment(part, segments, groups);
+  for (const part of prefix ? prefix.split("/") : []) {
+    addRouteSegment(part, segments, groups, false);
+  }
+  for (const part of withoutExt.split("/")) {
+    addRouteSegment(part, segments, groups, ordered);
   }
 
   const route = segments.length === 0 ? "/" : `/${segments.join("/")}`;
@@ -241,6 +251,8 @@ interface HeadingScanState {
    * end so a tag wrapped over several lines still matches.
    */
   anchorLines: string[];
+  /** The multi-line comment the scan is inside, if any — see `scanCommentLine`. */
+  comment: "html" | "jsx" | null;
   curlyMarkers: CurlyMarker[];
   fence: FenceState;
   /** 1-based body line of the line being scanned. */
@@ -473,6 +485,48 @@ const scanContentLine = (
   state.paragraph.push(line.trim());
 };
 
+// A comment that opens a line hides everything up to its close from the
+// reader: an HTML comment (`<!--` … `-->`, a CommonMark HTML block, so up to
+// 3 leading spaces) or an MDX JSX one (`{/*` … `*/}`, any indentation — MDX
+// has no indented code).
+const HTML_COMMENT_OPEN = /^ {0,3}<!--/u;
+const JSX_COMMENT_OPEN = /^\s*\{\/\*/u;
+const JSX_COMMENT_CLOSE = /\*\/\s*\}/u;
+
+/**
+ * Advance the multi-line comment state over one line, returning whether the
+ * line belongs to a comment. A commented-out `# Old title` renders nothing, so
+ * it must not become a heading — the page title, a TOC entry, or an anchor.
+ * A comment that closes on its opening line is left to the regular scan,
+ * which never reads a line starting with `<` or `{` as a heading. The
+ * CommonMark end condition is any `-->` on the line, the opening one
+ * included.
+ */
+const scanCommentLine = (line: string, state: HeadingScanState): boolean => {
+  if (state.comment === "html") {
+    if (line.includes("-->")) {
+      state.comment = null;
+    }
+    return true;
+  }
+  if (state.comment === "jsx") {
+    if (JSX_COMMENT_CLOSE.test(line)) {
+      state.comment = null;
+    }
+    return true;
+  }
+  if (HTML_COMMENT_OPEN.test(line) && !line.includes("-->")) {
+    state.comment = "html";
+    return true;
+  }
+  const jsx = JSX_COMMENT_OPEN.exec(line);
+  if (jsx && !JSX_COMMENT_CLOSE.test(line.slice(jsx[0].length))) {
+    state.comment = "jsx";
+    return true;
+  }
+  return false;
+};
+
 /** Scan one line for a heading, advancing the fence/paragraph state. */
 const scanHeadingLine = (
   line: string,
@@ -481,6 +535,18 @@ const scanHeadingLine = (
   headings: Heading[],
   isRefDefined: (label: string) => boolean
 ): void => {
+  // Comments hide fences too, and fences and prompts hide comments. A comment
+  // line still goes to the anchor pass, which strips HTML comments itself.
+  if (
+    state.fence === null &&
+    state.promptDepth === 0 &&
+    !state.promptTag &&
+    scanCommentLine(line, state)
+  ) {
+    state.anchorLines.push(line.replaceAll(INLINE_CODE, ""));
+    state.paragraph = [];
+    return;
+  }
   const next = nextFenceState(line, state.fence);
   // Skip fence delimiter lines themselves and anything inside a fence. A fence
   // also ends any open paragraph, so no underline can reach across it.
@@ -548,6 +614,7 @@ export const scanBody = (body: string): BodyScan => {
   const slugger = new GithubSlugger();
   const state: HeadingScanState = {
     anchorLines: [],
+    comment: null,
     curlyMarkers: [],
     fence: null,
     line: 0,
@@ -792,6 +859,14 @@ export const strippedLineOffset = (
 ): number =>
   raw ? Math.max(0, raw.split("\n").length - body.split("\n").length) : 0;
 
+/**
+ * How many lines of the entry's source file sit above its body: what the
+ * source reported (`bodyLineOffset`, when `raw` is a rewrite of the file), or
+ * else the height of `raw`'s stripped front matter.
+ */
+const entryLineOffset = (entry: SourceEntry): number =>
+  entry.bodyLineOffset ?? strippedLineOffset(entry.raw, entry.body.text);
+
 /**
  * Map links extracted from include-expanded text back to the file and raw
  * line each expanded line came from, so a broken link inside a partial is
@@ -834,10 +909,7 @@ const entryLinks = (entry: SourceEntry): PageLink[] =>
         entry.expanded.origins,
         entry.sourcePath
       )
-    : extractLinks(
-        entry.body.text,
-        strippedLineOffset(entry.raw, entry.body.text)
-      );
+    : extractLinks(entry.body.text, entryLineOffset(entry));
 
 /**
  * Diagnostics for `{#id}` heading markers in an `.mdx` page. The MDX parser
@@ -860,8 +932,7 @@ const curlyMarkerDiagnostics = (
     return {
       code: "BLUME_MDX_CURLY_ANCHOR",
       file: origin?.file ?? page,
-      line:
-        origin?.line ?? line + strippedLineOffset(entry.raw, entry.body.text),
+      line: origin?.line ?? line + entryLineOffset(entry),
       message: inPartial
         ? `\`{#${id}}\` is a JSX expression once this partial is included in ${page} (.mdx), so that page fails to compile.`
         : `\`{#${id}}\` is a JSX expression in .mdx, so this page fails to compile.`,
@@ -882,8 +953,17 @@ const deriveTitle = (
   if (firstHeading) {
     return firstHeading.text;
   }
-  const base = id.split("/").pop() ?? id;
-  return titleCase(stripNumericPrefix(base.replace(extname(base), "")));
+  const parts = id.split("/");
+  const base = parts.at(-1) ?? id;
+  const stem = stripNumericPrefix(base.replace(extname(base), ""));
+  // An index page stands for its folder, so an untitled one takes the label
+  // the sidebar gives that folder (`guides/index.md` is "Guides"). The
+  // content root's own index has no folder to borrow from.
+  const folder = stem === "index" ? parts.at(-2) : undefined;
+  if (folder !== undefined) {
+    return titleCase(stripNumericPrefix(groupLabel(folder) ?? folder));
+  }
+  return titleCase(stem);
 };
 
 /** Strip habitual leading/trailing slashes (`/getting-started`, `guides/`). */
@@ -902,6 +982,13 @@ const withPrefix = (prefix: string | undefined, path: string): string => {
 
 /** What a route resolution needs from the owning source and the config. */
 export type RouteContext = Pick<NormalizeContext, "i18n" | "versions"> & {
+  /**
+   * Whether the entry's ref is a path of file and folder names whose ordering
+   * prefixes (`01-intro`) sort the sidebar and drop from the route: true for
+   * filesystem sources. A staged source's ref is a slug, a release tag, or a
+   * note name, and keeps its leading numbers.
+   */
+  orderingPrefixes?: boolean;
   /** The source's route prefix (`NormalizeContext["source"]["prefix"]`). */
   prefix?: string;
 };
@@ -970,7 +1057,9 @@ export interface EntryRoute extends Pick<
  * A frontmatter `slug` wins, then the adapter-supplied `entry.slug` (the typed
  * SPI's "logical route input; defaults to ref if omitted"), then the ref. The
  * extension is re-appended so `mapRoute`'s extname strip can't eat a dotted
- * slug segment (`v1.2`). A slug that trims to nothing falls back. The version
+ * slug segment (`v1.2`). A slug that trims to nothing falls back. Only a
+ * filesystem ref (`ctx.orderingPrefixes`) loses its ordering prefixes; a slug
+ * is a route spelled out, so `2024-year-in-review` stays whole. The version
  * prefixes the mapped route *after* `mapRoute` runs: the mapped route is the
  * version-agnostic key, the config id is prepended verbatim (never
  * numeric-prefix-stripped), a frontmatter `slug` gets versionized so snapshots
@@ -987,8 +1076,18 @@ export const resolveEntryRoute = (
   const { locales, navPath, version } = placeEntryRef(entry.ref, ext, ctx);
   const slugInput = frontmatterSlug ?? entry.slug;
   const slug = slugInput ? trimSlashes(slugInput) : "";
-  const routeInput = withPrefix(ctx.prefix, slug ? `${slug}${ext}` : navPath);
-  const { segments, groups, route: versionKey } = mapRoute(routeInput);
+  // A frontmatter slug is a route spelled out; an adapter's `entry.slug` is
+  // one too unless the source's names are ordered file names (a vault note's
+  // path), which lose their prefixes like the ref does.
+  const ordered =
+    ctx.orderingPrefixes === true && frontmatterSlug === undefined;
+  const {
+    segments,
+    groups,
+    route: versionKey,
+  } = slug
+    ? mapRoute(ctx.prefix, `${slug}${ext}`, ordered)
+    : mapRoute(ctx.prefix, navPath, ctx.orderingPrefixes === true);
   return {
     groups,
     locales,
@@ -1192,6 +1291,7 @@ export const normalizeEntry = (
     versionKey,
   } = resolveEntryRoute(entry, ext, meta.slug, {
     i18n: ctx.i18n,
+    orderingPrefixes: !ctx.source.staged || ctx.source.orderedNames === true,
     prefix: ctx.source.prefix,
     versions: ctx.versions,
   });
@@ -1237,10 +1337,12 @@ export const normalizeEntry = (
   // `basePath` is applied outermost — after locale prefixing — so the route
   // reads `{basePath}/{locale?}/{prefix?}/…`; `navPath` and `translationKey`
   // stay base-less so the nav tree and translation matching are unaffected.
+  // The base is mounted unconditionally: a `docs/` folder under a `/docs`
+  // base is a real `/docs/docs/…` route, not an already-based one.
   const pages = locales.map((locale) => ({
     ...base,
     locale,
-    route: withBasePath(
+    route: mountBasePath(
       ctx.basePath ?? "",
       localizedRoute(logicalRoute, locale, ctx.i18n)
     ),

package/src/core/sources/notion.ts

@@ -15,7 +15,13 @@ import {
   pollingWatch,
   snapshotCache,
 } from "./cache.ts";
-import { codeFence, image, renderInline, renderLink } from "./lower.ts";
+import {
+  codeFence,
+  guardBlockStart,
+  image,
+  renderInline,
+  renderLink,
+} from "./lower.ts";
 import { slugifyPath } from "./normalize.ts";
 import type {
   ContentSource,
@@ -217,12 +223,12 @@ const withNotionRetry = async <T>(
     if (status !== RATE_LIMITED || attempt === MAX_RETRIES) {
       throw error;
     }
-    // SAFETY: same APIResponseError shape — `headers` maps lower-cased HTTP
-    // header names to their values; a missing header yields `NaN` and falls
-    // back to exponential backoff.
-    const retryAfter = Number(
-      (error as { headers?: Record<string, string> }).headers?.["retry-after"]
-    );
+    // SAFETY: same APIResponseError shape — `headers` is the failed
+    // response's fetch `Headers`, read with `get()`; a missing header (or
+    // headers without `get`) yields no positive wait and falls back to
+    // exponential backoff.
+    const { headers } = error as { headers?: Headers };
+    const retryAfter = Number(headers?.get?.("retry-after"));
     const wait =
       retryAfter > 0
         ? retryAfter * SECOND_MS
@@ -266,6 +272,12 @@ const richToPlain = (rich: NotionRichText[] = []): string =>
  */
 const jsxString = (value: string): string => `{${JSON.stringify(value)}}`;
 
+// `<Frame>` renders its caption as Markdown after escaping `<` and `>` itself
+// (so a caption can't inject HTML), which turns the lowering's own `\<` into
+// a visible `&lt;`. Its caption drops those backslashes and leaves the
+// escaping to Frame; every other escape still applies.
+const FRAME_ESCAPED = /\\(?=[<>])/gu;
+
 const YOUTUBE_HOST = /(?:^|\.)(?:youtube(?:-nocookie)?\.com|youtu\.be)$/u;
 
 // `parseYouTubeId` is host-agnostic on purpose (the component accepts bare
@@ -300,14 +312,14 @@ const renderVideo = (data: NotionBlockPayload): string => {
     ? `<YouTube${title} url=${JSON.stringify(url)} />`
     : `<video controls src=${JSON.stringify(url)} />`;
   return caption
-    ? `<Frame caption=${jsxString(caption)}>\n${media}\n</Frame>`
+    ? `<Frame caption=${jsxString(caption.replaceAll(FRAME_ESCAPED, ""))}>\n${media}\n</Frame>`
     : media;
 };
 
 /** Render a leaf (non-container) block to Markdown, or null for containers. */
 const renderLeaf = (block: NotionBlock): string | null => {
   const data = payloadOf(block) ?? {};
-  const text = richToMarkdown(blockField(block));
+  const text = guardBlockStart(richToMarkdown(blockField(block)));
   switch (block.type) {
     case "paragraph": {
       return text;
@@ -440,7 +452,10 @@ export const notionSource = (
     };
 
     if (block.type === "callout") {
-      const body = [richToMarkdown(blockField(block)), await children(block)]
+      const body = [
+        guardBlockStart(richToMarkdown(blockField(block))),
+        await children(block),
+      ]
         .filter(Boolean)
         .join("\n\n");
       return `<Callout>\n${body}\n</Callout>`;
@@ -680,5 +695,6 @@ export const notionSource = (
           () => load()
         )
       : undefined,
+    withContext: (next) => notionSource(options, next),
   };
 };

package/src/core/sources/obsidian.ts

@@ -20,6 +20,7 @@ import {
   placeEntryRef,
   resolveEntryRoute,
   slugifyPath,
+  strippedLineOffset,
 } from "./normalize.ts";
 import type {
   ContentSource,
@@ -84,6 +85,8 @@ interface ParsedNote {
   /** The note body, frontmatter stripped and otherwise untouched. */
   content: string;
   data: SourceEntry["data"];
+  /** How many lines of the file the frontmatter block (if any) spans. */
+  frontmatterLines: number;
   placement: EntryPlacement;
   /** Vault-relative path, e.g. `guides/Getting Started.md`. */
   rel: string;
@@ -638,7 +641,7 @@ const buildLinkIndex = (
       { ref: note.rel, slug: entrySlugFor(note.placement.navPath) },
       ".md",
       isStringValue(note.data.slug) ? note.data.slug : undefined,
-      options
+      { ...options, orderingPrefixes: true }
     );
     const built: IndexedNote = {
       anchors: new Map(),
@@ -756,10 +759,17 @@ const noteToEntry = (
     )
   );
   const merged = title === undefined ? data : { ...data, title };
-  const text = transformBody(note.content.trim(), index, pair.self, unresolved);
+  const body = note.content.trim();
+  const text = transformBody(body, index, pair.self, unresolved);
   const raw = matter.stringify(`${text}\n`, merged);
+  // `raw` re-serializes the frontmatter without the dropped properties, so
+  // its height is not the file's: count the file's own frontmatter and the
+  // blank lines the trim dropped, so a link diagnostic names the line the
+  // author sees in the note.
+  const leading = note.content.slice(0, note.content.indexOf(body));
   return {
     body: { format: "md", text },
+    bodyLineOffset: note.frontmatterLines + leading.split("\n").length - 1,
     data: merged,
     hash: hashText(raw),
     raw,
@@ -782,11 +792,13 @@ const readNote = async (
 ): Promise<ParsedNote | null> => {
   const absPath = join(vaultDir, rel);
   try {
-    const { content, data } = matter(await readFile(absPath, "utf-8"));
+    const file = await readFile(absPath, "utf-8");
+    const { content, data } = matter(file);
     return {
       absPath,
       content,
       data,
+      frontmatterLines: strippedLineOffset(file, content),
       // Version outermost, then locale, the way `normalizeEntry` reads the
       // ref — the slug is built from what remains, so the pipeline's own
       // re-prefixing does not stack a second `fr/` or `v1.0/` onto the route.
@@ -1030,6 +1042,8 @@ export const obsidianSource = (
     contentRoot: vaultDir,
     load,
     name: options.name,
+    // Notes are named like files: `01 Intro` sorts first and routes `/intro`.
+    orderedNames: true,
     prefix: options.prefix,
     read,
     staged: true,

package/src/core/sources/payload.ts

@@ -129,6 +129,7 @@ export const payloadSource = (
       name: options.name,
       pollInterval: options.pollInterval,
       prefix: options.prefix,
+      withContext: (next) => payloadSource(options, next),
     },
     ctx
   );

package/src/core/sources/portable-text.ts

@@ -4,7 +4,14 @@
  * user-supplied serializer or are skipped with a noted comment. Output is
  * Markdown text that flows through Blume's normal pipeline.
  */
-import { escapeMarkdownText, image, unsupported, writesMdx } from "./lower.ts";
+import {
+  guardBlockStart,
+  image,
+  renderInline,
+  renderLink,
+  unsupported,
+  writesMdx,
+} from "./lower.ts";
 
 /**
  * A field value on a Portable Text node: the arbitrary JSON the CMS query
@@ -66,47 +73,29 @@ const HEADING_STYLES = new Map([
   ["h6", "###### "],
 ]);
 
-/** Wrap a span's text in Markdown for its marks (decorators + link defs). */
+/**
+ * A span as Markdown for its marks, through the shared lowering every CMS
+ * uses: prose is escaped, a code span outruns the backticks inside it, edge
+ * whitespace stays outside emphasis, and a link def wraps last (so its label
+ * keeps emphasis) only when its destination is safe to click.
+ */
 const renderSpan = (
   span: PortableTextSpan,
   defs: Map<string, PortableTextMarkDef>
 ): string => {
-  // Code spans stay verbatim: their text is literal inside the backticks,
-  // and backslash escapes would render as backslashes.
-  const isCode = span.marks?.includes("code") ?? false;
-  let text = isCode ? (span.text ?? "") : escapeMarkdownText(span.text ?? "");
-  if (!span.marks || span.marks.length === 0) {
-    return text;
-  }
-  // Decorators wrap inline; a link def wraps last so its label keeps emphasis.
-  let link: PortableTextMarkDef | undefined;
-  for (const mark of span.marks) {
-    switch (mark) {
-      case "strong": {
-        text = `**${text}**`;
-        break;
-      }
-      case "em": {
-        text = `*${text}*`;
-        break;
-      }
-      case "code": {
-        text = `\`${text}\``;
-        break;
-      }
-      case "strike-through": {
-        text = `~~${text}~~`;
-        break;
-      }
-      default: {
-        const def = defs.get(mark);
-        if (def?._type === "link") {
-          link = def;
-        }
-      }
-    }
-  }
-  return link?.href ? `[${text}](${link.href})` : text;
+  const marks = span.marks ?? [];
+  const link = marks
+    .map((mark) => defs.get(mark))
+    .findLast((def) => def?._type === "link");
+  return renderLink(
+    renderInline(span.text ?? "", {
+      bold: marks.includes("strong"),
+      code: marks.includes("code"),
+      italic: marks.includes("em"),
+      strike: marks.includes("strike-through"),
+    }),
+    link?.href
+  );
 };
 
 /** Render the inline children of a block to a single Markdown string. */
@@ -114,16 +103,45 @@ const renderChildren = (block: PortableTextBlock): string => {
   const defs = new Map(
     (block.markDefs ?? []).map((def) => [def._key, def] as const)
   );
-  return (block.children ?? []).map((span) => renderSpan(span, defs)).join("");
+  return guardBlockStart(
+    (block.children ?? []).map((span) => renderSpan(span, defs)).join("")
+  );
 };
 
 /** Whether an image block's `alt` field is usable alt text (CMS JSON may hold anything). */
 const isAltText = (value: PortableTextValue): value is string =>
   typeof value === "string";
 
+/** The marker a list block opens with. */
+const listMarker = (block: PortableTextBlock): string =>
+  block.listItem === "number" ? "1." : "-";
+
+/**
+ * How far each block is indented. Portable Text lists are flat blocks with a
+ * `level`, while Markdown nests an item by indenting it to its parent item's
+ * content column: two past a `-` item's indent, three past a `1.` item's. The
+ * column comes from the item actually above, so a skipped level nests under
+ * the deepest open item instead of indenting into a code block.
+ */
+const listIndents = (blocks: PortableTextBlock[]): number[] => {
+  const columns: number[] = [];
+  return blocks.map((block) => {
+    if (!block.listItem) {
+      columns.length = 0;
+      return 0;
+    }
+    const depth = Math.min(Math.max(0, (block.level ?? 1) - 1), columns.length);
+    const indent = columns[depth - 1] ?? 0;
+    columns.length = depth;
+    columns.push(indent + listMarker(block).length + 1);
+    return indent;
+  });
+};
+
 const renderBlock = (
   block: PortableTextBlock,
-  options: PortableTextOptions
+  options: PortableTextOptions,
+  indent: number
 ): string => {
   const custom = options.serializers?.[block._type];
   if (custom) {
@@ -143,9 +161,7 @@ const renderBlock = (
 
   const inline = renderChildren(block);
   if (block.listItem) {
-    const indent = "  ".repeat(Math.max(0, (block.level ?? 1) - 1));
-    const marker = block.listItem === "number" ? "1." : "-";
-    return `${indent}${marker} ${inline}`;
+    return `${" ".repeat(indent)}${listMarker(block)} ${inline}`;
   }
   if (block.style === "blockquote") {
     return `> ${inline}`;
@@ -158,7 +174,10 @@ export const portableTextToMarkdown = (
   blocks: PortableTextBlock[],
   options: PortableTextOptions = {}
 ): string => {
-  const lines = blocks.map((block) => renderBlock(block, options));
+  const indents = listIndents(blocks);
+  const lines = blocks.map((block, i) =>
+    renderBlock(block, options, indents[i] ?? 0)
+  );
   // List items are single-newline separated; everything else gets a blank line.
   const out: string[] = [];
   for (let i = 0; i < lines.length; i += 1) {