wiki-formant 0.47.1 → 0.49.0

package/dist/editor.js

@@ -71,6 +71,8 @@ function cleanPastedHtml(html) {
  * which the editor cannot know, so the render path decides: `normaliseLinks`
  * from `wiki-formant/links`. Dropping both attributes from the mark also cleans
  * a legacy link the next time its page is saved.
+ *
+ * @internal
  */
 export const wikiLink = TiptapLink.extend({
     addAttributes() {
@@ -117,7 +119,7 @@ const SHORT_MAP = /maps\.app\.goo\.gl|goo\.gl\/maps/;
  * swap re-finds the node by its `url` attribute rather than caching a position,
  * because every keystroke between the paste and the resolve moves it.
  */
-export function insertEmbed(editor, url, { resolveMapUrl }) {
+function insertEmbed(editor, url, { resolveMapUrl }) {
     const yt = url.match(YOUTUBE);
     if (yt) {
         editor.chain().focus().setYoutubeVideo({ src: url }).run();
@@ -168,6 +170,8 @@ export function runTableAction(editor, command) {
  * two titled their buttons with the internal key — a screen reader said
  * "codeBlock", and inline code and code block shared one icon and one name.
  * Upload and embed stay with the caller: they are the parts that differ.
+ *
+ * @internal
  */
 export const TOOLBAR_ACTIONS = [
     { key: 'bold', label: 'Bold', active: 'bold', run: e => e.chain().focus().toggleBold().run() },
@@ -220,6 +224,8 @@ export function ToolbarButton({ label, pressed, onPress, className, children, })
  * the link the cursor is in, across the whole link rather than the collapsed
  * selection, and an emptied address takes it off while keeping the text. An
  * embed with no address does nothing.
+ *
+ * @internal
  */
 export function applyUrlPrompt(editor, kind, url, { resolveMapUrl }) {
     const href = url.trim();

package/dist/feed.d.ts

@@ -1,10 +1,4 @@
 export declare const escXml: (s: string) => string;
-/**
- * `content:encoded` carries raw HTML, so it travels inside CDATA. A literal
- * `]]>` in the body would close the section early and corrupt every item after
- * it — not just the one that contained it.
- */
-export declare const cdata: (html: string) => string;
 /**
  * Aggregators hard-truncate a description around 150 characters. Trimming on a
  * word boundary first means the cut lands between words rather than inside one.
@@ -45,14 +39,6 @@ export interface FeedChannel {
      */
     lastBuild?: Date | null;
 }
-/**
- * `lastBuildDate` comes from the newest item, not from the clock.
- *
- * A feed whose build date moves on every request tells every poller it changed
- * when it did not, which is exactly the recrawl the conditional-GET helpers
- * exist to prevent. An empty feed has no build date rather than a fictional one.
- */
-export declare function renderFeed(channel: FeedChannel, items: readonly FeedItem[]): string;
 /**
  * The feed as a response, with the validators a poller revalidates against.
  *

package/dist/feed.js

@@ -28,6 +28,8 @@ export const escXml = (s) => s.replace(/[&<>"']/g, c => XML_ESCAPES[c] ?? c);
  * `content:encoded` carries raw HTML, so it travels inside CDATA. A literal
  * `]]>` in the body would close the section early and corrupt every item after
  * it — not just the one that contained it.
+ *
+ * @internal
  */
 export const cdata = (html) => `<![CDATA[${html.replace(/]]>/g, ']]&gt;')}]]>`;
 /**
@@ -69,6 +71,8 @@ export function renderItem(item) {
  * A feed whose build date moves on every request tells every poller it changed
  * when it did not, which is exactly the recrawl the conditional-GET helpers
  * exist to prevent. An empty feed has no build date rather than a fictional one.
+ *
+ * @internal
  */
 export function renderFeed(channel, items) {
     const newest = lastBuild(channel, items);

package/dist/freshness.d.ts

@@ -4,7 +4,6 @@ export interface FreshnessInput {
     lastVerifiedAt?: Date | string | null;
     updatedAt?: Date | string | null;
 }
-export declare const DEFAULT_MAX_AGE_DAYS = 180;
 /** Whole days between `date` and `now`, or null when there is no usable date. */
 export declare function daysSince(date: Date | string | null | undefined, now: number): number | null;
 /**
@@ -13,12 +12,6 @@ export declare function daysSince(date: Date | string | null | undefined, now: n
  * edit is a weaker signal than a verification, but it is a signal.
  */
 export declare function isStale(page: FreshnessInput, now: number, maxAgeDays?: number): boolean;
-/**
- * The sentence the notice carries. Both wikis shipped this string identically,
- * down to the ISO date and the closing request, so it lives here rather than
- * being re-typed either side of the extraction.
- */
-export declare function freshnessNotice(page: FreshnessInput): string;
 /**
  * A synthetic `outdated` banner block for a stale page, or null when it is
  * fresh — the shape every wiki's `banner` type already stores, so it drops

package/dist/freshness.js

@@ -10,6 +10,7 @@
 // disagree with the one the server just sent.
 import { isoDate } from './html.js';
 export { isoDate };
+/** @internal */
 export const DEFAULT_MAX_AGE_DAYS = 180;
 const DAY_MS = 86_400_000;
 /** Whole days between `date` and `now`, or null when there is no usable date. */
@@ -34,6 +35,8 @@ export function isStale(page, now, maxAgeDays = DEFAULT_MAX_AGE_DAYS) {
  * The sentence the notice carries. Both wikis shipped this string identically,
  * down to the ISO date and the closing request, so it lives here rather than
  * being re-typed either side of the extraction.
+ *
+ * @internal
  */
 export function freshnessNotice(page) {
     const when = page.lastVerifiedAt

package/dist/headers.d.ts

@@ -9,16 +9,8 @@ export interface HeaderEntry {
  * embed that clears one clears the other.
  */
 export declare const DEFAULT_IFRAME_HOSTS: readonly string[];
-/** `frame-src` sources for a host list — the one a sanitiser was given. */
-export declare const frameSources: (hosts?: readonly string[]) => string[];
 /** CSP directive names this builder writes, in the order it writes them. */
 export type CspDirective = 'default-src' | 'base-uri' | 'object-src' | 'frame-ancestors' | 'form-action' | 'script-src' | 'style-src' | 'font-src' | 'img-src' | 'media-src' | 'connect-src' | 'frame-src' | 'worker-src' | 'manifest-src';
-/**
- * The policy all four origins shared line for line. Everything a site adds is
- * a source list it hands `contentSecurityPolicy`, which replaces the default
- * for that directive rather than appending, so a reader sees the whole list.
- */
-export declare const BASE_CSP: Readonly<Partial<Record<CspDirective, readonly string[]>>>;
 /**
  * The policy string: `BASE_CSP` with each directive in `directives` replacing
  * its default. An empty list drops the directive.

package/dist/headers.js

@@ -24,12 +24,14 @@ export const DEFAULT_IFRAME_HOSTS = [
     'www.google.com', 'maps.google.com',
     'embed.apple.com', 'maps.apple.com',
 ];
-/** `frame-src` sources for a host list — the one a sanitiser was given. */
+/** `frame-src` sources for a host list — the one a sanitiser was given. @internal */
 export const frameSources = (hosts = DEFAULT_IFRAME_HOSTS) => hosts.length ? hosts.map(h => `https://${h}`) : ["'none'"];
 /**
  * The policy all four origins shared line for line. Everything a site adds is
  * a source list it hands `contentSecurityPolicy`, which replaces the default
  * for that directive rather than appending, so a reader sees the whole list.
+ *
+ * @internal
  */
 export const BASE_CSP = {
     'default-src': ["'self'"],

package/dist/headings.d.ts

@@ -53,14 +53,6 @@ export declare function injectHeadingIds(html: string, options?: HeadingIdOption
  * consumers use only the injector above.
  */
 export declare function headingsFrom(html: string): Heading[];
-/**
- * Every heading in `html`, in document order, whether or not it carries an id —
- * the outline a crawler reads. `headingsFrom` above answers a different
- * question: which headings a rail can link to, which is why it drops the ones
- * with no id. An audit must not, because a chrome heading with no id still
- * takes a level in the outline, and the levels are the thing under test.
- */
-export declare function headingOutline(html: string): Heading[];
 /**
  * What is wrong with a page's heading outline.
  *

package/dist/headings.js

@@ -92,6 +92,8 @@ export function headingsFrom(html) {
  * question: which headings a rail can link to, which is why it drops the ones
  * with no id. An audit must not, because a chrome heading with no id still
  * takes a level in the outline, and the levels are the thing under test.
+ *
+ * @internal
  */
 export function headingOutline(html) {
     const out = [];

package/dist/history.d.ts

@@ -3,12 +3,6 @@ import { type BlockChange, type BlockGroup, type DiffBlock } from './revisions.j
 export type DiffPart = [-1 | 0 | 1, string];
 /** A change as a history view lists it: the diff it draws, not the two bodies behind it. */
 export type HistoryChange = BlockChange<DiffPart[]>;
-/**
- * Two HTML bodies as the words struck and added between them, or `undefined`
- * when their text is the same. Semantic cleanup is on: without it a rewritten
- * sentence comes out as fragments of the letters the two versions share.
- */
-export declare function textDiff(from: string, to: string): DiffPart[] | undefined;
 export interface HistoryOptions<B> {
     /** Defaults to `coreBlockGroups`, as in `diffBlocks`. */
     containers?: (block: B) => BlockGroup<B>[] | null;

package/dist/history.js

@@ -20,6 +20,8 @@ const clip = (t) => (t.length > KEPT_MAX ? `${t.slice(0, 30)}…${t.slice(-30)}`
  * Two HTML bodies as the words struck and added between them, or `undefined`
  * when their text is the same. Semantic cleanup is on: without it a rewritten
  * sentence comes out as fragments of the letters the two versions share.
+ *
+ * @internal
  */
 export function textDiff(from, to) {
     const a = stripHtml(from);

package/dist/http.d.ts

@@ -76,17 +76,6 @@ export declare function wantsMarkdown(request: {
 export declare const VARY_ACCEPT: {
     readonly Vary: "Accept";
 };
-/**
- * Headers for a JSON descriptor — an agent card, an OpenAPI document, a
- * registry manifest. These are the documents a client refetches most and the
- * ones that had no validator at all: served as `Cache-Control: public` with no
- * `max-age`, a caller falls back to heuristic freshness and can never
- * revalidate, so a corrected card takes an unbounded time to reach anyone.
- */
-export declare function descriptorHeaders(etag: string, opts?: {
-    maxAge?: number;
-    extra?: Record<string, string>;
-}): Record<string, string>;
 /**
  * A JSON descriptor served with a validator, answering a conditional GET.
  *

package/dist/http.js

@@ -141,6 +141,10 @@ export const VARY_ACCEPT = { Vary: 'Accept' };
  * ones that had no validator at all: served as `Cache-Control: public` with no
  * `max-age`, a caller falls back to heuristic freshness and can never
  * revalidate, so a corrected card takes an unbounded time to reach anyone.
+ * Every one is public and read by browser agents too, so each allows any
+ * origin; six of the nine routes passed that by hand and three did not.
+ *
+ * @internal
  */
 export function descriptorHeaders(etag, opts = {}) {
     const maxAge = opts.maxAge ?? 86400;
@@ -148,6 +152,7 @@ export function descriptorHeaders(etag, opts = {}) {
         'Content-Type': 'application/json; charset=utf-8',
         'Cache-Control': `public, max-age=300, s-maxage=${maxAge}, stale-while-revalidate=${maxAge * 7}`,
         ETag: etag,
+        'Access-Control-Allow-Origin': '*',
         ...opts.extra,
     };
 }

package/dist/license.d.ts

@@ -32,14 +32,6 @@ export interface LicenseBlockOptions {
     /** `Licence` where the site's prose says so. Defaults to `License`. */
     heading?: string;
 }
-/**
- * The block, as lines, ready to join into any text export.
- *
- * Returned as an array rather than a string because every caller splices it
- * into a document it is already building line by line, and a caller that wants
- * the string can join it.
- */
-export declare function licenseLines({ license, scope, scopeVerb, excludes, heading, }: LicenseBlockOptions): string[];
 export declare function licenseBlock(opts: LicenseBlockOptions): string;
 /** The one-line form, for a frontmatter field or a feed's `<copyright>`. */
 export declare function licenseNote(license: License): string;

package/dist/license.js

@@ -24,6 +24,8 @@ export function ccBy40(opts) {
  * Returned as an array rather than a string because every caller splices it
  * into a document it is already building line by line, and a caller that wants
  * the string can join it.
+ *
+ * @internal
  */
 export function licenseLines({ license, scope = 'This content', scopeVerb = 'is', excludes = [], heading = 'License & Attribution', }) {
     return [

package/dist/link-check.d.ts

@@ -15,22 +15,6 @@ export interface ProbeOptions {
     /** Second-attempt budget for a host that is merely slow. */
     slowTimeoutMs?: number;
 }
-/**
- * Codes that flap. A sweep found 16 status-0 rows and 15 were one host, every
- * one answering 200 when probed alone. Carry the code through so a caller can
- * treat these as retryable rather than banking a death.
- */
-export declare const TRANSIENT_CODES: Set<string>;
-/** A failure as a report row: the message, the code, and the TLS caveat. */
-export declare function describeFailure(err: unknown): Pick<Probe, 'error' | 'code' | 'tls' | 'note'>;
-/**
- * The URL to probe INSTEAD, where the public page lies about its own health.
- *
- * npmjs.com serves 403 to scripted requests whether or not the package exists,
- * which made every package citation a permanent false positive. The registry
- * answers honestly.
- */
-export declare function probeUrlFor(url: string): string;
 /**
  * Run `fn` with at most one request in flight against this hostname.
  *
@@ -59,11 +43,6 @@ export declare function extractLinks(html: string): Array<{
     href: string;
     text: string;
 }>;
-/** Every `<iframe>` and `<img>` source in a fragment. */
-export declare function extractEmbeds(html: string): Array<{
-    kind: string;
-    url: string;
-}>;
 /** What a page links to, split the way a checker probes it. */
 export interface BlockLinks {
     /** Absolute http(s) targets. */

package/dist/link-check.js

@@ -36,6 +36,8 @@ const TLS_CODES = new Set([
  * Codes that flap. A sweep found 16 status-0 rows and 15 were one host, every
  * one answering 200 when probed alone. Carry the code through so a caller can
  * treat these as retryable rather than banking a death.
+ *
+ * @internal
  */
 export const TRANSIENT_CODES = new Set([
     'UND_ERR_CONNECT_TIMEOUT',
@@ -48,7 +50,7 @@ export const TRANSIENT_CODES = new Set([
     'EAI_AGAIN',
     'EPIPE',
 ]);
-/** A failure as a report row: the message, the code, and the TLS caveat. */
+/** A failure as a report row: the message, the code, and the TLS caveat. @internal */
 export function describeFailure(err) {
     const e = err;
     if (e?.name === 'AbortError')
@@ -71,6 +73,8 @@ export function describeFailure(err) {
  * npmjs.com serves 403 to scripted requests whether or not the package exists,
  * which made every package citation a permanent false positive. The registry
  * answers honestly.
+ *
+ * @internal
  */
 export function probeUrlFor(url) {
     const npm = url.match(/^https:\/\/(?:www\.)?npmjs\.com\/package\/(.+?)\/?$/);
@@ -223,7 +227,7 @@ export function extractLinks(html) {
     }
     return out;
 }
-/** Every `<iframe>` and `<img>` source in a fragment. */
+/** Every `<iframe>` and `<img>` source in a fragment. @internal */
 export function extractEmbeds(html) {
     const out = [];
     for (const m of html.matchAll(EMBED_RE)) {

package/dist/links.d.ts

@@ -1,8 +1,3 @@
-/**
- * A readable label for an anchor whose text is empty, derived from its href.
- * Without one, crawlers and screen readers meet a link with nothing in it.
- */
-export declare function fallbackAnchorText(href: string): string;
 export interface NormaliseLinkOptions {
     /**
      * This wiki's own origin. An absolute link back to it is really internal, so

package/dist/links.js

@@ -18,6 +18,8 @@ import { getAttr, removeAttr, stripTags } from './html.js';
 /**
  * A readable label for an anchor whose text is empty, derived from its href.
  * Without one, crawlers and screen readers meet a link with nothing in it.
+ *
+ * @internal
  */
 export function fallbackAnchorText(href) {
     if (href.startsWith('#'))

package/dist/maintenance.d.ts

@@ -0,0 +1,61 @@
+export type SourceListItem = string | {
+    handle?: string;
+    name?: string;
+    url?: string;
+};
+export interface SourceEntry {
+    lastChecked?: string | null;
+    note?: string;
+    list?: SourceListItem[];
+}
+export type BacklogEntry = string | {
+    date?: string;
+    item: string;
+    status?: string;
+};
+export type FeedbackEntry = string | {
+    date?: string;
+    note: string;
+};
+export interface RunEntry {
+    date?: string;
+    category?: string;
+    summary?: string;
+    tweet?: string;
+}
+export interface LogState {
+    mission?: string;
+    positioning?: string;
+    totalRuns?: number;
+    lastRun?: string | null;
+    rotation?: {
+        order?: string[];
+        next?: string;
+    };
+    sources?: Record<string, SourceEntry>;
+    backlog?: BacklogEntry[];
+    feedback?: FeedbackEntry[];
+    runHistory?: RunEntry[];
+    [key: string]: unknown;
+}
+/** Drops what is closed or a diary entry, and caps what is append-only. Newest first. */
+export declare function compact(state: LogState): LogState;
+/** New backlog items, deduplicated against what is there, dated today unless they carry a date. */
+export declare function addBacklog(state: LogState, items: readonly BacklogEntry[], today: string): BacklogEntry[];
+/** The page's content blocks, re-rendered from state on every write. `routine` names who keeps it. */
+export declare function render(state: LogState, routine: string, newId?: () => string): {
+    id: string;
+    type: "content";
+    text: string;
+}[];
+/** A table or column name from the command line, quoted, or a thrown usage error. */
+export declare function ident(name: string | undefined, what: string): string;
+/**
+ * `--scope column` limits a bin to rows whose column is NULL, `--scope
+ * column=value` to rows where it equals the value: caper's platform pages
+ * have no caper, and its company pages share their tag paths.
+ */
+export declare function scopeSql(scope: string | undefined, param: number): {
+    sql: string;
+    values: unknown[];
+};

package/dist/maintenance.js

@@ -0,0 +1,137 @@
+// maintenance.ts — what the `maintenance-log` and `mark-verified` bins share,
+// kept pure so it is tested without a database.
+//
+// A wiki-sweep routine keeps its memory between runs (the rotation cursor,
+// source watermarks, backlog, feedback and run history) in one wiki page's
+// `metadata.state`, and that page shows a capped rendering of it. radix-wiki
+// and caper each had the script, with the same caps and rules and a different
+// table. The rules are here; the table is the bin's arguments.
+//
+// Every write compacts first. `backlog` holds only open work items, since a
+// run diary entry belongs in `runHistory`, which it duplicates, and the
+// append-only lists are capped. Uncapped, radix-wiki's log page reached 384 KB
+// of content and 710 KB of state, and a revision per run made it over half of
+// its revisions table. Two kinds of entry are pinned against the caps because
+// a run cannot recreate them: a backlog item flagged for a human, and a
+// watermark that banks a verdict on a whole class of site (a bot wall, a 403),
+// which is what lets an audit spend no probes on its flag list.
+//
+// No subpath exports this: the bins and the tests import it from dist.
+/** Held in state. */
+const MAX = { backlog: 60, runs: 30, feedback: 40, sources: 150 };
+/** Shown on the page. What a reader pays is words, and the entries run long. */
+const SHOWN = { backlog: 15, runs: 5, feedback: 8, sources: 15 };
+/** "run 214 (ecosystem): link audit CLEAN…" is a diary entry, not a work item. */
+const JOURNAL = /^run\s+\d+\b/i;
+const PINNED = /FLAG FOR A HUMAN/i;
+const BANKED = /\bbanked\b|bot[- ]?(wall|block)|\b(403|429|999)\b|cloudflare/i;
+const itemOf = (b) => (typeof b === 'string' ? b : b.item);
+const recency = (a, b) => String(b[1]?.lastChecked ?? '').localeCompare(String(a[1]?.lastChecked ?? ''));
+/** Drops what is closed or a diary entry, and caps what is append-only. Newest first. */
+export function compact(state) {
+    // Undated items fall back to append order: a later index is newer.
+    const open = (state.backlog ?? [])
+        .map((b, i) => ({ status: 'open', ...(typeof b === 'string' ? { date: '', item: b } : b), i }))
+        .filter(b => b.status === 'open' && b.item && (PINNED.test(b.item) || !JOURNAL.test(b.item)))
+        .sort((a, b) => String(b.date ?? '').localeCompare(String(a.date ?? '')) || b.i - a.i);
+    const backlog = [...open.filter(b => PINNED.test(b.item)), ...open.filter(b => !PINNED.test(b.item))]
+        .slice(0, MAX.backlog)
+        .map(({ i: _i, ...b }) => b);
+    // Most source keys are one-off verdicts on a single site. Sorting by
+    // lastChecked lets the cap age out only probes no run has touched since.
+    const entries = Object.entries(state.sources ?? {});
+    const banked = ([, v]) => BANKED.test(String(v?.note ?? ''));
+    const sources = Object.fromEntries([...entries.filter(banked), ...entries.filter(e => !banked(e)).sort(recency).slice(0, MAX.sources)].sort(recency));
+    return {
+        ...state,
+        backlog,
+        sources,
+        feedback: (state.feedback ?? []).slice(-MAX.feedback),
+        runHistory: (state.runHistory ?? []).slice(-MAX.runs),
+    };
+}
+/** New backlog items, deduplicated against what is there, dated today unless they carry a date. */
+export function addBacklog(state, items, today) {
+    const seen = new Set((state.backlog ?? []).map(itemOf));
+    const added = [];
+    for (const raw of items) {
+        const item = itemOf(raw);
+        if (!item || seen.has(item))
+            continue;
+        seen.add(item);
+        added.push({ date: (typeof raw === 'object' && raw.date) || today, item, status: 'open' });
+    }
+    return added;
+}
+const esc = (s) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const more = (shown, total, what) => total > shown ? `<p><em>${total - shown} older ${what} held in state.</em></p>` : '';
+const table = (head, rows) => `<table><tbody><tr>${head.map(h => `<td><strong>${h}</strong></td>`).join('')}</tr>` +
+    (rows.join('') || `<tr>${head.map(() => '<td>–</td>').join('')}</tr>`) +
+    '</tbody></table>';
+/** The page's content blocks, re-rendered from state on every write. `routine` names who keeps it. */
+export function render(state, routine, newId = () => crypto.randomUUID()) {
+    const rot = state.rotation ?? {};
+    const backlog = state.backlog ?? [];
+    const feedback = state.feedback ?? [];
+    const sources = Object.entries(state.sources ?? {}).sort(recency);
+    const block = (text) => ({ id: newId(), type: 'content', text });
+    const label = (x) => (typeof x === 'string' ? x : (x.handle ?? x.name ?? x.url ?? ''));
+    const sourceRows = sources.slice(0, SHOWN.sources).map(([key, v]) => {
+        const watch = (v.list ?? []).map(label).filter(Boolean);
+        const watching = watch.length ? ` — watching: ${esc(watch.slice(0, 8).join(', '))}${watch.length > 8 ? '…' : ''}` : '';
+        return `<tr><td>${esc(key)}</td><td>${esc(v.lastChecked || '–')}</td><td>${esc(v.note)}${watching}</td></tr>`;
+    });
+    const runRows = (state.runHistory ?? []).slice(-SHOWN.runs).reverse().map(r => {
+        const tweet = r.tweet && /^https?:\/\//.test(r.tweet) ? `<a href="${esc(r.tweet)}">link</a>` : esc(r.tweet);
+        return `<tr><td>${esc(r.date)}</td><td>${esc(r.category)}</td><td>${esc(r.summary)}</td><td>${tweet}</td></tr>`;
+    });
+    return [
+        block(`<p><em>Auto-maintained by the <code>${esc(routine)}</code> routine. Each run records what was swept, ` +
+            'advances the category rotation, logs ecosystem signals, and tracks community reception. ' +
+            'Do not hand-edit the state block – the routine overwrites it.</em></p>' +
+            (state.mission ? `<p><strong>Mission:</strong> ${esc(state.mission)}</p>` : '') +
+            (state.positioning ? `<p><strong>Positioning:</strong> ${esc(state.positioning)}</p>` : '')),
+        block('<h2>Current status</h2><table><tbody>' +
+            `<tr><td><strong>Next category in rotation</strong></td><td>${esc(rot.next || '–')}</td></tr>` +
+            `<tr><td><strong>Rotation order</strong></td><td>${esc((rot.order ?? []).join(' → '))}</td></tr>` +
+            `<tr><td><strong>Last run</strong></td><td>${esc(state.lastRun || '–')}</td></tr>` +
+            `<tr><td><strong>Total runs</strong></td><td>${esc(state.totalRuns ?? 0)}</td></tr>` +
+            '</tbody></table>'),
+        block(`<h2>Signal watermarks</h2>${table(['Source', 'Last checked', 'Note'], sourceRows)}` +
+            more(SHOWN.sources, sources.length, 'watermarks')),
+        block('<h2>Open backlog</h2>' +
+            (backlog.length
+                ? `<ul>${backlog.slice(0, SHOWN.backlog).map(b => `<li>${esc(itemOf(b))}</li>`).join('')}</ul>` +
+                    more(SHOWN.backlog, backlog.length, 'open items')
+                : '<p><em>Empty.</em></p>')),
+        block('<h2>Community feedback &amp; reception</h2>' +
+            (feedback.length
+                ? `<ul>${feedback
+                    .slice(-SHOWN.feedback)
+                    .reverse()
+                    .map(f => `<li>${esc(typeof f === 'string' ? f : `${f.date ?? ''} – ${f.note}`)}</li>`)
+                    .join('')}</ul>` + more(SHOWN.feedback, feedback.length, 'entries')
+                : '<p><em>Nothing logged yet.</em></p>')),
+        block(`<h2>Recent runs</h2>${table(['Date', 'Category', 'Summary', 'Tweet'], runRows)}`),
+    ];
+}
+const IDENT = /^[a-z_][a-z0-9_]*$/;
+/** A table or column name from the command line, quoted, or a thrown usage error. */
+export function ident(name, what) {
+    if (!name || !IDENT.test(name))
+        throw new Error(`${what} must be a lower-case SQL identifier, got ${JSON.stringify(name)}`);
+    return `"${name}"`;
+}
+/**
+ * `--scope column` limits a bin to rows whose column is NULL, `--scope
+ * column=value` to rows where it equals the value: caper's platform pages
+ * have no caper, and its company pages share their tag paths.
+ */
+export function scopeSql(scope, param) {
+    if (!scope)
+        return { sql: 'TRUE', values: [] };
+    const [column, value] = scope.split('=');
+    return value === undefined
+        ? { sql: `${ident(column, '--scope')} IS NULL`, values: [] }
+        : { sql: `${ident(column, '--scope')} = $${param}`, values: [value] };
+}

package/dist/maps.d.ts

@@ -3,12 +3,6 @@ export interface MapCoords {
     lon: number;
     zoom?: number | undefined;
 }
-/**
- * Dig a coordinate pair out of a maps URL. Four shapes in descending
- * specificity: the `@lat,lon,zoom` path segment, a `/search/lat,lon`, the
- * `!3d…!4d…` data blob, and finally an `ll`/`sll` query parameter.
- */
-export declare function extractCoordsFromUrl(url: string): MapCoords | null;
 /**
  * An embeddable URL for `url`, or null when it is not a map link this
  * understands. Already-embeddable URLs pass through untouched.

package/dist/maps.js

@@ -12,6 +12,8 @@ function mapsEmbedUrl(lat, lon, zoom = 15) {
  * Dig a coordinate pair out of a maps URL. Four shapes in descending
  * specificity: the `@lat,lon,zoom` path segment, a `/search/lat,lon`, the
  * `!3d…!4d…` data blob, and finally an `ll`/`sll` query parameter.
+ *
+ * @internal
  */
 export function extractCoordsFromUrl(url) {
     const coords = url.match(/@(-?\d+\.?\d*),(-?\d+\.?\d*),?(\d+\.?\d*)?z?/);

package/dist/markdown.d.ts

@@ -1,8 +1,6 @@
 export declare function decodeEntities(s: string): string;
 /** Inline-level HTML → markdown. Applied inside cells, list items, headings. */
 export declare function inlineToMarkdown(html: string): string;
-/** One `<table>` → a GFM table. Falls back to nothing when there are no rows. */
-export declare function tableToMarkdown(html: string): string;
 /** Block-level HTML → markdown. */
 export declare function htmlToMarkdown(html: string): string;
 export interface FrontmatterFields {

package/dist/markdown.js

@@ -62,7 +62,7 @@ export function inlineToMarkdown(html) {
         .replace(/\s+/g, ' ')
         .trim();
 }
-/** One `<table>` → a GFM table. Falls back to nothing when there are no rows. */
+/** One `<table>` → a GFM table. Falls back to nothing when there are no rows. @internal */
 export function tableToMarkdown(html) {
     const rows = [...html.matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/gi)].map(m => [...m[1].matchAll(/<(t[hd])\b[^>]*>([\s\S]*?)<\/\1>/gi)].map(c => inlineToMarkdown(c[2]).replace(/\|/g, '\\|')));
     if (!rows.length)

package/dist/mcp.d.ts

@@ -265,20 +265,6 @@ export declare const toolText: (id: RpcRequest["id"], text: string, isError?: bo
         }[];
     };
 };
-/** The methods one era has and the other does not. Everything else is shared. */
-declare const ERA_METHODS: {
-    readonly legacy: readonly ["initialize", "ping"];
-    readonly modern: readonly ["server/discover"];
-};
-type Era = keyof typeof ERA_METHODS;
-/** Everything the dispatcher needs that is not in the JSON-RPC entry itself. */
-interface Dispatch {
-    protocolVersion: McpProtocolVersion;
-    era: Era;
-    request?: Request;
-}
-/** Dispatch a parsed body. `null` means notification-only — answer 202, not 200. */
-export declare function handleMcp(body: RpcRequest | RpcRequest[], config: McpServerConfig, dispatch?: Dispatch): Promise<object | object[] | null>;
 export declare const MCP_CORS: Record<string, string>;
 export declare function withMcpCors<T extends Response>(res: T): T;
 export declare function mcpOptions(): Response;

package/dist/mcp.js

@@ -433,7 +433,7 @@ async function handleRpc(req, config, dispatch) {
         return rpcError(id, -32603, 'Internal error');
     }
 }
-/** Dispatch a parsed body. `null` means notification-only — answer 202, not 200. */
+/** Dispatch a parsed body. `null` means notification-only — answer 202, not 200. @internal */
 export async function handleMcp(body, config, dispatch = { protocolVersion: ASSUMED_VERSION, era: 'legacy' }) {
     const maxBatch = config.maxBatch ?? DEFAULT_MAX_BATCH;
     const isBatch = Array.isArray(body);