wiki-formant 0.22.0 → 0.23.0

package/dist/feed.js

@@ -13,6 +13,7 @@
 //
 // What stays with the caller is the channel's identity and the block walk that
 // turns a page into HTML. Every project owns its own type set.
+import { corpusEtag, notModified } from './http.js';
 // Numeric reference for the apostrophe: `'` is an XML entity that older
 // readers parsing the feed as HTML do not carry in their entity table.
 const XML_ESCAPES = {
@@ -70,8 +71,7 @@ export function renderItem(item) {
  * exist to prevent. An empty feed has no build date rather than a fictional one.
  */
 export function renderFeed(channel, items) {
-    const newest = channel.lastBuild ??
-        items.reduce((max, item) => (!max || item.date > max ? item.date : max), null);
+    const newest = lastBuild(channel, items);
     return [
         '<?xml version="1.0" encoding="UTF-8"?>',
         '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">',
@@ -88,7 +88,25 @@ export function renderFeed(channel, items) {
         '</rss>',
     ].join('\n');
 }
+const lastBuild = (channel, items) => channel.lastBuild ?? items.reduce((max, item) => (!max || item.date > max ? item.date : max), null);
 export const FEED_HEADERS = {
     'Content-Type': 'application/rss+xml; charset=utf-8',
     'Cache-Control': 'public, s-maxage=3600, stale-while-revalidate=86400',
 };
+/**
+ * The feed as a response, with the validators a poller revalidates against.
+ *
+ * All four feeds in the workspace were `new Response(renderFeed(...))` with
+ * `Cache-Control: public` and no ETag or Last-Modified, so a reader polling
+ * hourly could never be told "unchanged" and took the whole channel every time.
+ * The tag comes from the rendered XML, so it moves exactly when the feed does;
+ * Last-Modified is the channel's build date.
+ */
+export function feedResponse(request, channel, items, headers = FEED_HEADERS) {
+    const xml = `${renderFeed(channel, items)}\n`;
+    const etag = corpusEtag([xml]);
+    const built = lastBuild(channel, items);
+    const lastModified = built ? built.toUTCString() : null;
+    const sent = { ...headers, ETag: etag, ...(lastModified ? { 'Last-Modified': lastModified } : {}) };
+    return notModified(request, etag, lastModified, sent) ?? new Response(xml, { headers: sent });
+}

package/dist/freshness.d.ts

@@ -1,3 +1,5 @@
+import { isoDate } from './html.js';
+export { isoDate };
 export interface FreshnessInput {
     lastVerifiedAt?: Date | string | null;
     updatedAt?: Date | string | null;
@@ -31,3 +33,34 @@ export declare function freshnessBanner(page: FreshnessInput, nowMs: number, max
     variant: 'outdated';
     text: string;
 } | null;
+type When = Date | string | number;
+/**
+ * A calendar day for a reader: `Sep 19, 2026`. Always in UTC. A stored
+ * timestamp formatted in the server's zone, or the browser's, lands on the
+ * previous day for half the world, and the server and the hydrating client
+ * disagree about which day it is.
+ */
+export declare function formatDay(date: When, options?: Intl.DateTimeFormatOptions): string;
+/**
+ * - `compact`: `now`, `2m`, `3h`, `5d`, `2mo`, `1y` — for dense rows.
+ * - `short`: `just now`, `2m ago` … `1y ago`.
+ * - `long`: `today`, `yesterday`, `3 days ago`, `1 month ago` — day-grained,
+ *   because it suits a page cached for hours, where "3 hours ago" would be
+ *   frozen and wrong by the next reader.
+ */
+export type RelativeTimeStyle = 'compact' | 'short' | 'long';
+export interface RelativeTimeOptions {
+    style?: RelativeTimeStyle;
+    /** From this many whole days on, the date itself (`formatDay`) rather than a distance. */
+    absoluteAfterDays?: number;
+}
+/**
+ * How long before `now` a moment was. `now` is the render's time, passed in:
+ * a server render that read the clock would hydrate against a later one and
+ * the text would disagree. A moment after `now` (clock skew) reads as now.
+ *
+ * Three copies of this had drifted into three bugs between them: `0y` for a
+ * moment 360–364 days old, where twelve 30-day months fell through to a floor
+ * of zero years, and `1 months ago`.
+ */
+export declare function relativeTime(then: When, now: number, options?: RelativeTimeOptions): string;

package/dist/freshness.js

@@ -9,6 +9,7 @@
 // This runs during SSR, and a render that reads the clock is a render that can
 // disagree with the one the server just sent.
 import { isoDate } from './html.js';
+export { isoDate };
 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. */
@@ -53,3 +54,55 @@ export function freshnessBanner(page, nowMs, maxAgeDays = DEFAULT_MAX_AGE_DAYS)
         return null;
     return { id: '__freshness__', type: 'banner', variant: 'outdated', text: freshnessNotice(page) };
 }
+const toMs = (d) => (typeof d === 'number' ? d : d instanceof Date ? d.getTime() : Date.parse(d));
+/**
+ * A calendar day for a reader: `Sep 19, 2026`. Always in UTC. A stored
+ * timestamp formatted in the server's zone, or the browser's, lands on the
+ * previous day for half the world, and the server and the hydrating client
+ * disagree about which day it is.
+ */
+export function formatDay(date, options) {
+    return new Date(toMs(date)).toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        timeZone: 'UTC',
+        ...options,
+    });
+}
+const plural = (n, unit) => `${n} ${unit}${n === 1 ? '' : 's'} ago`;
+/**
+ * How long before `now` a moment was. `now` is the render's time, passed in:
+ * a server render that read the clock would hydrate against a later one and
+ * the text would disagree. A moment after `now` (clock skew) reads as now.
+ *
+ * Three copies of this had drifted into three bugs between them: `0y` for a
+ * moment 360–364 days old, where twelve 30-day months fell through to a floor
+ * of zero years, and `1 months ago`.
+ */
+export function relativeTime(then, now, options = {}) {
+    const { style = 'compact', absoluteAfterDays } = options;
+    const sec = Math.max(0, Math.floor((now - toMs(then)) / 1000));
+    const day = Math.floor(sec / 86_400);
+    if (absoluteAfterDays !== undefined && day >= absoluteAfterDays)
+        return formatDay(then);
+    // Nearest, not floor: 60 days is two months to a reader, and flooring by the
+    // mean month length made it one.
+    const months = Math.max(1, Math.round(day / 30.4375));
+    const years = Math.max(1, Math.round(day / 365.25));
+    if (style === 'long') {
+        if (day === 0)
+            return 'today';
+        if (day === 1)
+            return 'yesterday';
+        if (day < 30)
+            return plural(day, 'day');
+        return day < 365 ? plural(months, 'month') : plural(years, 'year');
+    }
+    const min = Math.floor(sec / 60);
+    const hr = Math.floor(min / 60);
+    const span = sec < 60 ? '' : min < 60 ? `${min}m` : hr < 24 ? `${hr}h` : day < 30 ? `${day}d` : day < 365 ? `${months}mo` : `${years}y`;
+    if (style === 'compact')
+        return span || 'now';
+    return span ? `${span} ago` : 'just now';
+}

package/dist/headings.d.ts

@@ -28,6 +28,13 @@ export interface HeadingIdOptions {
      * into a TOC label.
      */
     anchor?: (id: string) => string;
+    /**
+     * Ids already taken on this page, added to as headings are decorated. Pass
+     * ONE set across every fragment of a document — each content block of a page,
+     * seeded with any id the page template renders itself — or two fragments with
+     * the same heading text mint the same id. Omitted, dedupe covers this call only.
+     */
+    used?: Set<string>;
 }
 /**
  * Give every heading in `html` an id and a permalink anchor. Headings that

package/dist/headings.js

@@ -9,7 +9,10 @@
 //
 // Deduping, by contrast, is not a choice: two headings with the same text
 // otherwise mint the same id twice and every link to the second one lands on
-// the first, so this always dedupes.
+// the first, so this always dedupes. The unit is the DOCUMENT, not the call: a
+// block wiki calls the injector once per block, and all three consumers did
+// that with a fresh set each time, so a "Notes" in two blocks shipped two
+// `id="notes"`. One `used` set per page is what makes the dedupe hold.
 import { getAttr, stripTags } from './html.js';
 /** The default slug rule: lowercase words joined by hyphens. */
 export function slugifyHeading(text) {
@@ -46,11 +49,16 @@ export function injectHeadingIds(html, options = {}) {
         return html;
     const slug = options.slug ?? slugifyHeading;
     const anchor = options.anchor ?? defaultAnchor;
-    const used = new Set();
+    const used = options.used ?? new Set();
     return html.replace(HEADING, (match, tag, attrs, content) => {
-        if (content.includes('heading-anchor'))
-            return match;
         const existing = getAttr(attrs, 'id');
+        // Already decorated, by an earlier pass or by whoever stored it: left as it
+        // is, but its id is still taken, or the next fragment could mint it again.
+        if (content.includes('heading-anchor')) {
+            if (existing)
+                used.add(existing);
+            return match;
+        }
         const id = existing || uniqueHeadingId(slug(stripTags(content)), used);
         if (!id)
             return match;

package/dist/metadata.d.ts

@@ -1,3 +1,4 @@
+import type { ReferenceItem } from './blocks.js';
 export interface ArticleMeta {
     publishedTime?: string;
     modifiedTime?: string;
@@ -67,3 +68,56 @@ export declare function pageMetadata(o: PageMetadataOptions): {
         canonical: string;
     } | undefined;
 };
+/** A schema.org node: inline, or an `{ '@id' }` reference into the site's graph. */
+export type LdNode = Record<string, unknown>;
+export interface ArticleLdOptions {
+    /** `Article` by default; `BlogPosting`, `TechArticle`, `ScholarlyArticle`… */
+    type?: string;
+    headline: string;
+    /** Absolute canonical URL. */
+    url: string;
+    description?: string;
+    /**
+     * Absolute URL, and required: Google wants an image on every article. Pass
+     * the card `pageMetadata` was given, so the two cannot disagree.
+     */
+    image: string;
+    published?: Date | string;
+    modified?: Date | string;
+    publisher: LdNode;
+    isPartOf?: LdNode;
+    /** Omit rather than invent one: a system-authored row has no person to name. */
+    author?: LdNode;
+    license?: string;
+    /** Defaults to `en`. */
+    inLanguage?: string;
+    /** See `citationsFromReferences`. Left out when empty. */
+    citation?: LdNode[];
+    /** What only this wiki states — wordCount, articleSection, about, hasPart. Spread last. */
+    extra?: LdNode;
+}
+export declare function articleLd(o: ArticleLdOptions): LdNode;
+export interface CollectionLdOptions {
+    name: string;
+    /** Absolute. */
+    url: string;
+    description?: string;
+    isPartOf?: LdNode;
+    license?: string;
+    /** In display order; `url` absolute. */
+    items: readonly {
+        name: string;
+        url: string;
+    }[];
+    /** How many are listed. `numberOfItems` still counts every one. Defaults to 100. */
+    max?: number;
+    extra?: LdNode;
+}
+/** An index page and the pages it lists, as a CollectionPage over an ItemList. */
+export declare function collectionLd(o: CollectionLdOptions): LdNode;
+/**
+ * A page's `references` items as `Article.citation`, read off the block data
+ * rather than re-parsed out of rendered HTML. Tags out and entities decoded, so
+ * an authored `&amp;` is not what a crawler reads.
+ */
+export declare function citationsFromReferences(items: readonly ReferenceItem[], max?: number): LdNode[];

package/dist/metadata.js

@@ -12,6 +12,13 @@
 // wrote each page's metadata by hand.
 //
 // Plain objects in the shape Next's `Metadata` wants, so no `next` import.
+//
+// The schema.org nodes live here too, because they state the same facts to a
+// different reader. Three wikis built their Article and CollectionPage nodes
+// by hand and each dropped something the others kept: two shipped articles
+// with no image while their og:image named a card, one listed citations, one
+// collection page had no ItemList at all.
+import { decodeEntities } from './markdown.js';
 export function pageMetadata(o) {
     const { title, description, url, type = 'website', image, imageSize = { width: 1200, height: 630 }, siteName, locale, handle, markdownTwin, article } = o;
     const images = image ? [{ url: image, ...imageSize, alt: o.imageAlt ?? title }] : undefined;
@@ -43,3 +50,60 @@ export function pageMetadata(o) {
         },
     };
 }
+const iso = (d) => new Date(d).toISOString();
+export function articleLd(o) {
+    return {
+        '@context': 'https://schema.org',
+        '@type': o.type ?? 'Article',
+        headline: o.headline,
+        url: o.url,
+        mainEntityOfPage: { '@type': 'WebPage', '@id': o.url },
+        ...(o.description ? { description: o.description } : {}),
+        image: o.image,
+        ...(o.published ? { datePublished: iso(o.published) } : {}),
+        ...(o.modified ? { dateModified: iso(o.modified) } : {}),
+        inLanguage: o.inLanguage ?? 'en',
+        ...(o.author ? { author: o.author } : {}),
+        publisher: o.publisher,
+        ...(o.isPartOf ? { isPartOf: o.isPartOf } : {}),
+        ...(o.license ? { license: o.license } : {}),
+        ...(o.citation?.length ? { citation: o.citation } : {}),
+        ...o.extra,
+    };
+}
+/** An index page and the pages it lists, as a CollectionPage over an ItemList. */
+export function collectionLd(o) {
+    return {
+        '@context': 'https://schema.org',
+        '@type': 'CollectionPage',
+        name: o.name,
+        url: o.url,
+        ...(o.description ? { description: o.description } : {}),
+        ...(o.isPartOf ? { isPartOf: o.isPartOf } : {}),
+        ...(o.license ? { license: o.license } : {}),
+        mainEntity: {
+            '@type': 'ItemList',
+            numberOfItems: o.items.length,
+            itemListElement: o.items.slice(0, o.max ?? 100).map((item, i) => ({
+                '@type': 'ListItem',
+                position: i + 1,
+                name: item.name,
+                url: item.url,
+            })),
+        },
+        ...o.extra,
+    };
+}
+/**
+ * A page's `references` items as `Article.citation`, read off the block data
+ * rather than re-parsed out of rendered HTML. Tags out and entities decoded, so
+ * an authored `&` is not what a crawler reads.
+ */
+export function citationsFromReferences(items, max = 50) {
+    return items
+        .flatMap(ref => {
+        const name = decodeEntities(ref.text.replace(/<[^>]+>/g, '')).replace(/\s+/g, ' ').trim();
+        return name ? [{ '@type': 'CreativeWork', name: name.slice(0, 250), ...(ref.url ? { url: ref.url } : {}) }] : [];
+    })
+        .slice(0, max);
+}

package/dist/react-server.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentType, ReactNode } from 'react';
-import type { Control, FacetControlGroup } from './taxonomy.js';
+import type { Control, FacetControlGroup, MetadataRow } from './taxonomy.js';
 /**
  * The shape a router's link component has to satisfy here.
  *
@@ -49,6 +49,8 @@ export interface FacetBarProps {
     /** Lead with the A–Z row: two lines against a facet block's twenty. */
     alphaFirst?: boolean;
     classNames?: FacetBarClassNames;
+    /** The landmark's accessible name. */
+    label?: string;
 }
 /**
  * The section's second axis, as pressable chips.
@@ -60,7 +62,46 @@ export interface FacetBarProps {
  * `aria-current`, not `aria-pressed`: a link is not a toggle button and does not
  * take that attribute.
  */
-export declare function FacetBar({ link: Link, facets, letters, alphaLabel, alphaFirst, classNames, }: FacetBarProps): import("react").JSX.Element | null;
+export declare function FacetBar({ link: Link, facets, letters, alphaLabel, alphaFirst, classNames, label: navLabel, }: FacetBarProps): import("react").JSX.Element | null;
+export interface FacetSummaryProps {
+    shown: number;
+    total: number;
+    /** The section, as a reader names it. */
+    name: string;
+    /** The un-narrowed section. Pass it exactly when a facet or letter is active. */
+    clearHref?: string;
+    link?: WikiLinkComponent;
+}
+/**
+ * How much of the section the reader is looking at, and the way back to all of
+ * it. Two wikis printed the same sentence and one printed none; one had the
+ * Clear link and another had the only filtered-empty state. This is all three.
+ */
+export declare function FacetSummary({ shown, total, name, clearHref, link: Link }: FacetSummaryProps): import("react").JSX.Element;
+export interface RelatedPagesProps {
+    /** `rankRelated`'s pages, with the hrefs the wiki builds. */
+    pages: readonly {
+        href: string;
+        title: string;
+        detail?: string;
+    }[];
+    /** The heading's words — the wiki's own, since they name its sections. */
+    heading: ReactNode;
+    /**
+     * The set the heading opens: the section filtered to the facet `rankRelated`
+     * found in common. Omit and the heading is plain text.
+     */
+    href?: string;
+    link?: WikiLinkComponent;
+    /** Unique on the page; ties the landmark to its heading. */
+    id?: string;
+}
+/**
+ * The foot-of-article "see also". A labelled complementary landmark over a real
+ * list, because the two copies this replaced split those between them: one had
+ * the landmark and the list, the other neither.
+ */
+export declare function RelatedPages({ pages, heading, href, link: Link, id }: RelatedPagesProps): import("react").JSX.Element | null;
 /**
  * A JSON-LD payload, safe to place inside `<script type="application/ld+json">`.
  *
@@ -174,3 +215,41 @@ export interface PageNavProps {
  * link stays in the right one.
  */
 export declare function PageNav({ prev, next, link: Link, label, prevLabel, nextLabel, prevGlyph, nextGlyph, }: PageNavProps): import("react").JSX.Element | null;
+export interface InfoboxAsideProps {
+    /** The landmark's accessible name, e.g. `Key facts about ${title}`. */
+    label: string;
+    /** Wikipedia's "Part of a series on": the topic's main article. */
+    series?: {
+        title: string;
+        href: string;
+    } | null;
+    link?: WikiLinkComponent;
+    /** Added to `infobox`, for a design system's layout utility. */
+    className?: string;
+    children?: ReactNode;
+}
+/**
+ * The facts panel beside an article. Named, because two of the three asides
+ * this replaced had no accessible name, and a complementary landmark without
+ * one reads as "complementary" and nothing else.
+ */
+export declare function InfoboxAside({ label, series, link: Link, className, children }: InfoboxAsideProps): import("react").JSX.Element;
+/**
+ * A metadata value for reading: a date as its day, a URL (or a bare domain) as
+ * an external link, and a `<br>`-separated list as lines. Rendered as React
+ * nodes, never interpolated into markup: the string builders this replaced had
+ * to re-escape a `"` that would otherwise close an href, and one did not.
+ */
+export declare function formatFactValue(value: string, type: string): ReactNode;
+export interface InfoboxFactsProps {
+    /** `metadataRows`, or any rows of the same shape a wiki derives itself. */
+    rows: readonly Pick<MetadataRow, 'label' | 'value' | 'type' | 'href'>[];
+    link?: WikiLinkComponent;
+    /** Overrides how a row without an `href` is shown. */
+    formatValue?: (value: string, type: string) => ReactNode;
+}
+/**
+ * The derived facts table. A row with an `href` links into the facet view that
+ * shares its value — the way into the set, not dead text.
+ */
+export declare function InfoboxFacts({ rows, link: Link, formatValue }: InfoboxFactsProps): import("react").JSX.Element | null;

package/dist/react-server.js

@@ -19,6 +19,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // back to a full page load on every press. React is an optional peer, as it is
 // for `wiki-formant/react`.
 import { Fragment } from 'react';
+import { safeLinkHref } from './validation.js';
+import { isoDate } from './html.js';
 /**
  * The default for anything that does not need client-side navigation.
  *
@@ -36,7 +38,7 @@ export const Anchor = ({ href, className, children }) => _jsx("a", { href: href,
  * `aria-current`, not `aria-pressed`: a link is not a toggle button and does not
  * take that attribute.
  */
-export function FacetBar({ link: Link, facets, letters, alphaLabel = 'A–Z', alphaFirst = false, classNames = {}, }) {
+export function FacetBar({ link: Link, facets, letters, alphaLabel = 'A–Z', alphaFirst = false, classNames = {}, label: navLabel = 'Filter pages', }) {
     if (!facets.length && !letters.length)
         return null;
     const { root = 'stack tight', row = 'cluster', label = 'form-label', control = 'tag', controlActive = 'tag tag-removable', count, } = classNames;
@@ -51,7 +53,32 @@ export function FacetBar({ link: Link, facets, letters, alphaLabel = 'A–Z', al
                 n: l.count,
                 ...(l.reset ? { title: `All ${l.count} pages` } : {}),
             }))] }, "alpha"));
-    return _jsx("div", { className: root, children: alphaFirst ? [alphaRow, ...facetRows] : [...facetRows, alphaRow] });
+    // A landmark: every control in it narrows the list below, and a screen
+    // reader user skipping between regions should be able to land on it.
+    return (_jsx("nav", { className: root, "aria-label": navLabel, children: alphaFirst ? [alphaRow, ...facetRows] : [...facetRows, alphaRow] }));
+}
+/**
+ * How much of the section the reader is looking at, and the way back to all of
+ * it. Two wikis printed the same sentence and one printed none; one had the
+ * Clear link and another had the only filtered-empty state. This is all three.
+ */
+export function FacetSummary({ shown, total, name, clearHref, link: Link = Anchor }) {
+    const clear = clearHref ? (_jsxs(_Fragment, { children: [' ', _jsx(Link, { href: clearHref, className: "facet-summary-clear", children: "Clear filters" })] })) : null;
+    if (total === 0)
+        return _jsx("p", { className: "facet-summary", children: "This section has no pages yet." });
+    if (shown === 0)
+        return _jsxs("p", { className: "facet-summary", children: ["No pages match these filters.", clear] });
+    return (_jsxs("p", { className: "facet-summary", children: [shown === total ? (_jsxs(_Fragment, { children: ["The following ", _jsx("strong", { children: total }), " ", total === 1 ? 'page is' : 'pages are', " in ", name, "."] })) : (_jsxs(_Fragment, { children: ["Showing ", _jsx("strong", { children: shown }), " of ", total, " pages in ", name, "."] })), clear] }));
+}
+/**
+ * The foot-of-article "see also". A labelled complementary landmark over a real
+ * list, because the two copies this replaced split those between them: one had
+ * the landmark and the list, the other neither.
+ */
+export function RelatedPages({ pages, heading, href, link: Link = Anchor, id = 'see-also-heading' }) {
+    if (!pages.length)
+        return null;
+    return (_jsxs("aside", { className: "see-also", "aria-labelledby": id, children: [_jsx("h2", { id: id, className: "see-also-heading", children: href ? _jsx(Link, { href: href, children: heading }) : heading }), _jsx("ul", { className: "see-also-list", children: pages.map(p => (_jsx("li", { children: _jsxs(Link, { href: p.href, className: "see-also-item", children: [_jsx("span", { className: "see-also-title", children: p.title }), p.detail && _jsx("span", { className: "see-also-detail", children: p.detail })] }) }, p.href))) })] }));
 }
 // ---- structured data --------------------------------------------------------
 /**
@@ -138,3 +165,45 @@ export function PageNav({ prev, next, link: Link = Anchor, label = 'Article navi
         return null;
     return (_jsxs("nav", { className: "page-nav", "aria-label": label, children: [prev ? (_jsxs(Link, { href: prev.href, className: "page-nav-link", rel: "prev", children: [_jsxs("span", { className: "page-nav-label", children: [prevGlyph, prevLabel] }), _jsx("span", { className: "page-nav-title", children: prev.title })] })) : (_jsx("div", {})), next && (_jsxs(Link, { href: next.href, className: "page-nav-link page-nav-link--end", rel: "next", children: [_jsxs("span", { className: "page-nav-label page-nav-label--end", children: [nextLabel, nextGlyph] }), _jsx("span", { className: "page-nav-title", children: next.title })] }))] }));
 }
+/**
+ * The facts panel beside an article. Named, because two of the three asides
+ * this replaced had no accessible name, and a complementary landmark without
+ * one reads as "complementary" and nothing else.
+ */
+export function InfoboxAside({ label, series, link: Link = Anchor, className, children }) {
+    return (_jsxs("aside", { className: className ? `infobox ${className}` : 'infobox', "aria-label": label, children: [series && (_jsxs("div", { className: "infobox-series", children: [_jsx("span", { children: "Part of a series on" }), _jsx(Link, { href: series.href, children: series.title })] })), children] }));
+}
+const looksLikeUrl = (v, type) => type === 'url' || /^https?:\/\//i.test(v) || /^[^\s/]+\.[a-z]{2,}(\/\S*)?$/i.test(v);
+function externalLink(v) {
+    const href = safeLinkHref(/^[a-z][a-z0-9+.-]*:/i.test(v) ? v : `https://${v}`);
+    if (!href)
+        return v;
+    return (_jsx("a", { href: href, target: "_blank", rel: "noopener", children: v.replace(/^https?:\/\/(www\.)?/i, '').replace(/\/$/, '') }));
+}
+/**
+ * A metadata value for reading: a date as its day, a URL (or a bare domain) as
+ * an external link, and a `<br>`-separated list as lines. Rendered as React
+ * nodes, never interpolated into markup: the string builders this replaced had
+ * to re-escape a `"` that would otherwise close an href, and one did not.
+ */
+export function formatFactValue(value, type) {
+    if (type === 'date') {
+        const t = Date.parse(value);
+        if (!Number.isNaN(t))
+            return isoDate(new Date(t));
+    }
+    const parts = value.split(/<br\s*\/?>/i).map(s => s.trim()).filter(Boolean);
+    if (parts.length > 1) {
+        return parts.map((part, i) => (_jsxs(Fragment, { children: [i > 0 && _jsx("br", {}), looksLikeUrl(part, type) ? externalLink(part) : part] }, i)));
+    }
+    return looksLikeUrl(value, type) ? externalLink(value) : value;
+}
+/**
+ * The derived facts table. A row with an `href` links into the facet view that
+ * shares its value — the way into the set, not dead text.
+ */
+export function InfoboxFacts({ rows, link: Link = Anchor, formatValue = formatFactValue }) {
+    if (!rows.length)
+        return null;
+    return (_jsx("table", { className: "infobox-facts", children: _jsx("tbody", { children: rows.map(row => (_jsxs("tr", { children: [_jsx("th", { scope: "row", children: row.label }), _jsx("td", { children: row.href ? _jsx(Link, { href: row.href, children: row.value }) : formatValue(row.value, row.type) })] }, row.label))) }) }));
+}

package/dist/react.d.ts

@@ -1,5 +1,5 @@
 import { type ComboboxAria } from './combobox.js';
-import { Component, type CSSProperties, type DependencyList, type RefObject, type KeyboardEvent, type ReactNode } from 'react';
+import { Component, type CSSProperties, type DependencyList, type RefObject, type KeyboardEvent, type ReactNode, type ThHTMLAttributes } from 'react';
 export interface SidebarOptions {
     /**
      * Where the reader's choice is remembered, in `localStorage`. Give each wiki
@@ -253,6 +253,88 @@ export declare function useTableSort<T, K extends string>(rows: readonly T[], co
      */
     defaultDirection?: SortDirection | ((key: K) => SortDirection);
 }): TableSortState<T, K>;
+/**
+ * The header cell `useTableSort` drives: spread `headerProps(key)` onto it.
+ *
+ * The press target is a `<button>` inside the `<th>`, never the cell itself: a
+ * cell with an `onClick` cannot be reached or pressed from the keyboard, which
+ * is the state one of the two copies this replaced was in. The markup is the
+ * one `sortTables` in `wiki-formant/dom` writes for tables stored in articles,
+ * so one stylesheet rule keyed on `aria-sort` draws both kinds of arrow.
+ */
+export declare function SortHeader<K extends string>({ sortKey, onSort, active: _active, direction: _direction, 'aria-sort': ariaSort, label, icon, children, ...th }: Omit<ThHTMLAttributes<HTMLTableCellElement>, 'aria-sort' | 'children'> & ReturnType<TableSortState<unknown, K>['headerProps']> & {
+    /** Names a header whose content is an icon, for the button and its tooltip. */
+    label?: string;
+    /** Drawn after the content, e.g. a sort glyph; CSS on `aria-sort` is the default. */
+    icon?: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface BlockOperations<T> {
+    selectedIndex: number | null;
+    setSelectedIndex: (i: number | null) => void;
+    update: (i: number, block: T) => void;
+    remove: (i: number) => void;
+    duplicate: (i: number) => void;
+    /** No-op when `to` is off either end. */
+    move: (from: number, to: number) => void;
+    insert: (block: T, at?: number) => void;
+}
+/**
+ * The five edits every block editor makes to its list, with stable callbacks.
+ *
+ * The list and its setter are read through refs written after render, so a row
+ * memoised on these callbacks does not re-render on every keystroke elsewhere
+ * — and the setter may be a `useState` setter or a parent's `onChange`, which
+ * is what the three copies this replaced were split between. Creating and
+ * duplicating a block stay with the caller, whose union it is.
+ */
+export declare function useBlockOperations<T>(blocks: readonly T[], setBlocks: (next: T[]) => void, options: {
+    duplicate: (block: T) => T;
+}): BlockOperations<T>;
+export interface BlockActionsProps {
+    index: number;
+    total: number;
+    ops: Pick<BlockOperations<unknown>, 'move' | 'duplicate' | 'remove'>;
+    icons: {
+        up: ReactNode;
+        down: ReactNode;
+        duplicate?: ReactNode;
+        remove: ReactNode;
+    };
+    className?: string;
+    buttonClassName?: string;
+    /** Names the block in each button's label, e.g. "Move Table up". */
+    blockLabel?: string;
+}
+/**
+ * Move up, move down, duplicate, delete. Every button has an accessible name
+ * and the moves are disabled at the ends — the three bars this replaced had
+ * each of those only sometimes. Clicks do not bubble, so a row that selects on
+ * click is not also selected by pressing delete in it. Omit `icons.duplicate`
+ * for a bar without it.
+ */
+export declare function BlockActions({ index, total, ops, icons, className, buttonClassName, blockLabel }: BlockActionsProps): import("react").JSX.Element;
+/** Resolves to an error message to show, or null on success. */
+export type RestoreRevision<Id> = (id: Id) => Promise<string | null>;
+/**
+ * POST `{ revisionId }` to `endpoint`, the transport two of the wikis use; the
+ * third passes its server action instead.
+ */
+export declare function restoreViaPost<Id>(endpoint: string): RestoreRevision<Id>;
+/**
+ * Confirm, restore, report. Of the three copies one asked no confirmation, one
+ * dropped a failure silently, and one reported it through `alert`. A restore
+ * writes the old state forward as a new revision in all three, which is what
+ * the default question says.
+ */
+export declare function useRevisionRestore<Id>(restore: RestoreRevision<Id>, options: {
+    onRestored: () => void;
+    confirm?: (label: string) => string | false;
+}): {
+    restore: (id: Id, label: string) => Promise<void>;
+    busyId: Id | null;
+    error: string | null;
+};
 /**
  * "Copied", then not, after a beat. Six call sites across three repos wrote the
  * same three statements, and four of the six had no rejection handler — so a