wiki-formant 0.83.1 → 0.85.0

package/dist/mcp.js

@@ -203,7 +203,7 @@ function validateArgs(tool, args) {
     const allowed = Object.keys(properties);
     const problems = [];
     for (const key of Object.keys(args)) {
-        if (key in properties)
+        if (Object.hasOwn(properties, key))
             continue;
         problems.push(allowed.length
             ? `Unknown parameter "${key}". Allowed parameters: ${quote(allowed)}.`
@@ -309,6 +309,10 @@ async function handleRpc(req, config, dispatch) {
     const foreign = ERA_METHODS[dispatch.era === 'modern' ? 'legacy' : 'modern'];
     if (foreign.includes(method))
         return methodNotFound(id, method, config, dispatch.era);
+    // A notification has no response at all, a method-not-found included:
+    // `notifications/progress` or `roots/list_changed` is not an error to answer.
+    if (method.startsWith('notifications/'))
+        return null;
     try {
         switch (method) {
             case 'initialize':
@@ -326,10 +330,6 @@ async function handleRpc(req, config, dispatch) {
                     capabilities: capabilitiesOf(config),
                     instructions: config.instructions,
                 });
-            // Notifications have no response at all.
-            case 'notifications/initialized':
-            case 'notifications/cancelled':
-                return null;
             case 'ping':
                 return ok(id, {});
             case 'tools/list':
@@ -368,7 +368,9 @@ async function handleRpc(req, config, dispatch) {
                 });
             }
             case 'tools/call': {
-                const { name, arguments: rawArgs = {} } = p;
+                // `null` is how some clients spell "no arguments"; it means the same as omitting them.
+                const { name, arguments: rawArgs } = p;
+                const given = rawArgs ?? {};
                 const names = config.tools.map(t => t.name);
                 const tool = name ? config.tools.find(t => t.name === name) : undefined;
                 if (!tool) {
@@ -377,10 +379,10 @@ async function handleRpc(req, config, dispatch) {
                         availableTools: names,
                     });
                 }
-                if (typeOf(rawArgs) !== 'object') {
-                    return toolText(id, `"arguments" must be an object; received ${typeOf(rawArgs)}. Expected schema: ${JSON.stringify(tool.inputSchema)}`, true);
+                if (typeOf(given) !== 'object') {
+                    return toolText(id, `"arguments" must be an object; received ${typeOf(given)}. Expected schema: ${JSON.stringify(tool.inputSchema)}`, true);
                 }
-                const args = rawArgs;
+                const args = given;
                 const invalid = validateArgs(tool, args);
                 if (invalid)
                     return toolText(id, invalid, true);
@@ -395,7 +397,9 @@ async function handleRpc(req, config, dispatch) {
                 };
                 try {
                     const data = await tool.handler(args, ctx);
-                    const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+                    // `?? null`: a handler that returns nothing still owes a string, and
+                    // JSON.stringify(undefined) is undefined.
+                    const text = typeof data === 'string' ? data : JSON.stringify(data ?? null, null, 2);
                     // Every object answer, not only the schema-bearing ones. Gated on
                     // `outputSchema`, a JSON-returning tool without one would carry no
                     // `structuredContent`, and agents would parse prose to reach data the
@@ -526,7 +530,12 @@ export async function mcpResponse(request, config) {
     // Tracked before either era refuses anything: a probe the server turns away,
     // and a call an agent walked away from behind a gate, are exactly the ones
     // worth counting.
-    config.onCall?.(request, body);
+    try {
+        config.onCall?.(request, body);
+    }
+    catch {
+        // Analytics never blocks the response, a throwing hook included.
+    }
     return isModern(request, body)
         ? modernResponse(request, body, config, base)
         : legacyResponse(request, body, config, base);

package/dist/queues.d.ts

@@ -0,0 +1,45 @@
+export interface QueuePage {
+    id: string;
+    title: string;
+    tagPath: string;
+    slug: string;
+    content: unknown;
+    metadata: unknown;
+    updatedAt: Date | string;
+    lastVerifiedAt?: Date | string | null;
+}
+export interface QueueItem {
+    title: string;
+    href: string;
+    tagPath: string;
+    detail: string;
+}
+export type QueueKey = 'outdated' | 'orphaned' | 'unsourced' | 'incomplete';
+export interface MaintenanceQueue {
+    key: QueueKey;
+    title: string;
+    description: string;
+    items: QueueItem[];
+}
+export interface QueueOptions<P extends QueuePage> {
+    /** A page's address as its links name it: `/guides/install`, no trailing slash. */
+    href: (page: P) => string;
+    /** The facts a page's category requires, by key and label. */
+    required?: (tagPath: string) => readonly {
+        key: string;
+        label: string;
+    }[];
+    nowMs: number;
+    maxAgeDays?: number;
+    /** How a page is stamped as checked here, closing the outdated queue's description. */
+    verify?: string;
+    /** The ids a block names its pages by, for a list that picks pages by id rather than by link. */
+    listedIds?: (content: unknown) => Iterable<string>;
+}
+/**
+ * The four queues over a wiki's pages, empty ones dropped. Pass every page
+ * outside the home page and the back office: an orphan is a page nothing else
+ * links to, so the link graph needs them all. One pass reads each page's
+ * content for both the links in and the sources out.
+ */
+export declare function maintenanceQueues<P extends QueuePage>(pages: readonly P[], o: QueueOptions<P>): MaintenanceQueue[];

package/dist/queues.js

@@ -0,0 +1,91 @@
+// queues.ts — tracking categories, Wikipedia's hidden maintenance categories,
+// as work queues.
+//
+// A cleanup template files a page into `Articles needing update` or `Orphaned
+// articles`, and contributors pick work off the list. Every wiki here already
+// computed the same signals: `isStale` drives the outdated banner, the content
+// standard asks for linked sources, a category declares required facts. Each
+// surfaced only on the affected page, where nobody looking for work sees it.
+// These are those predicates gathered into lists, derived on every read, so
+// fixing a page takes it off the list with no ticket to close.
+//
+// radix-wiki wrote it over its own Prisma rows; caper, acuiq2 and miow's wikis
+// had none. What differs is how a page is addressed and which facts its
+// category requires, so those are the arguments.
+import { daysSince, isStale, DEFAULT_MAX_AGE_DAYS } from './freshness.js';
+import { metaValue } from './taxonomy.js';
+// An href inside stored JSON, its quotes escaped or not.
+const HREF = /href=\\?"([^"\\?#]+)/g;
+/** A `references` block keeps each citation in a `url` field, not an href. */
+const REF_URL = /"url":"https?:/g;
+/**
+ * The four queues over a wiki's pages, empty ones dropped. Pass every page
+ * outside the home page and the back office: an orphan is a page nothing else
+ * links to, so the link graph needs them all. One pass reads each page's
+ * content for both the links in and the sources out.
+ */
+export function maintenanceQueues(pages, o) {
+    const maxAgeDays = o.maxAgeDays ?? DEFAULT_MAX_AGE_DAYS;
+    const ids = new Set(pages.map(p => p.id));
+    const linkedPaths = new Set();
+    const linkedIds = new Set();
+    const sources = new Map();
+    for (const page of pages) {
+        const text = JSON.stringify(page.content ?? '');
+        // A page's link to itself is not a way in, as a list naming itself is not.
+        const self = o.href(page);
+        let outbound = 0;
+        for (const [, target] of text.matchAll(HREF)) {
+            if (!target)
+                continue;
+            if (target.startsWith('/')) {
+                const path = target.replace(/\/+$/, '') || '/';
+                if (path !== self)
+                    linkedPaths.add(path);
+            }
+            else if (/^https?:/i.test(target))
+                outbound++;
+        }
+        sources.set(page.id, outbound + (text.match(REF_URL)?.length ?? 0));
+        for (const id of o.listedIds?.(page.content) ?? [])
+            if (id !== page.id && ids.has(id))
+                linkedIds.add(id);
+    }
+    const item = (p, detail) => ({ title: p.title, href: o.href(p), tagPath: p.tagPath, detail });
+    // Missing is what the facts panel would not show, so a number counts as given.
+    const incomplete = pages.flatMap(p => {
+        const missing = (o.required?.(p.tagPath) ?? [])
+            .filter(k => !metaValue(p, k.key))
+            .map(k => k.label.replace(/:$/, ''));
+        return missing.length ? [item(p, `missing ${missing.join(', ')}`)] : [];
+    });
+    const queues = [
+        {
+            key: 'outdated',
+            title: 'Outdated',
+            description: `Not checked or changed in ${maxAgeDays} days. Re-check the facts against current sources${o.verify ? `, then ${o.verify}` : ''}.`,
+            items: pages
+                .filter(p => isStale(p, o.nowMs, maxAgeDays))
+                .map(p => item(p, `${daysSince(p.lastVerifiedAt ?? p.updatedAt, o.nowMs)} days`)),
+        },
+        {
+            key: 'orphaned',
+            title: 'Orphaned',
+            description: 'No other page links here, so readers arrive only by search or the category list. Link it from a related page.',
+            items: pages.filter(p => !linkedPaths.has(o.href(p)) && !linkedIds.has(p.id)).map(p => item(p, 'no links in')),
+        },
+        {
+            key: 'unsourced',
+            title: 'Unsourced',
+            description: 'No link out anywhere on the page. Every claim of fact should link to the source it came from.',
+            items: pages.filter(p => !sources.get(p.id)).map(p => item(p, 'no links out')),
+        },
+        {
+            key: 'incomplete',
+            title: 'Missing facts',
+            description: 'A fact the page’s category requires is empty, so its facts panel and the category’s filters leave it out.',
+            items: incomplete,
+        },
+    ];
+    return queues.filter(q => q.items.length > 0);
+}

package/dist/react-server.d.ts

@@ -1,6 +1,7 @@
 import type { ComponentType, ReactNode } from 'react';
 import type { Control, FacetControlGroup, MetadataRow } from './taxonomy.js';
 import type { HistoryChange } from './history.js';
+import type { MaintenanceQueue } from './queues.js';
 /**
  * The shape a router's link component has to satisfy here.
  *
@@ -298,3 +299,34 @@ export interface RevisionChangesProps {
  * are the importing stylesheet's.
  */
 export declare function RevisionChanges({ changes, label }: RevisionChangesProps): import("react").JSX.Element | null;
+export interface MaintenanceQueuesProps {
+    queues: readonly MaintenanceQueue[];
+    link?: WikiLinkComponent;
+    /** Shown when every queue is empty. */
+    empty?: ReactNode;
+    /** The level each queue's heading takes. */
+    headingLevel?: 'h2' | 'h3';
+}
+/**
+ * `maintenanceQueues`' lists, a heading and a count each. The page around them
+ * (its title, a sentence on what the queues are) is the wiki's.
+ */
+export declare function MaintenanceQueues({ queues, link: Link, empty, headingLevel: H }: MaintenanceQueuesProps): import("react").JSX.Element;
+export interface CiteProps {
+    /** Who publishes the page: the site's name. */
+    publisher: string;
+    title: string;
+    /** The day the page last changed, or was published where a wiki keeps that. */
+    date: Date | string;
+    /** The page's one canonical address. */
+    url: string;
+    className?: string;
+}
+/** The citation for a page, one line: `Publisher. "Title." October 22, 2026. url`, as acuiq2 first wrote it. */
+export declare const citation: ({ publisher, title, date, url }: Omit<CiteProps, "className">) => string;
+/**
+ * "Cite" in an article's meta line, opening on the citation to copy. Shown,
+ * not copied by a button, so it works with no script and a reader can take
+ * part of it.
+ */
+export declare function Cite({ className, ...page }: CiteProps): import("react").JSX.Element;

package/dist/react-server.js

@@ -22,6 +22,7 @@ import { Fragment } from 'react';
 import { safeLinkHref } from './validation.js';
 import { isoDate } from './html.js';
 import { blockLocation } from './revisions.js';
+import { formatDay } from './freshness.js';
 /**
  * The default for anything that does not need client-side navigation.
  *
@@ -199,7 +200,14 @@ export function SnapDots({ count, at, onGo, noun = 'item', className = '' }) {
 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);
+/** A file or library suffix no domain ends in: "Node.js", "Cargo.toml" and "setup.py" name things, not sites. */
+const NOT_A_TLD = /^(c?js|mjs|jsx|tsx?|json|ya?ml|toml|md|py|sol|wasm|txt|html?|css|pdf|png|jpe?g|svg|gif)$/i;
+const looksLikeUrl = (v, type) => {
+    if (type === 'url' || /^https?:\/\//i.test(v))
+        return true;
+    const bare = /^[^\s/]+\.([a-z]{2,})(\/\S*)?$/i.exec(v);
+    return !!bare && !NOT_A_TLD.test(bare[1]);
+};
 function externalLink(v) {
     const href = safeLinkHref(/^[a-z][a-z0-9+.-]*:/i.test(v) ? v : `https://${v}`);
     if (!href)
@@ -250,3 +258,22 @@ export function RevisionChanges({ changes, label = type => type }) {
         return null;
     return (_jsx("ul", { className: "revision-changes", children: changes.map((c, i) => (_jsxs("li", { className: "revision-change", "data-action": c.action, children: [_jsx("span", { className: "revision-change-action", children: ACTION_LABEL[c.action] }), ` – ${label(c.type)} at ${blockLocation(c.path)}`, c.leafDiff && (_jsx("p", { className: "revision-diff", children: c.leafDiff.map(([op, text], j) => op === -1 ? _jsx("del", { children: text }, j) : op === 1 ? _jsx("ins", { children: text }, j) : _jsx("span", { children: text }, j)) }))] }, i))) }));
 }
+/**
+ * `maintenanceQueues`' lists, a heading and a count each. The page around them
+ * (its title, a sentence on what the queues are) is the wiki's.
+ */
+export function MaintenanceQueues({ queues, link: Link = Anchor, empty = _jsx("p", { children: "Nothing needs attention." }), headingLevel: H = 'h2' }) {
+    if (!queues.length)
+        return _jsx(_Fragment, { children: empty });
+    return (_jsx(_Fragment, { children: queues.map(queue => (_jsxs("section", { className: "maintenance-queue", "aria-labelledby": `queue-${queue.key}`, children: [_jsxs(H, { id: `queue-${queue.key}`, children: [queue.title, " ", _jsx("span", { className: "maintenance-count", children: queue.items.length })] }), _jsx("p", { className: "maintenance-description", children: queue.description }), _jsx("ul", { className: "maintenance-list", children: queue.items.map(item => (_jsxs("li", { className: "maintenance-item", children: [_jsx(Link, { href: item.href, children: item.title }), _jsxs("span", { className: "maintenance-detail", children: [item.tagPath ? `${item.tagPath} · ` : '', item.detail] })] }, item.href))) })] }, queue.key))) }));
+}
+/** The citation for a page, one line: `Publisher. "Title." October 22, 2026. url`, as acuiq2 first wrote it. */
+export const citation = ({ publisher, title, date, url }) => `${publisher}. "${title}." ${formatDay(date, { month: 'long' })}. ${url}`;
+/**
+ * "Cite" in an article's meta line, opening on the citation to copy. Shown,
+ * not copied by a button, so it works with no script and a reader can take
+ * part of it.
+ */
+export function Cite({ className = 'article-cite', ...page }) {
+    return (_jsxs("details", { className: className, children: [_jsx("summary", { children: "Cite" }), _jsx("code", { children: citation(page) })] }));
+}

package/dist/react.d.ts

@@ -330,6 +330,15 @@ export declare function useUnsavedChanges(dirty: boolean, message?: string): ()
  * file. `save` is read when the key is pressed, so it may close over state.
  */
 export declare function useSaveShortcut(save: () => void): void;
+/**
+ * "/" opens search from anywhere, Wikipedia's key, unless the reader is
+ * already typing. `open` focuses the field, or opens whatever holds it, and
+ * returns false when there is nothing to open (a field hidden at this width),
+ * which leaves the key to the page.
+ */
+export declare function useSearchShortcut(open: () => boolean | void): void;
+/** Focus a search field that is shown: `useSearchShortcut(() => focusShown(ref.current))`. */
+export declare const focusShown: (input: HTMLInputElement | null) => boolean;
 /** Resolves to an error message to show, or null on success. */
 export type RestoreRevision<Id> = (id: Id) => Promise<string | null>;
 /**

package/dist/react.js

@@ -183,11 +183,23 @@ export function TableOfContents({ containerSelector, headings: providedHeadings,
                 setScanned(prev => (sameHeadings(prev, next) ? prev : next));
             }, 200);
         };
+        // A container missing at mount is waited for from the body, so an article
+        // that streams in later is still read; once it exists only it is watched.
+        let watched;
+        const observer = new MutationObserver(() => {
+            follow();
+            update();
+        });
+        const follow = () => {
+            const root = document.querySelector(containerSelector);
+            if (root === watched)
+                return;
+            watched = root;
+            observer.disconnect();
+            observer.observe(root ?? document.body, { childList: true, subtree: true });
+        };
+        follow();
         update();
-        const root = document.querySelector(containerSelector);
-        const observer = new MutationObserver(update);
-        if (root)
-            observer.observe(root, { childList: true, subtree: true });
         return () => {
             clearTimeout(timer);
             observer.disconnect();
@@ -344,7 +356,13 @@ export function useTypeahead({ fetch, onPick, onEscape, delay = 200, minLength =
         });
         return () => controller.abort();
     }, [debounced, fetch, minLength, cache]);
-    const clearItems = useCallback(() => setItems([]), []);
+    // Dismissing the list also drops the search in flight, or its answer would
+    // bring back the list the reader just closed.
+    const clearItems = useCallback(() => {
+        requestId.current++;
+        setItems([]);
+        setIsSearching(false);
+    }, []);
     const reset = useCallback(() => {
         requestId.current++;
         setQuery('');
@@ -355,7 +373,7 @@ export function useTypeahead({ fetch, onPick, onEscape, delay = 200, minLength =
     }, []);
     const onKeyDown = (e) => {
         if (e.key === 'Escape') {
-            setItems([]);
+            clearItems();
             onEscape?.();
             return;
         }
@@ -466,8 +484,11 @@ export function useLinkPreview({ eligible, fetch, cardClassName = 'link-preview-
             }, showDelay);
         };
         const onOut = (e) => {
-            // Moving into the card itself is not leaving.
-            if (e.relatedTarget?.closest(`.${cardClassName}`))
+            // Moving within the link (onto a <code> or <em> in it), or into the card
+            // itself, is not leaving. Leaving cancels the pending show, and re-entering
+            // the same link does not start it again.
+            const to = e.relatedTarget;
+            if (to && (e.target?.closest('a')?.contains(to) || to.closest(`.${cardClassName}`)))
                 return;
             clearTimers();
             hide();
@@ -654,6 +675,39 @@ export function useSaveShortcut(save) {
         return () => window.removeEventListener('keydown', onKey);
     }, []);
 }
+/**
+ * "/" opens search from anywhere, Wikipedia's key, unless the reader is
+ * already typing. `open` focuses the field, or opens whatever holds it, and
+ * returns false when there is nothing to open (a field hidden at this width),
+ * which leaves the key to the page.
+ */
+export function useSearchShortcut(open) {
+    const latest = useRef(open);
+    useEffect(() => {
+        latest.current = open;
+    });
+    useEffect(() => {
+        const onKey = (e) => {
+            if (e.key !== '/' || e.metaKey || e.ctrlKey || e.altKey)
+                return;
+            const t = e.target;
+            if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.tagName === 'SELECT' || t.isContentEditable))
+                return;
+            if (latest.current() !== false)
+                e.preventDefault();
+        };
+        window.addEventListener('keydown', onKey);
+        return () => window.removeEventListener('keydown', onKey);
+    }, []);
+}
+/** Focus a search field that is shown: `useSearchShortcut(() => focusShown(ref.current))`. */
+export const focusShown = (input) => {
+    // A field hidden at this width has no offsetParent.
+    if (!input?.offsetParent)
+        return false;
+    input.focus();
+    return true;
+};
 /**
  * POST `{ revisionId }` to `endpoint`, the transport two of the wikis use; the
  * third passes its server action instead.

package/dist/revisions.d.ts

@@ -29,13 +29,11 @@ export interface BlockChange<L = unknown> {
     /** Whatever `leafDiff` returned. Absent when no `leafDiff` was supplied. */
     leafDiff?: L;
 }
-export interface RevisionDiff<L = unknown> {
+export interface RevisionDiff {
     version: SemVer;
     changeType: ChangeType;
-    changes: BlockChange<L>[];
+    changes: BlockChange[];
     titleChanged: boolean;
-    /** A page-level flag outside the block tree — a banner, a notice, a status. */
-    metaChanged: boolean;
     summary: string;
 }
 export interface DiffOptions<B, L> {
@@ -72,21 +70,13 @@ export declare function diffBlocks<B extends DiffBlock, L = unknown>(oldBlocks:
 export declare function changeSummary(diff: {
     changes: readonly BlockChange<unknown>[];
     titleChanged: boolean;
-    metaChanged?: boolean;
-    metaLabel?: string;
 }): string;
-export declare function computeRevisionDiff<B extends DiffBlock, L = unknown>(opts: {
+export declare function computeRevisionDiff<B extends DiffBlock>(opts: {
     currentVersion: string | null | undefined;
     oldContent: readonly B[];
     newContent: readonly B[];
     oldTitle: string;
     newTitle: string;
-    /** A page-level value outside the block tree; compared by strict equality. */
-    oldMeta?: unknown;
-    newMeta?: unknown;
-    /** What to call that value in the summary. Defaults to `banner`. */
-    metaLabel?: string;
-    containers?: DiffOptions<B, L>['containers'];
-    leafDiff?: DiffOptions<B, L>['leafDiff'];
-}): RevisionDiff<L>;
+    containers?: DiffOptions<B, unknown>['containers'];
+}): RevisionDiff;
 export {};

package/dist/revisions.js

@@ -1,8 +1,7 @@
 // revisions.ts — what changed between two versions of a page.
 //
 // The semver lives next door in `versioning.ts`; this is the walk that decides
-// which bump to ask for. It carries a leaf-level diff, a changed-flag for the
-// page's banner, and a `patch` classification for when only that flag moved.
+// which bump to ask for, and carries a leaf-level diff for a history view.
 // Matching is by id.
 import { incrementVersion, parseVersion } from './versioning.js';
 import { coreBlockGroups } from './blocks.js';
@@ -128,29 +127,23 @@ export function diffBlocks(oldBlocks, newBlocks, opts) {
     return changes;
 }
 /**
- * `major` for structure, `minor` for prose, `patch` for a page-level flag.
+ * `major` for structure, `minor` for prose and the title.
  *
  * A `modified` change is only ever recorded when `diffAttributes` returned
  * something, so a non-empty change set is always at least a minor bump.
  *
  * @internal
  */
-export function classifyChanges(changes, titleChanged, metaChanged = false) {
-    if (changes.length === 0 && !titleChanged && !metaChanged)
-        return 'none';
+export function classifyChanges(changes, titleChanged) {
     if (changes.some(c => c.action === 'added' || c.action === 'removed' || c.action === 'moved')) {
         return 'major';
     }
-    if (changes.length > 0 || titleChanged)
-        return 'minor';
-    return 'patch';
+    return changes.length > 0 || titleChanged ? 'minor' : 'none';
 }
 export function changeSummary(diff) {
     const parts = [];
     if (diff.titleChanged)
         parts.push('title updated');
-    if (diff.metaChanged)
-        parts.push(`${diff.metaLabel ?? 'banner'} updated`);
     const count = (action) => diff.changes.filter(c => c.action === action).length;
     const plural = (n, word) => `${n} ${word}${n > 1 ? 's' : ''}`;
     for (const [action, verb] of [
@@ -166,19 +159,14 @@ export function changeSummary(diff) {
     return parts.length > 0 ? parts.join(', ') : 'no changes';
 }
 export function computeRevisionDiff(opts) {
-    const changes = diffBlocks(opts.oldContent, opts.newContent, {
-        containers: opts.containers,
-        leafDiff: opts.leafDiff,
-    });
+    const changes = diffBlocks(opts.oldContent, opts.newContent, { containers: opts.containers });
     const titleChanged = opts.oldTitle !== opts.newTitle;
-    const metaChanged = opts.oldMeta !== opts.newMeta;
-    const changeType = classifyChanges(changes, titleChanged, metaChanged);
+    const changeType = classifyChanges(changes, titleChanged);
     const partial = {
         version: incrementVersion(parseVersion(opts.currentVersion), changeType),
         changeType,
         changes,
         titleChanged,
-        metaChanged,
     };
-    return { ...partial, summary: changeSummary({ ...partial, metaLabel: opts.metaLabel }) };
+    return { ...partial, summary: changeSummary(partial) };
 }

package/dist/stats-figures.js

@@ -11,7 +11,7 @@ import { count } from './analytics.js';
 import { TimeChart, stepDecimals } from './chart.js';
 // Whole seconds and percentages, unless an axis tick's step needs more to tell it from the next.
 const places = (step) => (step ? stepDecimals(step) : 0);
-const duration = (s, step) => (s < 60 ? `${s.toFixed(places(step))}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`);
+const duration = (s, step) => (s < 60 ? `${s.toFixed(places(step))}s` : `${Math.floor(Math.round(s) / 60)}m ${Math.round(s) % 60}s`);
 const percent = (n, step) => `${n.toFixed(places(step))}%`;
 /**
  * The change from the window before: a share of the figure before, or for a

package/dist/store.js

@@ -35,6 +35,7 @@ export function toListing(row) {
     return { ...rest, snippet: describe(openingText(content)) };
 }
 const conflict = (message) => new HttpError(409, message);
+const SLUG_TAKEN = 'A page with that slug already exists in this category';
 /** Re-order rows to match an id list, dropping ids that no longer resolve. */
 export function orderByIds(rows, ids) {
     const byId = new Map(rows.map(row => [row.id, row]));
@@ -153,15 +154,17 @@ export function wikiStore(o) {
                      AND (${prose} ILIKE $3 OR (q.tsq IS NOT NULL AND p.search_tsv @@ q.tsq))))
        ),
        paged AS (
-         SELECT *, count(*) OVER ()::int AS total FROM matched
+         SELECT * FROM matched
           ORDER BY tier, CASE WHEN tier = 0 THEN title END, CASE WHEN tier = 3 THEN fts END DESC, "updatedAt" DESC
           LIMIT $7::int OFFSET $8::int
        )
+       -- The count is joined to the page rather than windowed over it, so a
+       -- page past the end still carries the total, on one row of nulls.
        SELECT ${COLUMNS}, tier, total,
               CASE WHEN tier = 3 THEN ts_headline('english', ${proseSql()}, tsq, '${HEADLINE_OPTIONS}') END AS headline
-         FROM paged
+         FROM (SELECT count(*)::int AS total FROM matched) t LEFT JOIN paged ON true
         ORDER BY tier, CASE WHEN tier = 0 THEN title END, CASE WHEN tier = 3 THEN fts END DESC, "updatedAt" DESC`, query.trim(), `${term}%`, `%${term}%`, hidden, site, tagPath, take, skip);
-        const items = found.map(({ tier, total: _, headline, content, ...row }) => ({
+        const items = found.filter(hit => hit.id !== null).map(({ tier, total: _, headline, content, ...row }) => ({
             ...row,
             ...(withContent ? { content: content } : {}),
             score: tier,
@@ -170,17 +173,19 @@ export function wikiStore(o) {
         }));
         return { items, total: found[0]?.total ?? 0 };
     };
+    /** A revision query's guard: `$1`, its page, is this site's. Another site's page id finds nothing. */
+    const OWN_PAGE = `"pageId" IN (SELECT id FROM ${PAGE} WHERE id = $1 AND "siteId" = $2)`;
     /**
      * A page's revisions, newest first, each with what changed against the one
      * before it. `limit` counts what is returned; one more is read so the oldest
      * shown is diffed against its real predecessor, not against nothing.
      */
     const history = async (pageId, { limit = 50, offset = 0 } = {}) => {
-        const revisions = await rows(`SELECT ${REVISION_COLUMNS} FROM ${REVISION} WHERE "pageId" = $1 ORDER BY "createdAt" DESC, id DESC LIMIT $2::int OFFSET $3::int`, pageId, limit + 1, offset);
+        const revisions = await rows(`SELECT ${REVISION_COLUMNS} FROM ${REVISION} WHERE "pageId" = $1 AND ${OWN_PAGE} ORDER BY "createdAt" DESC, id DESC LIMIT $3::int OFFSET $4::int`, pageId, site, limit + 1, offset);
         const entries = withChanges(revisions, { containers: o.containers });
         return revisions.length > limit ? entries.slice(0, limit) : entries;
     };
-    const revision = (pageId, revisionId) => one(`SELECT ${REVISION_COLUMNS} FROM ${REVISION} WHERE "pageId" = $1 AND id = $2`, pageId, revisionId);
+    const revision = (pageId, revisionId) => one(`SELECT ${REVISION_COLUMNS} FROM ${REVISION} WHERE "pageId" = $1 AND ${OWN_PAGE} AND id = $3`, pageId, site, revisionId);
     const create = async (input) => {
         if (input.title === undefined || input.content === undefined)
             throw new HttpError(400, 'A new page needs a title and content');
@@ -206,14 +211,18 @@ export function wikiStore(o) {
      */
     const save = async (input) => {
         const existing = await get(input.tagPath, input.slug);
+        if (!existing && input.baseVersion !== undefined) {
+            throw conflict(`This page was deleted since it was opened at v${input.baseVersion}. Saving now would create it again; reload to decide.`);
+        }
         if (!existing)
             return create(input);
         if (input.baseVersion !== undefined && input.baseVersion !== existing.version) {
             throw conflict(`This page changed since it was opened: it is at v${existing.version} now, not v${input.baseVersion}. Reload it and apply the edit again.`);
         }
         const slug = input.newSlug && input.newSlug !== existing.slug ? input.newSlug : existing.slug;
-        if (slug !== existing.slug && (await get(existing.tagPath, slug)))
-            throw conflict('A page with that slug already exists in this category');
+        const slugTaken = async () => slug !== existing.slug && (await get(existing.tagPath, slug)) !== null;
+        if (await slugTaken())
+            throw conflict(SLUG_TAKEN);
         const title = input.title ?? existing.title;
         const content = input.content ?? existing.content;
         const diff = computeRevisionDiff({
@@ -236,7 +245,13 @@ export function wikiStore(o) {
          INSERT INTO ${REVISION} ("pageId", title, content, version, "changeType", message, "authorId")
          SELECT id, title, content, version, $9::text, $10::text, $11::text FROM up WHERE $9::text <> 'none'
        )
-       SELECT * FROM up`, existing.id, existing.version, title, slug, JSON.stringify(content), input.metadata === undefined ? null : JSON.stringify(input.metadata), version, input.verified === true, changeType, input.message ?? diff.summary, input.authorId ?? null);
+       SELECT * FROM up`, existing.id, existing.version, title, slug, JSON.stringify(content), input.metadata === undefined ? null : JSON.stringify(input.metadata), version, input.verified === true, changeType, input.message ?? diff.summary, input.authorId ?? null).catch(async (err) => {
+            // A page that took the slug after the check above fails the unique index.
+            // Asked again rather than read off the error, whose shape is the driver's.
+            if (await slugTaken())
+                throw conflict(SLUG_TAKEN);
+            throw err;
+        });
         if (!page)
             throw conflict('This page was saved by someone else while this edit was being written. Reload it and apply the edit again.');
         return { page, created: false, changeType, summary: diff.summary };

package/dist/taxonomy.js

@@ -38,7 +38,8 @@ export function hrefBuilder(prefix = '') {
 export const defaultHref = hrefBuilder();
 const DEFAULT_ALPHA_INDEX_MIN_PAGES = 40;
 /** A key's value as text. Metadata is untyped JSON, and a number or a list stored under a key must not throw. */
-const metaValue = (page, key) => {
+/** A metadata value as the facts panel shows it: trimmed text or a number, else ''. @internal */
+export const metaValue = (page, key) => {
     const value = page.metadata?.[key];
     return typeof value === 'string' ? value.trim() : typeof value === 'number' ? String(value) : '';
 };