canopycms 0.5.0 → 0.7.0

package/dist/utils/markdown-restyle.js

@@ -0,0 +1,482 @@
+/**
+ * Restyles markdown to `MARKDOWN_EXPORT_OPTIONS`'s markers IN PLACE: each normalisation Prettier
+ * makes is an edit to the marker bytes of the text as typed, so every other byte (URLs, titles,
+ * entities, escapes, inline code, JSX) is the edit's own by construction. A serialiser cannot
+ * promise that: it writes every value from the tree, and a tree-equal rewrite of a URL or an
+ * entity is invisible to a tree check.
+ *
+ * The normalisations, each as Prettier 3 writes them:
+ * - emphasis `_`, or `*` where `_` could not delimit it (beside a word character) and inside
+ *   other emphasis; strong `**`. Emphasis after a literal `_` in its block keeps `*`, because
+ *   Prettier misreads `a_b _x_` (`underscoreStarts`);
+ * - bullets `-`, and ordered delimiters `.`, alternating with `*` / `)` for a list that follows
+ *   another; ordered numbering by `orderedNumber`, where that keeps each marker's width;
+ * - `---` rules (`***` inside a list, see `ruleIn`), `# x` headings for one-line setext and ATX
+ *   headings, backtick fences for `~~~`;
+ * - one blank line between blocks, none between link definitions; between list items and an
+ *   item's blocks, several blank lines become one, which keeps a list's looseness;
+ * - no trailing space before a soft line ending; an escaped `_` between two letters or digits
+ *   unescaped, except in links and in blocks holding `$` or `[[`;
+ * - tables padded to their columns, when every cell is printable ASCII.
+ *
+ * Each top-level block's edits are kept only if the text they are part of reads back as the
+ * edit (`readsBack`): all at once, then halves, within a parse budget, so a block that cannot be
+ * restyled leaves the others restyled.
+ */
+import { MARKDOWN_EXPORT_OPTIONS } from './markdown-export-options.js';
+const BULLETS = [MARKDOWN_EXPORT_OPTIONS.bullet, '*'];
+const DELIMITERS = ['.', ')'];
+const EMPHASIS = MARKDOWN_EXPORT_OPTIONS.emphasis;
+const STRONG = MARKDOWN_EXPORT_OPTIONS.strong.repeat(2);
+const RULE = MARKDOWN_EXPORT_OPTIONS.rule.repeat(3);
+/** A character Prettier counts as part of a word: neither whitespace nor punctuation. */
+const WORD_CHAR = /[^\s\p{P}\p{S}]/u;
+/** Where a block's text ends and the next one's begins: whitespace, and blockquote markers. */
+const GAP = /^[ \t>]*(?:\r?\n[ \t>]*)+$/;
+function startOf(node) {
+    return node?.position?.start.offset;
+}
+function endOf(node) {
+    return node?.position?.end.offset;
+}
+function apply(source, edits, from = 0, to = source.length) {
+    let out = '';
+    let at = from;
+    for (const edit of [...edits].sort((a, b) => a.start - b.start)) {
+        if (edit.start < at || edit.end > to)
+            continue;
+        out += source.slice(at, edit.start) + edit.text;
+        at = edit.end;
+    }
+    return out + source.slice(at, to);
+}
+/**
+ * Where each text or MDX expression under `node` that holds a literal `_` starts, outside
+ * bracketed links: Prettier reads `[a_b](u) _x_` and `<https://x/a_b> _x_` correctly, but a
+ * bare URL only when its host has a dot, so bare URLs count.
+ */
+function underscoreStarts(node) {
+    const bare = startOf(node) === startOf(node.children?.[0]);
+    if ((node.type === 'link' && !bare) || node.type === 'linkReference')
+        return [];
+    if (node.type === 'text' || node.type === 'mdxTextExpression') {
+        const start = startOf(node);
+        return start !== undefined && (node.value ?? '').includes('_') ? [start] : [];
+    }
+    return (node.children ?? []).flatMap(underscoreStarts);
+}
+/**
+ * The number Prettier writes for item `index` of an ordered list typed with `numbers`: the first
+ * keeps its number; the rest count up from it, or are all 1 when the list is typed that way
+ * (its second number is 1, and so is its third when it starts at 0).
+ */
+export function orderedNumber(numbers, index) {
+    const [first = 1, second, third] = numbers;
+    if (index === 0)
+        return first;
+    const ones = numbers.length > 1 && second === 1 && (first !== 0 || numbers.length < 3 || third === 1);
+    return ones ? 1 : first + index;
+}
+class Restyler {
+    constructor(source) {
+        this.source = source;
+        /** The marker each list is written with, its own when it is not restyled. */
+        this.listMarker = new Map();
+        /** Per block that holds phrasing, where its text nodes with a literal `_` start. */
+        this.underscores = new Map();
+    }
+    /** Edits for `node` and everything under it, given its ancestors (nearest last). */
+    collect(node, ancestors, out) {
+        const inside = [...ancestors, node];
+        switch (node.type) {
+            case 'emphasis':
+                this.emphasis(node, ancestors, out);
+                break;
+            case 'strong':
+                this.strong(node, out);
+                break;
+            case 'text':
+                this.text(node, ancestors, out);
+                return;
+            case 'thematicBreak':
+                this.replaceWhole(node, this.ruleIn(ancestors), out);
+                return;
+            case 'code':
+                this.fence(node, out);
+                return;
+            case 'heading':
+                this.heading(node, inside, out);
+                return;
+            case 'table':
+                this.table(node, inside, out);
+                return;
+            default:
+                break;
+        }
+        this.children(node, inside, out);
+    }
+    /**
+     * Edits for `parent`'s children and the gaps between them. `fixed` names children whose text
+     * must stay as it is (untouched top-level blocks); their lists still count for alternation.
+     */
+    children(parent, inside, out, fixed = () => false, outFor = () => out) {
+        const children = parent.children ?? [];
+        const markers = this.listMarkers(children, fixed);
+        children.forEach((child, index) => {
+            if (fixed(index))
+                return;
+            const edits = outFor(index);
+            const marker = markers.get(child);
+            if (marker !== undefined)
+                this.list(child, marker, edits);
+            this.collect(child, inside, edits);
+        });
+        const always = parent.type === 'root' || parent.type === 'blockquote';
+        const spaced = always || parent.type === 'list' || parent.type === 'listItem';
+        if (!spaced)
+            return;
+        for (let index = 1; index < children.length; index++) {
+            if (fixed(index) && fixed(index - 1))
+                continue;
+            this.gap(children[index - 1], children[index], always, outFor(fixed(index) ? index - 1 : index));
+        }
+    }
+    /** The marker each list among `children` takes: its own, then alternating with the one before. */
+    listMarkers(children, fixed) {
+        const markers = new Map();
+        let previous;
+        children.forEach((child, index) => {
+            if (child.type !== 'list') {
+                previous = undefined;
+                return;
+            }
+            const ordered = Boolean(child.ordered);
+            const current = this.markerOf(child);
+            if (current === undefined) {
+                previous = undefined;
+                return;
+            }
+            let marker = current;
+            if (!fixed(index)) {
+                const choices = ordered ? DELIMITERS : BULLETS;
+                const next = children[index + 1];
+                const nextFixed = next?.type === 'list' && Boolean(next.ordered) === ordered && fixed(index + 1)
+                    ? this.markerOf(next)
+                    : undefined;
+                const before = previous?.ordered === ordered ? previous.marker : undefined;
+                marker = choices.find((choice) => choice !== before && choice !== nextFixed) ?? current;
+                markers.set(child, marker);
+            }
+            this.listMarker.set(child, marker);
+            previous = { ordered, marker };
+        });
+        return markers;
+    }
+    /**
+     * A rule's text: `---`, but inside a list Prettier writes `***`, or `---` when the list takes
+     * the alternate marker.
+     */
+    ruleIn(ancestors) {
+        const list = [...ancestors].reverse().find((a) => a.type === 'list');
+        if (list === undefined)
+            return RULE;
+        const marker = this.listMarker.get(list);
+        return marker === BULLETS[0] || marker === DELIMITERS[0] ? '***' : RULE;
+    }
+    /** A list's bullet, or its ordered delimiter, read from its first item. */
+    markerOf(list) {
+        const at = startOf(list.children?.[0]);
+        if (at === undefined)
+            return undefined;
+        if (!list.ordered)
+            return this.source[at];
+        return /^\d{1,9}([.)])/.exec(this.source.slice(at, at + 10))?.[1];
+    }
+    /** Item markers: the list's bullet or delimiter, and Prettier's numbering where widths allow. */
+    list(list, marker, out) {
+        const items = list.children ?? [];
+        const starts = items.map(startOf);
+        if (!list.ordered) {
+            for (const at of starts) {
+                if (at !== undefined && this.source[at] !== marker) {
+                    out.push({ start: at, end: at + 1, text: marker });
+                }
+            }
+            return;
+        }
+        const numbers = starts.map((at) => at === undefined ? null : /^(\d{1,9})[.)]/.exec(this.source.slice(at, at + 11)));
+        const typed = numbers.map((match) => Number(match?.[1]));
+        const renumber = numbers.every((match, i) => match !== null && String(orderedNumber(typed, i)).length === match[1]?.length);
+        numbers.forEach((match, i) => {
+            const at = starts[i];
+            if (match === null || at === undefined)
+                return;
+            const digits = match[1] ?? '';
+            const wanted = renumber ? String(orderedNumber(typed, i)) : digits;
+            if (wanted !== digits || match[0].slice(-1) !== marker) {
+                out.push({ start: at, end: at + match[0].length, text: wanted + marker });
+            }
+        });
+    }
+    /**
+     * The gap between two siblings with exactly one blank line, kept in the container's own
+     * prefix and line ending; where `always` is false, only a gap that had a blank line.
+     */
+    gap(a, b, always, out) {
+        const end = this.contentEnd(a);
+        const start = startOf(b);
+        if (end === undefined || start === undefined)
+            return;
+        const gap = this.source.slice(end, start);
+        if (!GAP.test(gap))
+            return;
+        const lines = gap.split(/\r?\n/);
+        if (!always && lines.length < 3)
+            return;
+        const eol = gap.includes('\r\n') ? '\r\n' : '\n';
+        const prefix = lines[lines.length - 1] ?? '';
+        // Prettier keeps consecutive link reference definitions together.
+        const together = a?.type === 'definition' && b?.type === 'definition';
+        const text = together ? eol + prefix : eol + prefix.trimEnd() + eol + prefix;
+        if (text !== gap)
+            out.push({ start: end, end: start, text });
+    }
+    /**
+     * Where `node`'s last line of content ends: a list's position runs on over the blank lines
+     * after it, which in a block quote are lines of `>`.
+     */
+    contentEnd(node) {
+        const start = startOf(node);
+        let end = endOf(node);
+        if (start === undefined || end === undefined)
+            return end;
+        for (;;) {
+            const lineStart = this.source.lastIndexOf('\n', end - 1);
+            if (lineStart <= start || !/^[ \t>]*$/.test(this.source.slice(lineStart + 1, end)))
+                break;
+            end = this.source[lineStart - 1] === '\r' ? lineStart - 1 : lineStart;
+        }
+        return end;
+    }
+    emphasis(node, ancestors, out) {
+        const start = startOf(node);
+        const end = endOf(node);
+        if (start === undefined || end === undefined)
+            return;
+        const open = this.source[start];
+        if (open !== this.source[end - 1] || (open !== '*' && open !== '_'))
+            return;
+        const marker = ancestors.some((a) => a.type === 'emphasis') ||
+            this.besideWord(start, end) ||
+            this.afterUnderscore(start, ancestors)
+            ? '*'
+            : EMPHASIS;
+        if (open === marker)
+            return;
+        out.push({ start, end: start + 1, text: marker }, { start: end - 1, end, text: marker });
+    }
+    strong(node, out) {
+        const start = startOf(node);
+        const end = endOf(node);
+        if (start === undefined || end === undefined)
+            return;
+        if (this.source.slice(start, start + 2) !== '__' || this.source.slice(end - 2, end) !== '__') {
+            return;
+        }
+        out.push({ start, end: start + 2, text: STRONG }, { start: end - 2, end, text: STRONG });
+    }
+    /** Whether the characters past the markers around `[start, end)` include a word character. */
+    besideWord(start, end) {
+        const markers = '*_';
+        let before = start - 1;
+        while (before >= 0 && markers.includes(this.source[before] ?? ''))
+            before--;
+        let after = end;
+        while (after < this.source.length && markers.includes(this.source[after] ?? ''))
+            after++;
+        return WORD_CHAR.test(this.source[before] ?? ' ') || WORD_CHAR.test(this.source[after] ?? ' ');
+    }
+    afterUnderscore(start, ancestors) {
+        const block = [...ancestors]
+            .reverse()
+            .find((a) => a.type === 'paragraph' || a.type === 'heading' || a.type === 'tableCell');
+        if (block === undefined)
+            return false;
+        let starts = this.underscores.get(block);
+        if (starts === undefined) {
+            starts = underscoreStarts(block);
+            this.underscores.set(block, starts);
+        }
+        // Text in the link the emphasis is in counts as the block's own.
+        const link = [...ancestors]
+            .reverse()
+            .find((a) => a.type === 'link' || a.type === 'linkReference');
+        const inLink = (link?.children ?? []).flatMap(underscoreStarts);
+        return [...starts, ...inLink].some((at) => at < start);
+    }
+    text(node, ancestors, out) {
+        const start = startOf(node);
+        const end = endOf(node);
+        if (start === undefined || end === undefined)
+            return;
+        const raw = this.source.slice(start, end);
+        for (const match of raw.matchAll(/[ \t]+(?=\r?\n)/g)) {
+            out.push({ start: start + match.index, end: start + match.index + match[0].length, text: '' });
+        }
+        if (ancestors.some((a) => a.type === 'link' || a.type === 'linkReference'))
+            return;
+        // In `$` math and `[[wiki links]]`, which plugins read raw, `\_` and `_` differ.
+        const block = [...ancestors]
+            .reverse()
+            .find((a) => a.type === 'paragraph' || a.type === 'heading' || a.type === 'tableCell');
+        const blockStart = startOf(block);
+        const blockEnd = endOf(block);
+        if (blockStart === undefined || blockEnd === undefined)
+            return;
+        if (/\$|\[\[/.test(this.source.slice(blockStart, blockEnd)))
+            return;
+        for (const match of raw.matchAll(/(?<=[\p{L}\p{N}])\\_(?=[\p{L}\p{N}])/gu)) {
+            out.push({ start: start + match.index, end: start + match.index + 1, text: '' });
+        }
+    }
+    replaceWhole(node, text, out) {
+        const start = startOf(node);
+        const end = endOf(node);
+        if (start === undefined || end === undefined)
+            return;
+        if (this.source.slice(start, end) !== text)
+            out.push({ start, end, text });
+    }
+    /** A `~~~` fence as backticks, when nothing inside it would end a backtick fence. */
+    fence(node, out) {
+        const start = startOf(node);
+        const end = endOf(node);
+        if (start === undefined || end === undefined)
+            return;
+        const raw = this.source.slice(start, end);
+        const close = /(?:\r?\n)[ \t>]*(~{3,})[ \t]*$/.exec(raw);
+        if (!/^~~~(?!~)[^`\n]*\n/.test(raw) || close?.[1] === undefined || raw.includes('`'))
+            return;
+        const closeAt = start + close.index + close[0].indexOf('~');
+        out.push({ start, end: start + 3, text: '```' }, { start: closeAt, end: closeAt + close[1].length, text: '```' });
+    }
+    /** A one-line heading as `# x`, its content with its own edits. */
+    heading(node, inside, out) {
+        const inner = [];
+        this.children(node, inside, inner);
+        const children = node.children ?? [];
+        const start = startOf(node);
+        const end = endOf(node);
+        const contentStart = startOf(children[0]);
+        const contentEnd = endOf(children[children.length - 1]);
+        if (start === undefined ||
+            end === undefined ||
+            contentStart === undefined ||
+            contentEnd === undefined ||
+            /[\r\n]/.test(this.source.slice(contentStart, contentEnd))) {
+            out.push(...inner);
+            return;
+        }
+        const content = apply(this.source, inner, contentStart, contentEnd);
+        const text = `${'#'.repeat(node.depth ?? 1)} ${content}`;
+        if (text !== this.source.slice(start, end))
+            out.push({ start, end, text });
+        else
+            out.push(...inner);
+    }
+    /** A table padded to its columns, as Prettier pads it; its cells keep their own text. */
+    table(node, inside, out) {
+        const start = startOf(node);
+        const end = endOf(node);
+        if (start === undefined || end === undefined)
+            return;
+        const prefix = this.source.slice(this.source.lastIndexOf('\n', start - 1) + 1, start);
+        const inner = [];
+        const rows = (node.children ?? []).map((row) => (row.children ?? []).map((cell) => {
+            const edits = [];
+            this.children(cell, [...inside, row, cell], edits);
+            inner.push(...edits);
+            const content = cell.children ?? [];
+            const from = startOf(content[0]);
+            const to = endOf(content[content.length - 1]);
+            return from === undefined || to === undefined ? '' : apply(this.source, edits, from, to);
+        }));
+        // Prettier pads by display width, which counts wide and emoji characters twice.
+        const plain = rows.every((row) => row.every((cell) => /^[\x20-\x7e]*$/.test(cell)));
+        if (!plain || !/^[ \t>]*$/.test(prefix)) {
+            out.push(...inner);
+            return;
+        }
+        const align = node.align ?? [];
+        const columns = Math.max(...rows.map((row) => row.length), align.length);
+        const widths = Array.from({ length: columns }, (_, c) => Math.max(3, ...rows.map((row) => row[c]?.length ?? 0)));
+        const pad = (text, c) => {
+            const room = (widths[c] ?? 3) - text.length;
+            if (align[c] === 'right')
+                return ' '.repeat(room) + text;
+            if (align[c] === 'center') {
+                const left = Math.floor(room / 2);
+                return ' '.repeat(left) + text + ' '.repeat(room - left);
+            }
+            return text + ' '.repeat(room);
+        };
+        const delimiter = widths.map((width, c) => {
+            const a = align[c];
+            if (a === 'left')
+                return `:${'-'.repeat(width - 1)}`;
+            if (a === 'right')
+                return `${'-'.repeat(width - 1)}:`;
+            if (a === 'center')
+                return `:${'-'.repeat(width - 2)}:`;
+            return '-'.repeat(width);
+        });
+        const line = (cells) => `| ${cells.join(' | ')} |`;
+        const lines = rows.map((row) => line(row.map(pad)));
+        lines.splice(1, 0, line(delimiter));
+        const eol = this.source.slice(start, end).includes('\r\n') ? '\r\n' : '\n';
+        const text = lines.join(eol + prefix);
+        if (text !== this.source.slice(start, end))
+            out.push({ start, end, text });
+    }
+}
+/**
+ * `source` (whose parse is `tree`) restyled in place, every top-level block for which `fixed`
+ * is false; undefined when no restyle reads back. `readsBack` returns the parse of a candidate
+ * when it means what `source` means.
+ */
+export function restyleMarkdown(source, tree, fixed, readsBack) {
+    // Positions do not count a byte-order mark, so edits would land one byte early.
+    if (source.startsWith('\uFEFF'))
+        return undefined;
+    const blocks = tree.children ?? [];
+    const groups = blocks.map(() => []);
+    new Restyler(source).children(tree, [], [], fixed, (index) => groups[index] ?? []);
+    const changed = groups.filter((group) => group.length > 0);
+    if (changed.length === 0)
+        return undefined;
+    // The whole restyle first, then halves of it, until each block that does not read back stands
+    // alone: about two parses per such block per halving, so the budget covers about five of them
+    // spread through 200 blocks. Each parse reads the whole body under the write lock, so past the
+    // budget the restyle keeps what has read back.
+    let kept = [];
+    let best;
+    let budget = 8 * Math.ceil(Math.log2(changed.length + 1)) + 8;
+    const attempt = (tried) => {
+        if (budget-- <= 0)
+            return;
+        const trial = [...kept, ...tried.flat()];
+        const text = apply(source, trial);
+        const parsed = readsBack(text);
+        if (parsed !== undefined) {
+            kept = trial;
+            best = { text, tree: parsed };
+        }
+        else if (tried.length > 1) {
+            const half = Math.ceil(tried.length / 2);
+            attempt(tried.slice(0, half));
+            attempt(tried.slice(half));
+        }
+    };
+    attempt(changed);
+    return best;
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CANOPYCMS_VERSION = "0.5.0";
+export declare const CANOPYCMS_VERSION = "0.7.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/bump-version.mjs, its only writer. The package builds with plain
 // tsc (rootDir: src), so src/ cannot import ../package.json; version.test.ts keeps the two equal.
-export const CANOPYCMS_VERSION = '0.5.0';
+export const CANOPYCMS_VERSION = '0.7.0';

package/dist/worker/bundle-header.d.ts

@@ -1,9 +1,9 @@
 /**
  * A git bundle's header, read in node before git sees the bundle: the gateway refuses a pushed
- * bundle on it (worker/github-mirror.ts), and the worker checks the bundle it is about to send
- * (worker/github-transfer.ts). git's own parser reads everything after a head's first space as the
- * refname and accepts a tab, so nothing here is lenient: a header either matches this grammar
- * exactly or is refused.
+ * bundle on it (worker/github-mirror.ts), and the worker checks the bundle it is about to send and
+ * reads the prerequisites of one it takes in (worker/github-transfer.ts). git's own parser reads
+ * everything after a head's first space as the refname and accepts a tab, so nothing here is
+ * lenient: a header either matches this grammar exactly or is refused.
  *
  * ```
  * "# v2 git bundle" LF  |  "# v3 git bundle" LF ("@object-format=sha1" LF)?    at most once
@@ -24,7 +24,7 @@
  */
 /**
  * The header must end, with its blank line, within this many bytes, prerequisites' comments not
- * counted.
+ * counted, unless the reader is given another bound.
  * @internal Exported for tests.
  */
 export declare const BUNDLE_HEADER_MAX_BYTES: number;
@@ -35,7 +35,8 @@ export declare const BUNDLE_HEADER_MAX_BYTES: number;
 export declare const PREREQUISITE_COMMENT_MAX_BYTES = 1024;
 /**
  * The header must end within this many bytes counting comments too: the bytes read, when
- * refusing; the bytes kept and sent, when shortening. The most a reader holds of a header.
+ * refusing; the bytes kept and sent, when shortening. The most a refusing or shortening reader
+ * holds of a header.
  * @internal Exported for tests.
  */
 export declare const BUNDLE_HEADER_TOTAL_MAX_BYTES: number;
@@ -61,13 +62,16 @@ export interface ReadBundleHeader {
 }
 /**
  * Reads a header from a bundle's bytes as they arrive, holding at most
- * {@link BUNDLE_HEADER_TOTAL_MAX_BYTES} of it, however long a comment is. A comment over
+ * {@link BUNDLE_HEADER_TOTAL_MAX_BYTES} of it (`maxBytes`, skipping), however long a comment is.
+ * A comment over
  * {@link PREREQUISITE_COMMENT_MAX_BYTES} is refused (`'refuse'`, the gateway, which keeps no copy
  * of the header) or cut to it (`'shorten'`, the worker, which sends {@link ReadBundleHeader.bytes}
- * in its place).
+ * in its place). `'skip'` keeps no comment byte at all and bounds only `maxBytes`, for a bundle
+ * only read, never sent on.
  */
 export declare class BundleHeaderReader {
     private readonly comments;
+    private readonly maxBytes;
     private section;
     private sawCapability;
     private readonly prerequisites;
@@ -85,7 +89,7 @@ export declare class BundleHeaderReader {
     /** In a comment: its bytes so far, and those kept to send. */
     private comment;
     private done;
-    constructor(comments: 'refuse' | 'shorten');
+    constructor(comments: 'refuse' | 'shorten' | 'skip', maxBytes?: number);
     /**
      * Take the next bytes: null while the header may still be completed by more, the header once its
      * blank line has arrived. Throws {@link BundleHeaderError} once what has arrived breaks the

package/dist/worker/bundle-header.js

@@ -1,9 +1,9 @@
 /**
  * A git bundle's header, read in node before git sees the bundle: the gateway refuses a pushed
- * bundle on it (worker/github-mirror.ts), and the worker checks the bundle it is about to send
- * (worker/github-transfer.ts). git's own parser reads everything after a head's first space as the
- * refname and accepts a tab, so nothing here is lenient: a header either matches this grammar
- * exactly or is refused.
+ * bundle on it (worker/github-mirror.ts), and the worker checks the bundle it is about to send and
+ * reads the prerequisites of one it takes in (worker/github-transfer.ts). git's own parser reads
+ * everything after a head's first space as the refname and accepts a tab, so nothing here is
+ * lenient: a header either matches this grammar exactly or is refused.
  *
  * ```
  * "# v2 git bundle" LF  |  "# v3 git bundle" LF ("@object-format=sha1" LF)?    at most once
@@ -24,7 +24,7 @@
  */
 /**
  * The header must end, with its blank line, within this many bytes, prerequisites' comments not
- * counted.
+ * counted, unless the reader is given another bound.
  * @internal Exported for tests.
  */
 export const BUNDLE_HEADER_MAX_BYTES = 64 * 1024;
@@ -35,7 +35,8 @@ export const BUNDLE_HEADER_MAX_BYTES = 64 * 1024;
 export const PREREQUISITE_COMMENT_MAX_BYTES = 1024;
 /**
  * The header must end within this many bytes counting comments too: the bytes read, when
- * refusing; the bytes kept and sent, when shortening. The most a reader holds of a header.
+ * refusing; the bytes kept and sent, when shortening. The most a refusing or shortening reader
+ * holds of a header.
  * @internal Exported for tests.
  */
 export const BUNDLE_HEADER_TOTAL_MAX_BYTES = 256 * 1024;
@@ -57,14 +58,17 @@ const DASH = 0x2d;
 const PREREQUISITE_PREFIX_BYTES = 42;
 /**
  * Reads a header from a bundle's bytes as they arrive, holding at most
- * {@link BUNDLE_HEADER_TOTAL_MAX_BYTES} of it, however long a comment is. A comment over
+ * {@link BUNDLE_HEADER_TOTAL_MAX_BYTES} of it (`maxBytes`, skipping), however long a comment is.
+ * A comment over
  * {@link PREREQUISITE_COMMENT_MAX_BYTES} is refused (`'refuse'`, the gateway, which keeps no copy
  * of the header) or cut to it (`'shorten'`, the worker, which sends {@link ReadBundleHeader.bytes}
- * in its place).
+ * in its place). `'skip'` keeps no comment byte at all and bounds only `maxBytes`, for a bundle
+ * only read, never sent on.
  */
 export class BundleHeaderReader {
-    constructor(comments) {
+    constructor(comments, maxBytes = BUNDLE_HEADER_MAX_BYTES) {
         this.comments = comments;
+        this.maxBytes = maxBytes;
         this.section = 'signature';
         this.sawCapability = false;
         this.prerequisites = [];
@@ -167,9 +171,11 @@ export class BundleHeaderReader {
         this.checkBound();
     }
     checkBound() {
-        if (this.counted >= BUNDLE_HEADER_MAX_BYTES) {
-            throw new BundleHeaderError(`its header does not end within ${BUNDLE_HEADER_MAX_BYTES} bytes`);
+        if (this.counted >= this.maxBytes) {
+            throw new BundleHeaderError(`its header does not end within ${this.maxBytes} bytes`);
         }
+        if (this.comments === 'skip')
+            return;
         // Refusing, every comment byte is read; shortening, only the kept ones are held and sent, so
         // a single subject of any length shortens rather than counts.
         const total = this.comments === 'refuse' ? this.consumed : this.counted + this.keptBytes;

package/dist/worker/git-process.d.ts

@@ -1,7 +1,7 @@
 import { Readable } from 'node:stream';
 /**
- * git with its stdin or stdout as a stream, which simple-git cannot do: a bundle's way into
- * `bundle unbundle -` and `fetch`, out of `bundle create -`, and `update-ref --stdin`'s
+ * git with its stdin or stdout as a stream, which simple-git cannot do: a bundle's pack into
+ * `index-pack --stdin`, a bundle into `fetch`, out of `bundle create -`, and `update-ref --stdin`'s
  * transactions. The caller supplies the whole environment, config and working directory, so the
  * pins of the repository it runs in apply here exactly as they do through simple-git
  * (worker/shared-repo-git.ts, worker/github-mirror.ts).

package/dist/worker/github-gateway-http.js

@@ -219,8 +219,9 @@ class GatewayRequestHandler {
                 return {};
             },
             getPullRequest: async ({ number }, signal) => {
-                const { merged, merged_at, state, node_id } = await gateway.getPullRequest(number, signal);
-                return { merged, merged_at, state, node_id };
+                const { merged, merged_at, state, node_id, body } = await gateway.getPullRequest(number, signal);
+                // Octokit's type says string | null; a payload without the field crosses as null.
+                return { merged, merged_at, state, node_id, body: body ?? null };
             },
             createOrUpdatePullRequest: async (input, signal) => {
                 const { number, url, created } = await gateway.createOrUpdatePullRequest(input, signal);
@@ -631,8 +632,8 @@ const POLL_WAIT_MS = MAX_POLL_WAIT_MS;
 /** How long `health` waits for the gateway: `getSecret` alone has taken 87 s. */
 const HEALTH_WAIT_MS = 300_000;
 /**
- * How long `authSnapshot` waits: a membership request per user, one at a time, so tens of thousands
- * of users take tens of minutes. A later call joins a fetch an earlier one stopped waiting for.
+ * How long `authSnapshot` waits: a generous bound on a fetch that pages the provider's whole user,
+ * organization and membership lists one page at a time. A later call joins a fetch an earlier one stopped waiting for.
  */
 const AUTH_SNAPSHOT_WAIT_MS = 30 * 60_000;
 /** How long `termination` and `completeLifecycle` wait: a poll's wait is well inside it. */

package/dist/worker/github-gateway-wire.d.ts

@@ -190,14 +190,17 @@ export declare const answers: {
         merged_at: z.ZodNullable<z.ZodString>;
         state: z.ZodEnum<["open", "closed"]>;
         node_id: z.ZodString;
+        body: z.ZodNullable<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         merged: boolean;
         state: "open" | "closed";
+        body: string | null;
         merged_at: string | null;
         node_id: string;
     }, {
         merged: boolean;
         state: "open" | "closed";
+        body: string | null;
         merged_at: string | null;
         node_id: string;
     }>;