pr-shepherd 0.39.0 → 0.41.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pr-shepherd",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "author": {
     "name": "Jonathan Ong",
     "email": "jonathanrichardong@gmail.com"

package/README.md

@@ -25,7 +25,7 @@ Full reference: [docs/README.md](docs/README.md). Feature matrix: [docs/features
 
 `pr-shepherd` moves deterministic PR orchestration into a local MCP server, with a CLI for shells and CI. Both interfaces fetch the same GitHub state, emit raw-enough context, and return a numbered plan for the calling agent to follow.
 
-The MCP server exposes three tools: `iterate`, `apply`, and `build_suggestion_patch`. `apply` accepts ordered review mutations, file-view mutations, and journal entries. The shipped skills are thin dispatchers for those tools.
+The MCP server exposes three tools: `iterate`, `apply`, and `build_suggestion_patch`. `apply` accepts ordered review mutations, file-view mutations, and journal entries. Direct MCP calls require a repository-qualified `pr`: a GitHub PR URL or `owner/repo#N`, matching the repository where the server started. The CLI and programmatic API also retain bare-number and current-branch PR discovery. The shipped skills are thin dispatchers for those tools.
 
 Each tick returns exactly one action:
 
@@ -115,7 +115,7 @@ Grok:
 /pr-shepherd 42
 ```
 
-MCP clients call `iterate` once per tick, then use `apply` for review/file/journal mutations and `build_suggestion_patch` for an anchored suggestion. `iterate` returns the same structured action data as the CLI, including its review mutation arguments. The client owns recurrence, so this works consistently in Codex, Claude Code, Grok, and any other stdio MCP client.
+MCP clients call `iterate` once per tick, then use `apply` for review/file/journal mutations and `build_suggestion_patch` for an anchored suggestion. Every direct MCP call supplies the same repository-qualified PR reference. `iterate` returns the same structured action data as the CLI, including its review mutation arguments. The client owns recurrence, so this works consistently in Codex, Claude Code, Grok, and any other stdio MCP client.
 
 The CLI remains useful for shell workflows. Its canonical polling form is:
 
@@ -133,6 +133,24 @@ pr-shepherd iterate 42                 # single tick
 
 Use `apply` with ordered operations to reply/resolve/minimize/dismiss review items, mark changed files viewed, or append an idempotent Shepherd Journal item. Use `build_suggestion_patch` to turn one review suggestion into a validated patch and commit metadata; it never changes the worktree or git history.
 
+### Extract Shepherd Journal Entries
+
+The pure `pr-shepherd/journal` entry point can extract one validated journal without GitHub access:
+
+```ts
+import { extractShepherdJournal } from "pr-shepherd/journal";
+
+const result = extractShepherdJournal(prBody);
+if (!result.ok) throw new Error(result.error);
+
+for (const entry of result.journal?.entries ?? []) console.log(entry);
+```
+
+The result identifies canonical `details` versus historical `legacy` H2 journals and returns each
+complete Markdown list item with LF line endings. It fails closed for malformed or ambiguous
+containers and ignores journal-shaped examples hidden in Markdown constructs. The full journal API,
+including append and reconciliation helpers, is documented in [docs/api.md](docs/api.md).
+
 ### Clean Local State
 
 `pr-shepherd` stores seen markers, fix-attempt counters, stall fingerprints, ready-delay markers, and logs under `$PR_SHEPHERD_STATE_DIR` (default `$TMPDIR/pr-shepherd-state`).

package/bin/api.d.mts

@@ -6,7 +6,7 @@ export interface CreatePrShepherdOptions {
     /** Working directory used for git, config, and classification-rule lookups. */
     cwd?: string;
 }
-/** A positive PR number or canonical GitHub pull-request URL. */
+/** A positive PR number, GitHub pull-request URL, or owner/repo#number reference. */
 export type PrReference = number | string;
 export type IterateInput = Omit<IterateCommandOptions, "format" | "prNumber"> & {
     pr?: PrReference;

package/bin/api.mjs

@@ -8,6 +8,7 @@ import { runMarkFilesAsViewed, } from "./commands/mark-files-as-viewed.mjs";
 import { runResolveMutate } from "./commands/resolve-mutate.mjs";
 import { runWithExecutionCwd } from "./execution-context.mjs";
 import { getRepoInfo } from "./github/client.mjs";
+import { parsePrReference } from "./pr-reference.mjs";
 /** Raised before any API mutation when an input cannot be validated. */
 export class PrShepherdValidationError extends Error {
     constructor(message) {
@@ -108,7 +109,7 @@ function validateApplyInput(input) {
     }
     for (const operation of input.operations)
         validateOperation(operation);
-    parsePrReference(input.pr);
+    validatePrReference(input.pr);
 }
 function validateOperation(operation) {
     if (!operation || typeof operation !== "object") {
@@ -192,38 +193,21 @@ function validateSuggestionPatchInput(input) {
     if (input.description !== undefined && typeof input.description !== "string") {
         throw new PrShepherdValidationError("buildSuggestionPatch.description must be a string");
     }
-    parsePrReference(input.pr);
+    validatePrReference(input.pr);
 }
-function parsePrReference(pr) {
-    if (pr === undefined)
-        return {};
-    if (typeof pr === "number" && Number.isInteger(pr) && pr > 0)
-        return { number: pr };
-    if (typeof pr === "string") {
-        try {
-            const url = new URL(pr);
-            const parts = url.pathname.split("/").filter(Boolean);
-            if ((url.protocol === "https:" || url.protocol === "http:") &&
-                (url.hostname === "github.com" || url.hostname === "www.github.com") &&
-                parts.length === 4 &&
-                parts[2] === "pull" &&
-                /^[1-9][0-9]*$/.test(parts[3])) {
-                return { number: Number(parts[3]), repository: `${parts[0]}/${parts[1]}` };
-            }
-        }
-        catch {
-            // Construct the uniform public validation error below.
-        }
-    }
-    throw new PrShepherdValidationError("pr must be a positive number or a GitHub pull-request URL");
+function validatePrReference(pr) {
+    const parsed = parsePrReference(pr);
+    if (parsed !== null)
+        return parsed;
+    throw new PrShepherdValidationError("pr must be a positive number, a GitHub pull-request URL, or owner/repo#number");
 }
 async function resolvePrReference(pr) {
-    const parsed = parsePrReference(pr);
+    const parsed = validatePrReference(pr);
     if (parsed.repository !== undefined) {
         const repo = await getRepoInfo();
         const currentRepository = `${repo.owner}/${repo.name}`;
         if (parsed.repository.toLowerCase() !== currentRepository.toLowerCase()) {
-            throw new PrShepherdValidationError(`PR URL repository ${parsed.repository} does not match the configured repository ${currentRepository}`);
+            throw new PrShepherdValidationError(`PR reference repository ${parsed.repository} does not match the configured repository ${currentRepository}`);
         }
     }
     return parsed.number;

package/bin/commands/journal/journal-item.mjs

@@ -1,4 +1,53 @@
-import { isJournalLikeSummary, isReservedJournalMarker } from "./journal-markdown.mjs";
+import { inQuotedHtmlAttribute, rawHtmlEnd, rawHtmlStart } from "../../journal/markdown-html.mjs";
+import { stripMarkdownContainer } from "../../journal/markdown-container.mjs";
+import { scanMarkdownLines } from "../../journal/markdown-line.mjs";
+const RESERVED_CONTAINER_TAG = /(?:<details(?:\s+[^>]*)?\/?>|<\/details>)|<summary(?:\s+[^>]*)?>\s*Shepherd\s+Journal\b/i;
+function reservedContainerTag(lines) {
+    const syntax = scanMarkdownLines(lines);
+    for (const [index] of lines.entries()) {
+        const match = RESERVED_CONTAINER_TAG.exec(syntax[index].visiblePrefix);
+        if (match)
+            return match[0];
+    }
+    return reservedContainerTagInRawHtml(lines);
+}
+function reservedContainerTagInRawHtml(lines) {
+    let block = null;
+    for (const line of lines) {
+        if (block) {
+            const content = stripMarkdownContainer(line, block.container);
+            if (content === null) {
+                block = null;
+            }
+            else {
+                const marker = reservedContainerTagOutsideHtmlAttributes(content);
+                if (marker)
+                    return marker;
+                if (rawHtmlEnd(block, content) !== null)
+                    block = null;
+                continue;
+            }
+        }
+        const opening = rawHtmlStart(line);
+        if (!opening)
+            continue;
+        const content = stripMarkdownContainer(line, opening.container) ?? "";
+        const marker = reservedContainerTagOutsideHtmlAttributes(content);
+        if (marker)
+            return marker;
+        if (rawHtmlEnd(opening, content) === null)
+            block = opening;
+    }
+    return null;
+}
+function reservedContainerTagOutsideHtmlAttributes(line) {
+    const expression = new RegExp(RESERVED_CONTAINER_TAG.source, "gi");
+    for (const match of line.matchAll(expression)) {
+        if (!inQuotedHtmlAttribute(line, match.index))
+            return match[0];
+    }
+    return null;
+}
 export function validateJournalItem(input) {
     const lines = input.split("\n").map((line) => line.trimEnd());
     const nonBlank = lines.filter((line) => line.trim() !== "");
@@ -11,6 +60,13 @@ export function validateJournalItem(input) {
             error: `journal item must start with "- <text>"; got: ${JSON.stringify(nonBlank[0].slice(0, 40))}`,
         };
     }
+    const marker = reservedContainerTag(lines);
+    if (marker) {
+        return {
+            ok: false,
+            error: `journal item must not contain journal container marker ${JSON.stringify(marker)}`,
+        };
+    }
     for (const line of nonBlank.slice(1)) {
         if (line.startsWith("#")) {
             return {
@@ -18,12 +74,6 @@ export function validateJournalItem(input) {
                 error: "journal item lines must not start with # (would break section structure)",
             };
         }
-        if (isReservedJournalMarker(line.trim()) || isJournalLikeSummary(line.trim())) {
-            return {
-                ok: false,
-                error: `journal item must not contain standalone journal container marker ${JSON.stringify(line.trim())}`,
-            };
-        }
     }
     return { ok: true, item: lines.join("\n").trim() };
 }

package/bin/commands/journal/journal-markdown.d.mts

@@ -8,6 +8,5 @@ export type MarkdownScanState = {
 };
 export declare function findDetailsClose(lines: string[], startIdx: number): number;
 export declare function isJournalLikeSummary(line: string): boolean;
-export declare function isReservedJournalMarker(line: string): boolean;
 export declare function skipMarkdownLine(state: MarkdownScanState, line: string): boolean;
 export {};

package/bin/commands/journal/journal-markdown.mjs

@@ -1,4 +1,4 @@
-import { SHEPHERD_JOURNAL_DETAILS_CLOSE, SHEPHERD_JOURNAL_DETAILS_SUMMARY, } from "../shepherd-journal.mjs";
+import { SHEPHERD_JOURNAL_DETAILS_CLOSE } from "../shepherd-journal.mjs";
 export function findDetailsClose(lines, startIdx) {
     let depth = 1;
     const state = { fence: null, comment: false };
@@ -23,11 +23,6 @@ export function findDetailsClose(lines, startIdx) {
 export function isJournalLikeSummary(line) {
     return /^<summary>\s*Shepherd\s+Journal\b/i.test(line);
 }
-export function isReservedJournalMarker(line) {
-    return (isDetailsOpening(line) ||
-        line === SHEPHERD_JOURNAL_DETAILS_SUMMARY ||
-        line === SHEPHERD_JOURNAL_DETAILS_CLOSE);
-}
 function isDetailsOpening(line) {
     return /^<details(?:\s+[^>]*)?>$/.test(line);
 }

package/bin/journal/append.d.mts

@@ -0,0 +1,8 @@
+import { validateJournalItem } from "../commands/journal/journal-item.mts";
+export { validateJournalItem };
+export interface AppendResult {
+    body: string;
+    mutated: boolean;
+    sectionExisted: boolean;
+}
+export declare function appendJournalItem(body: string, item: string): AppendResult;

package/bin/journal/append.mjs

@@ -0,0 +1,96 @@
+import { validateJournalItem } from "../commands/journal/journal-item.mjs";
+import { fenceStart } from "./markdown-container.mjs";
+import { rawHtmlStart } from "./markdown-html.mjs";
+import { containsJournalEntry, scanShepherdJournal } from "./reconcile.mjs";
+import { isSafeMarkdownInsertionPoint } from "./markdown-line.mjs";
+const OPEN = "<details>";
+const SUMMARY = "<summary>Shepherd Journal</summary>";
+const CLOSE = "</details>";
+export { validateJournalItem };
+export function appendJournalItem(body, item) {
+    const validated = validateJournalItem(item);
+    if (!validated.ok)
+        throw new Error(validated.error);
+    if (validated.item
+        .split("\n")
+        .slice(1)
+        .some((line) => /^(?:[-+*]|\d{1,9}[.)])[ \t]+/.test(line)))
+        throw new Error("journal item must contain exactly one top-level list item");
+    item = validated.item;
+    if (item
+        .split("\n")
+        .some((line, index) => fenceStart(index === 0 ? line.slice(2) : line) ||
+        rawHtmlStart(index === 0 ? line.slice(2) : line)))
+        throw new Error("journal item must not start with a fenced or raw HTML block");
+    const newline = body.includes("\r\n") ? "\r\n" : "\n";
+    const lines = body.replaceAll("\r\n", "\n").split("\n");
+    const bounds = scanShepherdJournal(lines);
+    if (bounds === "error")
+        throw new Error("malformed, duplicate, or ambiguous Shepherd Journal container");
+    if (!bounds) {
+        if (!isSafeMarkdownInsertionPoint(lines))
+            throw new Error("cannot append Shepherd Journal inside an unterminated Markdown construct");
+        return create(lines, item, newline);
+    }
+    const content = lines.slice(bounds.contentStart, bounds.contentEnd);
+    if (bounds.format === "details" && containsJournalEntry(content, item))
+        return { body, mutated: false, sectionExisted: true };
+    const next = [...trimEnd(content), ...item.split("\n")];
+    if (bounds.format === "details") {
+        return {
+            body: [
+                ...lines.slice(0, bounds.contentStart),
+                ...next,
+                ...lines.slice(bounds.contentEnd),
+            ].join(newline),
+            mutated: true,
+            sectionExisted: true,
+        };
+    }
+    const legacyContent = trim(content);
+    const canonical = [
+        OPEN,
+        SUMMARY,
+        "",
+        ...legacyContent,
+        ...(containsJournalEntry(content, item) ? [] : item.split("\n")),
+        CLOSE,
+    ];
+    const suffix = lines.slice(bounds.end);
+    return {
+        body: [
+            ...lines.slice(0, bounds.start),
+            ...canonical,
+            ...(suffix[0]?.trim() ? [""] : []),
+            ...suffix,
+        ].join(newline),
+        mutated: true,
+        sectionExisted: true,
+    };
+}
+function create(lines, item, newline) {
+    const existing = trimEnd(lines);
+    return {
+        body: [
+            ...existing,
+            ...(existing.length ? [""] : []),
+            OPEN,
+            SUMMARY,
+            "",
+            ...item.split("\n"),
+            CLOSE,
+        ].join(newline),
+        mutated: true,
+        sectionExisted: false,
+    };
+}
+function trimEnd(lines) {
+    let end = lines.length;
+    while (end > 0 && lines[end - 1].trim() === "")
+        end--;
+    return lines.slice(0, end);
+}
+function trim(lines) {
+    const start = lines.findIndex((line) => line.trim() !== "");
+    return start === -1 ? [] : trimEnd(lines.slice(start));
+}

package/bin/journal/extract.d.mts

@@ -0,0 +1,16 @@
+/** Result of extracting the single visible structural Shepherd Journal from Markdown. */
+export type ShepherdJournalExtraction = {
+    journal: null;
+    ok: true;
+} | {
+    journal: {
+        entries: string[];
+        format: "details" | "legacy";
+    };
+    ok: true;
+} | {
+    error: string;
+    ok: false;
+};
+/** Extract ordered journal entries while failing closed on malformed or ambiguous content. */
+export declare function extractShepherdJournal(body: string): ShepherdJournalExtraction;

package/bin/journal/extract.mjs

@@ -0,0 +1,71 @@
+import { parseShepherdJournalEntries, scanShepherdJournal } from "./reconcile.mjs";
+import { isMarkdownBlockStart, scanMarkdownLines } from "./markdown-line.mjs";
+import { stripMarkdownContainer } from "./markdown-container.mjs";
+import { isIndentedCode } from "./markdown-structure.mjs";
+function hasUnrecognizedJournalContent(lines) {
+    const syntax = scanMarkdownLines(lines);
+    let foundEntry = false;
+    let lazyContinuation = false;
+    let nestedBlock = false;
+    for (const [index, line] of lines.entries()) {
+        const scanned = syntax[index];
+        if (scanned.visiblePrefix.startsWith("- ") && /^- \S/.test(line)) {
+            foundEntry = true;
+            lazyContinuation = true;
+            nestedBlock = false;
+            continue;
+        }
+        if (line.trim() === "") {
+            if (foundEntry)
+                lazyContinuation = false;
+            continue;
+        }
+        if (!foundEntry)
+            return true;
+        const content = stripMarkdownContainer(line, [{ kind: "list", width: 2 }]);
+        if (content === null) {
+            if (!lazyContinuation || isMarkdownBlockStart(line))
+                return true;
+            continue;
+        }
+        if (scanned.ignored || isMarkdownBlockStart(content) || isIndentedCode(content)) {
+            lazyContinuation = false;
+            nestedBlock = true;
+            continue;
+        }
+        if (nestedBlock && /^[ \t]/.test(content)) {
+            lazyContinuation = false;
+            continue;
+        }
+        lazyContinuation = true;
+        nestedBlock = false;
+    }
+    return false;
+}
+/** Extract ordered journal entries while failing closed on malformed or ambiguous content. */
+export function extractShepherdJournal(body) {
+    const lines = body.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const journal = scanShepherdJournal(lines);
+    if (journal === "error") {
+        return {
+            error: "malformed, duplicate, or ambiguous Shepherd Journal container",
+            ok: false,
+        };
+    }
+    if (!journal)
+        return { journal: null, ok: true };
+    const content = lines.slice(journal.contentStart, journal.contentEnd);
+    if (hasUnrecognizedJournalContent(content)) {
+        return {
+            error: "Shepherd Journal content uses an unrecognized entry format",
+            ok: false,
+        };
+    }
+    return {
+        journal: {
+            entries: parseShepherdJournalEntries(content).map((entry) => entry.join("\n")),
+            format: journal.format,
+        },
+        ok: true,
+    };
+}

package/bin/journal/index.d.mts

@@ -0,0 +1,4 @@
+/** GitHub-free Shepherd Journal helpers for programmatic PR-body reconciliation. */
+export { appendJournalItem, validateJournalItem, type AppendResult } from "./append.mts";
+export { extractShepherdJournal, type ShepherdJournalExtraction } from "./extract.mts";
+export { reconcileShepherdJournal, type ShepherdJournalReconcileResult } from "./reconcile.mts";

package/bin/journal/index.mjs

@@ -0,0 +1,4 @@
+/** GitHub-free Shepherd Journal helpers for programmatic PR-body reconciliation. */
+export { appendJournalItem, validateJournalItem } from "./append.mjs";
+export { extractShepherdJournal } from "./extract.mjs";
+export { reconcileShepherdJournal } from "./reconcile.mjs";

package/bin/journal/markdown-backticks.d.mts

@@ -0,0 +1,9 @@
+export type BacktickRun = {
+    escaped: boolean;
+    index: number;
+    length: number;
+    quoted: boolean;
+};
+export declare function backtickRuns(line: string): BacktickRun[];
+export declare function nextBacktickRun(runs: BacktickRun[], offset: number, length?: number): BacktickRun | undefined;
+export declare function nextCodeOpener(runs: BacktickRun[], offset: number): BacktickRun | undefined;

package/bin/journal/markdown-backticks.mjs

@@ -0,0 +1,34 @@
+export function backtickRuns(line) {
+    const runs = [];
+    let inTag = false;
+    let quote = null;
+    for (let i = 0; i < line.length; i++) {
+        if (!inTag && line[i] === "<" && /^\/?[A-Za-z]/.test(line.slice(i + 1)))
+            inTag = true;
+        else if (inTag && quote) {
+            if (line[i] === quote)
+                quote = null;
+        }
+        else if (inTag && (line[i] === '"' || line[i] === "'"))
+            quote = line[i] === '"' ? '"' : "'";
+        else if (inTag && line[i] === ">")
+            inTag = false;
+        if (line[i] !== "`")
+            continue;
+        let slashes = 0;
+        while (line[i - slashes - 1] === "\\")
+            slashes++;
+        let end = i;
+        while (line[end] === "`")
+            end++;
+        runs.push({ escaped: slashes % 2 === 1, index: i, length: end - i, quoted: quote !== null });
+        i = end - 1;
+    }
+    return runs;
+}
+export function nextBacktickRun(runs, offset, length) {
+    return runs.find((run) => run.index >= offset && (length === undefined || run.length === length));
+}
+export function nextCodeOpener(runs, offset) {
+    return runs.find((run) => run.index >= offset && !run.quoted);
+}

package/bin/journal/markdown-container.d.mts

@@ -0,0 +1,22 @@
+export type MarkdownContainer = Array<{
+    kind: "list";
+    width: number;
+} | {
+    kind: "quote";
+}>;
+export declare function markdownContainer(line: string): {
+    content: string;
+    indent: number;
+    tokens: MarkdownContainer;
+};
+export declare function resolveMarkdownContainer(line: string, active: MarkdownContainer): ReturnType<typeof markdownContainer>;
+export declare function fenceStart(line: string, parsed?: {
+    content: string;
+    indent: number;
+    tokens: MarkdownContainer;
+}): {
+    container: MarkdownContainer;
+    length: number;
+    marker: string;
+} | null;
+export declare function stripMarkdownContainer(line: string, tokens: MarkdownContainer): string | null;

package/bin/journal/markdown-container.mjs

@@ -0,0 +1,110 @@
+function visualColumn(line, end) {
+    let column = 0;
+    for (let i = 0; i < end; i++)
+        column = line[i] === "\t" ? column + (4 - (column % 4)) : column + 1;
+    return column;
+}
+function quoteEnd(line, offset) {
+    let marker = offset;
+    while (marker < offset + 3 && line[marker] === " ")
+        marker++;
+    if (line[marker] !== ">")
+        return null;
+    marker++;
+    return line[marker] === " " || line[marker] === "\t" ? marker + 1 : marker;
+}
+function listEnd(line, offset) {
+    let marker = offset;
+    while (marker < offset + 3 && line[marker] === " ")
+        marker++;
+    const match = line.slice(marker).match(/^(?:[-+*]|\d{1,9}[.)])/)?.[0];
+    if (!match)
+        return null;
+    let end = marker + match.length;
+    const paddingStart = end;
+    const startColumn = visualColumn(line, offset);
+    let column = visualColumn(line, end);
+    let padding = 0;
+    while (line[end] === " " || line[end] === "\t") {
+        const nextColumn = line[end] === "\t" ? column + (4 - (column % 4)) : column + 1;
+        padding += nextColumn - column;
+        column = nextColumn;
+        end++;
+    }
+    if (padding === 0)
+        return null;
+    if (padding > 4) {
+        end = paddingStart + 1;
+        const actualWidth = visualColumn(line, end) - visualColumn(line, paddingStart);
+        column = visualColumn(line, paddingStart) + 1;
+        return { end, indent: actualWidth - 1, width: column - startColumn };
+    }
+    return { end, indent: 0, width: column - startColumn };
+}
+export function markdownContainer(line) {
+    const tokens = [];
+    let indent = 0;
+    let offset = 0;
+    while (true) {
+        const quote = quoteEnd(line, offset);
+        if (quote !== null) {
+            tokens.push({ kind: "quote" });
+            offset = quote;
+            continue;
+        }
+        const list = listEnd(line, offset);
+        if (!list)
+            break;
+        tokens.push({ kind: "list", width: list.width });
+        offset = list.end;
+        indent = list.indent;
+        if (indent)
+            break;
+    }
+    return { content: line.slice(offset), indent, tokens };
+}
+export function resolveMarkdownContainer(line, active) {
+    for (let depth = active.length; depth > 0; depth--) {
+        const retained = active.slice(0, depth);
+        const continuation = stripMarkdownContainer(line, retained);
+        if (continuation === null)
+            continue;
+        const nested = markdownContainer(continuation);
+        return {
+            content: nested.content,
+            indent: nested.indent,
+            tokens: [...retained, ...nested.tokens],
+        };
+    }
+    return markdownContainer(line);
+}
+export function fenceStart(line, parsed = markdownContainer(line)) {
+    const match = `${" ".repeat(parsed.indent)}${parsed.content}`.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    return match && !(match[1][0] === "`" && match[2].includes("`"))
+        ? { container: parsed.tokens, length: match[1].length, marker: match[1][0] }
+        : null;
+}
+export function stripMarkdownContainer(line, tokens) {
+    let offset = 0;
+    for (const [index, token] of tokens.entries()) {
+        if (token.kind === "quote") {
+            const end = quoteEnd(line, offset);
+            if (end === null)
+                return null;
+            offset = end;
+            continue;
+        }
+        if (line.slice(offset).trim() === "" &&
+            tokens.slice(index).every((item) => item.kind === "list"))
+            return "";
+        const startColumn = visualColumn(line, offset);
+        let column = startColumn;
+        while (column - startColumn < token.width && (line[offset] === " " || line[offset] === "\t")) {
+            column = line[offset] === "\t" ? column + (4 - (column % 4)) : column + 1;
+            offset++;
+        }
+        if (column - startColumn < token.width)
+            return null;
+    }
+    return line.slice(offset);
+}

package/bin/journal/markdown-html.d.mts

@@ -0,0 +1,20 @@
+import { type MarkdownContainer } from "./markdown-container.mts";
+export type RawHtmlBlock = {
+    container: MarkdownContainer;
+    kind: "closing-tag";
+    tag: string;
+} | {
+    container: MarkdownContainer;
+    kind: "blank-line";
+} | {
+    container: MarkdownContainer;
+    kind: "terminator";
+    terminator: string;
+};
+export declare function rawHtmlStart(line: string, parsed?: {
+    content: string;
+    indent: number;
+    tokens: MarkdownContainer;
+}): RawHtmlBlock | null;
+export declare function rawHtmlEnd(block: RawHtmlBlock, content: string): number | null;
+export declare function inQuotedHtmlAttribute(line: string, offset: number): boolean;